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