admin/libiscsi
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

TESTS: Test that WRITESAME10/16 unmap can handle big number of logical blocks when unmapping.

Browse Source 
If  BLockLimits->MaxWriteSameLength is 0 (no limit) or >=256
then verify that both WRITESAME10 and WRITESAME16 can unmap with a
number of blocks == 2 byte field.
If not, then verify that a 256 block unmap results in INVALID FIELD IN CDB

If  BLockLimits->MaxWriteSameLength is 0 (no limit) or >=65536
then verify that WRITESAME16 can unmap with a
number of blocks == 3 byte field.
If not, then verify that a 65536 block unmap results in INVALID FIELD IN CDB

From discussions on linux-scsi there are devices that support WRITESAME16
but where the implementation only looks at the low 2 bytes of the 4 bytes for
num-blocks in the CDB.
This added test aims to find and flag such devices.
This commit is contained in:
Ronnie Sahlberg
2013-05-15 19:50:41 -07:00
parent 8c22f8d986
commit 864bf81c56
6 changed files with 279 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test-tool/iscsi-support.c
View File

@@ -48,6 +48,7 @@ const char *tgt_url;
struct scsi_inquiry_standard *inq;
struct scsi_inquiry_logical_block_provisioning *inq_lbp;
struct scsi_inquiry_block_limits *inq_bl;
struct scsi_readcapacity16 *rc16;
size_t block_size;

1
test-tool/iscsi-support.h
View File

