/* Invokes a SCSI READ BUFFER(10) command (spc5r02). Return of 0 -> success,
* various SG_LIB_CAT_* positive values or -1 -> other errors */
static int
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, int 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) {
fprintf(stderr, " Read buffer(10) cdb: ");
for (k = 0; k < SG_READ_BUFFER_10_CMDLEN; ++k)
fprintf(stderr, "%02x ", rb10_cb[k]);
fprintf(stderr, "\n");
}
ptvp = construct_scsi_pt_obj();
if (NULL == ptvp) {
fprintf(stderr, "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, (unsigned char *)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)
;
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)) {
fprintf(stderr, " Read buffer(10): response%s\n",
(ret > 256 ? ", first 256 bytes" : ""));
dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
}
ret = 0;
}
if (residp)
*residp = get_scsi_pt_resid(ptvp);
destruct_scsi_pt_obj(ptvp);
return ret;
}
/* Invokes a SCSI LOG SELECT command. Return of 0 -> success,
* various SG_LIB_CAT_* positive values or -1 -> other errors */
int
sg_ll_log_select(int sg_fd, int pcr, int sp, int pc, int pg_code,
int subpg_code, unsigned char * paramp, int param_len,
int noisy, int verbose)
{
static const char * const cdb_name_s = "log select";
int res, ret, k, sense_cat;
unsigned char logs_cdb[LOG_SELECT_CMDLEN] =
{LOG_SELECT_CMD, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned char sense_b[SENSE_BUFF_LEN];
struct sg_pt_base * ptvp;
if (param_len > 0xffff) {
pr2ws("%s: param_len too big\n", cdb_name_s);
return -1;
}
logs_cdb[1] = (unsigned char)((pcr ? 2 : 0) | (sp ? 1 : 0));
logs_cdb[2] = (unsigned char)(((pc << 6) & 0xc0) | (pg_code & 0x3f));
logs_cdb[3] = (unsigned char)(subpg_code & 0xff);
sg_put_unaligned_be16((int16_t)param_len, logs_cdb + 7);
if (verbose) {
pr2ws(" %s cdb: ", cdb_name_s);
for (k = 0; k < LOG_SELECT_CMDLEN; ++k)
pr2ws("%02x ", logs_cdb[k]);
pr2ws("\n");
}
if ((verbose > 1) && (param_len > 0)) {
pr2ws(" %s parameter list\n", cdb_name_s);
dStrHexErr((const char *)paramp, param_len, -1);
}
if (NULL == ((ptvp = create_pt_obj(cdb_name_s))))
return -1;
set_scsi_pt_cdb(ptvp, logs_cdb, sizeof(logs_cdb));
set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
set_scsi_pt_data_out(ptvp, paramp, param_len);
res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
ret = sg_cmds_process_resp(ptvp, cdb_name_s, 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;
}
/* Invokes a SCSI MODE SELECT (10) command. Return of 0 -> success,
* various SG_LIB_CAT_* positive values or -1 -> other errors */
int
sg_ll_mode_select10(int sg_fd, int pf, int sp, void * paramp, int param_len,
int noisy, int verbose)
{
static const char * const cdb_name_s = "mode select(10)";
int res, ret, k, sense_cat;
unsigned char modes_cdb[MODE_SELECT10_CMDLEN] =
{MODE_SELECT10_CMD, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned char sense_b[SENSE_BUFF_LEN];
struct sg_pt_base * ptvp;
modes_cdb[1] = (unsigned char)(((pf << 4) & 0x10) | (sp & 0x1));
sg_put_unaligned_be16((int16_t)param_len, modes_cdb + 7);
if (param_len > 0xffff) {
pr2ws("%s: param_len too big\n", cdb_name_s);
return -1;
}
if (verbose) {
pr2ws(" %s cdb: ", cdb_name_s);
for (k = 0; k < MODE_SELECT10_CMDLEN; ++k)
pr2ws("%02x ", modes_cdb[k]);
pr2ws("\n");
}
if (verbose > 1) {
pr2ws(" %s parameter list\n", cdb_name_s);
dStrHexErr((const char *)paramp, param_len, -1);
}
if (NULL == ((ptvp = create_pt_obj(cdb_name_s))))
return -1;
set_scsi_pt_cdb(ptvp, modes_cdb, sizeof(modes_cdb));
set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
set_scsi_pt_data_out(ptvp, (unsigned char *)paramp, param_len);
res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
ret = sg_cmds_process_resp(ptvp, cdb_name_s, 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;
}
/* Invokes a SCSI REPORT TIMESTAMP command. Return of 0 -> success,
* various SG_LIB_CAT_* positive values or -1 -> other errors */
static int
sg_ll_rep_timestamp(int sg_fd, void * resp, int mx_resp_len, int * residp,
int noisy, int verbose)
{
int k, ret, res, sense_cat;
unsigned char rtCmdBlk[REP_TIMESTAMP_CMDLEN] =
{SG_MAINTENANCE_IN, REP_TIMESTAMP_SA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned char sense_b[SENSE_BUFF_LEN];
struct sg_pt_base * ptvp;
sg_put_unaligned_be32((uint32_t)mx_resp_len, rtCmdBlk + 6);
if (verbose) {
pr2serr(" Report timestamp cdb: ");
for (k = 0; k < REP_TIMESTAMP_CMDLEN; ++k)
pr2serr("%02x ", rtCmdBlk[k]);
pr2serr("\n");
}
ptvp = construct_scsi_pt_obj();
if (NULL == ptvp) {
pr2serr("%s: out of memory\n", __func__);
return -1;
}
set_scsi_pt_cdb(ptvp, rtCmdBlk, sizeof(rtCmdBlk));
set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
ret = sg_cmds_process_resp(ptvp, "report timestamp", res, mx_resp_len,
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;
k = get_scsi_pt_resid(ptvp);
if (residp)
*residp = k;
if ((verbose > 2) && ((mx_resp_len - k) > 0)) {
pr2serr("Parameter data returned:\n");
dStrHexErr((const char *)resp, mx_resp_len - k,
((verbose > 3) ? -1 : 1));
}
destruct_scsi_pt_obj(ptvp);
return ret;
}
/* Invokes the SET TIMESTAMP command. Return of 0 -> success, various
* SG_LIB_CAT_* positive values or -1 -> other errors */
static int
sg_ll_set_timestamp(int sg_fd, void * paramp, int param_len, int noisy,
int verbose)
{
int k, ret, res, sense_cat;
unsigned char stCmdBlk[SET_TIMESTAMP_CMDLEN] =
{SG_MAINTENANCE_OUT, SET_TIMESTAMP_SA, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0};
unsigned char sense_b[SENSE_BUFF_LEN];
struct sg_pt_base * ptvp;
sg_put_unaligned_be32(param_len, stCmdBlk + 6);
if (verbose) {
pr2serr(" Set timestamp cdb: ");
for (k = 0; k < SET_TIMESTAMP_CMDLEN; ++k)
pr2serr("%02x ", stCmdBlk[k]);
pr2serr("\n");
if ((verbose > 1) && paramp && param_len) {
pr2serr(" set timestamp parameter list:\n");
dStrHexErr((const char *)paramp, 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, stCmdBlk, sizeof(stCmdBlk));
set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
set_scsi_pt_data_out(ptvp, (unsigned char *)paramp, param_len);
res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
ret = sg_cmds_process_resp(ptvp, "set timestamp", 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;
}
/* Invokes a SCSI MODE SENSE (10) command. Return of 0 -> success,
* various SG_LIB_CAT_* positive values or -1 -> other errors */
int
sg_ll_mode_sense10(int sg_fd, int llbaa, int dbd, int pc, int pg_code,
int sub_pg_code, void * resp, int mx_resp_len,
int noisy, int verbose)
{
static const char * const cdb_name_s = "mode sense(10)";
int res, ret, k, sense_cat, resid;
unsigned char modes_cdb[MODE_SENSE10_CMDLEN] =
{MODE_SENSE10_CMD, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned char sense_b[SENSE_BUFF_LEN];
struct sg_pt_base * ptvp;
modes_cdb[1] = (unsigned char)((dbd ? 0x8 : 0) | (llbaa ? 0x10 : 0));
modes_cdb[2] = (unsigned char)(((pc << 6) & 0xc0) | (pg_code & 0x3f));
modes_cdb[3] = (unsigned char)(sub_pg_code & 0xff);
sg_put_unaligned_be16((int16_t)mx_resp_len, modes_cdb + 7);
if (mx_resp_len > 0xffff) {
pr2ws("mx_resp_len too big\n");
return -1;
}
if (verbose) {
pr2ws(" %s cdb: ", cdb_name_s);
for (k = 0; k < MODE_SENSE10_CMDLEN; ++k)
pr2ws("%02x ", modes_cdb[k]);
pr2ws("\n");
}
if (NULL == ((ptvp = create_pt_obj(cdb_name_s))))
return -1;
set_scsi_pt_cdb(ptvp, modes_cdb, sizeof(modes_cdb));
set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
set_scsi_pt_data_in(ptvp, (unsigned char *)resp, mx_resp_len);
res = do_scsi_pt(ptvp, sg_fd, DEF_PT_TIMEOUT, verbose);
ret = sg_cmds_process_resp(ptvp, cdb_name_s, res, mx_resp_len, sense_b,
noisy, verbose, &sense_cat);
resid = get_scsi_pt_resid(ptvp);
destruct_scsi_pt_obj(ptvp);
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 {
if ((verbose > 2) && (ret > 0)) {
pr2ws(" %s: response", cdb_name_s);
if (3 == verbose) {
pr2ws("%s:\n", (ret > 256 ? ", first 256 bytes" : ""));
dStrHexErr((const char *)resp, (ret > 256 ? 256 : ret), -1);
} else {
pr2ws(":\n");
dStrHexErr((const char *)resp, ret, 0);
}
}
ret = 0;
}
if (resid > 0) {
if (resid > mx_resp_len) {
pr2ws("%s: resid (%d) should never exceed requested len=%d\n",
cdb_name_s, resid, mx_resp_len);
return ret ? ret : SG_LIB_CAT_MALFORMED;
}
/* zero unfilled section of response buffer */
memset((unsigned char *)resp + (mx_resp_len - resid), 0, resid);
}
return ret;
}
static int
do_wscan(char letter, int show_bt, int scsi_scan)
{
int k, j, n;
struct storage_elem * sp;
if (scsi_scan < 2) {
k = enum_pds();
if (k)
return k;
k = enum_cdroms();
if (k)
return k;
k = enum_tapes();
if (k)
return k;
k = enum_volumes(letter);
if (k)
return k;
for (k = 0; k < next_unused_elem; ++k) {
sp = storage_arr + k;
if ('\0' == sp->name[0])
continue;
printf("%-7s ", sp->name);
n = strlen(sp->volume_letters);
if (0 == n)
printf(" ");
else if (1 == n)
printf("[%s] ", sp->volume_letters);
else if (2 == n)
printf("[%s] ", sp->volume_letters);
else if (3 == n)
printf("[%s] ", sp->volume_letters);
else if (4 == n)
printf("[%s] ", sp->volume_letters);
else
printf("[%4s+] ", sp->volume_letters);
if (sp->qp_descriptor_valid) {
if (show_bt)
printf("<%s> ",
get_bus_type(sp->qp_descriptor.desc.BusType));
j = sp->qp_descriptor.desc.VendorIdOffset;
if (j > 0)
printf("%s ", sp->qp_descriptor.raw + j);
j = sp->qp_descriptor.desc.ProductIdOffset;
if (j > 0)
printf("%s ", sp->qp_descriptor.raw + j);
j = sp->qp_descriptor.desc.ProductRevisionOffset;
if (j > 0)
printf("%s ", sp->qp_descriptor.raw + j);
j = sp->qp_descriptor.desc.SerialNumberOffset;
if (j > 0)
printf("%s", sp->qp_descriptor.raw + j);
printf("\n");
if (verbose > 2)
dStrHexErr(sp->qp_descriptor.raw, 144, 0);
} else
printf("\n");
if ((verbose > 3) && sp->qp_uid_valid) {
printf(" UID valid, in hex:\n");
dStrHexErr(sp->qp_uid.raw, sizeof(sp->qp_uid.raw), 1);
}
}
}
if (scsi_scan) {
if (scsi_scan < 2)
printf("\n");
enum_scsi_adapters();
}
return 0;
}
int
main(int argc, char *argv[])
{
int ret = 0;
int res_cat, status, slen, k, ret2;
int sg_fd = -1;
struct sg_pt_base *ptvp = NULL;
unsigned char sense_buffer[32];
unsigned char * dxfer_buffer_in = NULL;
unsigned char * dxfer_buffer_out = NULL;
unsigned char *wrkBuf = NULL;
struct opts_t opts;
struct opts_t * op;
char b[128];
op = &opts;
memset(op, 0, sizeof(opts));
op->timeout = DEFAULT_TIMEOUT;
ret = process_cl(op, argc, argv);
if (ret != 0) {
usage();
goto done;
} else if (op->do_help) {
usage();
goto done;
} else if (op->do_version) {
version();
goto done;
}
sg_fd = scsi_pt_open_device(op->device_name, op->readonly,
op->do_verbose);
if (sg_fd < 0) {
fprintf(stderr, "%s: %s\n", op->device_name, safe_strerror(-sg_fd));
ret = SG_LIB_FILE_ERROR;
goto done;
}
ptvp = construct_scsi_pt_obj();
if (ptvp == NULL) {
fprintf(stderr, "out of memory\n");
ret = SG_LIB_CAT_OTHER;
goto done;
}
if (op->do_verbose) {
fprintf(stderr, " cdb to send: ");
for (k = 0; k < op->cdb_length; ++k)
fprintf(stderr, "%02x ", op->cdb[k]);
fprintf(stderr, "\n");
if (op->do_verbose > 2) {
sg_get_command_name(op->cdb, 0, sizeof(b) - 1, b);
b[sizeof(b) - 1] = '\0';
fprintf(stderr, " Command name: %s\n", b);
}
}
set_scsi_pt_cdb(ptvp, op->cdb, op->cdb_length);
set_scsi_pt_sense(ptvp, sense_buffer, sizeof(sense_buffer));
if (op->do_dataout) {
dxfer_buffer_out = fetch_dataout(op);
if (dxfer_buffer_out == NULL) {
ret = SG_LIB_CAT_OTHER;
goto done;
}
set_scsi_pt_data_out(ptvp, dxfer_buffer_out, op->dataout_len);
}
if (op->do_datain) {
dxfer_buffer_in = my_memalign(op->datain_len, &wrkBuf);
if (dxfer_buffer_in == NULL) {
perror("malloc");
ret = SG_LIB_CAT_OTHER;
goto done;
}
set_scsi_pt_data_in(ptvp, dxfer_buffer_in, op->datain_len);
}
ret = do_scsi_pt(ptvp, sg_fd, op->timeout, op->do_verbose);
if (ret > 0) {
if (SCSI_PT_DO_BAD_PARAMS == ret) {
fprintf(stderr, "do_scsi_pt: bad pass through setup\n");
ret = SG_LIB_CAT_OTHER;
} else if (SCSI_PT_DO_TIMEOUT == ret) {
fprintf(stderr, "do_scsi_pt: timeout\n");
ret = SG_LIB_CAT_TIMEOUT;
} else
ret = SG_LIB_CAT_OTHER;
goto done;
} else if (ret < 0) {
fprintf(stderr, "do_scsi_pt: %s\n", safe_strerror(-ret));
ret = SG_LIB_CAT_OTHER;
goto done;
}
slen = 0;
res_cat = get_scsi_pt_result_category(ptvp);
switch (res_cat) {
case SCSI_PT_RESULT_GOOD:
ret = 0;
break;
case SCSI_PT_RESULT_SENSE:
slen = get_scsi_pt_sense_len(ptvp);
ret = sg_err_category_sense(sense_buffer, slen);
break;
case SCSI_PT_RESULT_TRANSPORT_ERR:
get_scsi_pt_transport_err_str(ptvp, sizeof(b), b);
fprintf(stderr, ">>> transport error: %s\n", b);
ret = SG_LIB_CAT_OTHER;
break;
case SCSI_PT_RESULT_OS_ERR:
get_scsi_pt_os_err_str(ptvp, sizeof(b), b);
fprintf(stderr, ">>> os error: %s\n", b);
ret = SG_LIB_CAT_OTHER;
break;
default:
fprintf(stderr, ">>> unknown pass through result category (%d)\n",
res_cat);
ret = SG_LIB_CAT_OTHER;
break;
}
status = get_scsi_pt_status_response(ptvp);
fprintf(stderr, "SCSI Status: ");
sg_print_scsi_status(status);
fprintf(stderr, "\n\n");
if ((SAM_STAT_CHECK_CONDITION == status) && (! op->no_sense)) {
if (SCSI_PT_RESULT_SENSE != res_cat)
slen = get_scsi_pt_sense_len(ptvp);
if (0 == slen)
fprintf(stderr, ">>> Strange: status is CHECK CONDITION but no "
"Sense Information\n");
else {
fprintf(stderr, "Sense Information:\n");
sg_print_sense(NULL, sense_buffer, slen, (op->do_verbose > 0));
fprintf(stderr, "\n");
}
}
if (SAM_STAT_RESERVATION_CONFLICT == status)
ret = SG_LIB_CAT_RES_CONFLICT;
if (op->do_datain) {
int data_len = op->datain_len - get_scsi_pt_resid(ptvp);
if (ret && !(SG_LIB_CAT_RECOVERED == ret ||
SG_LIB_CAT_NO_SENSE == ret))
fprintf(stderr, "Error %d occurred, no data received\n", ret);
else if (data_len == 0) {
fprintf(stderr, "No data received\n");
} else {
if (op->datain_file == NULL && !op->datain_binary) {
fprintf(stderr, "Received %d bytes of data:\n", data_len);
dStrHexErr((const char *)dxfer_buffer_in, data_len, 0);
} else {
const char * cp = "stdout";
if (op->datain_file &&
! ((1 == strlen(op->datain_file)) &&
('-' == op->datain_file[0])))
cp = op->datain_file;
fprintf(stderr, "Writing %d bytes of data to %s\n", data_len,
cp);
ret2 = write_dataout(op->datain_file, dxfer_buffer_in,
data_len);
if (0 != ret2) {
if (0 == ret)
ret = ret2;
goto done;
}
}
}
}
done:
if (op->do_verbose) {
sg_get_category_sense_str(ret, sizeof(b), b, op->do_verbose - 1);
fprintf(stderr, "%s\n", b);
}
if (wrkBuf)
free(wrkBuf);
if (ptvp)
destruct_scsi_pt_obj(ptvp);
if (sg_fd >= 0)
scsi_pt_close_device(sg_fd);
return ret;
}
/* 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;
}