/* Invokes a SCSI READ BUFFER(10) command (spc5r02). Return of 0 -> success,
* various SG_LIB_CAT_* positive values or -1 -> other errors */
static int
sg_ll_read_buffer_10(int sg_fd, int rb_mode, int rb_mode_sp, int rb_id,
uint32_t rb_offset, void * resp, int mx_resp_len,
int * residp, bool noisy, int verbose)
{
int k, ret, res, sense_cat;
uint8_t rb10_cb[SG_READ_BUFFER_10_CMDLEN] =
{SG_READ_BUFFER_10_CMD, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t sense_b[SENSE_BUFF_LEN];
struct sg_pt_base * ptvp;
rb10_cb[1] = (uint8_t)(rb_mode & 0x1f);
if (rb_mode_sp)
rb10_cb[1] |= (uint8_t)((rb_mode_sp & 0x7) << 5);
rb10_cb[2] = (uint8_t)rb_id;
sg_put_unaligned_be24(rb_offset, rb10_cb + 3);
sg_put_unaligned_be24(mx_resp_len, rb10_cb + 6);
if (verbose) {
pr2serr(" Read buffer(10) cdb: ");
for (k = 0; k < SG_READ_BUFFER_10_CMDLEN; ++k)
pr2serr("%02x ", rb10_cb[k]);
pr2serr("\n");
}
ptvp = construct_scsi_pt_obj();
if (NULL == ptvp) {
pr2serr("Read buffer(10): out of memory\n");
return -1;
}
set_scsi_pt_cdb(ptvp, rb10_cb, sizeof(rb10_cb));
set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
set_scsi_pt_data_in(ptvp, (uint8_t *)resp, mx_resp_len);
res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
ret = sg_cmds_process_resp(ptvp, "Read buffer(10)", res, mx_resp_len,
sense_b, noisy, verbose, &sense_cat);
if (-1 == ret)
ret = sg_convert_errno(get_scsi_pt_os_err(ptvp));
else if (-2 == ret) {
switch (sense_cat) {
case SG_LIB_CAT_RECOVERED:
case SG_LIB_CAT_NO_SENSE:
ret = 0;
break;
default:
ret = sense_cat;
break;
}
} else {
if ((verbose > 2) && (ret > 0)) {
pr2serr(" Read buffer(10): response%s\n",
(ret > 256 ? ", first 256 bytes" : ""));
hex2stderr((const uint8_t *)resp, (ret > 256 ? 256 : ret), -1);
}
ret = 0;
}
if (residp)
*residp = get_scsi_pt_resid(ptvp);
destruct_scsi_pt_obj(ptvp);
return ret;
}
static int
sg_build_scsi_cdb(unsigned char * cdbp, int cdb_sz, unsigned int blocks,
int64_t start_block, int write_true, int fua, int dpo)
{
int rd_opcode[] = {0x8, 0x28, 0xa8, 0x88};
int wr_opcode[] = {0xa, 0x2a, 0xaa, 0x8a};
int sz_ind;
memset(cdbp, 0, cdb_sz);
if (dpo)
cdbp[1] |= 0x10;
if (fua)
cdbp[1] |= 0x8;
switch (cdb_sz) {
case 6:
sz_ind = 0;
cdbp[0] = (unsigned char)(write_true ? wr_opcode[sz_ind] :
rd_opcode[sz_ind]);
sg_put_unaligned_be24(0x1fffff & start_block, cdbp + 1);
cdbp[4] = (256 == blocks) ? 0 : (unsigned char)blocks;
if (blocks > 256) {
pr2serr(ME "for 6 byte commands, maximum number of blocks is "
"256\n");
return 1;
}
if ((start_block + blocks - 1) & (~0x1fffff)) {
pr2serr(ME "for 6 byte commands, can't address blocks beyond "
"%d\n", 0x1fffff);
return 1;
}
if (dpo || fua) {
pr2serr(ME "for 6 byte commands, neither dpo nor fua bits "
"supported\n");
return 1;
}
break;
case 10:
sz_ind = 1;
cdbp[0] = (unsigned char)(write_true ? wr_opcode[sz_ind] :
rd_opcode[sz_ind]);
sg_put_unaligned_be32((uint32_t)start_block, cdbp + 2);
sg_put_unaligned_be16((uint16_t)blocks, cdbp + 7);
if (blocks & (~0xffff)) {
pr2serr(ME "for 10 byte commands, maximum number of blocks is "
"%d\n", 0xffff);
return 1;
}
break;
case 12:
sz_ind = 2;
cdbp[0] = (unsigned char)(write_true ? wr_opcode[sz_ind] :
rd_opcode[sz_ind]);
sg_put_unaligned_be32((uint32_t)start_block, cdbp + 2);
sg_put_unaligned_be32((uint32_t)blocks, cdbp + 6);
break;
case 16:
sz_ind = 3;
cdbp[0] = (unsigned char)(write_true ? wr_opcode[sz_ind] :
rd_opcode[sz_ind]);
sg_put_unaligned_be64((uint64_t)start_block, cdbp + 2);
sg_put_unaligned_be32((uint32_t)blocks, cdbp + 10);
break;
default:
pr2serr(ME "expected cdb size of 6, 10, 12, or 16 but got %d\n",
cdb_sz);
return 1;
}
return 0;
}
int write_buffer (int sg_fd, unsigned ssize)
{
uint8_t wb_cdb[] = {WRITE_BUFFER, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int bufSize = ssize + addwrite;
uint8_t * free_wbBuff = NULL;
uint8_t * wbBuff = (uint8_t *)sg_memalign(bufSize, 0, &free_wbBuff,
false);
uint8_t sense_buffer[32];
struct sg_io_hdr io_hdr;
int k, res;
if (NULL == wbBuff)
return -1;
memset(wbBuff, 0, bufSize);
do_fill_buffer ((int*)wbBuff, ssize);
wb_cdb[1] = RWB_MODE_DATA;
sg_put_unaligned_be24((uint32_t)bufSize, wb_cdb + 6);
memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
io_hdr.interface_id = 'S';
io_hdr.cmd_len = sizeof(wb_cdb);
io_hdr.mx_sb_len = sizeof(sense_buffer);
io_hdr.dxfer_direction = SG_DXFER_TO_DEV;
io_hdr.dxfer_len = bufSize;
io_hdr.dxferp = wbBuff;
io_hdr.cmdp = wb_cdb;
io_hdr.sbp = sense_buffer;
io_hdr.pack_id = 1;
io_hdr.timeout = 60000; /* 60000 millisecs == 60 seconds */
if (verbose) {
pr2serr(" write buffer [mode data] cdb: ");
for (k = 0; k < (int)sizeof(wb_cdb); ++k)
pr2serr("%02x ", wb_cdb[k]);
pr2serr("\n");
}
if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
perror(ME "SG_IO WRITE BUFFER data error");
free(wbBuff);
return -1;
}
/* now for the error processing */
res = sg_err_category3(&io_hdr);
switch (res) {
case SG_LIB_CAT_RECOVERED:
sg_chk_n_print3("WRITE BUFFER data, continuing", &io_hdr, true);
#if defined(__GNUC__)
#if (__GNUC__ >= 7)
__attribute__((fallthrough));
/* FALL THROUGH */
#endif
#endif
case SG_LIB_CAT_CLEAN:
break;
default: /* won't bother decoding other categories */
sg_chk_n_print3("WRITE BUFFER data error", &io_hdr, true);
free(wbBuff);
return res;
}
if (free_wbBuff)
free(free_wbBuff);
return res;
}
/* Invokes a SCSI WRITE BUFFER command (SPC). Return of 0 ->
* success, SG_LIB_CAT_INVALID_OP -> invalid opcode,
* SG_LIB_CAT_ILLEGAL_REQ -> bad field in cdb, SG_LIB_CAT_UNIT_ATTENTION,
* SG_LIB_CAT_NOT_READY -> device not ready, SG_LIB_CAT_ABORTED_COMMAND,
* -1 -> other failure */
static int
sg_ll_write_buffer_v2(int sg_fd, int mode, int m_specific, int buffer_id,
uint32_t buffer_offset, void * paramp,
uint32_t param_len, int to_secs, int noisy, int verbose)
{
int k, res, ret, sense_cat;
uint8_t wbuf_cdb[WRITE_BUFFER_CMDLEN] =
{WRITE_BUFFER_CMD, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t sense_b[SENSE_BUFF_LEN];
struct sg_pt_base * ptvp;
if (buffer_offset > 0xffffff) {
pr2serr("%s: buffer_offset value too large for 24 bits\n", __func__);
return -1;
}
if (param_len > 0xffffff) {
pr2serr("%s: param_len value too large for 24 bits\n", __func__);
return -1;
}
wbuf_cdb[1] = (uint8_t)(mode & 0x1f);
wbuf_cdb[1] |= (uint8_t)((m_specific & 0x7) << 5);
wbuf_cdb[2] = (uint8_t)(buffer_id & 0xff);
sg_put_unaligned_be24(buffer_offset, wbuf_cdb + 3);
sg_put_unaligned_be24(param_len, wbuf_cdb + 6);
if (verbose) {
pr2serr(" Write buffer cdb: ");
for (k = 0; k < WRITE_BUFFER_CMDLEN; ++k)
pr2serr("%02x ", wbuf_cdb[k]);
pr2serr("\n");
if ((verbose > 1) && paramp && param_len) {
pr2serr(" Write buffer parameter list%s:\n",
((param_len > 256) ? " (first 256 bytes)" : ""));
dStrHexErr((const char *)paramp,
((param_len > 256) ? 256 : param_len), -1);
}
}
ptvp = construct_scsi_pt_obj();
if (NULL == ptvp) {
pr2serr("%s: out of memory\n", __func__);
return -1;
}
set_scsi_pt_cdb(ptvp, wbuf_cdb, sizeof(wbuf_cdb));
set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
set_scsi_pt_data_out(ptvp, (uint8_t *)paramp, param_len);
res = do_scsi_pt(ptvp, sg_fd, to_secs, verbose);
ret = sg_cmds_process_resp(ptvp, "Write buffer", res, 0, sense_b,
noisy, verbose, &sense_cat);
if (-1 == ret)
;
else if (-2 == ret) {
switch (sense_cat) {
case SG_LIB_CAT_RECOVERED:
case SG_LIB_CAT_NO_SENSE:
ret = 0;
break;
default:
ret = sense_cat;
break;
}
} else
ret = 0;
destruct_scsi_pt_obj(ptvp);
return ret;
}