@@ -130,6 +130,7 @@ do { \
extern struct scsi_inquiry_standard *inq;
extern struct scsi_inquiry_logical_block_provisioning *inq_lbp;
extern struct scsi_inquiry_block_limits *inq_bl;
extern struct scsi_readcapacity16 *rc16;
extern size_t block_size;

29
test-tool/iscsi-test-cu.c
View File

@@ -865,6 +865,7 @@ main(int argc, char *argv[])
struct scsi_readcapacity10 *rc10;
struct scsi_task *inq_task = NULL;
struct scsi_task *inq_lbp_task = NULL;
struct scsi_task *inq_bl_task = NULL;
struct scsi_task *rc16_task = NULL;
int full_size;
int is_usb;
@@ -1051,6 +1052,31 @@ main(int argc, char *argv[])
}
}
/* try reading block limits vpd */
inq_bl_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, 64);
if (inq_bl_task && inq_bl_task->status != SCSI_STATUS_GOOD) {
scsi_free_scsi_task(inq_bl_task);
inq_bl_task = NULL;
}
if (inq_bl_task) {
full_size = scsi_datain_getfullsize(inq_bl_task);
if (full_size > inq_bl_task->datain.size) {
scsi_free_scsi_task(inq_lbp_task);
if ((inq_bl_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS, full_size)) == NULL) {
printf("Inquiry command failed : %s\n", iscsi_get_error(iscsic));
return -1;
}
}
inq_bl = scsi_datain_unmarshall(inq_bl_task);
if (inq_bl == NULL) {
printf("failed to unmarshall inquiry datain blob\n");
return -1;
}
}
/* if thin provisioned we also need to read the VPD page for it */
if (rc16 && rc16->lbpme != 0){
inq_lbp_task = iscsi_inquiry_sync(iscsic, lun, 1, SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING, 64);
@@ -1141,6 +1167,9 @@ main(int argc, char *argv[])
if (inq_task != NULL) {
scsi_free_scsi_task(inq_task);
}
if (inq_bl_task != NULL) {
scsi_free_scsi_task(inq_bl_task);
}
if (inq_lbp_task != NULL) {
scsi_free_scsi_task(inq_lbp_task);
}

24
test-tool/test_inquiry_block_limits.c
View File

@@ -28,7 +28,7 @@ void
test_inquiry_block_limits(void)
{
int ret;
struct scsi_inquiry_block_limits *inq_bl;
struct scsi_inquiry_block_limits *bl;
struct scsi_task *bl_task = NULL;
struct scsi_inquiry_logical_block_provisioning *lbp = NULL;
struct scsi_task *lbp_task = NULL;
@@ -44,8 +44,8 @@ test_inquiry_block_limits(void)
64, &bl_task);
CU_ASSERT_EQUAL(ret, 0);
inq_bl = scsi_datain_unmarshall(bl_task);
if (inq_bl == NULL) {
bl = scsi_datain_unmarshall(bl_task);
if (bl == NULL) {
logging(LOG_NORMAL, "[FAILURE] failed to unmarshall inquiry "
"datain blob.");
CU_FAIL("[FAILURE] failed to unmarshall inquiry "
@@ -125,36 +125,36 @@ test_inquiry_block_limits(void)
logging(LOG_VERBOSE, "Device claims UNMAP support via LBPU");
logging(LOG_VERBOSE, "Verify that MAXIMUM UNMAP LBA COUNT is "
"not 0");
CU_ASSERT_NOT_EQUAL(inq_bl->max_unmap, 0);
CU_ASSERT_NOT_EQUAL(bl->max_unmap, 0);
logging(LOG_VERBOSE, "Verify that MAXIMUM UNMAP LBA COUNT is "
"at least 2^LBPPBE");
CU_ASSERT_EQUAL(inq_bl->max_unmap >= (1U << rc16->lbppbe), 1);
CU_ASSERT_EQUAL(bl->max_unmap >= (1U << rc16->lbppbe), 1);
if (inq_bl->max_unmap != 0xffffffff) {
if (bl->max_unmap != 0xffffffff) {
logging(LOG_VERBOSE, "Verify that MAXIMUM UNMAP LBA "
"COUNT is not insanely big");
CU_ASSERT_EQUAL(inq_bl->max_unmap <= 1024*1024, 0);
CU_ASSERT_EQUAL(bl->max_unmap <= 1024*1024, 0);
}
logging(LOG_VERBOSE, "Verify that MAXIMUM UNMAP BLOCK "
"DESCRIPTOR COUNT is not 0");
CU_ASSERT_NOT_EQUAL(inq_bl->max_unmap_bdc, 0);
if (inq_bl->max_unmap_bdc != 0xffffffff) {
CU_ASSERT_NOT_EQUAL(bl->max_unmap_bdc, 0);
if (bl->max_unmap_bdc != 0xffffffff) {
logging(LOG_VERBOSE, "Verify that MAXIMUM UNMAP "
"BLOCK DESCRIPTOR COUNT is not insanely big");
CU_ASSERT_EQUAL(inq_bl->max_unmap_bdc <= 1024*1024, 0);
CU_ASSERT_EQUAL(bl->max_unmap_bdc <= 1024*1024, 0);
}
} else {
logging(LOG_VERBOSE, "Device does not claim UNMAP support via "
"LBPU");
logging(LOG_VERBOSE, "Verify that MAXIMUM UNMAP LBA COUNT is "
"0");
CU_ASSERT_EQUAL(inq_bl->max_unmap, 0);
CU_ASSERT_EQUAL(bl->max_unmap, 0);
logging(LOG_VERBOSE, "Verify that MAXIMUM UNMAP BLOCK "
"DESCRIPTOR COUNT is 0");
CU_ASSERT_EQUAL(inq_bl->max_unmap_bdc, 0);
CU_ASSERT_EQUAL(bl->max_unmap_bdc, 0);
}

183
test-tool/test_writesame10_unmap.c
View File

@@ -16,6 +16,7 @@
*/
#include <stdio.h>
#include <alloca.h>
#include <CUnit/CUnit.h>
@@ -30,6 +31,7 @@ test_writesame10_unmap(void)
{
int i, ret;
unsigned int j;
unsigned char *buf = malloc(block_size * 256);
CHECK_FOR_DATALOSS;
CHECK_FOR_THIN_PROVISIONING;
@@ -37,9 +39,118 @@ test_writesame10_unmap(void)
CHECK_FOR_SBC;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the start of the LUN");
logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the start of "
"the LUN");
for (i = 1; i <= 256; i++) {
unsigned char *buf = malloc(block_size * i);
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write10(iscsic, tgt_lun, 0,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
logging(LOG_VERBOSE, "LBPRZ is set. Read the unmapped "
"blocks back and verify they are all zero");
logging(LOG_VERBOSE, "Read %d blocks and verify they "
"are now zero", i);
ret = read10(iscsic, tgt_lun, 0,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
for (j = 0; j < block_size * i; j++) {
if (buf[j] != 0) {
CU_ASSERT_EQUAL(buf[j], 0);
}
}
} else {
logging(LOG_VERBOSE, "LBPRZ is clear. Skip the read "
"and verify zero test");
}
}
logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the end of "
"the LUN");
for (i = 1; i <= 256; i++) {
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write10(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10(iscsic, tgt_lun, num_blocks - i,
block_size, i,
0, 1, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
logging(LOG_VERBOSE, "LBPRZ is set. Read the unmapped "
"blocks back and verify they are all zero");
logging(LOG_VERBOSE, "Read %d blocks and verify they "
"are now zero", i);
ret = read10(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
for (j = 0; j < block_size * i; j++) {
if (buf[j] != 0) {
CU_ASSERT_EQUAL(buf[j], 0);
}
}
} else {
logging(LOG_VERBOSE, "LBPRZ is clear. Skip the read "
"and verify zero test");
}
}
logging(LOG_VERBOSE, "Verify that WRITESAME10 ANCHOR==1 + UNMAP==0 is "
"invalid");
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 0, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
if (inq_lbp->anc_sup) {
logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0");
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, NULL);
} else {
logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0 no "
"ANC_SUP so expecting to fail");
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, NULL);
}
CU_ASSERT_EQUAL(ret, 0);
if (inq_bl == NULL) {
logging(LOG_VERBOSE, "[FAILED] WRITESAME10 works but "
"BlockLimits VPD is missing.");
CU_FAIL("[FAILED] WRITESAME10 works but "
"BlockLimits VPD is missing.");
free(buf);
return;
}
i = 256;
if (inq_bl->max_ws_len == 0 || inq_bl->max_ws_len >= 256) {
logging(LOG_VERBOSE, "Block Limits VPD page reports MAX_WS_LEN "
"as either 0 (==no limit) or >= 256. Test Unmapping "
"256 blocks to verify that it can handle 2-byte "
"lengths");
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
@@ -72,68 +183,16 @@ test_writesame10_unmap(void)
logging(LOG_VERBOSE, "LBPRZ is clear. Skip the read "
"and verify zero test");
}
free(buf);
}
logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the end of the LUN");
for (i = 1; i <= 256; i++) {
unsigned char *buf = malloc(block_size * i);
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write10(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
} else {
logging(LOG_VERBOSE, "Block Limits VPD page reports MAX_WS_LEN "
"as <256. Verify that a 256 block unmap fails with "
"INVALID_FIELD_IN_CDB.");
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10(iscsic, tgt_lun, num_blocks - i,
block_size, i,
0, 1, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
logging(LOG_VERBOSE, "LBPRZ is set. Read the unmapped "
"blocks back and verify they are all zero");
logging(LOG_VERBOSE, "Read %d blocks and verify they "
"are now zero", i);
ret = read10(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
for (j = 0; j < block_size * i; j++) {
if (buf[j] != 0) {
CU_ASSERT_EQUAL(buf[j], 0);
}
}
} else {
logging(LOG_VERBOSE, "LBPRZ is clear. Skip the read "
"and verify zero test");
}
free(buf);
}
logging(LOG_VERBOSE, "Verify that WRITESAME10 ANCHOR==1 + UNMAP==0 is invalid");
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 0, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
if (inq_lbp->anc_sup) {
logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0");
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, NULL);
} else {
logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0 no ANC_SUP so expecting to fail");
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, NULL);
block_size, i,
0, 1, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
}
CU_ASSERT_EQUAL(ret, 0);
free(buf);
}

117
test-tool/test_writesame16_unmap.c
View File

@@ -16,7 +16,6 @@
*/
#include <stdio.h>
#include <alloca.h>
#include <CUnit/CUnit.h>
@@ -31,7 +30,7 @@ test_writesame16_unmap(void)
{
int i, ret;
unsigned int j;
unsigned char *buf = alloca(256 * block_size);
unsigned char *buf = malloc(block_size * 65536);
CHECK_FOR_DATALOSS;
@@ -55,6 +54,7 @@ test_writesame16_unmap(void)
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
free(buf);
return;
}
CU_ASSERT_EQUAL(ret, 0);
@@ -135,4 +135,117 @@ test_writesame16_unmap(void)
CU_ASSERT_EQUAL(ret, 0);
if (inq_bl == NULL) {
logging(LOG_VERBOSE, "[FAILED] WRITESAME16 works but "
"BlockLimits VPD is missing.");
CU_FAIL("[FAILED] WRITESAME10 works but "
"BlockLimits VPD is missing.");
free(buf);
return;
}
i = 256;
if (inq_bl->max_ws_len == 0 || inq_bl->max_ws_len >= 256) {
logging(LOG_VERBOSE, "Block Limits VPD page reports MAX_WS_LEN "
"as either 0 (==no limit) or >= 256. Test Unmapping "
"256 blocks to verify that it can handle 2-byte "
"lengths");
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write10(iscsic, tgt_lun, 0,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
logging(LOG_VERBOSE, "LBPRZ is set. Read the unmapped "
"blocks back and verify they are all zero");
logging(LOG_VERBOSE, "Read %d blocks and verify they "
"are now zero", i);
ret = read10(iscsic, tgt_lun, 0,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
for (j = 0; j < block_size * i; j++) {
if (buf[j] != 0) {
CU_ASSERT_EQUAL(buf[j], 0);
}
}
} else {
logging(LOG_VERBOSE, "LBPRZ is clear. Skip the read "
"and verify zero test");
}
} else {
logging(LOG_VERBOSE, "Block Limits VPD page reports MAX_WS_LEN "
"as <256. Verify that a 256 block unmap fails with "
"INVALID_FIELD_IN_CDB.");
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
}
i = 65536;
if (inq_bl->max_ws_len == 0 || inq_bl->max_ws_len >= 256) {
logging(LOG_VERBOSE, "Block Limits VPD page reports MAX_WS_LEN "
"as either 0 (==no limit) or >= 256. Test Unmapping "
"256 blocks to verify that it can handle 2-byte "
"lengths");
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write10(iscsic, tgt_lun, 0,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
logging(LOG_VERBOSE, "LBPRZ is set. Read the unmapped "
"blocks back and verify they are all zero");
logging(LOG_VERBOSE, "Read %d blocks and verify they "
"are now zero", i);
ret = read10(iscsic, tgt_lun, 0,
i * block_size, block_size,
0, 0, 0, 0, 0, buf);
for (j = 0; j < block_size * i; j++) {
if (buf[j] != 0) {
CU_ASSERT_EQUAL(buf[j], 0);
}
}
} else {
logging(LOG_VERBOSE, "LBPRZ is clear. Skip the read "
"and verify zero test");
}
} else {
logging(LOG_VERBOSE, "Block Limits VPD page reports MAX_WS_LEN "
"as <256. Verify that a 256 block unmap fails with "
"INVALID_FIELD_IN_CDB.");
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, NULL);
CU_ASSERT_EQUAL(ret, 0);
}
free(buf);
}