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 36 #include "common/lib/test_env.c" 37 #include "spdk_cunit.h" 38 39 #include "iscsi/conn.c" 40 41 #include "spdk_internal/mock.h" 42 43 SPDK_LOG_REGISTER_COMPONENT("iscsi", SPDK_LOG_ISCSI) 44 45 #define DMIN32(A,B) ((uint32_t) ((uint32_t)(A) > (uint32_t)(B) ? (uint32_t)(B) : (uint32_t)(A))) 46 47 struct spdk_iscsi_globals g_spdk_iscsi; 48 static TAILQ_HEAD(, spdk_iscsi_task) g_ut_read_tasks = TAILQ_HEAD_INITIALIZER(g_ut_read_tasks); 49 50 DEFINE_STUB(spdk_app_get_shm_id, int, (void), 0); 51 52 DEFINE_STUB(spdk_env_get_current_core, uint32_t, (void), 0); 53 54 DEFINE_STUB(spdk_env_get_first_core, uint32_t, (void), 0); 55 56 DEFINE_STUB(spdk_env_get_last_core, uint32_t, (void), 0); 57 58 DEFINE_STUB(spdk_env_get_next_core, uint32_t, (uint32_t prev_core), 0); 59 60 DEFINE_STUB(spdk_event_allocate, struct spdk_event *, 61 (uint32_t lcore, spdk_event_fn fn, void *arg1, void *arg2), 62 NULL); 63 64 DEFINE_STUB_V(spdk_event_call, (struct spdk_event *event)); 65 66 DEFINE_STUB(spdk_sock_getaddr, int, 67 (struct spdk_sock *sock, char *saddr, int slen, uint16_t *sport, 68 char *caddr, int clen, uint16_t *cport), 69 0); 70 71 int 72 spdk_sock_close(struct spdk_sock **sock) 73 { 74 *sock = NULL; 75 return 0; 76 } 77 78 DEFINE_STUB(spdk_sock_recv, ssize_t, 79 (struct spdk_sock *sock, void *buf, size_t len), 0); 80 81 DEFINE_STUB(spdk_sock_readv, ssize_t, 82 (struct spdk_sock *sock, struct iovec *iov, int iovcnt), 0); 83 84 DEFINE_STUB(spdk_sock_writev, ssize_t, 85 (struct spdk_sock *sock, struct iovec *iov, int iovcnt), 0); 86 87 DEFINE_STUB(spdk_sock_set_recvlowat, int, (struct spdk_sock *s, int nbytes), 0); 88 89 DEFINE_STUB(spdk_sock_set_recvbuf, int, (struct spdk_sock *sock, int sz), 0); 90 91 DEFINE_STUB(spdk_sock_set_sendbuf, int, (struct spdk_sock *sock, int sz), 0); 92 93 DEFINE_STUB(spdk_sock_group_add_sock, int, 94 (struct spdk_sock_group *group, struct spdk_sock *sock, 95 spdk_sock_cb cb_fn, void *cb_arg), 96 0); 97 98 DEFINE_STUB(spdk_sock_group_remove_sock, int, 99 (struct spdk_sock_group *group, struct spdk_sock *sock), 0); 100 101 DEFINE_STUB_V(spdk_scsi_task_put, (struct spdk_scsi_task *task)); 102 103 DEFINE_STUB(spdk_scsi_dev_get_lun, struct spdk_scsi_lun *, 104 (struct spdk_scsi_dev *dev, int lun_id), NULL); 105 106 DEFINE_STUB(spdk_scsi_dev_has_pending_tasks, bool, 107 (const struct spdk_scsi_dev *dev), true); 108 109 DEFINE_STUB(spdk_scsi_lun_open, int, 110 (struct spdk_scsi_lun *lun, spdk_scsi_lun_remove_cb_t hotremove_cb, 111 void *hotremove_ctx, struct spdk_scsi_lun_desc **desc), 112 0); 113 114 DEFINE_STUB_V(spdk_scsi_lun_close, (struct spdk_scsi_lun_desc *desc)); 115 116 DEFINE_STUB(spdk_scsi_lun_allocate_io_channel, int, 117 (struct spdk_scsi_lun_desc *desc), 0); 118 119 DEFINE_STUB_V(spdk_scsi_lun_free_io_channel, (struct spdk_scsi_lun_desc *desc)); 120 121 DEFINE_STUB(spdk_scsi_lun_get_id, int, (const struct spdk_scsi_lun *lun), 0); 122 123 DEFINE_STUB(spdk_scsi_port_get_name, const char *, 124 (const struct spdk_scsi_port *port), NULL); 125 126 void 127 spdk_scsi_task_copy_status(struct spdk_scsi_task *dst, 128 struct spdk_scsi_task *src) 129 { 130 dst->status = src->status; 131 } 132 133 DEFINE_STUB_V(spdk_put_pdu, (struct spdk_iscsi_pdu *pdu)); 134 135 DEFINE_STUB_V(spdk_iscsi_param_free, (struct iscsi_param *params)); 136 137 DEFINE_STUB(spdk_iscsi_conn_params_init, int, (struct iscsi_param **params), 0); 138 139 DEFINE_STUB_V(spdk_clear_all_transfer_task, 140 (struct spdk_iscsi_conn *conn, struct spdk_scsi_lun *lun, 141 struct spdk_iscsi_pdu *pdu)); 142 143 DEFINE_STUB(spdk_iscsi_build_iovs, int, 144 (struct spdk_iscsi_conn *conn, struct iovec *iov, int num_iovs, 145 struct spdk_iscsi_pdu *pdu, uint32_t *mapped_length), 146 0); 147 148 DEFINE_STUB(spdk_iscsi_is_deferred_free_pdu, bool, 149 (struct spdk_iscsi_pdu *pdu), false); 150 151 DEFINE_STUB_V(spdk_iscsi_task_response, 152 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_task *task)); 153 154 DEFINE_STUB_V(spdk_iscsi_task_mgmt_response, 155 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_task *task)); 156 157 DEFINE_STUB_V(spdk_iscsi_send_nopin, (struct spdk_iscsi_conn *conn)); 158 159 DEFINE_STUB(spdk_iscsi_execute, int, 160 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu), 0); 161 162 DEFINE_STUB_V(spdk_del_transfer_task, 163 (struct spdk_iscsi_conn *conn, uint32_t task_tag)); 164 165 DEFINE_STUB(spdk_iscsi_conn_handle_queued_datain_tasks, int, 166 (struct spdk_iscsi_conn *conn), 0); 167 168 DEFINE_STUB(spdk_iscsi_read_pdu, int, 169 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu **_pdu), 0); 170 171 DEFINE_STUB_V(spdk_free_sess, (struct spdk_iscsi_sess *sess)); 172 173 DEFINE_STUB(spdk_iscsi_tgt_node_cleanup_luns, int, 174 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_tgt_node *target), 175 0); 176 177 DEFINE_STUB(spdk_iscsi_pdu_calc_header_digest, uint32_t, 178 (struct spdk_iscsi_pdu *pdu), 0); 179 180 DEFINE_STUB(spdk_iscsi_pdu_calc_data_digest, uint32_t, 181 (struct spdk_iscsi_pdu *pdu), 0); 182 183 DEFINE_STUB_V(spdk_shutdown_iscsi_conns_done, (void)); 184 185 static struct spdk_iscsi_task * 186 ut_conn_task_get(struct spdk_iscsi_task *parent) 187 { 188 struct spdk_iscsi_task *task; 189 190 task = calloc(1, sizeof(*task)); 191 SPDK_CU_ASSERT_FATAL(task != NULL); 192 193 if (parent) { 194 task->parent = parent; 195 } 196 return task; 197 } 198 199 static void 200 ut_conn_create_read_tasks(int transfer_len) 201 { 202 struct spdk_iscsi_task *task, *subtask; 203 int32_t remaining_size = 0; 204 205 task = ut_conn_task_get(NULL); 206 207 task->scsi.transfer_len = transfer_len; 208 task->scsi.offset = 0; 209 task->scsi.length = DMIN32(SPDK_BDEV_LARGE_BUF_MAX_SIZE, task->scsi.transfer_len); 210 task->scsi.status = SPDK_SCSI_STATUS_GOOD; 211 212 remaining_size = task->scsi.transfer_len - task->scsi.length; 213 task->current_datain_offset = 0; 214 215 if (remaining_size == 0) { 216 TAILQ_INSERT_TAIL(&g_ut_read_tasks, task, link); 217 return; 218 } 219 220 while (1) { 221 if (task->current_datain_offset == 0) { 222 task->current_datain_offset = task->scsi.length; 223 TAILQ_INSERT_TAIL(&g_ut_read_tasks, task, link); 224 continue; 225 } 226 227 if (task->current_datain_offset < task->scsi.transfer_len) { 228 remaining_size = task->scsi.transfer_len - task->current_datain_offset; 229 230 subtask = ut_conn_task_get(task); 231 232 subtask->scsi.offset = task->current_datain_offset; 233 subtask->scsi.length = DMIN32(SPDK_BDEV_LARGE_BUF_MAX_SIZE, remaining_size); 234 subtask->scsi.status = SPDK_SCSI_STATUS_GOOD; 235 236 task->current_datain_offset += subtask->scsi.length; 237 238 TAILQ_INSERT_TAIL(&g_ut_read_tasks, subtask, link); 239 } 240 241 if (task->current_datain_offset == task->scsi.transfer_len) { 242 break; 243 } 244 } 245 } 246 247 static void 248 read_task_split_in_order_case(void) 249 { 250 struct spdk_iscsi_task *primary, *task, *tmp; 251 252 ut_conn_create_read_tasks(SPDK_BDEV_LARGE_BUF_MAX_SIZE * 8); 253 254 TAILQ_FOREACH(task, &g_ut_read_tasks, link) { 255 primary = spdk_iscsi_task_get_primary(task); 256 process_read_task_completion(NULL, task, primary); 257 } 258 259 primary = TAILQ_FIRST(&g_ut_read_tasks); 260 SPDK_CU_ASSERT_FATAL(primary != NULL); 261 262 if (primary != NULL) { 263 CU_ASSERT(primary->bytes_completed == primary->scsi.transfer_len); 264 } 265 266 TAILQ_FOREACH_SAFE(task, &g_ut_read_tasks, link, tmp) { 267 TAILQ_REMOVE(&g_ut_read_tasks, task, link); 268 free(task); 269 } 270 271 CU_ASSERT(TAILQ_EMPTY(&g_ut_read_tasks)); 272 } 273 274 static void 275 propagate_scsi_error_status_for_split_read_tasks(void) 276 { 277 struct spdk_iscsi_task primary, task1, task2, task3, task4, task5, task6; 278 279 memset(&primary, 0, sizeof(struct spdk_iscsi_task)); 280 primary.scsi.length = 512; 281 primary.scsi.status = SPDK_SCSI_STATUS_GOOD; 282 primary.rsp_scsi_status = SPDK_SCSI_STATUS_GOOD; 283 TAILQ_INIT(&primary.subtask_list); 284 285 memset(&task1, 0, sizeof(struct spdk_iscsi_task)); 286 task1.scsi.offset = 512; 287 task1.scsi.length = 512; 288 task1.scsi.status = SPDK_SCSI_STATUS_GOOD; 289 290 memset(&task2, 0, sizeof(struct spdk_iscsi_task)); 291 task2.scsi.offset = 512 * 2; 292 task2.scsi.length = 512; 293 task2.scsi.status = SPDK_SCSI_STATUS_CHECK_CONDITION; 294 295 memset(&task3, 0, sizeof(struct spdk_iscsi_task)); 296 task3.scsi.offset = 512 * 3; 297 task3.scsi.length = 512; 298 task3.scsi.status = SPDK_SCSI_STATUS_GOOD; 299 300 memset(&task4, 0, sizeof(struct spdk_iscsi_task)); 301 task4.scsi.offset = 512 * 4; 302 task4.scsi.length = 512; 303 task4.scsi.status = SPDK_SCSI_STATUS_GOOD; 304 305 memset(&task5, 0, sizeof(struct spdk_iscsi_task)); 306 task5.scsi.offset = 512 * 5; 307 task5.scsi.length = 512; 308 task5.scsi.status = SPDK_SCSI_STATUS_GOOD; 309 310 memset(&task6, 0, sizeof(struct spdk_iscsi_task)); 311 task6.scsi.offset = 512 * 6; 312 task6.scsi.length = 512; 313 task6.scsi.status = SPDK_SCSI_STATUS_GOOD; 314 315 /* task2 has check condition status, and verify if the check condition 316 * status is propagated to remaining tasks correctly when these tasks complete 317 * by the following order, task4, task3, task2, task1, primary, task5, and task6. 318 */ 319 process_read_task_completion(NULL, &task4, &primary); 320 process_read_task_completion(NULL, &task3, &primary); 321 process_read_task_completion(NULL, &task2, &primary); 322 process_read_task_completion(NULL, &task1, &primary); 323 process_read_task_completion(NULL, &primary, &primary); 324 process_read_task_completion(NULL, &task5, &primary); 325 process_read_task_completion(NULL, &task6, &primary); 326 327 CU_ASSERT(primary.scsi.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 328 CU_ASSERT(task1.scsi.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 329 CU_ASSERT(task2.scsi.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 330 CU_ASSERT(task3.scsi.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 331 CU_ASSERT(task4.scsi.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 332 CU_ASSERT(task5.scsi.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 333 CU_ASSERT(task6.scsi.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 334 CU_ASSERT(TAILQ_EMPTY(&primary.subtask_list)); 335 } 336 337 int 338 main(int argc, char **argv) 339 { 340 CU_pSuite suite = NULL; 341 unsigned int num_failures; 342 343 if (CU_initialize_registry() != CUE_SUCCESS) { 344 return CU_get_error(); 345 } 346 347 suite = CU_add_suite("conn_suite", NULL, NULL); 348 if (suite == NULL) { 349 CU_cleanup_registry(); 350 return CU_get_error(); 351 } 352 353 if ( 354 CU_add_test(suite, "read task split in order", read_task_split_in_order_case) == NULL || 355 CU_add_test(suite, "propagate_scsi_error_status_for_split_read_tasks", 356 propagate_scsi_error_status_for_split_read_tasks) == NULL 357 ) { 358 CU_cleanup_registry(); 359 return CU_get_error(); 360 } 361 362 CU_basic_set_mode(CU_BRM_VERBOSE); 363 CU_basic_run_tests(); 364 num_failures = CU_get_number_of_failures(); 365 CU_cleanup_registry(); 366 return num_failures; 367 } 368