1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 #include "spdk/util.h" 36 37 #include "spdk_internal/mock.h" 38 39 #include "spdk_cunit.h" 40 41 #include "common/lib/test_env.c" 42 #include "sock/uring/uring.c" 43 44 DEFINE_STUB(spdk_sock_map_insert, int, (struct spdk_sock_map *map, int placement_id, 45 struct spdk_sock_group_impl *group), 0); 46 DEFINE_STUB_V(spdk_sock_map_release, (struct spdk_sock_map *map, int placement_id)); 47 DEFINE_STUB(spdk_sock_map_lookup, int, (struct spdk_sock_map *map, int placement_id, 48 struct spdk_sock_group_impl **group, struct spdk_sock_group_impl *hint), 0); 49 DEFINE_STUB(spdk_sock_map_find_free, int, (struct spdk_sock_map *map), -1); 50 DEFINE_STUB_V(spdk_sock_map_cleanup, (struct spdk_sock_map *map)); 51 52 DEFINE_STUB_V(spdk_net_impl_register, (struct spdk_net_impl *impl, int priority)); 53 DEFINE_STUB(spdk_sock_close, int, (struct spdk_sock **s), 0); 54 DEFINE_STUB(__io_uring_get_cqe, int, (struct io_uring *ring, struct io_uring_cqe **cqe_ptr, 55 unsigned submit, 56 unsigned wait_nr, sigset_t *sigmask), 0); 57 DEFINE_STUB(io_uring_submit, int, (struct io_uring *ring), 0); 58 DEFINE_STUB(io_uring_get_sqe, struct io_uring_sqe *, (struct io_uring *ring), 0); 59 DEFINE_STUB(io_uring_queue_init, int, (unsigned entries, struct io_uring *ring, unsigned flags), 0); 60 DEFINE_STUB_V(io_uring_queue_exit, (struct io_uring *ring)); 61 62 static void 63 _req_cb(void *cb_arg, int len) 64 { 65 *(bool *)cb_arg = true; 66 CU_ASSERT(len == 0); 67 } 68 69 static void 70 flush_client(void) 71 { 72 struct spdk_uring_sock_group_impl group = {}; 73 struct spdk_uring_sock usock = {}; 74 struct spdk_sock *sock = &usock.base; 75 struct spdk_sock_request *req1, *req2; 76 bool cb_arg1, cb_arg2; 77 int rc; 78 79 /* Set up data structures */ 80 TAILQ_INIT(&sock->queued_reqs); 81 TAILQ_INIT(&sock->pending_reqs); 82 sock->group_impl = &group.base; 83 84 req1 = calloc(1, sizeof(struct spdk_sock_request) + 3 * sizeof(struct iovec)); 85 SPDK_CU_ASSERT_FATAL(req1 != NULL); 86 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_base = (void *)100; 87 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_len = 64; 88 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_base = (void *)200; 89 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_len = 64; 90 SPDK_SOCK_REQUEST_IOV(req1, 2)->iov_base = (void *)300; 91 SPDK_SOCK_REQUEST_IOV(req1, 2)->iov_len = 64; 92 req1->iovcnt = 3; 93 req1->cb_fn = _req_cb; 94 req1->cb_arg = &cb_arg1; 95 96 req2 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec)); 97 SPDK_CU_ASSERT_FATAL(req2 != NULL); 98 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_base = (void *)100; 99 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_len = 32; 100 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_base = (void *)200; 101 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_len = 32; 102 req2->iovcnt = 2; 103 req2->cb_fn = _req_cb; 104 req2->cb_arg = &cb_arg2; 105 106 /* Simple test - a request with a 3 element iovec 107 * that gets submitted in a single sendmsg. */ 108 spdk_sock_request_queue(sock, req1); 109 MOCK_SET(sendmsg, 192); 110 cb_arg1 = false; 111 rc = _sock_flush_client(sock); 112 CU_ASSERT(rc == 0); 113 CU_ASSERT(cb_arg1 == true); 114 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 115 116 /* Two requests, where both can fully send. */ 117 spdk_sock_request_queue(sock, req1); 118 spdk_sock_request_queue(sock, req2); 119 MOCK_SET(sendmsg, 256); 120 cb_arg1 = false; 121 cb_arg2 = false; 122 rc = _sock_flush_client(sock); 123 CU_ASSERT(rc == 0); 124 CU_ASSERT(cb_arg1 == true); 125 CU_ASSERT(cb_arg2 == true); 126 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 127 128 /* Two requests. Only first one can send */ 129 spdk_sock_request_queue(sock, req1); 130 spdk_sock_request_queue(sock, req2); 131 MOCK_SET(sendmsg, 192); 132 cb_arg1 = false; 133 cb_arg2 = false; 134 rc = _sock_flush_client(sock); 135 CU_ASSERT(rc == 0); 136 CU_ASSERT(cb_arg1 == true); 137 CU_ASSERT(cb_arg2 == false); 138 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req2); 139 TAILQ_REMOVE(&sock->queued_reqs, req2, internal.link); 140 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 141 142 /* One request. Partial send. */ 143 spdk_sock_request_queue(sock, req1); 144 MOCK_SET(sendmsg, 10); 145 cb_arg1 = false; 146 rc = _sock_flush_client(sock); 147 CU_ASSERT(rc == 0); 148 CU_ASSERT(cb_arg1 == false); 149 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 150 151 /* Do a second flush that partial sends again. */ 152 MOCK_SET(sendmsg, 52); 153 cb_arg1 = false; 154 rc = _sock_flush_client(sock); 155 CU_ASSERT(rc == 0); 156 CU_ASSERT(cb_arg1 == false); 157 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 158 159 /* Flush the rest of the data */ 160 MOCK_SET(sendmsg, 130); 161 cb_arg1 = false; 162 rc = _sock_flush_client(sock); 163 CU_ASSERT(rc == 0); 164 CU_ASSERT(cb_arg1 == true); 165 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 166 167 free(req1); 168 free(req2); 169 } 170 171 static void 172 flush_server(void) 173 { 174 struct spdk_uring_sock_group_impl group = {}; 175 struct spdk_uring_sock usock = {}; 176 struct spdk_sock *sock = &usock.base; 177 struct spdk_sock_request *req1, *req2; 178 bool cb_arg1, cb_arg2; 179 int rc; 180 181 /* Set up data structures */ 182 TAILQ_INIT(&sock->queued_reqs); 183 TAILQ_INIT(&sock->pending_reqs); 184 sock->group_impl = &group.base; 185 usock.write_task.sock = &usock; 186 usock.group = &group; 187 188 req1 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec)); 189 SPDK_CU_ASSERT_FATAL(req1 != NULL); 190 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_base = (void *)100; 191 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_len = 64; 192 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_base = (void *)200; 193 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_len = 64; 194 req1->iovcnt = 2; 195 req1->cb_fn = _req_cb; 196 req1->cb_arg = &cb_arg1; 197 198 req2 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec)); 199 SPDK_CU_ASSERT_FATAL(req2 != NULL); 200 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_base = (void *)100; 201 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_len = 32; 202 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_base = (void *)200; 203 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_len = 32; 204 req2->iovcnt = 2; 205 req2->cb_fn = _req_cb; 206 req2->cb_arg = &cb_arg2; 207 208 /* we should not call _sock_flush directly, since it will finally 209 * call liburing related functions */ 210 211 /* Simple test - a request with a 2 element iovec 212 * that is fully completed. */ 213 spdk_sock_request_queue(sock, req1); 214 cb_arg1 = false; 215 rc = spdk_sock_prep_reqs(sock, usock.write_task.iovs, 0, NULL, NULL); 216 CU_ASSERT(rc == 2); 217 sock_complete_reqs(sock, 128, 0); 218 CU_ASSERT(cb_arg1 == true); 219 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 220 221 /* Two requests, where both can be fully completed. */ 222 spdk_sock_request_queue(sock, req1); 223 spdk_sock_request_queue(sock, req2); 224 cb_arg1 = false; 225 cb_arg2 = false; 226 rc = spdk_sock_prep_reqs(sock, usock.write_task.iovs, 0, NULL, NULL); 227 CU_ASSERT(rc == 4); 228 sock_complete_reqs(sock, 192, 0); 229 CU_ASSERT(cb_arg1 == true); 230 CU_ASSERT(cb_arg2 == true); 231 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 232 233 234 /* One request that is partially sent. */ 235 spdk_sock_request_queue(sock, req1); 236 cb_arg1 = false; 237 rc = spdk_sock_prep_reqs(sock, usock.write_task.iovs, 0, NULL, NULL); 238 CU_ASSERT(rc == 2); 239 sock_complete_reqs(sock, 92, 0); 240 CU_ASSERT(rc == 2); 241 CU_ASSERT(cb_arg1 == false); 242 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 243 244 /* Get the second time partial sent result. */ 245 sock_complete_reqs(sock, 10, 0); 246 CU_ASSERT(cb_arg1 == false); 247 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 248 249 /* Data is finally sent. */ 250 sock_complete_reqs(sock, 26, 0); 251 CU_ASSERT(cb_arg1 == true); 252 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 253 254 free(req1); 255 free(req2); 256 } 257 258 int 259 main(int argc, char **argv) 260 { 261 CU_pSuite suite = NULL; 262 unsigned int num_failures; 263 264 CU_set_error_action(CUEA_ABORT); 265 CU_initialize_registry(); 266 267 suite = CU_add_suite("uring", NULL, NULL); 268 269 270 CU_ADD_TEST(suite, flush_client); 271 CU_ADD_TEST(suite, flush_server); 272 273 CU_basic_set_mode(CU_BRM_VERBOSE); 274 275 CU_basic_run_tests(); 276 277 num_failures = CU_get_number_of_failures(); 278 CU_cleanup_registry(); 279 280 return num_failures; 281 } 282