/* Invokes a SCSI INQUIRY command and yields the response. Returns 0 when
* successful, various SG_LIB_CAT_* positive values, negated errno or
* -1 -> other errors. The CMDDT field is obsolete in the INQUIRY cdb. */
int
sg_ll_inquiry(int sg_fd, bool cmddt, bool evpd, int pg_op, void * resp,
int mx_resp_len, bool noisy, int verbose)
{
int ret;
struct sg_pt_base * ptvp;
ptvp = construct_scsi_pt_obj_with_fd(sg_fd, verbose);
if (NULL == ptvp)
return sg_convert_errno(ENOMEM);
ret = sg_ll_inquiry_com(ptvp, cmddt, evpd, pg_op, resp, mx_resp_len,
0 /* timeout_sec */, NULL, noisy, verbose);
destruct_scsi_pt_obj(ptvp);
return ret;
}
/* Invokes a SCSI INQUIRY command and yields the response. Returns 0 when
* successful, various SG_LIB_CAT_* positive values or -1 -> other errors.
* The CMDDT field is obsolete in the INQUIRY cdb (since spc3r16 in 2003) so
* an argument to set it has been removed (use the REPORT SUPPORTED OPERATION
* CODES command instead). Adds the ability to set the command abort timeout
* and the ability to report the residual count. If timeout_secs is zero
* or less the default command abort timeout (60 seconds) is used.
* If residp is non-NULL then the residual value is written where residp
* points. A residual value of 0 implies mx_resp_len bytes have be written
* where resp points. If the residual value equals mx_resp_len then no
* bytes have been written. */
int
sg_ll_inquiry_v2(int sg_fd, bool evpd, int pg_op, void * resp,
int mx_resp_len, int timeout_secs, int * residp,
bool noisy, int verbose)
{
int ret;
struct sg_pt_base * ptvp;
ptvp = construct_scsi_pt_obj_with_fd(sg_fd, verbose);
if (NULL == ptvp)
return sg_convert_errno(ENOMEM);
ret = sg_ll_inquiry_com(ptvp, false, evpd, pg_op, resp, mx_resp_len,
timeout_secs, residp, noisy, verbose);
destruct_scsi_pt_obj(ptvp);
return ret;
}
int
sg_ll_start_stop_unit(int sg_fd, bool immed, int pc_mod__fl_num,
int power_cond, bool noflush__fl, bool loej, bool start,
bool noisy, int verbose)
{
int ret;
struct sg_pt_base * ptvp;
ptvp = construct_scsi_pt_obj_with_fd(sg_fd, verbose);
if (NULL == ptvp)
return sg_convert_errno(ENOMEM);
ret = sg_ll_start_stop_unit_pt(ptvp, immed, pc_mod__fl_num, power_cond,
noflush__fl, loej, start, noisy, verbose);
destruct_scsi_pt_obj(ptvp);
return ret;
}
struct sg_pt_base *
construct_scsi_pt_obj()
{
return construct_scsi_pt_obj_with_fd(-1, 0);
}
int
main(int argc, char * argv[])
{
bool start_tm_valid = false;
int k, res, progress, pr, rem, num_done;
int err = 0;
int ret = 0;
int sg_fd = -1;
int64_t elapsed_usecs = 0;
#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
struct timespec start_tm, end_tm;
#elif defined(HAVE_GETTIMEOFDAY)
struct timeval start_tm, end_tm;
#endif
struct loop_res_t loop_res;
struct loop_res_t * resp = &loop_res;
struct sg_pt_base * ptvp = NULL;
struct opts_t opts;
struct opts_t * op = &opts;
memset(op, 0, sizeof(opts));
memset(resp, 0, sizeof(loop_res));
op->do_number = 1;
res = parse_cmd_line(op, argc, argv);
if (res)
return res;
if (op->do_help) {
usage_for(op);
return 0;
}
#ifdef DEBUG
pr2serr("In DEBUG mode, ");
if (op->verbose_given && op->version_given) {
pr2serr("but override: '-vV' given, zero verbose and continue\n");
op->verbose_given = false;
op->version_given = false;
op->verbose = 0;
} else if (! op->verbose_given) {
pr2serr("set '-vv'\n");
op->verbose = 2;
} else
pr2serr("keep verbose=%d\n", op->verbose);
#else
if (op->verbose_given && op->version_given)
pr2serr("Not in DEBUG mode, so '-vV' has no special action\n");
#endif
if (op->version_given) {
pr2serr("Version string: %s\n", version_str);
return 0;
}
if (NULL == op->device_name) {
pr2serr("No DEVICE argument given\n");
usage_for(op);
return SG_LIB_SYNTAX_ERROR;
}
if ((sg_fd = sg_cmds_open_device(op->device_name, true /* ro */,
op->verbose)) < 0) {
pr2serr("%s: error opening file: %s: %s\n", __func__,
op->device_name, safe_strerror(-sg_fd));
ret = sg_convert_errno(-sg_fd);
goto fini;
}
ptvp = construct_scsi_pt_obj_with_fd(sg_fd, op->verbose);
if ((NULL == ptvp) || ((err = get_scsi_pt_os_err(ptvp)))) {
pr2serr("%s: unable to construct pt object\n", __func__);
ret = sg_convert_errno(err ? err : ENOMEM);
goto fini;
}
if (op->do_progress) {
for (k = 0; k < op->do_number; ++k) {
if (k > 0)
sleep_for(30);
progress = -1;
res = sg_ll_test_unit_ready_progress_pt(ptvp, k, &progress,
(1 == op->do_number), op->verbose);
if (progress < 0) {
ret = res;
break;
} else {
pr = (progress * 100) / 65536;
rem = ((progress * 100) % 65536) / 656;
printf("Progress indication: %d.%02d%% done\n", pr, rem);
}
}
if (op->do_number > 1)
printf("Completed %d Test Unit Ready commands\n",
((k < op->do_number) ? k + 1 : k));
} else { /* --progress not given */
#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
if (op->do_time) {
start_tm.tv_sec = 0;
start_tm.tv_nsec = 0;
if (0 == clock_gettime(CLOCK_MONOTONIC, &start_tm))
start_tm_valid = true;
else
perror("clock_gettime(CLOCK_MONOTONIC)\n");
}
#elif defined(HAVE_GETTIMEOFDAY)
if (op->do_time) {
start_tm.tv_sec = 0;
start_tm.tv_usec = 0;
gettimeofday(&start_tm, NULL);
start_tm_valid = true;
}
#else
start_tm_valid = false;
#endif
num_done = loop_turs(ptvp, resp, op);
if (op->do_time && start_tm_valid) {
#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
if (start_tm.tv_sec || start_tm.tv_nsec) {
res = clock_gettime(CLOCK_MONOTONIC, &end_tm);
if (res < 0) {
err = errno;
perror("clock_gettime");
if (EINVAL == err)
pr2serr("clock_gettime(CLOCK_MONOTONIC) not "
"supported\n");
}
elapsed_usecs = (end_tm.tv_sec - start_tm.tv_sec) * 1000000;
/* Note: (end_tm.tv_nsec - start_tm.tv_nsec) may be negative */
elapsed_usecs += (end_tm.tv_nsec - start_tm.tv_nsec) / 1000;
}
#elif defined(HAVE_GETTIMEOFDAY)
if (start_tm.tv_sec || start_tm.tv_usec) {
gettimeofday(&end_tm, NULL);
elapsed_usecs = (end_tm.tv_sec - start_tm.tv_sec) * 1000000;
elapsed_usecs += (end_tm.tv_usec - start_tm.tv_usec);
}
#endif
if (elapsed_usecs > 0) {
int64_t nom = num_done;
printf("time to perform commands was %u.%06u secs",
(unsigned)(elapsed_usecs / 1000000),
(unsigned)(elapsed_usecs % 1000000));
nom *= 1000000; /* scale for integer division */
printf("; %d operations/sec\n", (int)(nom / elapsed_usecs));
} else
printf("Recorded 0 or less elapsed microseconds ??\n");
}
if (((op->do_number > 1) || (resp->num_errs > 0)) &&
(! resp->reported))
printf("Completed %d Test Unit Ready commands with %d errors\n",
op->do_number, resp->num_errs);
if (1 == op->do_number)
ret = resp->ret;
}
fini:
if (ptvp)
destruct_scsi_pt_obj(ptvp);
if (sg_fd >= 0)
sg_cmds_close_device(sg_fd);
return (ret >= 0) ? ret : SG_LIB_CAT_OTHER;
}
