1668 lines
54 KiB
C
1668 lines
54 KiB
C
/*
|
|
* Test code for the extensions to the Linux OS SCSI generic ("sg")
|
|
* device driver.
|
|
* Copyright (C) 1999-2022 D. Gilbert and P. Allworth
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
|
*
|
|
* This program is a specialization of the Unix "dd" command in which
|
|
* one or both of the given files is a scsi generic device. A block size
|
|
* ('bs') is assumed to be 512 if not given. This program complains if
|
|
* 'ibs' or 'obs' are given with some other value than 'bs'.
|
|
* If 'if' is not given or 'if=-' then stdin is assumed. If 'of' is
|
|
* not given of 'of=-' then stdout assumed. The multipliers "c, b, k, m"
|
|
* are recognized on numeric arguments.
|
|
*
|
|
* A non-standard argument "bpt" (blocks per transfer) is added to control
|
|
* the maximum number of blocks in each transfer. The default bpt value is
|
|
* (64 * 1024 * 1024 / bs) or 1 if the first expression is 0. That is an
|
|
* integer division (rounds toward 0). For example if "bs=512" and "bpt=32"
|
|
* are given then a maximum of 32 blocks (16KB in this case) are transferred
|
|
* to or from the sg device in a single SCSI command.
|
|
*
|
|
* BEWARE: If the 'of' file is a 'sg' device (eg a disk) then it _will_
|
|
* be written to, potentially destroying its previous contents.
|
|
*
|
|
* This version should compile with Linux sg drivers with version numbers
|
|
* >= 30000 . Also this version also allows SIGPOLL or a RT signal to be
|
|
* chosen. SIGIO is a synonym for SIGPOLL; SIGIO seems to be deprecated.
|
|
*/
|
|
|
|
/* We need F_SETSIG, (signal redirect), so following define */
|
|
#define _GNU_SOURCE 1
|
|
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdbool.h>
|
|
#include <stdarg.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <poll.h>
|
|
#include <signal.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h> /* for mmap() system call */
|
|
#include <sys/eventfd.h>
|
|
#include <sys/epoll.h>
|
|
#define __STDC_FORMAT_MACROS 1
|
|
#include <inttypes.h>
|
|
|
|
#ifndef HAVE_LINUX_SG_V4_HDR
|
|
/* Kernel uapi header contain __user decorations on user space pointers
|
|
* to indicate they are unsafe in the kernel space. However glibc takes
|
|
* all those __user decorations out from headers in /usr/include/linux .
|
|
* So to stop compile errors when directly importing include/uapi/scsi/sg.h
|
|
* undef __user before doing that include. */
|
|
#define __user
|
|
|
|
/* Want to block the original sg.h header from also being included. That
|
|
* causes lots of multiple definition errors. This will only work if this
|
|
* header is included _before_ the original sg.h header. */
|
|
#define _SCSI_GENERIC_H /* original kernel header guard */
|
|
#define _SCSI_SG_H /* glibc header guard */
|
|
|
|
#include "uapi_sg.h" /* local copy of include/uapi/scsi/sg.h */
|
|
|
|
#else
|
|
#define __user
|
|
#endif /* end of: ifndef HAVE_LINUX_SG_V4_HDR */
|
|
|
|
#include "sg_lib.h"
|
|
#include "sg_linux_inc.h"
|
|
#include "sg_io_linux.h"
|
|
#include "sg_pr2serr.h"
|
|
#include "sg_unaligned.h"
|
|
|
|
|
|
static const char * version_str = "4.24 20221020";
|
|
static const char * my_name = "sgs_dd";
|
|
|
|
#ifndef SGV4_FLAG_POLLED
|
|
#define SGV4_FLAG_POLLED 0x800
|
|
#endif
|
|
|
|
#define DEF_BLOCK_SIZE 512
|
|
#define DEF_BPT_TIMES_BS_SZ (64 * 1024) /* 64 KB */
|
|
|
|
#define SENSE_BUFF_LEN 32 /* Arbitrary, could be larger */
|
|
#define DEF_TIMEOUT 40000 /* 40,000 millisecs == 40 seconds */
|
|
#define S_RW_LEN 10 /* Use SCSI READ(10) and WRITE(10) */
|
|
#define SGQ_MAX_RD_AHEAD 32
|
|
#define SGQ_MAX_WR_AHEAD 32
|
|
#define SGQ_NUM_ELEMS (SGQ_MAX_RD_AHEAD + SGQ_MAX_WR_AHEAD + 1)
|
|
#define MAX_BPT_VALUE (1 << 24) /* used for maximum bs as well */
|
|
#define MAX_COUNT_SKIP_SEEK (1LL << 48) /* coverity wants upper bound */
|
|
|
|
#define SGQ_FREE 0
|
|
#define SGQ_IO_STARTED 1
|
|
#define SGQ_IO_FINISHED 2
|
|
#define SGQ_IO_ERR 3
|
|
#define SGQ_IO_WAIT 4
|
|
|
|
#define SGQ_CAN_DO_NOTHING 0 /* only temporarily in use */
|
|
#define SGQ_CAN_READ 1
|
|
#define SGQ_CAN_WRITE 2
|
|
#define SGQ_TIMEOUT 4
|
|
|
|
#define DEF_SIGTIMEDWAIT_USEC 100
|
|
|
|
|
|
#define STR_SZ 1024
|
|
#define INOUTF_SZ 900
|
|
#define EBUFF_SZ 1024
|
|
|
|
struct flags_t {
|
|
bool dio;
|
|
bool evfd;
|
|
bool excl;
|
|
bool immed;
|
|
bool mmap;
|
|
bool noxfer;
|
|
bool pack;
|
|
bool polled;
|
|
bool tag;
|
|
bool v3;
|
|
bool v4;
|
|
bool given_v3v4;
|
|
};
|
|
|
|
typedef struct request_element
|
|
{
|
|
struct request_element * nextp;
|
|
bool stop_after_wr;
|
|
bool wr;
|
|
int state;
|
|
int blk;
|
|
int num_blks;
|
|
uint8_t * buffp;
|
|
uint8_t * free_buffp;
|
|
sg_io_hdr_t io_hdr;
|
|
struct sg_io_v4 io_v4;
|
|
struct flags_t * iflagp;
|
|
struct flags_t * oflagp;
|
|
uint8_t cmd[S_RW_LEN];
|
|
uint8_t sb[SENSE_BUFF_LEN];
|
|
int result;
|
|
} Rq_elem;
|
|
|
|
typedef struct request_collection
|
|
{
|
|
bool in_is_sg;
|
|
bool out_is_sg;
|
|
bool no_sig;
|
|
bool use_rt_sig;
|
|
bool both_mmap;
|
|
int infd;
|
|
int in_evfd;
|
|
int in_blk; /* most recent read */
|
|
int in_count; /* most recent read */
|
|
int in_done_count; /* count of completed in blocks */
|
|
int in_partial;
|
|
int outfd;
|
|
int out_evfd;
|
|
int lowest_seek;
|
|
int out_blk; /* most recent write */
|
|
int out_count; /* most recent write */
|
|
int out_done_count; /* count of completed out blocks */
|
|
int out_partial;
|
|
int bs;
|
|
int bpt;
|
|
int dio_incomplete;
|
|
int sum_of_resids;
|
|
int poll_ms;
|
|
int pollerr_count;
|
|
int debug; /* also set with -v up to -vvvvv */
|
|
sigset_t blocked_sigs;
|
|
int sigs_waiting;
|
|
int sigs_rt_received;
|
|
int sigs_io_received;
|
|
int blk_poll_count;
|
|
Rq_elem * rd_posp;
|
|
Rq_elem * wr_posp;
|
|
uint8_t * in_mmapp;
|
|
uint8_t * out_mmapp;
|
|
struct flags_t iflag;
|
|
struct flags_t oflag;
|
|
Rq_elem elem[SGQ_NUM_ELEMS];
|
|
} Rq_coll;
|
|
|
|
static bool sgs_old_sg_driver = false; /* true if VERSION_NUM < 4.00.00 */
|
|
static bool sgs_full_v4_sg_driver = false; /* set if VERSION_NUM >= 4.00.30 */
|
|
static bool sgs_nanosec_unit = false;
|
|
|
|
static int sgq_rd_ahead_lim = SGQ_MAX_RD_AHEAD;
|
|
static int sgq_wr_ahead_lim = SGQ_MAX_WR_AHEAD;
|
|
static int sgq_num_elems = (SGQ_MAX_RD_AHEAD + SGQ_MAX_WR_AHEAD + 1);
|
|
|
|
|
|
static void
|
|
usage(int pg_num)
|
|
{
|
|
if (pg_num > 1)
|
|
goto second_page;
|
|
printf("Usage: "
|
|
"sgs_dd [bpt=BPT] [bs=BS] [count=NUM] [deb=DEB] [if=IFILE]\n"
|
|
" [iflag=FLAGS] [no_sig=0|1] [of=OFILE] "
|
|
"[oflag=FLAGS]\n"
|
|
" [poll_ms=MS] [rt_sig=0|1] [seek=SEEK] "
|
|
"[skip=SKIP]\n"
|
|
" [--help] [--version]\n"
|
|
"where:\n"
|
|
" bpt blocks_per_transfer (default: 65536/bs (or 128 for "
|
|
"bs=512))\n"
|
|
" bs must be the logical block size of device (def: 512)\n"
|
|
" deb debug: 0->no debug (def); > 0 -> more debug\n"
|
|
" -v (up to -vvvvv) sets deb value to number of 'v's\n"
|
|
" iflag comma separated list from: dio,evfd,excl,immed,mmap,"
|
|
"noxfer,\n"
|
|
" null,pack,polled,tag,v3,v4 bound to IFILE\n"
|
|
" no_sig 0-> use signals; 1-> no signals, hard polling "
|
|
"instead;\n"
|
|
" default 0, unless polled flag(s) given then it's 1\n"
|
|
" oflag same flags as iflag but bound to OFILE\n"
|
|
" poll_ms number of milliseconds to wait on poll (def: 0)\n"
|
|
" rt_sig 0->use SIGIO (def); 1->use RT sig (SIGRTMIN + 1)\n"
|
|
" <other operands> as per dd command\n\n");
|
|
printf("dd clone for testing Linux sg driver SIGPOLL and/or polling. "
|
|
"Either\nIFILE or OFILE must be a scsi generic device. If OFILE "
|
|
"not given then\n/dev/null assumed (rather than stdout like "
|
|
"dd). Use '-hh' for flag\ninformation.\n");
|
|
return;
|
|
second_page:
|
|
printf("flag description:\n"
|
|
" dio this driver's version of O_DIRECT\n"
|
|
" evfd when poll() gives POLLIN, use eventfd to find "
|
|
"out how many\n"
|
|
" excl open IFILE or OFILE with O_EXCL\n"
|
|
" hipri same as 'polled'; name 'hipri' is deprecated\n"
|
|
" immed use SGV4_FLAG_IMMED flag on each request\n"
|
|
" mmap use mmap()-ed IO on IFILE or OFILE\n"
|
|
" noxfer no transfer between user space and kernel IO "
|
|
"buffers\n"
|
|
" null does nothing, placeholder\n"
|
|
" pack submit with rising pack_id, complete matching "
|
|
"each pack_id\n"
|
|
" polled set POLLED flag and use blk_poll() for completion\n"
|
|
" tag use tag (from block layer) rather than "
|
|
"pack_id\n"
|
|
" v3 use sg v3 interface (default)\n"
|
|
" v4 use sg vr interface (i.e. struct sg_io_v4)\n");
|
|
}
|
|
|
|
static int
|
|
get_mmap_addr(int fd, int num, uint8_t ** mmpp)
|
|
{
|
|
uint8_t * mmp;
|
|
|
|
if (! mmpp)
|
|
return -EINVAL;
|
|
mmp = (uint8_t *)mmap(NULL, num, PROT_READ | PROT_WRITE,
|
|
MAP_SHARED, fd, 0);
|
|
if (MAP_FAILED == mmp) {
|
|
int err = errno;
|
|
|
|
pr2serr("%s%s: sz=%d, fd=%d, mmap() failed: %s\n",
|
|
my_name, __func__, num, fd, strerror(err));
|
|
return -err;
|
|
}
|
|
*mmpp = mmp;
|
|
return 0;
|
|
}
|
|
|
|
/* Return of 0 -> success, -1 -> failure, 2 -> try again */
|
|
static int
|
|
read_capacity(int sg_fd, int * num_sect, int * sect_sz)
|
|
{
|
|
int res;
|
|
uint8_t rcCmdBlk [10] = {0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
uint8_t rcBuff[64];
|
|
uint8_t sense_b[64];
|
|
sg_io_hdr_t io_hdr;
|
|
|
|
memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
|
|
io_hdr.interface_id = 'S';
|
|
io_hdr.cmd_len = sizeof(rcCmdBlk);
|
|
io_hdr.mx_sb_len = sizeof(sense_b);
|
|
io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
|
|
io_hdr.dxfer_len = sizeof(rcBuff);
|
|
io_hdr.dxferp = rcBuff;
|
|
io_hdr.cmdp = rcCmdBlk;
|
|
io_hdr.sbp = sense_b;
|
|
io_hdr.timeout = DEF_TIMEOUT;
|
|
|
|
if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
|
|
res = -errno;
|
|
perror("read_capacity (SG_IO) error");
|
|
return res;
|
|
}
|
|
res = sg_err_category3(&io_hdr);
|
|
if (SG_LIB_CAT_UNIT_ATTENTION == res)
|
|
return 2; /* probably have another go ... */
|
|
else if (SG_LIB_CAT_CLEAN != res) {
|
|
sg_chk_n_print3("read capacity", &io_hdr, true);
|
|
return -1;
|
|
}
|
|
*num_sect = sg_get_unaligned_be32(rcBuff + 0) + 1;
|
|
*sect_sz = sg_get_unaligned_be32(rcBuff + 4);
|
|
return 0;
|
|
}
|
|
|
|
/* -ve -> unrecoverable error, 0 -> successful, 1 -> recoverable (ENOMEM) */
|
|
static int
|
|
sg_start_io(Rq_coll * clp, Rq_elem * rep)
|
|
{
|
|
bool is_wr = rep->wr;
|
|
int res;
|
|
int fd = is_wr ? clp->outfd : clp->infd;
|
|
int num_bytes = clp->bs * rep->num_blks;
|
|
struct flags_t * flagp = is_wr ? rep->oflagp : rep->iflagp;
|
|
sg_io_hdr_t * hp = &rep->io_hdr;
|
|
struct sg_io_v4 * h4p = &rep->io_v4;
|
|
|
|
if (clp->both_mmap && is_wr)
|
|
memcpy(clp->out_mmapp, clp->in_mmapp, num_bytes);
|
|
memset(rep->cmd, 0, sizeof(rep->cmd));
|
|
rep->cmd[0] = is_wr ? 0x2a : 0x28;
|
|
sg_put_unaligned_be32((uint32_t)rep->blk, rep->cmd + 2);
|
|
sg_put_unaligned_be16((uint16_t)rep->num_blks, rep->cmd + 7);
|
|
if (flagp->v4)
|
|
goto do_v4;
|
|
|
|
memset(hp, 0, sizeof(sg_io_hdr_t));
|
|
hp->interface_id = 'S';
|
|
hp->cmd_len = sizeof(rep->cmd);
|
|
hp->cmdp = rep->cmd;
|
|
hp->dxfer_direction = is_wr ? SG_DXFER_TO_DEV : SG_DXFER_FROM_DEV;
|
|
hp->dxfer_len = num_bytes;
|
|
hp->mx_sb_len = sizeof(rep->sb);
|
|
hp->sbp = rep->sb;
|
|
hp->timeout = DEF_TIMEOUT;
|
|
hp->usr_ptr = rep;
|
|
hp->pack_id = rep->blk;
|
|
if (flagp->dio)
|
|
hp->flags |= SG_FLAG_DIRECT_IO;
|
|
if (flagp->noxfer)
|
|
hp->flags |= SG_FLAG_NO_DXFER;
|
|
if (flagp->immed)
|
|
hp->flags |= SGV4_FLAG_IMMED;
|
|
if (flagp->polled)
|
|
hp->flags |= SGV4_FLAG_POLLED;
|
|
if (flagp->mmap) {
|
|
hp->flags |= SG_FLAG_MMAP_IO;
|
|
hp->dxferp = is_wr ? clp->out_mmapp : clp->in_mmapp;
|
|
} else
|
|
hp->dxferp = rep->buffp;
|
|
if (flagp->evfd)
|
|
hp->flags |= SGV4_FLAG_EVENTFD;
|
|
if (clp->debug > 5) {
|
|
pr2serr("%s: SCSI %s, blk=%d num_blks=%d\n", __func__,
|
|
is_wr ? "WRITE" : "READ", rep->blk, rep->num_blks);
|
|
sg_print_command(hp->cmdp);
|
|
pr2serr("dir=%d, len=%d, dxfrp=%p, cmd_len=%d\n", hp->dxfer_direction,
|
|
hp->dxfer_len, hp->dxferp, hp->cmd_len);
|
|
}
|
|
|
|
while (((res = write(fd, hp, sizeof(sg_io_hdr_t))) < 0) &&
|
|
(EINTR == errno))
|
|
;
|
|
if (res < 0) {
|
|
if (ENOMEM == errno)
|
|
return 1;
|
|
if ((EDOM == errno) || (EAGAIN == errno) || (EBUSY == errno)) {
|
|
rep->state = SGQ_IO_WAIT; /* busy so wait */
|
|
return 0;
|
|
}
|
|
pr2serr("%s: write(): %s [%d]\n", __func__, strerror(errno), errno);
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
rep->state = SGQ_IO_STARTED;
|
|
if (! clp->no_sig)
|
|
clp->sigs_waiting++;
|
|
return 0;
|
|
do_v4:
|
|
memset(h4p, 0, sizeof(struct sg_io_v4));
|
|
h4p->guard = 'Q';
|
|
h4p->request_len = sizeof(rep->cmd);
|
|
h4p->request = (uint64_t)(uintptr_t)rep->cmd;
|
|
if (is_wr)
|
|
h4p->dout_xfer_len = num_bytes;
|
|
else if (rep->num_blks > 0)
|
|
h4p->din_xfer_len = num_bytes;
|
|
h4p->max_response_len = sizeof(rep->sb);
|
|
h4p->response = (uint64_t)(uintptr_t)rep->sb;
|
|
h4p->timeout = DEF_TIMEOUT;
|
|
h4p->usr_ptr = (uint64_t)(uintptr_t)rep;
|
|
h4p->request_extra = rep->blk;/* N.B. blk --> pack_id --> request_extra */
|
|
if (flagp->dio)
|
|
h4p->flags |= SG_FLAG_DIRECT_IO;
|
|
if (flagp->noxfer)
|
|
h4p->flags |= SG_FLAG_NO_DXFER;
|
|
if (flagp->immed)
|
|
h4p->flags |= SGV4_FLAG_IMMED;
|
|
if (flagp->polled)
|
|
h4p->flags |= SGV4_FLAG_POLLED;
|
|
if (flagp->mmap) {
|
|
h4p->flags |= SG_FLAG_MMAP_IO;
|
|
hp->dxferp = is_wr ? clp->out_mmapp : clp->in_mmapp;
|
|
} else {
|
|
if (is_wr)
|
|
h4p->dout_xferp = (uint64_t)(uintptr_t)rep->buffp;
|
|
else if (rep->num_blks > 0)
|
|
h4p->din_xferp = (uint64_t)(uintptr_t)rep->buffp;
|
|
}
|
|
if (flagp->tag)
|
|
h4p->flags |= SGV4_FLAG_YIELD_TAG;
|
|
if (flagp->evfd)
|
|
h4p->flags |= SGV4_FLAG_EVENTFD;
|
|
if (! clp->no_sig)
|
|
h4p->flags |= SGV4_FLAG_SIGNAL;
|
|
|
|
while (((res = ioctl(fd, SG_IOSUBMIT, h4p)) < 0) && (EINTR == errno))
|
|
;
|
|
if (res < 0) {
|
|
if (ENOMEM == errno)
|
|
return 1;
|
|
if ((EDOM == errno) || (EAGAIN == errno) || (EBUSY == errno)) {
|
|
rep->state = SGQ_IO_WAIT; /* busy so wait */
|
|
return 0;
|
|
}
|
|
pr2serr("%s: ioctl(SG_IOSUBMIT): %s [%d]\n", __func__,
|
|
strerror(errno), errno);
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
rep->state = SGQ_IO_STARTED;
|
|
if (! clp->no_sig)
|
|
clp->sigs_waiting++;
|
|
if (clp->debug > 5) {
|
|
if (is_wr ? clp->oflag.tag : clp->iflag.tag)
|
|
pr2serr("%s: generated_tag=0x%" PRIx64 "\n", __func__,
|
|
(uint64_t)h4p->generated_tag);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* -1 -> unrecoverable error, 0 -> successful, 1 -> try again */
|
|
static int
|
|
sg_finish_io(Rq_coll * clp, bool wr, Rq_elem ** repp)
|
|
{
|
|
struct flags_t *flagsp = wr ? &clp->oflag : &clp->iflag;
|
|
bool dio = false;
|
|
bool is_v4 = flagsp->v4;
|
|
bool use_pack = flagsp->pack;
|
|
bool use_tag = flagsp->tag;
|
|
int fd = wr ? clp->outfd : clp->infd;
|
|
int res, id, n;
|
|
sg_io_hdr_t io_hdr;
|
|
sg_io_hdr_t * hp;
|
|
struct sg_io_v4 io_v4;
|
|
struct sg_io_v4 * h4p;
|
|
Rq_elem * rep;
|
|
|
|
if (is_v4)
|
|
goto do_v4;
|
|
if (use_pack) {
|
|
while (true) {
|
|
if ( ((res = ioctl(fd, SG_GET_NUM_WAITING, &n))) < 0) {
|
|
res = -errno;
|
|
pr2serr("%s: ioctl(SG_GET_NUM_WAITING): %s [%d]\n",
|
|
__func__, strerror(errno), errno);
|
|
return res;
|
|
}
|
|
if (n > 0) {
|
|
if ( (ioctl(fd, SG_GET_PACK_ID, &id)) < 0) {
|
|
res = errno;
|
|
pr2serr("%s: ioctl(SG_GET_PACK_ID): %s [%d]\n",
|
|
__func__, strerror(res), res);
|
|
return -res;
|
|
}
|
|
/* got pack_id or tag of first waiting */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
memset(&io_hdr, 0 , sizeof(sg_io_hdr_t));
|
|
if (use_pack)
|
|
io_hdr.pack_id = id;
|
|
while (((res = read(fd, &io_hdr, sizeof(sg_io_hdr_t))) < 0) &&
|
|
((EINTR == errno) || (EAGAIN == errno) || (EBUSY == errno)))
|
|
;
|
|
rep = (Rq_elem *)io_hdr.usr_ptr;
|
|
if (rep) {
|
|
dio = flagsp->dio;
|
|
if (rep->io_hdr.flags & SGV4_FLAG_POLLED)
|
|
++clp->blk_poll_count;
|
|
}
|
|
if (res < 0) {
|
|
res = -errno;
|
|
pr2serr("%s: read(): %s [%d]\n", __func__, strerror(errno), errno);
|
|
if (rep)
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
if (! (rep && (SGQ_IO_STARTED == rep->state))) {
|
|
pr2serr("%s: bad usr_ptr\n", __func__);
|
|
if (rep)
|
|
rep->state = SGQ_IO_ERR;
|
|
return -1;
|
|
}
|
|
memcpy(&rep->io_hdr, &io_hdr, sizeof(sg_io_hdr_t));
|
|
hp = &rep->io_hdr;
|
|
if (repp)
|
|
*repp = rep;
|
|
|
|
switch (sg_err_category3(hp)) {
|
|
case SG_LIB_CAT_CLEAN:
|
|
break;
|
|
case SG_LIB_CAT_RECOVERED:
|
|
pr2serr("Recovered error on block=%d, num=%d\n", rep->blk,
|
|
rep->num_blks);
|
|
break;
|
|
case SG_LIB_CAT_UNIT_ATTENTION:
|
|
return 1;
|
|
default:
|
|
sg_chk_n_print3(wr ? "writing": "reading", hp, true);
|
|
rep->state = SGQ_IO_ERR;
|
|
return -1;
|
|
}
|
|
if (dio && ((hp->info & SG_INFO_DIRECT_IO_MASK) != SG_INFO_DIRECT_IO))
|
|
++clp->dio_incomplete; /* count dios done as indirect IO */
|
|
clp->sum_of_resids += hp->resid;
|
|
rep->state = SGQ_IO_FINISHED;
|
|
if (clp->debug > 5) {
|
|
pr2serr("%s: %s ", __func__, wr ? "writing" : "reading");
|
|
pr2serr(" SGQ_IO_FINISHED elem idx=%zd\n", rep - clp->elem);
|
|
}
|
|
return 0;
|
|
do_v4:
|
|
id = -1;
|
|
if (use_pack || use_tag) {
|
|
while (true) {
|
|
if ( ((res = ioctl(fd, SG_GET_NUM_WAITING, &n))) < 0) {
|
|
res = -errno;
|
|
pr2serr("%s: ioctl(SG_GET_NUM_WAITING): %s [%d]\n",
|
|
__func__, strerror(errno), errno);
|
|
return res;
|
|
}
|
|
if (n > 0) {
|
|
if ( (ioctl(fd, SG_GET_PACK_ID, &id)) < 0) {
|
|
res = errno;
|
|
pr2serr("%s: ioctl(SG_GET_PACK_ID): %s [%d]\n",
|
|
__func__, strerror(res), res);
|
|
return -res;
|
|
}
|
|
/* got pack_id or tag of first waiting */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
memset(&io_v4, 0 , sizeof(io_v4));
|
|
io_v4.guard = 'Q';
|
|
if (use_tag)
|
|
io_v4.request_tag = id;
|
|
else if (use_pack)
|
|
io_v4.request_extra = id;
|
|
io_v4.flags |= SGV4_FLAG_IMMED;
|
|
if (flagsp->evfd)
|
|
io_v4.flags |= SGV4_FLAG_EVENTFD;
|
|
while (((res = ioctl(fd, SG_IORECEIVE, &io_v4)) < 0) &&
|
|
((EINTR == errno) || (EAGAIN == errno) || (EBUSY == errno)))
|
|
;
|
|
rep = (Rq_elem *)(unsigned long)io_v4.usr_ptr;
|
|
if (res < 0) {
|
|
res = -errno;
|
|
pr2serr("%s: ioctl(SG_IORECEIVE): %s [%d]\n", __func__,
|
|
strerror(errno), errno);
|
|
if (rep)
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
if (rep) {
|
|
if (rep->io_v4.flags & SGV4_FLAG_POLLED)
|
|
++clp->blk_poll_count;
|
|
}
|
|
if (! (rep && (SGQ_IO_STARTED == rep->state))) {
|
|
pr2serr("%s: bad usr_ptr=0x%p\n", __func__, (void *)rep);
|
|
if (rep)
|
|
rep->state = SGQ_IO_ERR;
|
|
return -1;
|
|
}
|
|
memcpy(&rep->io_v4, &io_v4, sizeof(struct sg_io_v4));
|
|
h4p = &rep->io_v4;
|
|
if (repp)
|
|
*repp = rep;
|
|
|
|
res = sg_err_category_new(h4p->device_status, h4p->transport_status,
|
|
h4p->driver_status,
|
|
(const uint8_t *)(unsigned long)h4p->response,
|
|
h4p->response_len);
|
|
switch (res) {
|
|
case SG_LIB_CAT_CLEAN:
|
|
break;
|
|
case SG_LIB_CAT_RECOVERED:
|
|
pr2serr("Recovered error on block=%d, num=%d\n", rep->blk,
|
|
rep->num_blks);
|
|
break;
|
|
case SG_LIB_CAT_UNIT_ATTENTION:
|
|
return 1;
|
|
default:
|
|
sg_linux_sense_print(wr ? "writing": "reading",
|
|
h4p->device_status, h4p->transport_status,
|
|
h4p->driver_status,
|
|
(const uint8_t *)(unsigned long)h4p->response,
|
|
h4p->response_len, true);
|
|
rep->state = SGQ_IO_ERR;
|
|
return -1;
|
|
}
|
|
if (dio && ((h4p->info & SG_INFO_DIRECT_IO_MASK) != SG_INFO_DIRECT_IO))
|
|
++clp->dio_incomplete; /* count dios done as indirect IO */
|
|
clp->sum_of_resids += h4p->din_resid;
|
|
rep->state = SGQ_IO_FINISHED;
|
|
if (clp->debug > 5) {
|
|
pr2serr("%s: %s ", __func__, wr ? "writing" : "reading");
|
|
pr2serr(" SGQ_IO_FINISHED elem idx=%zd\n", rep - clp->elem);
|
|
if (use_pack)
|
|
pr2serr("%s: pack_id=%d\n", __func__, h4p->request_extra);
|
|
else if (use_tag)
|
|
pr2serr("%s: request_tag=0x%" PRIx64 "\n", __func__,
|
|
(uint64_t)h4p->request_tag);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
sz_reserve(Rq_coll * clp, bool is_in)
|
|
{
|
|
const struct flags_t *flagsp = is_in ? &clp->iflag : &clp->oflag;
|
|
bool pack = flagsp->pack;
|
|
bool vb = clp->debug;
|
|
int res, t, flags, err;
|
|
int fd = is_in ? clp->infd : clp->outfd;
|
|
int tag = flagsp->tag;
|
|
struct sg_extended_info sei;
|
|
struct sg_extended_info * seip;
|
|
|
|
seip = &sei;
|
|
res = ioctl(fd, SG_GET_VERSION_NUM, &t);
|
|
if ((res < 0) || (t < 30000)) {
|
|
pr2serr("%s: sg driver prior to 3.0.00\n", my_name);
|
|
return 1;
|
|
} else if (t < 40000) {
|
|
if (vb)
|
|
pr2serr("%s: warning: sg driver prior to 4.0.00\n", my_name);
|
|
sgs_old_sg_driver = true;
|
|
} else if (t < 40045) {
|
|
sgs_old_sg_driver = false;
|
|
sgs_full_v4_sg_driver = false;
|
|
} else
|
|
sgs_full_v4_sg_driver = true;
|
|
t = clp->bs * clp->bpt;
|
|
res = ioctl(fd, SG_SET_RESERVED_SIZE, &t);
|
|
if (res < 0)
|
|
perror("sgs_dd: SG_SET_RESERVED_SIZE error");
|
|
|
|
if (sgs_full_v4_sg_driver) {
|
|
if (sgs_nanosec_unit) {
|
|
memset(seip, 0, sizeof(*seip));
|
|
seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS;
|
|
seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_TIME_IN_NS;
|
|
seip->ctl_flags |= SG_CTL_FLAGM_TIME_IN_NS;
|
|
if (ioctl(fd, SG_SET_GET_EXTENDED, seip) < 0) {
|
|
pr2serr("ioctl(EXTENDED(TIME_IN_NS)) failed, errno=%d %s\n",
|
|
errno, strerror(errno));
|
|
return 1;
|
|
}
|
|
}
|
|
if (tag || pack) {
|
|
t = 1;
|
|
if (ioctl(fd, SG_SET_FORCE_PACK_ID, &t) < 0) {
|
|
pr2serr("ioctl(SG_SET_FORCE_PACK_ID(on)) failed, errno=%d "
|
|
"%s\n", errno, strerror(errno));
|
|
return 1;
|
|
}
|
|
if (tag) {
|
|
memset(seip, 0, sizeof(*seip));
|
|
seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS;
|
|
seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_TAG_FOR_PACK_ID;
|
|
seip->ctl_flags |= SG_CTL_FLAGM_TAG_FOR_PACK_ID;
|
|
if (ioctl(fd, SG_SET_GET_EXTENDED, seip) < 0) {
|
|
pr2serr("ioctl(EXTENDED(TAG_FOR_PACK_ID)) failed, "
|
|
"errno=%d %s\n", errno, strerror(errno));
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
if (flagsp->evfd) {
|
|
int evfd = eventfd(0,0);
|
|
|
|
if (evfd < 0) {
|
|
err = errno;
|
|
pr2serr("eventfd() failed: %s\n", strerror(err));
|
|
return 1;
|
|
}
|
|
if (is_in)
|
|
clp->in_evfd = evfd;
|
|
else
|
|
clp->out_evfd = evfd;
|
|
|
|
memset(seip, 0, sizeof(*seip));
|
|
seip->sei_wr_mask |= SG_SEIM_EVENTFD;
|
|
seip->sei_rd_mask |= SG_SEIM_EVENTFD;
|
|
seip->share_fd = evfd;
|
|
if (ioctl(fd, SG_SET_GET_EXTENDED, seip) < 0) {
|
|
err = errno;
|
|
pr2serr("ioctl(EXTENDED(SG_SEIM_EVENTFD)) failed, "
|
|
"errno=%d %s\n", err, strerror(err));
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
if (!clp->no_sig) {
|
|
if (-1 == fcntl(fd, F_SETOWN, getpid())) {
|
|
perror("fcntl(F_SETOWN)");
|
|
return 1;
|
|
}
|
|
flags = fcntl(fd, F_GETFL, 0);
|
|
if (-1 == fcntl(fd, F_SETFL, flags | O_ASYNC)) {
|
|
perror("fcntl(F_SETFL)");
|
|
return 1;
|
|
}
|
|
if (clp->use_rt_sig) {/* displaces SIGIO/SIGPOLL with SIGRTMIN + 1 */
|
|
if (-1 == fcntl(fd, F_SETSIG, SIGRTMIN + 1))
|
|
perror("fcntl(F_SETSIG)");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
init_elems(Rq_coll * clp)
|
|
{
|
|
bool either_mmap = false;
|
|
int res = 0;
|
|
int num_bytes = clp->bpt * clp->bs;
|
|
int k;
|
|
Rq_elem * rep;
|
|
|
|
clp->wr_posp = &clp->elem[0]; /* making ring buffer */
|
|
clp->rd_posp = clp->wr_posp;
|
|
if (clp->iflag.mmap || clp->oflag.mmap) {
|
|
int res;
|
|
|
|
either_mmap = true;
|
|
sgq_num_elems = 2;
|
|
sgq_rd_ahead_lim = 1;
|
|
sgq_wr_ahead_lim = 1;
|
|
if (clp->iflag.mmap) {
|
|
res = get_mmap_addr(clp->infd, num_bytes, &clp->in_mmapp);
|
|
if (res < 0)
|
|
return res;
|
|
}
|
|
if (clp->oflag.mmap) {
|
|
res = get_mmap_addr(clp->outfd, num_bytes, &clp->out_mmapp);
|
|
if (res < 0)
|
|
return res;
|
|
}
|
|
}
|
|
for (k = 0; k < sgq_num_elems - 1; ++k)
|
|
clp->elem[k].nextp = &clp->elem[k + 1];
|
|
clp->elem[sgq_num_elems - 1].nextp = &clp->elem[0];
|
|
for (k = 0; k < sgq_num_elems; ++k) {
|
|
rep = &clp->elem[k];
|
|
rep->state = SGQ_FREE;
|
|
rep->iflagp = &clp->iflag;
|
|
rep->oflagp = &clp->oflag;
|
|
if (either_mmap) {
|
|
if (clp->both_mmap)
|
|
continue;
|
|
if (clp->iflag.mmap)
|
|
rep->buffp = clp->in_mmapp;
|
|
else
|
|
rep->buffp = clp->out_mmapp;
|
|
continue;
|
|
}
|
|
rep->buffp = sg_memalign(num_bytes, 0, &rep->free_buffp, false);
|
|
if (NULL == rep->buffp) {
|
|
pr2serr("out of memory creating user buffers\n");
|
|
res = -ENOMEM;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
remove_elems(Rq_coll * clp)
|
|
{
|
|
Rq_elem * rep;
|
|
int k;
|
|
|
|
for (k = 0; k < sgq_num_elems; ++k) {
|
|
rep = &clp->elem[k];
|
|
if (rep->free_buffp)
|
|
free(rep->free_buffp);
|
|
}
|
|
}
|
|
|
|
static int
|
|
start_read(Rq_coll * clp)
|
|
{
|
|
int blocks = (clp->in_count > clp->bpt) ? clp->bpt : clp->in_count;
|
|
Rq_elem * rep = clp->rd_posp;
|
|
int buf_sz, res;
|
|
char ebuff[EBUFF_SZ];
|
|
|
|
if (clp->debug > 5)
|
|
pr2serr("%s: elem idx=%zd\n", __func__, rep - clp->elem);
|
|
rep->wr = false;
|
|
rep->blk = clp->in_blk;
|
|
rep->num_blks = blocks;
|
|
clp->in_blk += blocks;
|
|
clp->in_count -= blocks;
|
|
if (clp->in_is_sg) {
|
|
res = sg_start_io(clp, rep);
|
|
if (1 == res) { /* ENOMEM, find what's available+try that */
|
|
if (ioctl(clp->infd, SG_GET_RESERVED_SIZE, &buf_sz) < 0) {
|
|
res = -errno;
|
|
perror("RESERVED_SIZE ioctls failed");
|
|
return res;
|
|
}
|
|
clp->bpt = (buf_sz + clp->bs - 1) / clp->bs;
|
|
pr2serr("Reducing blocks per transfer to %d\n", clp->bpt);
|
|
if (clp->bpt < 1)
|
|
return -ENOMEM;
|
|
res = sg_start_io(clp, rep);
|
|
if (1 == res)
|
|
res = -ENOMEM;
|
|
}
|
|
if (res < 0) {
|
|
pr2serr("%s: inputting from sg failed, blk=%d\n", my_name,
|
|
rep->blk);
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
}
|
|
else {
|
|
rep->state = SGQ_IO_STARTED;
|
|
while (((res = read(clp->infd, rep->buffp, blocks * clp->bs)) < 0) &&
|
|
(EINTR == errno))
|
|
;
|
|
if (res < 0) {
|
|
res = -errno;
|
|
snprintf(ebuff, EBUFF_SZ, "%s: reading, in_blk=%d ", my_name,
|
|
rep->blk);
|
|
perror(ebuff);
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
if (res < blocks * clp->bs) {
|
|
int o_blocks = blocks;
|
|
rep->stop_after_wr = true;
|
|
blocks = res / clp->bs;
|
|
if ((res % clp->bs) > 0) {
|
|
blocks++;
|
|
clp->in_partial++;
|
|
}
|
|
/* Reverse out + re-apply blocks on clp */
|
|
clp->in_blk -= o_blocks;
|
|
clp->in_count += o_blocks;
|
|
rep->num_blks = blocks;
|
|
clp->in_blk += blocks;
|
|
clp->in_count -= blocks;
|
|
}
|
|
clp->in_done_count -= blocks;
|
|
rep->state = SGQ_IO_FINISHED;
|
|
}
|
|
clp->rd_posp = rep->nextp;
|
|
return blocks;
|
|
}
|
|
|
|
static int
|
|
start_write(Rq_coll * clp)
|
|
{
|
|
Rq_elem * rep = clp->wr_posp;
|
|
int res, blocks;
|
|
char ebuff[EBUFF_SZ];
|
|
|
|
while ((0 != rep->wr) || (SGQ_IO_FINISHED != rep->state)) {
|
|
rep = rep->nextp;
|
|
if (rep == clp->rd_posp)
|
|
return -1;
|
|
}
|
|
if (clp->debug > 5)
|
|
pr2serr("%s: elem idx=%zd\n", __func__, rep - clp->elem);
|
|
rep->wr = true;
|
|
blocks = rep->num_blks;
|
|
rep->blk = clp->out_blk;
|
|
clp->out_blk += blocks;
|
|
clp->out_count -= blocks;
|
|
if (clp->out_is_sg) {
|
|
res = sg_start_io(clp, rep);
|
|
if (1 == res) /* ENOMEM, give up */
|
|
return -ENOMEM;
|
|
else if (res < 0) {
|
|
pr2serr("%s: output to sg failed, blk=%d\n", my_name, rep->blk);
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
}
|
|
else {
|
|
rep->state = SGQ_IO_STARTED;
|
|
while (((res = write(clp->outfd, rep->buffp,
|
|
rep->num_blks * clp->bs)) < 0) && (EINTR == errno))
|
|
;
|
|
if (res < 0) {
|
|
res = -errno;
|
|
snprintf(ebuff, EBUFF_SZ, "%s: output, out_blk=%d ", my_name,
|
|
rep->blk);
|
|
perror(ebuff);
|
|
rep->state = SGQ_IO_ERR;
|
|
return res;
|
|
}
|
|
if (res < blocks * clp->bs) {
|
|
blocks = res / clp->bs;
|
|
if ((res % clp->bs) > 0) {
|
|
blocks++;
|
|
clp->out_partial++;
|
|
}
|
|
rep->num_blks = blocks;
|
|
}
|
|
rep->state = SGQ_IO_FINISHED;
|
|
}
|
|
return blocks;
|
|
}
|
|
|
|
/* Returns 0 if SIGIO/SIGPOLL or (SIGRTMIN + 1) received, else returns negated
|
|
* errno value; -EAGAIN for timeout. */
|
|
static int
|
|
do_sigwait(Rq_coll * clp, bool inc1_clear0)
|
|
{
|
|
siginfo_t info;
|
|
struct timespec ts;
|
|
|
|
if (clp->debug > 9)
|
|
pr2serr("%s: inc1_clear0=%d\n", __func__, (int)inc1_clear0);
|
|
ts.tv_sec = 0;
|
|
ts.tv_nsec = DEF_SIGTIMEDWAIT_USEC * 1000;
|
|
while (sigtimedwait(&clp->blocked_sigs, &info, &ts) < 0) {
|
|
int err = errno;
|
|
|
|
if (EINTR != err) {
|
|
|
|
if (EAGAIN != err)
|
|
pr2serr("%s: sigtimedwait(): %s [%d]\n", __func__,
|
|
strerror(err), err);
|
|
return -err; /* EAGAIN is timeout error */
|
|
}
|
|
}
|
|
if ((SIGRTMIN + 1) == info.si_signo) {
|
|
if (inc1_clear0) {
|
|
clp->sigs_waiting--;
|
|
clp->sigs_rt_received++;
|
|
} else
|
|
clp->sigs_waiting = 0;
|
|
} else if (SIGPOLL == info.si_signo) {
|
|
if (inc1_clear0) {
|
|
clp->sigs_waiting--;
|
|
clp->sigs_io_received++;
|
|
} else
|
|
clp->sigs_waiting = 0;
|
|
} else {
|
|
pr2serr("%s: sigwaitinfo() returned si_signo=%d\n",
|
|
__func__, info.si_signo);
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Returns 1 (or more) on success (found), 0 on not found, -1 on error. */
|
|
static int
|
|
do_num_poll_in(Rq_coll * clp, int fd, bool is_evfd)
|
|
{
|
|
int err, res;
|
|
struct pollfd a_pollfd = {0, POLLIN | POLLOUT, 0};
|
|
|
|
if (! clp->no_sig) {
|
|
if (clp->sigs_waiting) {
|
|
int res = do_sigwait(clp, true);
|
|
|
|
if ((res < 0) && (-EAGAIN != res))
|
|
return res;
|
|
}
|
|
}
|
|
a_pollfd.fd = fd;
|
|
if (poll(&a_pollfd, 1, clp->poll_ms) < 0) {
|
|
err = errno;
|
|
pr2serr("%s: poll(): %s [%d]\n", __func__, strerror(err), err);
|
|
return -err;
|
|
}
|
|
/* pr2serr("%s: revents=0x%x\n", __func__, a_pollfd.revents); */
|
|
if (a_pollfd.revents & POLLIN) {
|
|
if (is_evfd) {
|
|
uint64_t count;
|
|
|
|
if ((res = read(fd, &count, sizeof(count))) < 0) {
|
|
err = errno;
|
|
pr2serr("%s: read(): %s [%d]\n", __func__,
|
|
strerror(err), err);
|
|
return -err;
|
|
}
|
|
return (res < (int)sizeof(uint64_t)) ? 0 : (int)count;
|
|
} else
|
|
return 1; /* could be more but don't know without evfd */
|
|
} else if (a_pollfd.revents & POLLERR)
|
|
++clp->pollerr_count;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
can_read_write(Rq_coll * clp)
|
|
{
|
|
Rq_elem * rep = NULL;
|
|
bool writeable = false;
|
|
bool in_is_evfd = (clp->in_evfd >= 0);
|
|
bool out_is_evfd = (clp->out_evfd >= 0);
|
|
int res = 0;
|
|
int reading = 0;
|
|
int writing = 0;
|
|
int rd_waiting = 0;
|
|
int wr_waiting = 0;
|
|
int sg_finished = 0;
|
|
int num;
|
|
int ofd = out_is_evfd ? clp->out_evfd : clp->outfd;
|
|
int ifd= in_is_evfd ? clp->in_evfd : clp->infd;
|
|
|
|
/* if write completion pending, then complete it + start read */
|
|
if (clp->out_is_sg) {
|
|
while ((res = do_num_poll_in(clp, ofd, out_is_evfd))) {
|
|
if (res < 0)
|
|
return res;
|
|
num = res;
|
|
while (--num >= 0) {
|
|
res = sg_finish_io(clp, true /* write */, &rep);
|
|
if (res < 0)
|
|
return res;
|
|
else if (1 == res) {
|
|
res = sg_start_io(clp, rep);
|
|
if (0 != res)
|
|
return -1; /* give up if any problems with retry */
|
|
} else
|
|
sg_finished++;
|
|
}
|
|
}
|
|
while ((rep = clp->wr_posp) && (SGQ_IO_FINISHED == rep->state) &&
|
|
rep->wr && (rep != clp->rd_posp)) {
|
|
rep->state = SGQ_FREE;
|
|
clp->out_done_count -= rep->num_blks;
|
|
clp->wr_posp = rep->nextp;
|
|
if (rep->stop_after_wr)
|
|
return -1;
|
|
}
|
|
}
|
|
else if ((rep = clp->wr_posp) && rep->wr &&
|
|
(SGQ_IO_FINISHED == rep->state)) {
|
|
rep->state = SGQ_FREE;
|
|
clp->out_done_count -= rep->num_blks;
|
|
clp->wr_posp = rep->nextp;
|
|
if (rep->stop_after_wr)
|
|
return -1;
|
|
}
|
|
|
|
/* if read completion pending, then complete it + start maybe write */
|
|
if (clp->in_is_sg) {
|
|
while ((res = do_num_poll_in(clp, ifd, in_is_evfd))) {
|
|
if (res < 0)
|
|
return res;
|
|
num = res;
|
|
while (--num >= 0) {
|
|
res = sg_finish_io(clp, false /* read */, &rep);
|
|
if (res < 0)
|
|
return res;
|
|
if (1 == res) {
|
|
res = sg_start_io(clp, rep);
|
|
if (0 != res)
|
|
return -1; /* give up if any problems with retry */
|
|
} else {
|
|
sg_finished++;
|
|
clp->in_done_count -= rep->num_blks;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (rep = clp->wr_posp, res = 1;
|
|
rep && (rep != clp->rd_posp); rep = rep->nextp) {
|
|
if (SGQ_IO_STARTED == rep->state) {
|
|
if (rep->wr)
|
|
++writing;
|
|
else {
|
|
res = 0;
|
|
++reading;
|
|
}
|
|
}
|
|
else if ((! rep->wr) && (SGQ_IO_FINISHED == rep->state)) {
|
|
if (res)
|
|
writeable = true;
|
|
}
|
|
else if (SGQ_IO_WAIT == rep->state) {
|
|
res = 0;
|
|
if (rep->wr)
|
|
++wr_waiting;
|
|
else
|
|
++rd_waiting;
|
|
}
|
|
else
|
|
res = 0;
|
|
}
|
|
if (clp->debug > 6) {
|
|
if ((clp->debug > 7) || wr_waiting || rd_waiting) {
|
|
pr2serr("%d/%d (nwb/nrb): read=%d/%d (do/wt) "
|
|
"write=%d/%d (do/wt) writeable=%d sg_fin=%d\n",
|
|
clp->out_blk, clp->in_blk, reading, rd_waiting,
|
|
writing, wr_waiting, (int)writeable, sg_finished);
|
|
}
|
|
// fflush(stdout);
|
|
}
|
|
if (writeable && (writing < sgq_wr_ahead_lim) && (clp->out_count > 0))
|
|
return SGQ_CAN_WRITE;
|
|
if ((reading < sgq_rd_ahead_lim) && (clp->in_count > 0) &&
|
|
(0 == rd_waiting) && (clp->rd_posp->nextp != clp->wr_posp))
|
|
return SGQ_CAN_READ;
|
|
|
|
if (clp->out_done_count <= 0)
|
|
return SGQ_CAN_DO_NOTHING;
|
|
|
|
/* usleep(10000); */ /* hang about for 10 milliseconds */
|
|
if ((! clp->no_sig) && clp->sigs_waiting) {
|
|
res = do_sigwait(clp, false);
|
|
if ((res < 0) && (-EAGAIN != res))
|
|
return res; /* wasn't timeout */
|
|
}
|
|
/* Now check the _whole_ buffer for pending requests */
|
|
for (rep = clp->rd_posp->nextp; rep && (rep != clp->rd_posp);
|
|
rep = rep->nextp) {
|
|
if (SGQ_IO_WAIT == rep->state) {
|
|
res = sg_start_io(clp, rep);
|
|
if (res < 0)
|
|
return res;
|
|
if (res > 0)
|
|
return -1;
|
|
break;
|
|
}
|
|
}
|
|
return SGQ_CAN_DO_NOTHING;
|
|
}
|
|
|
|
static bool
|
|
process_flags(const char * arg, struct flags_t * fp)
|
|
{
|
|
char buff[256];
|
|
char * cp;
|
|
char * np;
|
|
|
|
strncpy(buff, arg, sizeof(buff));
|
|
buff[sizeof(buff) - 1] = '\0';
|
|
if ('\0' == buff[0]) {
|
|
pr2serr("no flag found, 'null' can be used as a placeholder\n");
|
|
return false;
|
|
}
|
|
cp = buff;
|
|
do {
|
|
np = strchr(cp, ',');
|
|
if (np)
|
|
*np++ = '\0';
|
|
if (0 == strcmp(cp, "dio"))
|
|
fp->dio = true;
|
|
else if (0 == strcmp(cp, "evfd"))
|
|
fp->evfd = true;
|
|
else if (0 == strcmp(cp, "excl"))
|
|
fp->excl = true;
|
|
else if (0 == strcmp(cp, "hipri"))
|
|
fp->polled = true;
|
|
else if (0 == strcmp(cp, "immed"))
|
|
fp->immed = true;
|
|
else if (0 == strcmp(cp, "mmap"))
|
|
fp->mmap = true;
|
|
else if (0 == strcmp(cp, "noxfer"))
|
|
fp->noxfer = true;
|
|
else if (0 == strcmp(cp, "null"))
|
|
;
|
|
else if (0 == strcmp(cp, "pack"))
|
|
fp->pack = true;
|
|
else if (0 == strcmp(cp, "polled"))
|
|
fp->polled = true;
|
|
else if (0 == strcmp(cp, "tag"))
|
|
fp->tag = true;
|
|
else if (0 == strcmp(cp, "v3")) {
|
|
fp->v3 = true;
|
|
fp->v4 = false;
|
|
fp->given_v3v4 = true;
|
|
} else if (0 == strcmp(cp, "v4")) {
|
|
fp->v3 = false;
|
|
fp->v4 = true;
|
|
fp->given_v3v4 = true;
|
|
} else {
|
|
pr2serr("unrecognised flag: %s\n", cp);
|
|
return false;
|
|
}
|
|
cp = np;
|
|
} while (cp);
|
|
if (fp->dio && fp->mmap) {
|
|
pr2serr(" Can't set both mmap and dio\n");
|
|
return false;
|
|
}
|
|
if ((fp->dio || fp->mmap) && fp->noxfer) {
|
|
pr2serr(" Can't have mmap or dio with noxfer\n");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
int
|
|
main(int argc, char * argv[])
|
|
{
|
|
bool bs_given = false;
|
|
bool no_sig_given = false;
|
|
bool polled_present;
|
|
int skip = 0;
|
|
int seek = 0;
|
|
int ibs = 0;
|
|
int obs = 0;
|
|
int count = -1;
|
|
int in_num_sect = 0;
|
|
int out_num_sect = 0;
|
|
int help_pg = 0;
|
|
int res, k, in_sect_sz, out_sect_sz, crw, open_fl;
|
|
char str[STR_SZ];
|
|
char * key;
|
|
char * buf;
|
|
char inf[INOUTF_SZ];
|
|
char outf[INOUTF_SZ];
|
|
char ebuff[EBUFF_SZ];
|
|
Rq_coll rcoll;
|
|
Rq_coll * clp = &rcoll;
|
|
|
|
memset(clp, 0, sizeof(*clp));
|
|
clp->bpt = 0;
|
|
clp->in_evfd = -1;
|
|
clp->out_evfd = -1;
|
|
clp->iflag.v3 = true;
|
|
clp->oflag.v3 = true;
|
|
inf[0] = '\0';
|
|
outf[0] = '\0';
|
|
if (argc < 2) {
|
|
usage(1);
|
|
return 1;
|
|
}
|
|
sgs_nanosec_unit = !!getenv("SG3_UTILS_LINUX_NANO");
|
|
|
|
for(k = 1; k < argc; k++) {
|
|
if (argv[k]) {
|
|
strncpy(str, argv[k], STR_SZ);
|
|
str[STR_SZ - 1] = '\0';
|
|
}
|
|
else
|
|
continue;
|
|
for(key = str, buf = key; *buf && *buf != '=';)
|
|
buf++;
|
|
if (*buf)
|
|
*buf++ = '\0';
|
|
if (0 == strcmp(key,"bpt")) {
|
|
clp->bpt = sg_get_num(buf);
|
|
if ((clp->bpt < 0) || (clp->bpt > MAX_BPT_VALUE)) {
|
|
pr2serr("%s: bad argument to 'bpt='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (0 == strcmp(key,"bs")) {
|
|
clp->bs = sg_get_num(buf);
|
|
if ((clp->bs < 0) || (clp->bs > MAX_BPT_VALUE)) {
|
|
pr2serr("%s: bad argument to 'bs='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (0 == strcmp(key,"count")) {
|
|
count = sg_get_num(buf);
|
|
if (count < 0) {
|
|
pr2serr("%s: bad argument to 'count='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (0 == strcmp(key,"deb"))
|
|
clp->debug += sg_get_num(buf);
|
|
else if (0 == strcmp(key,"ibs")) {
|
|
ibs = sg_get_num(buf);
|
|
if ((ibs < 0) || (ibs > MAX_BPT_VALUE)) {
|
|
pr2serr("%s: bad argument to 'ibs='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (strcmp(key,"if") == 0) {
|
|
memcpy(inf, buf, INOUTF_SZ);
|
|
inf[INOUTF_SZ - 1] = '\0';
|
|
} else if (0 == strcmp(key, "iflag")) {
|
|
if (! process_flags(buf, &clp->iflag)) {
|
|
pr2serr("%s: bad argument to 'iflag='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (strcmp(key,"mrq") == 0)
|
|
; /* do nothing */
|
|
else if (0 == strcmp(key,"no_sig")) { /* default changes */
|
|
clp->no_sig = !!sg_get_num(buf);
|
|
no_sig_given = true;
|
|
} else if (0 == strcmp(key,"obs")) {
|
|
obs = sg_get_num(buf);
|
|
if ((obs < 0) || (obs > MAX_BPT_VALUE)) {
|
|
pr2serr("%s: bad argument to 'obs='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (strcmp(key,"of") == 0) {
|
|
memcpy(outf, buf, INOUTF_SZ);
|
|
outf[INOUTF_SZ - 1] = '\0';
|
|
} else if (0 == strcmp(key, "oflag")) {
|
|
if (! process_flags(buf, &clp->oflag)) {
|
|
pr2serr("%s: bad argument to 'oflag='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (0 == strcmp(key,"poll_ms"))
|
|
clp->poll_ms = sg_get_num(buf);
|
|
else if (0 == strcmp(key,"rt_sig"))
|
|
clp->use_rt_sig = !!sg_get_num(buf);
|
|
else if (0 == strcmp(key,"seek")) {
|
|
seek = sg_get_num(buf);
|
|
if (seek < 0) {
|
|
pr2serr("%s: bad argument to 'seek='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (0 == strcmp(key,"skip")) {
|
|
skip = sg_get_num(buf);
|
|
if (skip < 0) {
|
|
pr2serr("%s: bad argument to 'skip='\n", my_name);
|
|
return SG_LIB_SYNTAX_ERROR;
|
|
}
|
|
} else if (0 == strcmp(key,"time"))
|
|
; /* do nothing */
|
|
else if ((0 == strcmp(key,"-V")) || (0 == strcmp(key,"--version"))) {
|
|
pr2serr("%s: version: %s\n", my_name, version_str);
|
|
return 0;
|
|
} else if (0 == strncmp(key,"-vvvvvvv", 8))
|
|
clp->debug += 7;
|
|
else if (0 == strncmp(key,"-vvvvvv", 7))
|
|
clp->debug += 6;
|
|
else if (0 == strncmp(key,"-vvvvv", 6))
|
|
clp->debug += 5;
|
|
else if (0 == strncmp(key,"-vvvv", 5))
|
|
clp->debug += 4;
|
|
else if (0 == strncmp(key,"-vvv", 4))
|
|
clp->debug += 3;
|
|
else if (0 == strncmp(key,"-vv", 3))
|
|
clp->debug += 2;
|
|
else if ((0 == strcmp(key,"--verbose")) || (0 == strncmp(key,"-v", 2)))
|
|
++clp->debug;
|
|
else if (0 == strcmp(key,"-hhhh"))
|
|
help_pg += 4;
|
|
else if (0 == strcmp(key,"-hhh"))
|
|
help_pg += 3;
|
|
else if (0 == strcmp(key,"-hh"))
|
|
help_pg += 2;
|
|
else if ((0 == strcmp(key,"-h")) || (0 == strcmp(key,"--help")))
|
|
++help_pg;
|
|
else {
|
|
pr2serr("Unrecognized argument '%s'\n", key);
|
|
usage(help_pg);
|
|
return 1;
|
|
}
|
|
}
|
|
if (clp->bs <= 0) {
|
|
clp->bs = DEF_BLOCK_SIZE;
|
|
} else
|
|
bs_given = true;
|
|
|
|
if (help_pg > 0) {
|
|
usage(help_pg);
|
|
return 0;
|
|
}
|
|
|
|
polled_present = (clp->iflag.polled || clp->oflag.polled);
|
|
if (no_sig_given) {
|
|
if ((0 == clp->no_sig) && polled_present)
|
|
pr2serr("Warning: signalling doesn't work with polled flag\n");
|
|
} else /* no_sig default varies: 0 normally and 1 if polled present */
|
|
clp->no_sig = polled_present ? 1 : 0;
|
|
|
|
if ((ibs && (ibs != clp->bs)) || (obs && (obs != clp->bs))) {
|
|
pr2serr("If 'ibs' or 'obs' given must be same as 'bs'\n");
|
|
usage(1);
|
|
return 1;
|
|
}
|
|
if (clp->bpt <= 0) {
|
|
clp->bpt = (DEF_BPT_TIMES_BS_SZ / clp->bs);
|
|
if (0 == clp->bpt)
|
|
clp->bpt = 1;
|
|
if (! bs_given)
|
|
pr2serr("Assume blocks size bs=%d [bytes] and blocks "
|
|
"per transfer bpt=%d\n", clp->bs, clp->bpt);
|
|
} else if (! bs_given)
|
|
pr2serr("Assume 'bs' (block size) of %d bytes\n", clp->bs);
|
|
|
|
if ((skip < 0) || (seek < 0)) {
|
|
pr2serr("%s: skip and seek cannot be negative\n", my_name);
|
|
return 1;
|
|
}
|
|
if (clp->iflag.mmap && clp->oflag.mmap)
|
|
clp->both_mmap = true;
|
|
|
|
if (clp->debug > 3)
|
|
pr2serr("%s: if=%s skip=%d of=%s seek=%d count=%d\n", my_name,
|
|
inf, skip, outf, seek, count);
|
|
if (! clp->no_sig) {
|
|
/* Need to block signals before SIGPOLL is enabled in sz_reserve() */
|
|
sigemptyset(&clp->blocked_sigs);
|
|
if (clp->use_rt_sig)
|
|
sigaddset(&clp->blocked_sigs, SIGRTMIN + 1);
|
|
sigaddset(&clp->blocked_sigs, SIGINT);
|
|
sigaddset(&clp->blocked_sigs, SIGPOLL);
|
|
sigprocmask(SIG_BLOCK, &clp->blocked_sigs, 0);
|
|
}
|
|
|
|
clp->infd = STDIN_FILENO;
|
|
clp->outfd = STDOUT_FILENO;
|
|
if (inf[0] && ('-' != inf[0])) {
|
|
open_fl = clp->iflag.excl ? O_EXCL : 0;
|
|
if ((clp->infd = open(inf, open_fl | O_RDONLY)) < 0) {
|
|
snprintf(ebuff, EBUFF_SZ, "%s: could not open %s for reading",
|
|
my_name, inf);
|
|
perror(ebuff);
|
|
return 1;
|
|
}
|
|
if (ioctl(clp->infd, SG_GET_TIMEOUT, 0) < 0) {
|
|
clp->in_is_sg = false;
|
|
if (skip > 0) {
|
|
off_t offset = skip;
|
|
|
|
offset *= clp->bs; /* could overflow here! */
|
|
if (lseek(clp->infd, offset, SEEK_SET) < 0) {
|
|
snprintf(ebuff, EBUFF_SZ, "%s: couldn't skip to required "
|
|
"position on %s", my_name, inf);
|
|
perror(ebuff);
|
|
return 1;
|
|
}
|
|
}
|
|
} else { /* looks like sg device so close then re-open it RW */
|
|
close(clp->infd);
|
|
open_fl = clp->iflag.excl ? O_EXCL : 0;
|
|
open_fl |= (O_RDWR | O_NONBLOCK);
|
|
if ((clp->infd = open(inf, open_fl)) < 0) {
|
|
pr2serr("If %s is a sg device, need read+write "
|
|
"permissions, even to read it!\n", inf);
|
|
return 1;
|
|
}
|
|
clp->in_is_sg = true;
|
|
if (sz_reserve(clp, true /* is_in */))
|
|
return 1;
|
|
if (sgs_old_sg_driver && (clp->iflag.v4 || clp->oflag.v4)) {
|
|
pr2serr("Unable to implement v4 flag because sg driver too "
|
|
"old\n");
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
if (outf[0] && ('-' != outf[0])) {
|
|
open_fl = clp->oflag.excl ? O_EXCL : 0;
|
|
open_fl |= (O_RDWR | O_NONBLOCK);
|
|
if ((clp->outfd = open(outf, open_fl)) >= 0) {
|
|
if (ioctl(clp->outfd, SG_GET_TIMEOUT, 0) < 0) {
|
|
/* not a scsi generic device so now try and open RDONLY */
|
|
close(clp->outfd);
|
|
clp->outfd = -1;
|
|
}
|
|
else {
|
|
clp->out_is_sg = true;
|
|
if (sz_reserve(clp, false /* hence ! is_in */))
|
|
return 1;
|
|
if (sgs_old_sg_driver && (clp->iflag.v4 || clp->oflag.v4)) {
|
|
pr2serr("Unable to implement v4 flag because sg driver "
|
|
"too old\n");
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
if (! clp->out_is_sg) {
|
|
if (clp->outfd >= 0) {
|
|
close(clp->outfd);
|
|
clp->outfd = -1;
|
|
}
|
|
open_fl = clp->oflag.excl ? O_EXCL : 0;
|
|
open_fl |= (O_WRONLY | O_CREAT);
|
|
if ((clp->outfd = open(outf, open_fl, 0666)) < 0) {
|
|
snprintf(ebuff, EBUFF_SZ,
|
|
"%s: could not open %s for writing", my_name, outf);
|
|
perror(ebuff);
|
|
return 1;
|
|
}
|
|
else if (seek > 0) {
|
|
off_t offset = seek;
|
|
|
|
offset *= clp->bs; /* could overflow here! */
|
|
if (lseek(clp->outfd, offset, SEEK_SET) < 0) {
|
|
snprintf(ebuff, EBUFF_SZ, "%s: couldn't seek to required "
|
|
"position on %s", my_name, outf);
|
|
perror(ebuff);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
} else if ('\0' == outf[0]) {
|
|
if (STDIN_FILENO == clp->infd) {
|
|
pr2serr("Can't have both 'if' as stdin _and_ 'of' as "
|
|
"/dev/null\n");
|
|
return 1;
|
|
}
|
|
clp->outfd = open("/dev/null", O_RDWR);
|
|
if (clp->outfd < 0) {
|
|
perror("sgs_dd: could not open /dev/null");
|
|
return 1;
|
|
}
|
|
clp->out_is_sg = false;
|
|
/* ignore any seek */
|
|
} else { /* must be '-' for stdout */
|
|
if (STDIN_FILENO == clp->infd) {
|
|
pr2serr("Can't have both 'if' as stdin _and_ 'of' as stdout\n");
|
|
return 1;
|
|
}
|
|
}
|
|
if ((clp->in_is_sg || clp->out_is_sg) && !clp->iflag.given_v3v4 &&
|
|
!clp->oflag.given_v3v4 && (clp->debug > 0)) {
|
|
clp->iflag.v3 = true;
|
|
pr2serr("using sg driver version 3 interface on %s\n",
|
|
clp->in_is_sg ? inf : outf);
|
|
}
|
|
|
|
if (0 == count)
|
|
return 0;
|
|
else if (count < 0) {
|
|
if (clp->in_is_sg) {
|
|
res = read_capacity(clp->infd, &in_num_sect, &in_sect_sz);
|
|
if (2 == res) {
|
|
pr2serr("Unit attention, media changed(in), try again\n");
|
|
res = read_capacity(clp->infd, &in_num_sect, &in_sect_sz);
|
|
}
|
|
if (0 != res) {
|
|
pr2serr("Unable to read capacity on %s\n", inf);
|
|
in_num_sect = -1;
|
|
} else {
|
|
if (clp->debug > 4)
|
|
pr2serr("ifile: number of sectors=%d, sector size=%d\n",
|
|
in_num_sect, in_sect_sz);
|
|
if (in_num_sect > skip)
|
|
in_num_sect -= skip;
|
|
}
|
|
}
|
|
if (clp->out_is_sg) {
|
|
res = read_capacity(clp->outfd, &out_num_sect, &out_sect_sz);
|
|
if (2 == res) {
|
|
pr2serr("Unit attention, media changed(out), try again\n");
|
|
res = read_capacity(clp->outfd, &out_num_sect, &out_sect_sz);
|
|
}
|
|
if (0 != res) {
|
|
pr2serr("Unable to read capacity on %s\n", outf);
|
|
out_num_sect = -1;
|
|
} else {
|
|
if (clp->debug > 4)
|
|
pr2serr("ofile: number of sectors=%d, sector size=%d\n",
|
|
out_num_sect, out_sect_sz);
|
|
if (out_num_sect > seek)
|
|
out_num_sect -= seek;
|
|
}
|
|
}
|
|
if (clp->debug > 3)
|
|
pr2serr("Start of loop, count=%d, in_num_sect=%d, "
|
|
"out_num_sect=%d\n", count, in_num_sect, out_num_sect);
|
|
if (in_num_sect > 0) {
|
|
if (out_num_sect > 0)
|
|
count = (in_num_sect > out_num_sect) ? out_num_sect :
|
|
in_num_sect;
|
|
else
|
|
count = in_num_sect;
|
|
}
|
|
else
|
|
count = out_num_sect;
|
|
}
|
|
if (clp->debug > 4)
|
|
pr2serr("Start of loop, count=%d, bpt=%d\n", count, clp->bpt);
|
|
|
|
clp->in_count = count;
|
|
clp->in_done_count = count;
|
|
clp->in_blk = skip;
|
|
clp->out_count = count;
|
|
clp->out_done_count = count;
|
|
clp->out_blk = seek;
|
|
res = init_elems(clp);
|
|
if (res < 0)
|
|
pr2serr("init_elems() failed, res=%d\n", res);
|
|
res = 0;
|
|
|
|
/* vvvvvvvvvvvvvvvvv Main Loop vvvvvvvvvvvvvvvvvvvvvvvv */
|
|
while (clp->out_done_count > 0) {
|
|
crw = can_read_write(clp);
|
|
if (crw < 0)
|
|
break;
|
|
if (SGQ_CAN_READ & crw) {
|
|
res = start_read(clp);
|
|
if (res <= 0) {
|
|
pr2serr("start_read: res=%d\n", res);
|
|
break;
|
|
}
|
|
res = 0;
|
|
}
|
|
if (SGQ_CAN_WRITE & crw) {
|
|
res = start_write(clp);
|
|
if (res <= 0) {
|
|
pr2serr("start_write: res=%d\n", res);
|
|
break;
|
|
}
|
|
res = 0;
|
|
}
|
|
}
|
|
|
|
if ((STDIN_FILENO != clp->infd) && (clp->infd >= 0))
|
|
close(clp->infd);
|
|
if ((STDOUT_FILENO != clp->outfd) && (clp->outfd >= 0))
|
|
close(clp->outfd);
|
|
if (0 != clp->out_count) {
|
|
pr2serr("Some error occurred, remaining blocks=%d\n", clp->out_count);
|
|
res = 1;
|
|
}
|
|
pr2serr("%d+%d records in\n", count - clp->in_done_count,
|
|
clp->in_partial);
|
|
pr2serr("%d+%d records out\n", count - clp->out_done_count,
|
|
clp->out_partial);
|
|
if (clp->dio_incomplete)
|
|
pr2serr(">> Direct IO requested but incomplete %d times\n",
|
|
clp->dio_incomplete);
|
|
if (clp->sum_of_resids)
|
|
pr2serr(">> Non-zero sum of residual counts=%d\n",
|
|
clp->sum_of_resids);
|
|
if (clp->debug > 0) {
|
|
if (! clp->no_sig)
|
|
pr2serr("SIGIO/SIGPOLL signals received: %d, RT sigs: %d\n",
|
|
clp->sigs_io_received, clp->sigs_rt_received);
|
|
if (polled_present)
|
|
pr2serr("POLLED (blk_poll) used to complete %d commands\n",
|
|
clp->blk_poll_count);
|
|
}
|
|
if (clp->pollerr_count > 0)
|
|
pr2serr(">> poll() system call gave POLLERR %d times\n",
|
|
clp->pollerr_count);
|
|
remove_elems(clp);
|
|
return res < 0 ? 99 : res;
|
|
}
|