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 "scsi/port.c" 37 #include "scsi/scsi_pr.c" 38 39 #include "spdk_cunit.h" 40 41 #include "spdk_internal/mock.h" 42 43 SPDK_LOG_REGISTER_COMPONENT("scsi", SPDK_LOG_SCSI) 44 45 void 46 spdk_scsi_task_set_status(struct spdk_scsi_task *task, int sc, int sk, 47 int asc, int ascq) 48 { 49 task->status = sc; 50 } 51 52 /* 53 * Reservation Unit Test Configuration 54 * 55 * -------- -------- ------- 56 * | Host A | | Host B | | Host C| 57 * -------- -------- ------- 58 * | | | 59 * ------ ------ ------ 60 * |Port A| |Port B| |Port C| 61 * ------ ------ ------ 62 * \ | / 63 * \ | / 64 * \ | / 65 * ------------------------ 66 * | Target Node 1 Port 0 | 67 * ------------------------ 68 * | 69 * ---------------------------------- 70 * | Target Node | 71 * ---------------------------------- 72 * | 73 * ----- 74 * |LUN 0| 75 * ----- 76 * 77 */ 78 79 static struct spdk_scsi_lun g_lun; 80 static struct spdk_scsi_port g_i_port_a; 81 static struct spdk_scsi_port g_i_port_b; 82 static struct spdk_scsi_port g_i_port_c; 83 static struct spdk_scsi_port g_t_port_0; 84 85 static void 86 ut_lun_deinit(void) 87 { 88 struct spdk_scsi_pr_registrant *reg, *tmp; 89 90 TAILQ_FOREACH_SAFE(reg, &g_lun.reg_head, link, tmp) { 91 TAILQ_REMOVE(&g_lun.reg_head, reg, link); 92 free(reg); 93 } 94 g_lun.reservation.rtype = 0; 95 g_lun.reservation.crkey = 0; 96 g_lun.reservation.holder = NULL; 97 g_lun.pr_generation = 0; 98 } 99 100 static void 101 ut_port_init(void) 102 { 103 int rc; 104 105 /* g_i_port_a */ 106 rc = spdk_scsi_port_construct(&g_i_port_a, 0xa, 0, 107 "iqn.2016-06.io.spdk:fe5aacf7420a,i,0x00023d00000a"); 108 SPDK_CU_ASSERT_FATAL(rc == 0); 109 spdk_scsi_port_set_iscsi_transport_id(&g_i_port_a, 110 "iqn.2016-06.io.spdk:fe5aacf7420a", 0x00023d00000a); 111 /* g_i_port_b */ 112 rc = spdk_scsi_port_construct(&g_i_port_b, 0xb, 0, 113 "iqn.2016-06.io.spdk:fe5aacf7420b,i,0x00023d00000b"); 114 SPDK_CU_ASSERT_FATAL(rc == 0); 115 spdk_scsi_port_set_iscsi_transport_id(&g_i_port_b, 116 "iqn.2016-06.io.spdk:fe5aacf7420b", 0x00023d00000b); 117 /* g_i_port_c */ 118 rc = spdk_scsi_port_construct(&g_i_port_c, 0xc, 0, 119 "iqn.2016-06.io.spdk:fe5aacf7420c,i,0x00023d00000c"); 120 SPDK_CU_ASSERT_FATAL(rc == 0); 121 spdk_scsi_port_set_iscsi_transport_id(&g_i_port_c, 122 "iqn.2016-06.io.spdk:fe5aacf7420c", 0x00023d00000c); 123 /* g_t_port_0 */ 124 rc = spdk_scsi_port_construct(&g_t_port_0, 0x0, 1, 125 "iqn.2016-06.io.spdk:fe5aacf74200,t,0x00023d000000"); 126 SPDK_CU_ASSERT_FATAL(rc == 0); 127 spdk_scsi_port_set_iscsi_transport_id(&g_t_port_0, 128 "iqn.2016-06.io.spdk:fe5aacf74200", 0x00023d000000); 129 } 130 131 static void 132 ut_lun_init(void) 133 { 134 TAILQ_INIT(&g_lun.reg_head); 135 } 136 137 static void 138 ut_init_reservation_test(void) 139 { 140 ut_lun_init(); 141 ut_port_init(); 142 ut_lun_init(); 143 } 144 145 static void 146 ut_deinit_reservation_test(void) 147 { 148 ut_lun_deinit(); 149 } 150 151 /* Host A: register with key 0xa. 152 * Host B: register with key 0xb. 153 * Host C: register with key 0xc. 154 */ 155 static void 156 test_build_registrants(void) 157 { 158 struct spdk_scsi_pr_registrant *reg; 159 struct spdk_scsi_task task = {0}; 160 uint32_t gen; 161 int rc; 162 163 task.lun = &g_lun; 164 task.target_port = &g_t_port_0; 165 166 gen = g_lun.pr_generation; 167 168 /* I_T nexus: Initiator Port A to Target Port 0 */ 169 task.initiator_port = &g_i_port_a; 170 /* Test Case: Host A registers with a new key */ 171 task.status = 0; 172 rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, 173 0x0, 0xa1, 0, 0, 0); 174 SPDK_CU_ASSERT_FATAL(rc == 0); 175 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); 176 SPDK_CU_ASSERT_FATAL(reg != NULL); 177 SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa1); 178 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); 179 180 /* Test Case: Host A replaces with a new key */ 181 task.status = 0; 182 rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, 183 0xa1, 0xa, 0, 0, 0); 184 SPDK_CU_ASSERT_FATAL(rc == 0); 185 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); 186 SPDK_CU_ASSERT_FATAL(reg != NULL); 187 SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa); 188 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 2); 189 190 /* Test Case: Host A replaces with a new key, reservation conflict is expected */ 191 task.status = 0; 192 rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, 193 0xa1, 0xdead, 0, 0, 0); 194 SPDK_CU_ASSERT_FATAL(rc < 0); 195 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); 196 SPDK_CU_ASSERT_FATAL(reg != NULL); 197 SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa); 198 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 2); 199 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 200 201 /* I_T nexus: Initiator Port B to Target Port 0 */ 202 task.initiator_port = &g_i_port_b; 203 /* Test Case: Host B registers with a new key */ 204 task.status = 0; 205 rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, 206 0x0, 0xb, 0, 0, 0); 207 SPDK_CU_ASSERT_FATAL(rc == 0); 208 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_b, &g_t_port_0); 209 SPDK_CU_ASSERT_FATAL(reg != NULL); 210 SPDK_CU_ASSERT_FATAL(reg->rkey == 0xb); 211 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 3); 212 213 /* I_T nexus: Initiator Port C to Target Port 0 */ 214 task.initiator_port = &g_i_port_c; 215 /* Test Case: Host C registers with a new key */ 216 task.status = 0; 217 rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, 218 0x0, 0xc, 0, 0, 0); 219 SPDK_CU_ASSERT_FATAL(rc == 0); 220 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0); 221 SPDK_CU_ASSERT_FATAL(reg != NULL); 222 SPDK_CU_ASSERT_FATAL(reg->rkey == 0xc); 223 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 4); 224 } 225 226 static void 227 test_reservation_register(void) 228 { 229 ut_init_reservation_test(); 230 231 test_build_registrants(); 232 233 ut_deinit_reservation_test(); 234 } 235 236 static void 237 test_reservation_reserve(void) 238 { 239 struct spdk_scsi_pr_registrant *reg; 240 struct spdk_scsi_task task = {0}; 241 uint32_t gen; 242 int rc; 243 244 task.lun = &g_lun; 245 task.target_port = &g_t_port_0; 246 247 ut_init_reservation_test(); 248 test_build_registrants(); 249 250 gen = g_lun.pr_generation; 251 252 task.initiator_port = &g_i_port_a; 253 task.status = 0; 254 /* Test Case: Host A acquires the reservation */ 255 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE, 256 0xa, 0, 0, 0); 257 SPDK_CU_ASSERT_FATAL(rc == 0); 258 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); 259 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); 260 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen); 261 262 /* Test Case: Host B acquires the reservation, reservation 263 * conflict is expected. 264 */ 265 task.initiator_port = &g_i_port_b; 266 task.status = 0; 267 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE, 268 0xb, 0, 0, 0); 269 SPDK_CU_ASSERT_FATAL(rc < 0); 270 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 271 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); 272 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); 273 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen); 274 275 /* Test Case: Host A unregister with reservation */ 276 task.initiator_port = &g_i_port_a; 277 task.status = 0; 278 rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, 279 0xa, 0, 0, 0, 0); 280 SPDK_CU_ASSERT_FATAL(rc == 0); 281 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == 0); 282 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0); 283 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); 284 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); 285 SPDK_CU_ASSERT_FATAL(reg == NULL); 286 287 /* Test Case: Host B acquires the reservation */ 288 task.initiator_port = &g_i_port_b; 289 task.status = 0; 290 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS, 291 0xb, 0, 0, 0); 292 SPDK_CU_ASSERT_FATAL(rc == 0); 293 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); 294 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); 295 296 /* Test Case: Host C acquires the reservation with invalid type */ 297 task.initiator_port = &g_i_port_c; 298 task.status = 0; 299 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE, 300 0xc, 0, 0, 0); 301 SPDK_CU_ASSERT_FATAL(rc < 0); 302 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 303 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); 304 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); 305 306 /* Test Case: Host C acquires the reservation, all registrants type */ 307 task.status = 0; 308 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS, 309 0xc, 0, 0, 0); 310 SPDK_CU_ASSERT_FATAL(rc == 0); 311 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); 312 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); 313 314 ut_deinit_reservation_test(); 315 } 316 317 static void 318 test_reservation_preempt_non_all_regs(void) 319 { 320 struct spdk_scsi_pr_registrant *reg; 321 struct spdk_scsi_task task = {0}; 322 uint32_t gen; 323 int rc; 324 325 task.lun = &g_lun; 326 task.target_port = &g_t_port_0; 327 328 ut_init_reservation_test(); 329 test_build_registrants(); 330 331 task.initiator_port = &g_i_port_a; 332 task.status = 0; 333 gen = g_lun.pr_generation; 334 /* Host A acquires the reservation */ 335 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, 336 0xa, 0, 0, 0); 337 SPDK_CU_ASSERT_FATAL(rc == 0); 338 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY); 339 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); 340 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen); 341 342 /* Test Case: Host B premmpts Host A, Check condition is expected 343 * for zeroed service action reservation key */ 344 task.initiator_port = &g_i_port_b; 345 task.status = 0; 346 rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, 347 SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, 348 0xb, 0); 349 SPDK_CU_ASSERT_FATAL(rc < 0); 350 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_CHECK_CONDITION); 351 352 /* Test Case: Host B preempts Host A, Host A is unregisted */ 353 task.status = 0; 354 gen = g_lun.pr_generation; 355 rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, 356 SPDK_SCSI_PR_WRITE_EXCLUSIVE, 357 0xb, 0xa); 358 SPDK_CU_ASSERT_FATAL(rc == 0); 359 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); 360 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb); 361 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); 362 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); 363 SPDK_CU_ASSERT_FATAL(reg == NULL); 364 365 /* Test Case: Host B preempts itself */ 366 task.status = 0; 367 gen = g_lun.pr_generation; 368 rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, 369 SPDK_SCSI_PR_WRITE_EXCLUSIVE, 370 0xb, 0xb); 371 SPDK_CU_ASSERT_FATAL(rc == 0); 372 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); 373 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb); 374 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); 375 376 /* Test Case: Host B preempts itself and remove registrants */ 377 task.status = 0; 378 gen = g_lun.pr_generation; 379 rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, 380 SPDK_SCSI_PR_WRITE_EXCLUSIVE, 381 0xb, 0xc); 382 SPDK_CU_ASSERT_FATAL(rc == 0); 383 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); 384 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb); 385 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0); 386 SPDK_CU_ASSERT_FATAL(reg == NULL); 387 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); 388 389 ut_deinit_reservation_test(); 390 } 391 392 static void 393 test_reservation_preempt_all_regs(void) 394 { 395 struct spdk_scsi_pr_registrant *reg; 396 struct spdk_scsi_task task = {0}; 397 uint32_t gen; 398 int rc; 399 400 task.lun = &g_lun; 401 task.target_port = &g_t_port_0; 402 403 ut_init_reservation_test(); 404 test_build_registrants(); 405 406 /* Test Case: No reservation yet, Host B removes Host C's registrant */ 407 task.initiator_port = &g_i_port_b; 408 task.status = 0; 409 gen = g_lun.pr_generation; 410 rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, 411 SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, 412 0xb, 0xc); 413 SPDK_CU_ASSERT_FATAL(rc == 0); 414 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0); 415 SPDK_CU_ASSERT_FATAL(reg == NULL); 416 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); 417 418 task.initiator_port = &g_i_port_a; 419 task.status = 0; 420 gen = g_lun.pr_generation; 421 /* Host A acquires the reservation */ 422 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS, 423 0xa, 0, 0, 0); 424 SPDK_CU_ASSERT_FATAL(rc == 0); 425 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); 426 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen); 427 428 /* Test Case: Host B removes Host A's registrant and preempt */ 429 task.initiator_port = &g_i_port_b; 430 task.status = 0; 431 gen = g_lun.pr_generation; 432 rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, 433 SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS, 434 0xb, 0x0); 435 SPDK_CU_ASSERT_FATAL(rc == 0); 436 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); 437 SPDK_CU_ASSERT_FATAL(reg == NULL); 438 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS); 439 SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); 440 441 ut_deinit_reservation_test(); 442 } 443 444 static void 445 test_reservation_cmds_conflict(void) 446 { 447 struct spdk_scsi_pr_registrant *reg; 448 struct spdk_scsi_task task = {0}; 449 uint8_t cdb[32]; 450 int rc; 451 452 task.lun = &g_lun; 453 task.target_port = &g_t_port_0; 454 task.cdb = cdb; 455 456 ut_init_reservation_test(); 457 test_build_registrants(); 458 459 /* Host A acquires the reservation */ 460 task.initiator_port = &g_i_port_a; 461 rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, 462 0xa, 0, 0, 0); 463 SPDK_CU_ASSERT_FATAL(rc == 0); 464 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY); 465 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); 466 467 /* Remove Host B registrant */ 468 task.initiator_port = &g_i_port_b; 469 task.status = 0; 470 rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, 471 0xb, 0, 0, 0, 0); 472 SPDK_CU_ASSERT_FATAL(rc == 0); 473 reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_b, &g_t_port_0); 474 SPDK_CU_ASSERT_FATAL(reg == NULL); 475 476 /* Test Case: Host B sends Read/Write commands, 477 * reservation conflict is expected. 478 */ 479 task.cdb[0] = SPDK_SBC_READ_10; 480 task.status = 0; 481 rc = spdk_scsi_pr_check(&task); 482 SPDK_CU_ASSERT_FATAL(rc == 0); 483 task.cdb[0] = SPDK_SBC_WRITE_10; 484 task.status = 0; 485 rc = spdk_scsi_pr_check(&task); 486 SPDK_CU_ASSERT_FATAL(rc < 0); 487 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 488 489 /* Test Case: Host C sends Read/Write commands */ 490 task.initiator_port = &g_i_port_c; 491 task.cdb[0] = SPDK_SBC_READ_10; 492 task.status = 0; 493 rc = spdk_scsi_pr_check(&task); 494 SPDK_CU_ASSERT_FATAL(rc == 0); 495 task.cdb[0] = SPDK_SBC_WRITE_10; 496 task.status = 0; 497 rc = spdk_scsi_pr_check(&task); 498 SPDK_CU_ASSERT_FATAL(rc == 0); 499 500 /* Host A preempts itself with SPDK_SCSI_PR_EXCLUSIVE_ACCESS */ 501 task.initiator_port = &g_i_port_a; 502 rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, 503 SPDK_SCSI_PR_EXCLUSIVE_ACCESS, 504 0xa, 0xa); 505 SPDK_CU_ASSERT_FATAL(rc == 0); 506 SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS); 507 SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); 508 509 /* Test Case: Host C sends Read/Write commands */ 510 task.initiator_port = &g_i_port_c; 511 task.cdb[0] = SPDK_SBC_READ_10; 512 task.status = 0; 513 rc = spdk_scsi_pr_check(&task); 514 SPDK_CU_ASSERT_FATAL(rc < 0); 515 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 516 task.cdb[0] = SPDK_SBC_WRITE_10; 517 task.status = 0; 518 rc = spdk_scsi_pr_check(&task); 519 SPDK_CU_ASSERT_FATAL(rc < 0); 520 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 521 522 /* Test Case: Host B sends Read/Write commands */ 523 task.initiator_port = &g_i_port_b; 524 task.cdb[0] = SPDK_SBC_READ_10; 525 task.status = 0; 526 rc = spdk_scsi_pr_check(&task); 527 SPDK_CU_ASSERT_FATAL(rc < 0); 528 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 529 task.cdb[0] = SPDK_SBC_WRITE_10; 530 task.status = 0; 531 rc = spdk_scsi_pr_check(&task); 532 SPDK_CU_ASSERT_FATAL(rc < 0); 533 SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); 534 535 ut_deinit_reservation_test(); 536 } 537 538 int 539 main(int argc, char **argv) 540 { 541 CU_pSuite suite = NULL; 542 unsigned int num_failures; 543 544 if (CU_initialize_registry() != CUE_SUCCESS) { 545 return CU_get_error(); 546 } 547 548 suite = CU_add_suite("reservation_suite", NULL, NULL); 549 if (suite == NULL) { 550 CU_cleanup_registry(); 551 return CU_get_error(); 552 } 553 554 if (CU_add_test(suite, "register", test_reservation_register) == NULL || 555 CU_add_test(suite, "reserve", test_reservation_reserve) == NULL || 556 CU_add_test(suite, "preempt", test_reservation_preempt_non_all_regs) == NULL || 557 CU_add_test(suite, "preempt all regs", test_reservation_preempt_all_regs) == NULL || 558 CU_add_test(suite, "conflict", test_reservation_cmds_conflict) == NULL) { 559 CU_cleanup_registry(); 560 return CU_get_error(); 561 } 562 563 CU_basic_set_mode(CU_BRM_VERBOSE); 564 CU_basic_run_tests(); 565 num_failures = CU_get_number_of_failures(); 566 CU_cleanup_registry(); 567 return num_failures; 568 569 } 570