void test_sanitize_exit_failure_mode(void) { struct iscsi_data data; struct scsi_command_descriptor *cd; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test SANITIZE EXIT FAILURE MODE"); CHECK_FOR_SANITIZE; CHECK_FOR_DATALOSS; logging(LOG_VERBOSE, "Check that SANITIZE EXIT FAILURE MODE is " "supported in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_EXIT_FAILURE_MODE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE EXIT FAILURE MODE is " "not implemented according to " "REPORT_SUPPORTED_OPCODES."); CU_PASS("SANITIZE is not implemented."); return; } data.size = 8; data.data = alloca(data.size); memset(data.data, 0, data.size); logging(LOG_VERBOSE, "EXIT_FAILURE_MODE parameter list length must " "be 0"); logging(LOG_VERBOSE, "Test that non-zero param length is an error for " "EXIT_FAILURE_MODE"); SANITIZE(sd, 0, 0, SCSI_SANITIZE_EXIT_FAILURE_MODE, 8, &data, EXPECT_INVALID_FIELD_IN_CDB); }
void test_sanitize_block_erase(void) { struct iscsi_data data; struct scsi_command_descriptor *cd; unsigned char *buf = alloca(256 * block_size); logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test SANITIZE BLOCK ERASE"); CHECK_FOR_SANITIZE; CHECK_FOR_DATALOSS; logging(LOG_VERBOSE, "Check that SANITIZE BLOCK_ERASE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_BLOCK_ERASE); if (cd == NULL) { logging(LOG_VERBOSE, "Opcode is not supported. Verify that " "WABEREQ is zero."); if (inq_bdc && inq_bdc->wabereq) { logging(LOG_NORMAL, "[FAILED] WABEREQ is not 0 but " "SANITIZE BLOCK ERASE opcode is not supported"); CU_FAIL("[FAILED] WABEREQ is not 0 but BLOCK ERASE " "is not supported."); } logging(LOG_NORMAL, "[SKIPPED] SANITIZE BLOCK_ERASE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); CU_PASS("SANITIZE is not implemented."); return; } logging(LOG_VERBOSE, "Verify that we have BlockDeviceCharacteristics " "VPD page."); if (inq_bdc == NULL) { logging(LOG_NORMAL, "[FAILED] SANITIZE BLOCK ERASE opcode is " "supported but BlockDeviceCharacteristics VPD page is " "missing"); CU_FAIL("[FAILED] BlockDeviceCharacteristics VPD " "page is missing"); } logging(LOG_VERBOSE, "Verify that we have READCAPACITY16"); if (!rc16) { logging(LOG_NORMAL, "[FAILED] SANITIZE BLOCK ERASE opcode is " "supported but READCAPACITY16 is missing."); CU_FAIL("[FAILED] READCAPACITY16 is missing"); } logging(LOG_VERBOSE, "Verify that logical block provisioning (LBPME) " "is available."); if (!rc16 || !(rc16->lbpme)) { logging(LOG_NORMAL, "[FAILED] SANITIZE BLOCK ERASE opcode is " "supported but LBPME==0."); CU_FAIL("[FAILED] SANITIZE BLOCK ERASE opcode is " "supported but LBPME==0."); } logging(LOG_VERBOSE, "Check MediumRotationRate whether this is a HDD " "or a SSD device."); if (inq_bdc && inq_bdc->medium_rotation_rate != 0) { logging(LOG_NORMAL, "This is a HDD device"); logging(LOG_NORMAL, "[WARNING] SANITIZE BLOCK ERASE opcode is " "supported but MediumRotationRate is not 0 " "indicating that this is a HDD. Only SSDs should " "implement BLOCK ERASE"); } else { logging(LOG_NORMAL, "This is a HDD device"); } logging(LOG_VERBOSE, "Write 'a' to the first 256 LBAs"); memset(scratch, 'a', 256 * block_size); WRITE16(sd, 0, 256 * block_size, block_size, 0, 0, 0, 0, 0, scratch, EXPECT_STATUS_GOOD); logging(LOG_VERBOSE, "Write 'a' to the last 256 LBAs"); WRITE16(sd, num_blocks - 256, 256 * block_size, block_size, 0, 0, 0, 0, 0, scratch, EXPECT_STATUS_GOOD); logging(LOG_VERBOSE, "Test we can perform basic BLOCK ERASE SANITIZE"); SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL, EXPECT_STATUS_GOOD); logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped."); check_lun_is_wiped(buf, 0); logging(LOG_VERBOSE, "Check that the last 256 LBAs are wiped."); check_lun_is_wiped(buf, num_blocks - 256); data.size = 8; data.data = alloca(data.size); memset(data.data, 0, data.size); logging(LOG_VERBOSE, "BLOCK_ERASE parameter list length must be 0"); logging(LOG_VERBOSE, "Test that non-zero param length is an error for " "BLOCK ERASE"); SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 8, &data, EXPECT_INVALID_FIELD_IN_CDB); if (inq_bdc) { logging(LOG_VERBOSE, "Check WABEREQ setting and that READ " "after SANITIZE works correctly."); check_wabereq(); } logging(LOG_VERBOSE, "Verify that all blocks are unmapped after " "SANITIZE BLOCK_ERASE"); check_unmap(); }
void test_sanitize_overwrite(void) { int i, ret; struct iscsi_data data; struct scsi_command_descriptor *cd; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test SANITIZE OVERWRITE"); CHECK_FOR_SANITIZE; CHECK_FOR_DATALOSS; logging(LOG_VERBOSE, "Check that SANITIZE OVERWRITE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_OVERWRITE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE OVERWRITE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); CU_PASS("SANITIZE is not implemented."); return; } logging(LOG_VERBOSE, "Verify that we have BlockDeviceCharacteristics " "VPD page."); if (inq_bdc == NULL) { logging(LOG_NORMAL, "[FAILED] SANITIZE OVERWRITE opcode is " "supported but BlockDeviceCharacteristics VPD page is " "missing"); CU_FAIL("[FAILED] BlockDeviceCharacteristics VPD " "page is missing"); } logging(LOG_VERBOSE, "Check MediumRotationRate whether this is a HDD " "or a SSD device."); if (inq_bdc && inq_bdc->medium_rotation_rate == 0) { logging(LOG_NORMAL, "This is a HDD device"); logging(LOG_NORMAL, "[WARNING] SANITIZE OVERWRITE opcode is " "supported but MediumRotationRate is 0 " "indicating that this is an SSD. Only HDDs should " "implement OVERWRITE"); } else { logging(LOG_NORMAL, "This is a SSD device"); } logging(LOG_VERBOSE, "Write 'a' to the first 256 LBAs"); init_lun_with_data(0); logging(LOG_VERBOSE, "Write 'a' to the last 256 LBAs"); init_lun_with_data(num_blocks - 256); logging(LOG_VERBOSE, "Test SANITIZE OVERWRITE with initialization pattern of one full block"); data.size = block_size + 4; data.data = alloca(data.size); memset(&data.data[4], 0xaa, block_size); data.data[0] = 0x01; data.data[1] = 0x00; data.data[2] = block_size >> 8; data.data[3] = block_size & 0xff; ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, EXPECT_STATUS_GOOD); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped."); check_lun_is_wiped(0, 0xaa); logging(LOG_VERBOSE, "Check that the last 256 LBAs are wiped."); check_lun_is_wiped(num_blocks - 256, 0xaa); logging(LOG_VERBOSE, "Test SANITIZE OVERWRITE with initialization pattern of one half block"); data.size = block_size / 2 + 4; data.data[2] = (block_size / 2) >> 8; data.data[3] = (block_size / 2 ) & 0xff; ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, EXPECT_STATUS_GOOD); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Test SANITIZE OVERWRITE with initialization pattern of 4 bytes"); data.size = 4 + 4; data.data[2] = 0; data.data[3] = 4; ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, EXPECT_STATUS_GOOD); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "OVERWRITE parameter list length must " "be > 4 and < blocksize+5"); for (i = 0; i < 5; i++) { logging(LOG_VERBOSE, "Test OVERWRITE with ParamLen:%d is an " "error.", i); ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, i, &data, EXPECT_INVALID_FIELD_IN_CDB); if (ret == -2) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not " "implemented."); CU_PASS("SANITIZE is not implemented."); return; } else { CU_ASSERT_EQUAL(ret, 0); } } logging(LOG_VERBOSE, "Test OVERWRITE with ParamLen:%zd (blocksize+5) " "is an error.", block_size + 5); data.size = block_size + 8; data.data = alloca(block_size + 8); /* so we can send IP > blocksize */ memset(data.data, 0, data.size); ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, block_size + 5, &data, EXPECT_INVALID_FIELD_IN_CDB); if (ret == -2) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not " "implemented."); CU_PASS("SANITIZE is not implemented."); return; } else { CU_ASSERT_EQUAL(ret, 0); } logging(LOG_VERBOSE, "Test OVERWRITE COUNT == 0 is an error"); data.size = block_size + 4; data.data[0] = 0x00; data.data[1] = 0x00; data.data[2] = block_size >> 8; data.data[3] = block_size & 0xff; ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, EXPECT_INVALID_FIELD_IN_CDB); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Test INITIALIZATION PATTERN LENGTH == 0 is an " "error"); data.size = block_size + 4; data.data[0] = 0x00; data.data[1] = 0x00; data.data[2] = 0x00; data.data[3] = 0x00; ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, EXPECT_INVALID_FIELD_IN_CDB); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Test INITIALIZATION PATTERN LENGTH == %zd > %zd " "(blocksize) is an error", block_size + 4, block_size); data.size = block_size + 4; data.data[0] = 0x00; data.data[1] = 0x00; data.data[2] = (block_size + 4) >> 8; data.data[3] = (block_size + 4) & 0xff; ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, EXPECT_INVALID_FIELD_IN_CDB); CU_ASSERT_EQUAL(ret, 0); }
void test_sanitize_reset(void) { int ret; struct scsi_command_descriptor *cd; struct scsi_task *sanitize_task; struct scsi_task *rl_task; struct iscsi_data data; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test SANITIZE with Task/Lun/Target/Session reset"); CHECK_FOR_SANITIZE; CHECK_FOR_DATALOSS; if (sd->iscsi_ctx == NULL) { const char *err = "[SKIPPED] This SANITIZE test is only " "supported for iSCSI backends"; logging(LOG_NORMAL, "%s", err); CU_PASS(err); return; } logging(LOG_VERBOSE, "Check that SANITIZE OVERWRITE will continue " "even after Task/Lun/Target/* reset."); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_OVERWRITE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE OVERWRITE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); CU_PASS("SANITIZE is not implemented."); return; } logging(LOG_VERBOSE, "Send an asyncronous SANITIZE to the target."); data.size = block_size + 4; data.data = alloca(data.size); memset(&data.data[4], 0, block_size); data.data[0] = 0x01; data.data[1] = 0x00; data.data[2] = block_size >> 8; data.data[3] = block_size & 0xff; sanitize_task = iscsi_sanitize_task(sd->iscsi_ctx, sd->iscsi_lun, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, sanitize_cb, NULL); CU_ASSERT_NOT_EQUAL(sanitize_task, NULL); /* just send something so that we know the sanitize command is sent * to the target */ rl_task = iscsi_reportluns_sync(sd->iscsi_ctx, 0, 64); if (rl_task) { scsi_free_scsi_task(rl_task); } logging(LOG_VERBOSE, "Sleep for three seconds incase the target is " "slow to start the SANITIZE"); sleep(3); logging(LOG_VERBOSE, "Verify that the SANITIZE has started and that " "TESTUNITREADY fails with SANITIZE_IN_PROGRESS"); TESTUNITREADY(sd, EXPECT_SANITIZE); logging(LOG_VERBOSE, "Verify that STARTSTOPUNIT fails with " "SANITIZE_IN_PROGRESS"); STARTSTOPUNIT(sd, 1, 0, 1, 0, 1, 0, EXPECT_SANITIZE); logging(LOG_VERBOSE, "Verify that READ16 fails with " "SANITIZE_IN_PROGRESS"); READ16(sd, NULL, 0, block_size, block_size, 0, 0, 0, 0, 0, NULL, EXPECT_SANITIZE); logging(LOG_VERBOSE, "Verify that INQUIRY is still allowed while " "SANITIZE is in progress"); ret = inquiry(sd, NULL, 0, 0, 255, EXPECT_STATUS_GOOD); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Send an ABORT TASK"); ret = iscsi_task_mgmt_abort_task_sync(sd->iscsi_ctx, sanitize_task); if (ret != 0) { logging(LOG_NORMAL, "ABORT TASK failed. %s", iscsi_get_error(sd->iscsi_ctx)); } logging(LOG_VERBOSE, "Send an ABORT TASK SET"); ret = iscsi_task_mgmt_abort_task_set_sync(sd->iscsi_ctx, sd->iscsi_lun); if (ret != 0) { logging(LOG_NORMAL, "ABORT TASK SET failed. %s", iscsi_get_error(sd->iscsi_ctx)); } logging(LOG_VERBOSE, "Send a LUN Reset"); ret = iscsi_task_mgmt_lun_reset_sync(sd->iscsi_ctx, sd->iscsi_lun); if (ret != 0) { logging(LOG_NORMAL, "LUN reset failed. %s", iscsi_get_error(sd->iscsi_ctx)); } logging(LOG_VERBOSE, "Send a Warm Reset"); ret = iscsi_task_mgmt_target_warm_reset_sync(sd->iscsi_ctx); if (ret != 0) { logging(LOG_NORMAL, "Warm reset failed. %s", iscsi_get_error(sd->iscsi_ctx)); } logging(LOG_VERBOSE, "Send a Cold Reset"); ret = iscsi_task_mgmt_target_cold_reset_sync(sd->iscsi_ctx); if (ret != 0) { logging(LOG_NORMAL, "Cold reset failed. %s", iscsi_get_error(sd->iscsi_ctx)); } logging(LOG_VERBOSE, "Disconnect from the target."); iscsi_destroy_context(sd->iscsi_ctx); logging(LOG_VERBOSE, "Sleep for one seconds incase the target is " "slow to reset"); sleep(1); logging(LOG_VERBOSE, "Reconnect to target"); sd->iscsi_ctx = iscsi_context_login(initiatorname1, sd->iscsi_url, &sd->iscsi_lun); if (sd->iscsi_ctx == NULL) { logging(LOG_VERBOSE, "Failed to login to target"); return; } logging(LOG_VERBOSE, "Verify that the SANITIZE is still going."); TESTUNITREADY(sd, EXPECT_SANITIZE); logging(LOG_VERBOSE, "Wait until the SANITIZE operation has finished"); while (testunitready_clear_ua(sd)) { sleep(60); } }
void test_sanitize_readonly(void) { int ret; struct iscsi_data data; struct scsi_command_descriptor *cd; struct scsi_device sd2; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test SANITIZE with READONLY devices"); CHECK_FOR_SANITIZE; CHECK_FOR_DATALOSS; if (sd->iscsi_ctx == NULL) { const char *err = "[SKIPPED] This SANITIZE test is only " "supported for iSCSI backends"; logging(LOG_NORMAL, "%s", err); CU_PASS(err); return; } logging(LOG_VERBOSE, "Create a second connection to the target"); memset(&sd2, 0, sizeof(sd2)); sd2.iscsi_url = sd->iscsi_url; sd2.iscsi_lun = sd->iscsi_lun; sd2.iscsi_ctx = iscsi_context_login(initiatorname2, sd2.iscsi_url, &sd2.iscsi_lun); if (sd2.iscsi_ctx == NULL) { logging(LOG_VERBOSE, "Failed to login to target"); return; } logging(LOG_VERBOSE, "Set Software Write Protect on the second connection"); ret = set_swp(&sd2); CU_ASSERT_EQUAL(ret, 0); if (ret != 0) { return; } logging(LOG_VERBOSE, "Use TESTUNITREADY to clear unit attention on " "first connection"); while (testunitready_clear_ua(sd)) { sleep(1); } logging(LOG_VERBOSE, "Check if SANITIZE OVERWRITE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_OVERWRITE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE OVERWRITE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); } else { logging(LOG_VERBOSE, "Test SANITIZE OVERWRITE with " "initialization pattern of one full block"); data.size = block_size + 4; data.data = alloca(data.size); memset(&data.data[4], 0xaa, block_size); data.data[0] = 0x01; data.data[1] = 0x00; data.data[2] = block_size >> 8; data.data[3] = block_size & 0xff; ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data, EXPECT_WRITE_PROTECTED); CU_ASSERT_EQUAL(ret, 0); } logging(LOG_VERBOSE, "Check if SANITIZE BLOCK_ERASE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_BLOCK_ERASE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE BLOCK_ERASE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); } else { logging(LOG_VERBOSE, "Test SANITIZE BLOCK_ERASE"); ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL, EXPECT_WRITE_PROTECTED); CU_ASSERT_EQUAL(ret, 0); } logging(LOG_VERBOSE, "Check if SANITIZE CRYPTO_ERASE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_CRYPTO_ERASE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE CRYPTO_ERASE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); } else { logging(LOG_VERBOSE, "Test SANITIZE CRYPTO_ERASE"); ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL, EXPECT_WRITE_PROTECTED); CU_ASSERT_EQUAL(ret, 0); } logging(LOG_VERBOSE, "Clear Software Write Protect on the second connection"); ret = clear_swp(&sd2); logging(LOG_VERBOSE, "Use TESTUNITREADY to clear unit attention on " "first connection"); while (testunitready_clear_ua(sd)) { sleep(1); } iscsi_destroy_context(sd2.iscsi_ctx); }
void test_sanitize_reservations(void) { int ret; struct iscsi_data data; struct scsi_command_descriptor *cd; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test SANITIZE with RESERVATIONS"); CHECK_FOR_SANITIZE; CHECK_FOR_DATALOSS; logging(LOG_VERBOSE, "Create a second connection to the target"); iscsic2 = iscsi_context_login(initiatorname1, tgt_url, &tgt_lun); if (iscsic2 == NULL) { logging(LOG_VERBOSE, "Failed to login to target"); return; } logging(LOG_VERBOSE, "Take out a RESERVE6 from the second " "initiator"); ret = reserve6(iscsic2, tgt_lun); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Check if SANITIZE OVERWRITE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_OVERWRITE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE OVERWRITE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); } else { logging(LOG_VERBOSE, "Test SANITIZE OVERWRITE with " "initialization pattern of one full block"); data.size = block_size + 4; data.data = alloca(data.size); memset(&data.data[4], 0xaa, block_size); data.data[0] = 0x01; data.data[1] = 0x00; data.data[2] = block_size >> 8; data.data[3] = block_size & 0xff; ret = sanitize_conflict(iscsic, tgt_lun, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data); CU_ASSERT_EQUAL(ret, 0); } logging(LOG_VERBOSE, "Check if SANITIZE BLOCK_ERASE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_BLOCK_ERASE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE BLOCK_ERASE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); } else { logging(LOG_VERBOSE, "Test SANITIZE BLOCK_ERASE"); ret = sanitize_conflict(iscsic, tgt_lun, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL); CU_ASSERT_EQUAL(ret, 0); } logging(LOG_VERBOSE, "Check if SANITIZE CRYPTO_ERASE is supported " "in REPORT_SUPPORTED_OPCODES"); cd = get_command_descriptor(SCSI_OPCODE_SANITIZE, SCSI_SANITIZE_CRYPTO_ERASE); if (cd == NULL) { logging(LOG_NORMAL, "[SKIPPED] SANITIZE CRYPTO_ERASE is not " "implemented according to REPORT_SUPPORTED_OPCODES."); } else { logging(LOG_VERBOSE, "Test SANITIZE CRYPTO_ERASE"); ret = sanitize_conflict(iscsic, tgt_lun, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL); CU_ASSERT_EQUAL(ret, 0); } iscsi_destroy_context(iscsic2); iscsic2 = NULL; }