int
librbd_discard(struct rbd_ctx *ctx, uint64_t off, uint64_t len)
{
int ret;
ret = rbd_discard(ctx->image, off, len);
if (ret < 0) {
prt("rbd_discard(%llu, %llu) failed\n", off, len);
return ret;
}
return 0;
}
void
do_punch_hole(unsigned offset, unsigned length)
{
unsigned end_offset;
int max_offset = 0;
int max_len = 0;
int ret;
if (length == 0) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping zero length punch hole\n");
log4(OP_SKIPPED, OP_PUNCH_HOLE, offset, length);
return;
}
if (file_size <= (loff_t)offset) {
if (!quiet && testcalls > simulatedopcount)
prt("skipping hole punch off the end of the file\n");
log4(OP_SKIPPED, OP_PUNCH_HOLE, offset, length);
return;
}
end_offset = offset + length;
log4(OP_PUNCH_HOLE, offset, length, 0);
if (testcalls <= simulatedopcount)
return;
if ((progressinterval && testcalls % progressinterval == 0) ||
(debug && (monitorstart == -1 || monitorend == -1 ||
end_offset <= monitorend))) {
prt("%lu punch\tfrom 0x%x to 0x%x, (0x%x bytes)\n", testcalls,
offset, offset+length, length);
}
if ((ret = rbd_discard(image, (unsigned long long) offset,
(unsigned long long) length)) < 0) {
prt("%punch hole: %x to %x\n", offset, length);
prterrcode("do_punch_hole: discard", ret);
report_failure(161);
}
max_offset = offset < file_size ? offset : file_size;
max_len = max_offset + length <= file_size ? length :
file_size - max_offset;
memset(good_buf + max_offset, '\0', max_len);
}
static void bs_rbd_request(struct scsi_cmd *cmd)
{
int ret;
uint32_t length;
int result = SAM_STAT_GOOD;
uint8_t key;
uint16_t asc;
#if 0
/*
* This should go in the sense data on error for COMPARE_AND_WRITE, but
* there doesn't seem to be any attempt to do so...
*/
uint32_t info = 0;
#endif
char *tmpbuf;
size_t blocksize;
uint64_t offset = cmd->offset;
uint32_t tl = cmd->tl;
int do_verify = 0;
int i;
char *ptr;
const char *write_buf = NULL;
ret = length = 0;
key = asc = 0;
struct active_rbd *rbd = RBDP(cmd->dev->fd);
switch (cmd->scb[0]) {
case ORWRITE_16:
length = scsi_get_out_length(cmd);
tmpbuf = malloc(length);
if (!tmpbuf) {
result = SAM_STAT_CHECK_CONDITION;
key = HARDWARE_ERROR;
asc = ASC_INTERNAL_TGT_FAILURE;
break;
}
ret = rbd_read(rbd->rbd_image, offset, length, tmpbuf);
if (ret != length) {
set_medium_error(&result, &key, &asc);
free(tmpbuf);
break;
}
ptr = scsi_get_out_buffer(cmd);
for (i = 0; i < length; i++)
ptr[i] |= tmpbuf[i];
free(tmpbuf);
write_buf = scsi_get_out_buffer(cmd);
goto write;
case COMPARE_AND_WRITE:
/* Blocks are transferred twice, first the set that
* we compare to the existing data, and second the set
* to write if the compare was successful.
*/
length = scsi_get_out_length(cmd) / 2;
if (length != cmd->tl) {
result = SAM_STAT_CHECK_CONDITION;
key = ILLEGAL_REQUEST;
asc = ASC_INVALID_FIELD_IN_CDB;
break;
}
tmpbuf = malloc(length);
if (!tmpbuf) {
result = SAM_STAT_CHECK_CONDITION;
key = HARDWARE_ERROR;
asc = ASC_INTERNAL_TGT_FAILURE;
break;
}
ret = rbd_read(rbd->rbd_image, offset, length, tmpbuf);
if (ret != length) {
set_medium_error(&result, &key, &asc);
free(tmpbuf);
break;
}
if (memcmp(scsi_get_out_buffer(cmd), tmpbuf, length)) {
uint32_t pos = 0;
char *spos = scsi_get_out_buffer(cmd);
char *dpos = tmpbuf;
/*
* Data differed, this is assumed to be 'rare'
* so use a much more expensive byte-by-byte
* comparasion to find out at which offset the
* data differs.
*/
for (pos = 0; pos < length && *spos++ == *dpos++;
pos++)
;
#if 0
/* See comment above at declaration */
info = pos;
#endif
result = SAM_STAT_CHECK_CONDITION;
key = MISCOMPARE;
asc = ASC_MISCOMPARE_DURING_VERIFY_OPERATION;
free(tmpbuf);
break;
}
/* no DPO bit (cache retention advice) support */
free(tmpbuf);
write_buf = scsi_get_out_buffer(cmd) + length;
goto write;
case SYNCHRONIZE_CACHE:
case SYNCHRONIZE_CACHE_16:
/* TODO */
length = (cmd->scb[0] == SYNCHRONIZE_CACHE) ? 0 : 0;
if (cmd->scb[1] & 0x2) {
result = SAM_STAT_CHECK_CONDITION;
key = ILLEGAL_REQUEST;
asc = ASC_INVALID_FIELD_IN_CDB;
} else
bs_sync_sync_range(cmd, length, &result, &key, &asc);
break;
case WRITE_VERIFY:
case WRITE_VERIFY_12:
case WRITE_VERIFY_16:
do_verify = 1;
case WRITE_6:
case WRITE_10:
case WRITE_12:
case WRITE_16:
length = scsi_get_out_length(cmd);
write_buf = scsi_get_out_buffer(cmd);
write:
ret = rbd_write(rbd->rbd_image, offset, length, write_buf);
if (ret == length) {
struct mode_pg *pg;
/*
* it would be better not to access to pg
* directy.
*/
pg = find_mode_page(cmd->dev, 0x08, 0);
if (pg == NULL) {
result = SAM_STAT_CHECK_CONDITION;
key = ILLEGAL_REQUEST;
asc = ASC_INVALID_FIELD_IN_CDB;
break;
}
if (((cmd->scb[0] != WRITE_6) && (cmd->scb[1] & 0x8)) ||
!(pg->mode_data[0] & 0x04))
bs_sync_sync_range(cmd, length, &result, &key,
&asc);
} else
set_medium_error(&result, &key, &asc);
if (do_verify)
goto verify;
break;
case WRITE_SAME:
case WRITE_SAME_16:
/* WRITE_SAME used to punch hole in file */
if (cmd->scb[1] & 0x08) {
ret = rbd_discard(rbd->rbd_image, offset, tl);
if (ret != 0) {
eprintf("Failed to punch hole for WRITE_SAME"
" command\n");
result = SAM_STAT_CHECK_CONDITION;
key = HARDWARE_ERROR;
asc = ASC_INTERNAL_TGT_FAILURE;
break;
}
break;
}
while (tl > 0) {
blocksize = 1 << cmd->dev->blk_shift;
tmpbuf = scsi_get_out_buffer(cmd);
switch (cmd->scb[1] & 0x06) {
case 0x02: /* PBDATA==0 LBDATA==1 */
put_unaligned_be32(offset, tmpbuf);
break;
case 0x04: /* PBDATA==1 LBDATA==0 */
/* physical sector format */
put_unaligned_be64(offset, tmpbuf);
break;
}
ret = rbd_write(rbd->rbd_image, offset, blocksize,
tmpbuf);
if (ret != blocksize)
set_medium_error(&result, &key, &asc);
offset += blocksize;
tl -= blocksize;
}
break;
case READ_6:
case READ_10:
case READ_12:
case READ_16:
length = scsi_get_in_length(cmd);
ret = rbd_read(rbd->rbd_image, offset, length,
scsi_get_in_buffer(cmd));
if (ret != length)
set_medium_error(&result, &key, &asc);
break;
case PRE_FETCH_10:
case PRE_FETCH_16:
break;
case VERIFY_10:
case VERIFY_12:
case VERIFY_16:
verify:
length = scsi_get_out_length(cmd);
tmpbuf = malloc(length);
if (!tmpbuf) {
result = SAM_STAT_CHECK_CONDITION;
key = HARDWARE_ERROR;
asc = ASC_INTERNAL_TGT_FAILURE;
break;
}
ret = rbd_read(rbd->rbd_image, offset, length, tmpbuf);
if (ret != length)
set_medium_error(&result, &key, &asc);
else if (memcmp(scsi_get_out_buffer(cmd), tmpbuf, length)) {
result = SAM_STAT_CHECK_CONDITION;
key = MISCOMPARE;
asc = ASC_MISCOMPARE_DURING_VERIFY_OPERATION;
}
free(tmpbuf);
break;
case UNMAP:
if (!cmd->dev->attrs.thinprovisioning) {
result = SAM_STAT_CHECK_CONDITION;
key = ILLEGAL_REQUEST;
asc = ASC_INVALID_FIELD_IN_CDB;
break;
}
length = scsi_get_out_length(cmd);
tmpbuf = scsi_get_out_buffer(cmd);
if (length < 8)
break;
length -= 8;
tmpbuf += 8;
while (length >= 16) {
offset = get_unaligned_be64(&tmpbuf[0]);
offset = offset << cmd->dev->blk_shift;
tl = get_unaligned_be32(&tmpbuf[8]);
tl = tl << cmd->dev->blk_shift;
if (offset + tl > cmd->dev->size) {
eprintf("UNMAP beyond EOF\n");
result = SAM_STAT_CHECK_CONDITION;
key = ILLEGAL_REQUEST;
asc = ASC_LBA_OUT_OF_RANGE;
break;
}
if (tl > 0) {
if (rbd_discard(rbd->rbd_image, offset, tl)
!= 0) {
eprintf("Failed to punch hole for"
" UNMAP at offset:%" PRIu64
" length:%d\n",
offset, tl);
result = SAM_STAT_CHECK_CONDITION;
key = HARDWARE_ERROR;
asc = ASC_INTERNAL_TGT_FAILURE;
break;
}
}
length -= 16;
tmpbuf += 16;
}
break;
default:
break;
}
dprintf("io done %p %x %d %u\n", cmd, cmd->scb[0], ret, length);
scsi_set_result(cmd, result);
if (result != SAM_STAT_GOOD) {
eprintf("io error %p %x %d %d %" PRIu64 ", %m\n",
cmd, cmd->scb[0], ret, length, offset);
sense_data_build(cmd, key, asc);
}
}
