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_internal/cunit.h"
12
13 #include "common/lib/test_env.c"
14 #include "sock/posix/posix.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));
25 DEFINE_STUB(spdk_sock_set_default_impl, int, (const char *impl_name), 0);
26 DEFINE_STUB(spdk_sock_close, int, (struct spdk_sock **s), 0);
27 DEFINE_STUB(spdk_sock_group_provide_buf, int, (struct spdk_sock_group *group, void *buf,
28 size_t len, void *ctx), 0);
29 DEFINE_STUB(spdk_sock_group_get_buf, size_t, (struct spdk_sock_group *group, void **buf,
30 void **ctx), 0);
31
32 static void
_req_cb(void * cb_arg,int len)33 _req_cb(void *cb_arg, int len)
34 {
35 *(bool *)cb_arg = true;
36 CU_ASSERT(len == 0);
37 }
38
39 static void
flush(void)40 flush(void)
41 {
42 struct spdk_posix_sock_group_impl group = {};
43 struct spdk_posix_sock psock = {};
44 struct spdk_sock *sock = &psock.base;
45 struct spdk_sock_request *req1, *req2;
46 bool cb_arg1, cb_arg2;
47 int rc;
48
49 /* Set up data structures */
50 TAILQ_INIT(&sock->queued_reqs);
51 TAILQ_INIT(&sock->pending_reqs);
52 sock->group_impl = &group.base;
53
54 req1 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec));
55 SPDK_CU_ASSERT_FATAL(req1 != NULL);
56 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_base = (void *)100;
57 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_len = 32;
58 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_base = (void *)200;
59 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_len = 32;
60 req1->iovcnt = 2;
61 req1->cb_fn = _req_cb;
62 req1->cb_arg = &cb_arg1;
63
64 req2 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec));
65 SPDK_CU_ASSERT_FATAL(req2 != NULL);
66 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_base = (void *)100;
67 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_len = 32;
68 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_base = (void *)200;
69 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_len = 32;
70 req2->iovcnt = 2;
71 req2->cb_fn = _req_cb;
72 req2->cb_arg = &cb_arg2;
73
74 /* Simple test - a request with a 2 element iovec
75 * that gets submitted in a single sendmsg. */
76 spdk_sock_request_queue(sock, req1);
77 MOCK_SET(sendmsg, 64);
78 cb_arg1 = false;
79 rc = _sock_flush(sock);
80 CU_ASSERT(rc == 64);
81 CU_ASSERT(cb_arg1 == true);
82 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs));
83
84 /* Two requests, where both can fully send. */
85 spdk_sock_request_queue(sock, req1);
86 spdk_sock_request_queue(sock, req2);
87 MOCK_SET(sendmsg, 128);
88 cb_arg1 = false;
89 cb_arg2 = false;
90 rc = _sock_flush(sock);
91 CU_ASSERT(rc == 128);
92 CU_ASSERT(cb_arg1 == true);
93 CU_ASSERT(cb_arg2 == true);
94 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs));
95
96 /* Two requests. Only first one can send */
97 spdk_sock_request_queue(sock, req1);
98 spdk_sock_request_queue(sock, req2);
99 MOCK_SET(sendmsg, 64);
100 cb_arg1 = false;
101 cb_arg2 = false;
102 rc = _sock_flush(sock);
103 CU_ASSERT(rc == 64);
104 CU_ASSERT(cb_arg1 == true);
105 CU_ASSERT(cb_arg2 == false);
106 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req2);
107 TAILQ_REMOVE(&sock->queued_reqs, req2, internal.link);
108 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs));
109
110 /* One request. Partial send. */
111 spdk_sock_request_queue(sock, req1);
112 MOCK_SET(sendmsg, 10);
113 cb_arg1 = false;
114 rc = _sock_flush(sock);
115 CU_ASSERT(rc == 10);
116 CU_ASSERT(cb_arg1 == false);
117 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1);
118
119 /* Do a second flush that partial sends again. */
120 MOCK_SET(sendmsg, 24);
121 cb_arg1 = false;
122 rc = _sock_flush(sock);
123 CU_ASSERT(rc == 24);
124 CU_ASSERT(cb_arg1 == false);
125 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1);
126
127 /* Flush the rest of the data */
128 MOCK_SET(sendmsg, 30);
129 cb_arg1 = false;
130 rc = _sock_flush(sock);
131 CU_ASSERT(rc == 30);
132 CU_ASSERT(cb_arg1 == true);
133 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs));
134
135 free(req1);
136 free(req2);
137 }
138
139 int
main(int argc,char ** argv)140 main(int argc, char **argv)
141 {
142 CU_pSuite suite = NULL;
143 unsigned int num_failures;
144
145 CU_initialize_registry();
146
147 suite = CU_add_suite("posix", NULL, NULL);
148
149 CU_ADD_TEST(suite, flush);
150
151
152 num_failures = spdk_ut_run_tests(argc, argv, NULL);
153
154 CU_cleanup_registry();
155
156 return num_failures;
157 }
158