mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-29 11:11:45 -04:00
block: introduce new block status code type
Currently we use nornal Linux errno values in the block layer, and while we accept any error a few have overloaded magic meanings. This patch instead introduces a new blk_status_t value that holds block layer specific status codes and explicitly explains their meaning. Helpers to convert from and to the previous special meanings are provided for now, but I suspect we want to get rid of them in the long run - those drivers that have a errno input (e.g. networking) usually get errnos that don't know about the special block layer overloads, and similarly returning them to userspace will usually return somethings that strictly speaking isn't correct for file system operations, but that's left as an exercise for later. For now the set of errors is a very limited set that closely corresponds to the previous overloaded errno values, but there is some low hanging fruite to improve it. blk_status_t (ab)uses the sparse __bitwise annotations to allow for sparse typechecking, so that we can easily catch places passing the wrong values. Signed-off-by: Christoph Hellwig <[email protected]> Signed-off-by: Jens Axboe <[email protected]>
This commit is contained in:
Christoph Hellwig
Jens Axboe
parent
1be5690984
commit
2a842acab1
76 changed files with 474 additions and 428 deletions
|
|
@ -3464,7 +3464,7 @@ static inline bool DAC960_ProcessCompletedRequest(DAC960_Command_T *Command,
|
|||
bool SuccessfulIO)
|
||||
{
|
||||
struct request *Request = Command->Request;
|
||||
int Error = SuccessfulIO ? 0 : -EIO;
|
||||
blk_status_t Error = SuccessfulIO ? BLK_STS_OK : BLK_STS_IOERR;
|
||||
|
||||
pci_unmap_sg(Command->Controller->PCIDevice, Command->cmd_sglist,
|
||||
Command->SegmentCount, Command->DmaDirection);
|
||||
|
|
|
|||
|
|
@ -1378,7 +1378,7 @@ static void redo_fd_request(void)
|
|||
struct amiga_floppy_struct *floppy;
|
||||
char *data;
|
||||
unsigned long flags;
|
||||
int err;
|
||||
blk_status_t err;
|
||||
|
||||
next_req:
|
||||
rq = set_next_request();
|
||||
|
|
@ -1392,7 +1392,7 @@ next_req:
|
|||
|
||||
next_segment:
|
||||
/* Here someone could investigate to be more efficient */
|
||||
for (cnt = 0, err = 0; cnt < blk_rq_cur_sectors(rq); cnt++) {
|
||||
for (cnt = 0, err = BLK_STS_OK; cnt < blk_rq_cur_sectors(rq); cnt++) {
|
||||
#ifdef DEBUG
|
||||
printk("fd: sector %ld + %d requested for %s\n",
|
||||
blk_rq_pos(rq), cnt,
|
||||
|
|
@ -1400,7 +1400,7 @@ next_segment:
|
|||
#endif
|
||||
block = blk_rq_pos(rq) + cnt;
|
||||
if ((int)block > floppy->blocks) {
|
||||
err = -EIO;
|
||||
err = BLK_STS_IOERR;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -1413,7 +1413,7 @@ next_segment:
|
|||
#endif
|
||||
|
||||
if (get_track(drive, track) == -1) {
|
||||
err = -EIO;
|
||||
err = BLK_STS_IOERR;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -1424,7 +1424,7 @@ next_segment:
|
|||
|
||||
/* keep the drive spinning while writes are scheduled */
|
||||
if (!fd_motor_on(drive)) {
|
||||
err = -EIO;
|
||||
err = BLK_STS_IOERR;
|
||||
break;
|
||||
}
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -1071,7 +1071,7 @@ aoe_end_request(struct aoedev *d, struct request *rq, int fastfail)
|
|||
do {
|
||||
bio = rq->bio;
|
||||
bok = !fastfail && !bio->bi_error;
|
||||
} while (__blk_end_request(rq, bok ? 0 : -EIO, bio->bi_iter.bi_size));
|
||||
} while (__blk_end_request(rq, bok ? BLK_STS_OK : BLK_STS_IOERR, bio->bi_iter.bi_size));
|
||||
|
||||
/* cf. http://lkml.org/lkml/2006/10/31/28 */
|
||||
if (!fastfail)
|
||||
|
|
|
|||
|
|
@ -378,7 +378,7 @@ static DEFINE_TIMER(readtrack_timer, fd_readtrack_check, 0, 0);
|
|||
static DEFINE_TIMER(timeout_timer, fd_times_out, 0, 0);
|
||||
static DEFINE_TIMER(fd_timer, check_change, 0, 0);
|
||||
|
||||
static void fd_end_request_cur(int err)
|
||||
static void fd_end_request_cur(blk_status_t err)
|
||||
{
|
||||
if (!__blk_end_request_cur(fd_request, err))
|
||||
fd_request = NULL;
|
||||
|
|
@ -620,7 +620,7 @@ static void fd_error( void )
|
|||
fd_request->error_count++;
|
||||
if (fd_request->error_count >= MAX_ERRORS) {
|
||||
printk(KERN_ERR "fd%d: too many errors.\n", SelectedDrive );
|
||||
fd_end_request_cur(-EIO);
|
||||
fd_end_request_cur(BLK_STS_IOERR);
|
||||
}
|
||||
else if (fd_request->error_count == RECALIBRATE_ERRORS) {
|
||||
printk(KERN_WARNING "fd%d: recalibrating\n", SelectedDrive );
|
||||
|
|
@ -739,7 +739,7 @@ static void do_fd_action( int drive )
|
|||
}
|
||||
else {
|
||||
/* all sectors finished */
|
||||
fd_end_request_cur(0);
|
||||
fd_end_request_cur(BLK_STS_OK);
|
||||
redo_fd_request();
|
||||
return;
|
||||
}
|
||||
|
|
@ -1144,7 +1144,7 @@ static void fd_rwsec_done1(int status)
|
|||
}
|
||||
else {
|
||||
/* all sectors finished */
|
||||
fd_end_request_cur(0);
|
||||
fd_end_request_cur(BLK_STS_OK);
|
||||
redo_fd_request();
|
||||
}
|
||||
return;
|
||||
|
|
@ -1445,7 +1445,7 @@ repeat:
|
|||
if (!UD.connected) {
|
||||
/* drive not connected */
|
||||
printk(KERN_ERR "Unknown Device: fd%d\n", drive );
|
||||
fd_end_request_cur(-EIO);
|
||||
fd_end_request_cur(BLK_STS_IOERR);
|
||||
goto repeat;
|
||||
}
|
||||
|
||||
|
|
@ -1461,12 +1461,12 @@ repeat:
|
|||
/* user supplied disk type */
|
||||
if (--type >= NUM_DISK_MINORS) {
|
||||
printk(KERN_WARNING "fd%d: invalid disk format", drive );
|
||||
fd_end_request_cur(-EIO);
|
||||
fd_end_request_cur(BLK_STS_IOERR);
|
||||
goto repeat;
|
||||
}
|
||||
if (minor2disktype[type].drive_types > DriveType) {
|
||||
printk(KERN_WARNING "fd%d: unsupported disk format", drive );
|
||||
fd_end_request_cur(-EIO);
|
||||
fd_end_request_cur(BLK_STS_IOERR);
|
||||
goto repeat;
|
||||
}
|
||||
type = minor2disktype[type].index;
|
||||
|
|
@ -1476,7 +1476,7 @@ repeat:
|
|||
}
|
||||
|
||||
if (blk_rq_pos(fd_request) + 1 > UDT->blocks) {
|
||||
fd_end_request_cur(-EIO);
|
||||
fd_end_request_cur(BLK_STS_IOERR);
|
||||
goto repeat;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1864,7 +1864,8 @@ static void cciss_softirq_done(struct request *rq)
|
|||
/* set the residual count for pc requests */
|
||||
if (blk_rq_is_passthrough(rq))
|
||||
scsi_req(rq)->resid_len = c->err_info->ResidualCnt;
|
||||
blk_end_request_all(rq, scsi_req(rq)->result ? -EIO : 0);
|
||||
blk_end_request_all(rq, scsi_req(rq)->result ?
|
||||
BLK_STS_IOERR : BLK_STS_OK);
|
||||
|
||||
spin_lock_irqsave(&h->lock, flags);
|
||||
cmd_free(h, c);
|
||||
|
|
|
|||
|
|
@ -2202,7 +2202,7 @@ static int do_format(int drive, struct format_descr *tmp_format_req)
|
|||
* =============================
|
||||
*/
|
||||
|
||||
static void floppy_end_request(struct request *req, int error)
|
||||
static void floppy_end_request(struct request *req, blk_status_t error)
|
||||
{
|
||||
unsigned int nr_sectors = current_count_sectors;
|
||||
unsigned int drive = (unsigned long)req->rq_disk->private_data;
|
||||
|
|
@ -2263,7 +2263,7 @@ static void request_done(int uptodate)
|
|||
DRWE->last_error_generation = DRS->generation;
|
||||
}
|
||||
spin_lock_irqsave(q->queue_lock, flags);
|
||||
floppy_end_request(req, -EIO);
|
||||
floppy_end_request(req, BLK_STS_IOERR);
|
||||
spin_unlock_irqrestore(q->queue_lock, flags);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -464,7 +464,7 @@ static void lo_complete_rq(struct request *rq)
|
|||
zero_fill_bio(bio);
|
||||
}
|
||||
|
||||
blk_mq_end_request(rq, cmd->ret < 0 ? -EIO : 0);
|
||||
blk_mq_end_request(rq, cmd->ret < 0 ? BLK_STS_IOERR : BLK_STS_OK);
|
||||
}
|
||||
|
||||
static void lo_rw_aio_complete(struct kiocb *iocb, long ret, long ret2)
|
||||
|
|
|
|||
|
|
@ -532,7 +532,7 @@ static int mtip_read_log_page(struct mtip_port *port, u8 page, u16 *buffer,
|
|||
static int mtip_get_smart_attr(struct mtip_port *port, unsigned int id,
|
||||
struct smart_attr *attrib);
|
||||
|
||||
static void mtip_complete_command(struct mtip_cmd *cmd, int status)
|
||||
static void mtip_complete_command(struct mtip_cmd *cmd, blk_status_t status)
|
||||
{
|
||||
struct request *req = blk_mq_rq_from_pdu(cmd);
|
||||
|
||||
|
|
@ -568,7 +568,7 @@ static void mtip_handle_tfe(struct driver_data *dd)
|
|||
if (test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags)) {
|
||||
cmd = mtip_cmd_from_tag(dd, MTIP_TAG_INTERNAL);
|
||||
dbg_printk(MTIP_DRV_NAME " TFE for the internal command\n");
|
||||
mtip_complete_command(cmd, -EIO);
|
||||
mtip_complete_command(cmd, BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -667,7 +667,7 @@ static void mtip_handle_tfe(struct driver_data *dd)
|
|||
tag,
|
||||
fail_reason != NULL ?
|
||||
fail_reason : "unknown");
|
||||
mtip_complete_command(cmd, -ENODATA);
|
||||
mtip_complete_command(cmd, BLK_STS_MEDIUM);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
|
@ -690,7 +690,7 @@ static void mtip_handle_tfe(struct driver_data *dd)
|
|||
dev_warn(&port->dd->pdev->dev,
|
||||
"retiring tag %d\n", tag);
|
||||
|
||||
mtip_complete_command(cmd, -EIO);
|
||||
mtip_complete_command(cmd, BLK_STS_IOERR);
|
||||
}
|
||||
}
|
||||
print_tags(dd, "reissued (TFE)", tagaccum, cmd_cnt);
|
||||
|
|
@ -2753,7 +2753,7 @@ static void mtip_abort_cmd(struct request *req, void *data,
|
|||
dbg_printk(MTIP_DRV_NAME " Aborting request, tag = %d\n", req->tag);
|
||||
|
||||
clear_bit(req->tag, dd->port->cmds_to_issue);
|
||||
cmd->status = -EIO;
|
||||
cmd->status = BLK_STS_IOERR;
|
||||
mtip_softirq_done_fn(req);
|
||||
}
|
||||
|
||||
|
|
@ -3597,7 +3597,7 @@ static int mtip_submit_request(struct blk_mq_hw_ctx *hctx, struct request *rq)
|
|||
int err;
|
||||
|
||||
err = mtip_send_trim(dd, blk_rq_pos(rq), blk_rq_sectors(rq));
|
||||
blk_mq_end_request(rq, err);
|
||||
blk_mq_end_request(rq, err ? BLK_STS_IOERR : BLK_STS_OK);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -3730,7 +3730,7 @@ static enum blk_eh_timer_return mtip_cmd_timeout(struct request *req,
|
|||
if (reserved) {
|
||||
struct mtip_cmd *cmd = blk_mq_rq_to_pdu(req);
|
||||
|
||||
cmd->status = -ETIME;
|
||||
cmd->status = BLK_STS_TIMEOUT;
|
||||
return BLK_EH_HANDLED;
|
||||
}
|
||||
|
||||
|
|
@ -3961,7 +3961,7 @@ static void mtip_no_dev_cleanup(struct request *rq, void *data, bool reserv)
|
|||
{
|
||||
struct mtip_cmd *cmd = blk_mq_rq_to_pdu(rq);
|
||||
|
||||
cmd->status = -ENODEV;
|
||||
cmd->status = BLK_STS_IOERR;
|
||||
blk_mq_complete_request(rq);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -342,7 +342,7 @@ struct mtip_cmd {
|
|||
int retries; /* The number of retries left for this command. */
|
||||
|
||||
int direction; /* Data transfer direction */
|
||||
int status;
|
||||
blk_status_t status;
|
||||
};
|
||||
|
||||
/* Structure used to describe a port. */
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ struct nbd_cmd {
|
|||
int index;
|
||||
int cookie;
|
||||
struct completion send_complete;
|
||||
int status;
|
||||
blk_status_t status;
|
||||
};
|
||||
|
||||
#if IS_ENABLED(CONFIG_DEBUG_FS)
|
||||
|
|
@ -286,7 +286,7 @@ static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req,
|
|||
struct nbd_config *config;
|
||||
|
||||
if (!refcount_inc_not_zero(&nbd->config_refs)) {
|
||||
cmd->status = -EIO;
|
||||
cmd->status = BLK_STS_TIMEOUT;
|
||||
return BLK_EH_HANDLED;
|
||||
}
|
||||
|
||||
|
|
@ -331,7 +331,7 @@ static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req,
|
|||
"Connection timed out\n");
|
||||
}
|
||||
set_bit(NBD_TIMEDOUT, &config->runtime_flags);
|
||||
cmd->status = -EIO;
|
||||
cmd->status = BLK_STS_IOERR;
|
||||
sock_shutdown(nbd);
|
||||
nbd_config_put(nbd);
|
||||
|
||||
|
|
@ -578,7 +578,7 @@ static struct nbd_cmd *nbd_read_stat(struct nbd_device *nbd, int index)
|
|||
if (ntohl(reply.error)) {
|
||||
dev_err(disk_to_dev(nbd->disk), "Other side returned error (%d)\n",
|
||||
ntohl(reply.error));
|
||||
cmd->status = -EIO;
|
||||
cmd->status = BLK_STS_IOERR;
|
||||
return cmd;
|
||||
}
|
||||
|
||||
|
|
@ -603,7 +603,7 @@ static struct nbd_cmd *nbd_read_stat(struct nbd_device *nbd, int index)
|
|||
*/
|
||||
if (nbd_disconnected(config) ||
|
||||
config->num_connections <= 1) {
|
||||
cmd->status = -EIO;
|
||||
cmd->status = BLK_STS_IOERR;
|
||||
return cmd;
|
||||
}
|
||||
return ERR_PTR(-EIO);
|
||||
|
|
@ -655,7 +655,7 @@ static void nbd_clear_req(struct request *req, void *data, bool reserved)
|
|||
if (!blk_mq_request_started(req))
|
||||
return;
|
||||
cmd = blk_mq_rq_to_pdu(req);
|
||||
cmd->status = -EIO;
|
||||
cmd->status = BLK_STS_IOERR;
|
||||
blk_mq_complete_request(req);
|
||||
}
|
||||
|
||||
|
|
@ -744,7 +744,7 @@ static int nbd_handle_cmd(struct nbd_cmd *cmd, int index)
|
|||
nbd_config_put(nbd);
|
||||
return -EINVAL;
|
||||
}
|
||||
cmd->status = 0;
|
||||
cmd->status = BLK_STS_OK;
|
||||
again:
|
||||
nsock = config->socks[index];
|
||||
mutex_lock(&nsock->tx_lock);
|
||||
|
|
|
|||
|
|
@ -229,11 +229,11 @@ static void end_cmd(struct nullb_cmd *cmd)
|
|||
|
||||
switch (queue_mode) {
|
||||
case NULL_Q_MQ:
|
||||
blk_mq_end_request(cmd->rq, 0);
|
||||
blk_mq_end_request(cmd->rq, BLK_STS_OK);
|
||||
return;
|
||||
case NULL_Q_RQ:
|
||||
INIT_LIST_HEAD(&cmd->rq->queuelist);
|
||||
blk_end_request_all(cmd->rq, 0);
|
||||
blk_end_request_all(cmd->rq, BLK_STS_OK);
|
||||
break;
|
||||
case NULL_Q_BIO:
|
||||
bio_endio(cmd->bio);
|
||||
|
|
@ -422,11 +422,12 @@ static void cleanup_queues(struct nullb *nullb)
|
|||
|
||||
#ifdef CONFIG_NVM
|
||||
|
||||
static void null_lnvm_end_io(struct request *rq, int error)
|
||||
static void null_lnvm_end_io(struct request *rq, blk_status_t status)
|
||||
{
|
||||
struct nvm_rq *rqd = rq->end_io_data;
|
||||
|
||||
rqd->error = error;
|
||||
/* XXX: lighnvm core seems to expect NVM_RSP_* values here.. */
|
||||
rqd->error = status ? -EIO : 0;
|
||||
nvm_end_io(rqd);
|
||||
|
||||
blk_put_request(rq);
|
||||
|
|
|
|||
|
|
@ -783,7 +783,7 @@ static void pcd_request(void)
|
|||
ps_set_intr(do_pcd_read, NULL, 0, nice);
|
||||
return;
|
||||
} else {
|
||||
__blk_end_request_all(pcd_req, -EIO);
|
||||
__blk_end_request_all(pcd_req, BLK_STS_IOERR);
|
||||
pcd_req = NULL;
|
||||
}
|
||||
}
|
||||
|
|
@ -794,7 +794,7 @@ static void do_pcd_request(struct request_queue *q)
|
|||
pcd_request();
|
||||
}
|
||||
|
||||
static inline void next_request(int err)
|
||||
static inline void next_request(blk_status_t err)
|
||||
{
|
||||
unsigned long saved_flags;
|
||||
|
||||
|
|
@ -837,7 +837,7 @@ static void pcd_start(void)
|
|||
|
||||
if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
|
||||
pcd_bufblk = -1;
|
||||
next_request(-EIO);
|
||||
next_request(BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -871,7 +871,7 @@ static void do_pcd_read_drq(void)
|
|||
return;
|
||||
}
|
||||
pcd_bufblk = -1;
|
||||
next_request(-EIO);
|
||||
next_request(BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -438,7 +438,7 @@ static void run_fsm(void)
|
|||
phase = NULL;
|
||||
spin_lock_irqsave(&pd_lock, saved_flags);
|
||||
if (!__blk_end_request_cur(pd_req,
|
||||
res == Ok ? 0 : -EIO)) {
|
||||
res == Ok ? 0 : BLK_STS_IOERR)) {
|
||||
if (!set_next_request())
|
||||
stop = 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -801,7 +801,7 @@ static int set_next_request(void)
|
|||
return pf_req != NULL;
|
||||
}
|
||||
|
||||
static void pf_end_request(int err)
|
||||
static void pf_end_request(blk_status_t err)
|
||||
{
|
||||
if (pf_req && !__blk_end_request_cur(pf_req, err))
|
||||
pf_req = NULL;
|
||||
|
|
@ -821,7 +821,7 @@ repeat:
|
|||
pf_count = blk_rq_cur_sectors(pf_req);
|
||||
|
||||
if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
|
||||
pf_end_request(-EIO);
|
||||
pf_end_request(BLK_STS_IOERR);
|
||||
goto repeat;
|
||||
}
|
||||
|
||||
|
|
@ -836,7 +836,7 @@ repeat:
|
|||
pi_do_claimed(pf_current->pi, do_pf_write);
|
||||
else {
|
||||
pf_busy = 0;
|
||||
pf_end_request(-EIO);
|
||||
pf_end_request(BLK_STS_IOERR);
|
||||
goto repeat;
|
||||
}
|
||||
}
|
||||
|
|
@ -868,7 +868,7 @@ static int pf_next_buf(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static inline void next_request(int err)
|
||||
static inline void next_request(blk_status_t err)
|
||||
{
|
||||
unsigned long saved_flags;
|
||||
|
||||
|
|
@ -896,7 +896,7 @@ static void do_pf_read_start(void)
|
|||
pi_do_claimed(pf_current->pi, do_pf_read_start);
|
||||
return;
|
||||
}
|
||||
next_request(-EIO);
|
||||
next_request(BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
pf_mask = STAT_DRQ;
|
||||
|
|
@ -915,7 +915,7 @@ static void do_pf_read_drq(void)
|
|||
pi_do_claimed(pf_current->pi, do_pf_read_start);
|
||||
return;
|
||||
}
|
||||
next_request(-EIO);
|
||||
next_request(BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
pi_read_block(pf_current->pi, pf_buf, 512);
|
||||
|
|
@ -942,7 +942,7 @@ static void do_pf_write_start(void)
|
|||
pi_do_claimed(pf_current->pi, do_pf_write_start);
|
||||
return;
|
||||
}
|
||||
next_request(-EIO);
|
||||
next_request(BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -955,7 +955,7 @@ static void do_pf_write_start(void)
|
|||
pi_do_claimed(pf_current->pi, do_pf_write_start);
|
||||
return;
|
||||
}
|
||||
next_request(-EIO);
|
||||
next_request(BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
pi_write_block(pf_current->pi, pf_buf, 512);
|
||||
|
|
@ -975,7 +975,7 @@ static void do_pf_write_done(void)
|
|||
pi_do_claimed(pf_current->pi, do_pf_write_start);
|
||||
return;
|
||||
}
|
||||
next_request(-EIO);
|
||||
next_request(BLK_STS_IOERR);
|
||||
return;
|
||||
}
|
||||
pi_disconnect(pf_current->pi);
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
|
|||
if (res) {
|
||||
dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__,
|
||||
__LINE__, op, res);
|
||||
__blk_end_request_all(req, -EIO);
|
||||
__blk_end_request_all(req, BLK_STS_IOERR);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -180,7 +180,7 @@ static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
|
|||
if (res) {
|
||||
dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
|
||||
__func__, __LINE__, res);
|
||||
__blk_end_request_all(req, -EIO);
|
||||
__blk_end_request_all(req, BLK_STS_IOERR);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -208,7 +208,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
|
|||
break;
|
||||
default:
|
||||
blk_dump_rq_flags(req, DEVICE_NAME " bad request");
|
||||
__blk_end_request_all(req, -EIO);
|
||||
__blk_end_request_all(req, BLK_STS_IOERR);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -231,7 +231,8 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
|
|||
struct ps3_storage_device *dev = data;
|
||||
struct ps3disk_private *priv;
|
||||
struct request *req;
|
||||
int res, read, error;
|
||||
int res, read;
|
||||
blk_status_t error;
|
||||
u64 tag, status;
|
||||
const char *op;
|
||||
|
||||
|
|
@ -269,7 +270,7 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
|
|||
if (status) {
|
||||
dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
|
||||
__LINE__, op, status);
|
||||
error = -EIO;
|
||||
error = BLK_STS_IOERR;
|
||||
} else {
|
||||
dev_dbg(&dev->sbd.core, "%s:%u: %s completed\n", __func__,
|
||||
__LINE__, op);
|
||||
|
|
|
|||
|
|
@ -2293,11 +2293,13 @@ static bool rbd_img_obj_end_request(struct rbd_obj_request *obj_request)
|
|||
rbd_assert(img_request->obj_request != NULL);
|
||||
more = obj_request->which < img_request->obj_request_count - 1;
|
||||
} else {
|
||||
blk_status_t status = errno_to_blk_status(result);
|
||||
|
||||
rbd_assert(img_request->rq != NULL);
|
||||
|
||||
more = blk_update_request(img_request->rq, result, xferred);
|
||||
more = blk_update_request(img_request->rq, status, xferred);
|
||||
if (!more)
|
||||
__blk_mq_end_request(img_request->rq, result);
|
||||
__blk_mq_end_request(img_request->rq, status);
|
||||
}
|
||||
|
||||
return more;
|
||||
|
|
@ -4149,7 +4151,7 @@ err_rq:
|
|||
obj_op_name(op_type), length, offset, result);
|
||||
ceph_put_snap_context(snapc);
|
||||
err:
|
||||
blk_mq_end_request(rq, result);
|
||||
blk_mq_end_request(rq, errno_to_blk_status(result));
|
||||
}
|
||||
|
||||
static int rbd_queue_rq(struct blk_mq_hw_ctx *hctx,
|
||||
|
|
|
|||
|
|
@ -451,8 +451,8 @@ static void skd_send_special_fitmsg(struct skd_device *skdev,
|
|||
struct skd_special_context *skspcl);
|
||||
static void skd_request_fn(struct request_queue *rq);
|
||||
static void skd_end_request(struct skd_device *skdev,
|
||||
struct skd_request_context *skreq, int error);
|
||||
static int skd_preop_sg_list(struct skd_device *skdev,
|
||||
struct skd_request_context *skreq, blk_status_t status);
|
||||
static bool skd_preop_sg_list(struct skd_device *skdev,
|
||||
struct skd_request_context *skreq);
|
||||
static void skd_postop_sg_list(struct skd_device *skdev,
|
||||
struct skd_request_context *skreq);
|
||||
|
|
@ -491,7 +491,7 @@ static void skd_fail_all_pending(struct skd_device *skdev)
|
|||
if (req == NULL)
|
||||
break;
|
||||
blk_start_request(req);
|
||||
__blk_end_request_all(req, -EIO);
|
||||
__blk_end_request_all(req, BLK_STS_IOERR);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -545,7 +545,6 @@ static void skd_request_fn(struct request_queue *q)
|
|||
struct request *req = NULL;
|
||||
struct skd_scsi_request *scsi_req;
|
||||
unsigned long io_flags;
|
||||
int error;
|
||||
u32 lba;
|
||||
u32 count;
|
||||
int data_dir;
|
||||
|
|
@ -716,9 +715,7 @@ static void skd_request_fn(struct request_queue *q)
|
|||
if (!req->bio)
|
||||
goto skip_sg;
|
||||
|
||||
error = skd_preop_sg_list(skdev, skreq);
|
||||
|
||||
if (error != 0) {
|
||||
if (!skd_preop_sg_list(skdev, skreq)) {
|
||||
/*
|
||||
* Complete the native request with error.
|
||||
* Note that the request context is still at the
|
||||
|
|
@ -730,7 +727,7 @@ static void skd_request_fn(struct request_queue *q)
|
|||
*/
|
||||
pr_debug("%s:%s:%d error Out\n",
|
||||
skdev->name, __func__, __LINE__);
|
||||
skd_end_request(skdev, skreq, error);
|
||||
skd_end_request(skdev, skreq, BLK_STS_RESOURCE);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -805,7 +802,7 @@ skip_sg:
|
|||
}
|
||||
|
||||
static void skd_end_request(struct skd_device *skdev,
|
||||
struct skd_request_context *skreq, int error)
|
||||
struct skd_request_context *skreq, blk_status_t error)
|
||||
{
|
||||
if (unlikely(error)) {
|
||||
struct request *req = skreq->req;
|
||||
|
|
@ -822,7 +819,7 @@ static void skd_end_request(struct skd_device *skdev,
|
|||
__blk_end_request_all(skreq->req, error);
|
||||
}
|
||||
|
||||
static int skd_preop_sg_list(struct skd_device *skdev,
|
||||
static bool skd_preop_sg_list(struct skd_device *skdev,
|
||||
struct skd_request_context *skreq)
|
||||
{
|
||||
struct request *req = skreq->req;
|
||||
|
|
@ -839,7 +836,7 @@ static int skd_preop_sg_list(struct skd_device *skdev,
|
|||
|
||||
n_sg = blk_rq_map_sg(skdev->queue, req, sg);
|
||||
if (n_sg <= 0)
|
||||
return -EINVAL;
|
||||
return false;
|
||||
|
||||
/*
|
||||
* Map scatterlist to PCI bus addresses.
|
||||
|
|
@ -847,7 +844,7 @@ static int skd_preop_sg_list(struct skd_device *skdev,
|
|||
*/
|
||||
n_sg = pci_map_sg(skdev->pdev, sg, n_sg, pci_dir);
|
||||
if (n_sg <= 0)
|
||||
return -EINVAL;
|
||||
return false;
|
||||
|
||||
SKD_ASSERT(n_sg <= skdev->sgs_per_request);
|
||||
|
||||
|
|
@ -882,7 +879,7 @@ static int skd_preop_sg_list(struct skd_device *skdev,
|
|||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
static void skd_postop_sg_list(struct skd_device *skdev,
|
||||
|
|
@ -2333,7 +2330,7 @@ static void skd_resolve_req_exception(struct skd_device *skdev,
|
|||
switch (skd_check_status(skdev, cmp_status, &skreq->err_info)) {
|
||||
case SKD_CHECK_STATUS_REPORT_GOOD:
|
||||
case SKD_CHECK_STATUS_REPORT_SMART_ALERT:
|
||||
skd_end_request(skdev, skreq, 0);
|
||||
skd_end_request(skdev, skreq, BLK_STS_OK);
|
||||
break;
|
||||
|
||||
case SKD_CHECK_STATUS_BUSY_IMMINENT:
|
||||
|
|
@ -2355,7 +2352,7 @@ static void skd_resolve_req_exception(struct skd_device *skdev,
|
|||
|
||||
case SKD_CHECK_STATUS_REPORT_ERROR:
|
||||
default:
|
||||
skd_end_request(skdev, skreq, -EIO);
|
||||
skd_end_request(skdev, skreq, BLK_STS_IOERR);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -2748,7 +2745,7 @@ static int skd_isr_completion_posted(struct skd_device *skdev,
|
|||
* native request.
|
||||
*/
|
||||
if (likely(cmp_status == SAM_STAT_GOOD))
|
||||
skd_end_request(skdev, skreq, 0);
|
||||
skd_end_request(skdev, skreq, BLK_STS_OK);
|
||||
else
|
||||
skd_resolve_req_exception(skdev, skreq);
|
||||
}
|
||||
|
|
@ -3190,7 +3187,7 @@ static void skd_recover_requests(struct skd_device *skdev, int requeue)
|
|||
SKD_MAX_RETRIES)
|
||||
blk_requeue_request(skdev->queue, skreq->req);
|
||||
else
|
||||
skd_end_request(skdev, skreq, -EIO);
|
||||
skd_end_request(skdev, skreq, BLK_STS_IOERR);
|
||||
|
||||
skreq->req = NULL;
|
||||
|
||||
|
|
|
|||
|
|
@ -316,7 +316,7 @@ static void vdc_end_one(struct vdc_port *port, struct vio_dring_state *dr,
|
|||
|
||||
rqe->req = NULL;
|
||||
|
||||
__blk_end_request(req, (desc->status ? -EIO : 0), desc->size);
|
||||
__blk_end_request(req, (desc->status ? BLK_STS_IOERR : 0), desc->size);
|
||||
|
||||
vdc_blk_queue_start(port);
|
||||
}
|
||||
|
|
@ -1023,7 +1023,7 @@ static void vdc_queue_drain(struct vdc_port *port)
|
|||
struct request *req;
|
||||
|
||||
while ((req = blk_fetch_request(port->disk->queue)) != NULL)
|
||||
__blk_end_request_all(req, -EIO);
|
||||
__blk_end_request_all(req, BLK_STS_IOERR);
|
||||
}
|
||||
|
||||
static void vdc_ldc_reset_timer(unsigned long _arg)
|
||||
|
|
|
|||
|
|
@ -493,7 +493,7 @@ static inline int swim_read_sector(struct floppy_state *fs,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int floppy_read_sectors(struct floppy_state *fs,
|
||||
static blk_status_t floppy_read_sectors(struct floppy_state *fs,
|
||||
int req_sector, int sectors_nb,
|
||||
unsigned char *buffer)
|
||||
{
|
||||
|
|
@ -516,7 +516,7 @@ static int floppy_read_sectors(struct floppy_state *fs,
|
|||
ret = swim_read_sector(fs, side, track, sector,
|
||||
buffer);
|
||||
if (try-- == 0)
|
||||
return -EIO;
|
||||
return BLK_STS_IOERR;
|
||||
} while (ret != 512);
|
||||
|
||||
buffer += ret;
|
||||
|
|
@ -553,7 +553,7 @@ static void do_fd_request(struct request_queue *q)
|
|||
|
||||
req = swim_next_request(swd);
|
||||
while (req) {
|
||||
int err = -EIO;
|
||||
blk_status_t err = BLK_STS_IOERR;
|
||||
|
||||
fs = req->rq_disk->private_data;
|
||||
if (blk_rq_pos(req) >= fs->total_secs)
|
||||
|
|
|
|||
|
|
@ -257,7 +257,7 @@ static unsigned int floppy_check_events(struct gendisk *disk,
|
|||
unsigned int clearing);
|
||||
static int floppy_revalidate(struct gendisk *disk);
|
||||
|
||||
static bool swim3_end_request(struct floppy_state *fs, int err, unsigned int nr_bytes)
|
||||
static bool swim3_end_request(struct floppy_state *fs, blk_status_t err, unsigned int nr_bytes)
|
||||
{
|
||||
struct request *req = fs->cur_req;
|
||||
int rc;
|
||||
|
|
@ -334,7 +334,7 @@ static void start_request(struct floppy_state *fs)
|
|||
if (fs->mdev->media_bay &&
|
||||
check_media_bay(fs->mdev->media_bay) != MB_FD) {
|
||||
swim3_dbg("%s", " media bay absent, dropping req\n");
|
||||
swim3_end_request(fs, -ENODEV, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -350,12 +350,12 @@ static void start_request(struct floppy_state *fs)
|
|||
if (blk_rq_pos(req) >= fs->total_secs) {
|
||||
swim3_dbg(" pos out of bounds (%ld, max is %ld)\n",
|
||||
(long)blk_rq_pos(req), (long)fs->total_secs);
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
continue;
|
||||
}
|
||||
if (fs->ejected) {
|
||||
swim3_dbg("%s", " disk ejected\n");
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -364,7 +364,7 @@ static void start_request(struct floppy_state *fs)
|
|||
fs->write_prot = swim3_readbit(fs, WRITE_PROT);
|
||||
if (fs->write_prot) {
|
||||
swim3_dbg("%s", " try to write, disk write protected\n");
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
|
@ -548,7 +548,7 @@ static void act(struct floppy_state *fs)
|
|||
if (fs->retries > 5) {
|
||||
swim3_err("Wrong cylinder in transfer, want: %d got %d\n",
|
||||
fs->req_cyl, fs->cur_cyl);
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
return;
|
||||
}
|
||||
|
|
@ -584,7 +584,7 @@ static void scan_timeout(unsigned long data)
|
|||
out_8(&sw->intr_enable, 0);
|
||||
fs->cur_cyl = -1;
|
||||
if (fs->retries > 5) {
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
start_request(fs);
|
||||
} else {
|
||||
|
|
@ -608,7 +608,7 @@ static void seek_timeout(unsigned long data)
|
|||
out_8(&sw->select, RELAX);
|
||||
out_8(&sw->intr_enable, 0);
|
||||
swim3_err("%s", "Seek timeout\n");
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
start_request(fs);
|
||||
spin_unlock_irqrestore(&swim3_lock, flags);
|
||||
|
|
@ -637,7 +637,7 @@ static void settle_timeout(unsigned long data)
|
|||
goto unlock;
|
||||
}
|
||||
swim3_err("%s", "Seek settle timeout\n");
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
start_request(fs);
|
||||
unlock:
|
||||
|
|
@ -666,7 +666,7 @@ static void xfer_timeout(unsigned long data)
|
|||
swim3_err("Timeout %sing sector %ld\n",
|
||||
(rq_data_dir(fs->cur_req)==WRITE? "writ": "read"),
|
||||
(long)blk_rq_pos(fs->cur_req));
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
start_request(fs);
|
||||
spin_unlock_irqrestore(&swim3_lock, flags);
|
||||
|
|
@ -703,7 +703,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
|
|||
swim3_err("%s", "Seen sector but cyl=ff?\n");
|
||||
fs->cur_cyl = -1;
|
||||
if (fs->retries > 5) {
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
start_request(fs);
|
||||
} else {
|
||||
|
|
@ -786,7 +786,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
|
|||
swim3_err("Error %sing block %ld (err=%x)\n",
|
||||
rq_data_dir(req) == WRITE? "writ": "read",
|
||||
(long)blk_rq_pos(req), err);
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -795,7 +795,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
|
|||
swim3_err("fd dma error: stat=%x resid=%d\n", stat, resid);
|
||||
swim3_err(" state=%d, dir=%x, intr=%x, err=%x\n",
|
||||
fs->state, rq_data_dir(req), intr, err);
|
||||
swim3_end_request(fs, -EIO, 0);
|
||||
swim3_end_request(fs, BLK_STS_IOERR, 0);
|
||||
fs->state = idle;
|
||||
start_request(fs);
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -745,7 +745,7 @@ static unsigned int carm_fill_get_fw_ver(struct carm_host *host,
|
|||
|
||||
static inline void carm_end_request_queued(struct carm_host *host,
|
||||
struct carm_request *crq,
|
||||
int error)
|
||||
blk_status_t error)
|
||||
{
|
||||
struct request *req = crq->rq;
|
||||
int rc;
|
||||
|
|
@ -791,7 +791,7 @@ static inline void carm_round_robin(struct carm_host *host)
|
|||
}
|
||||
|
||||
static inline void carm_end_rq(struct carm_host *host, struct carm_request *crq,
|
||||
int error)
|
||||
blk_status_t error)
|
||||
{
|
||||
carm_end_request_queued(host, crq, error);
|
||||
if (max_queue == 1)
|
||||
|
|
@ -869,14 +869,14 @@ queue_one_request:
|
|||
sg = &crq->sg[0];
|
||||
n_elem = blk_rq_map_sg(q, rq, sg);
|
||||
if (n_elem <= 0) {
|
||||
carm_end_rq(host, crq, -EIO);
|
||||
carm_end_rq(host, crq, BLK_STS_IOERR);
|
||||
return; /* request with no s/g entries? */
|
||||
}
|
||||
|
||||
/* map scatterlist to PCI bus addresses */
|
||||
n_elem = pci_map_sg(host->pdev, sg, n_elem, pci_dir);
|
||||
if (n_elem <= 0) {
|
||||
carm_end_rq(host, crq, -EIO);
|
||||
carm_end_rq(host, crq, BLK_STS_IOERR);
|
||||
return; /* request with no s/g entries? */
|
||||
}
|
||||
crq->n_elem = n_elem;
|
||||
|
|
@ -937,7 +937,7 @@ queue_one_request:
|
|||
|
||||
static void carm_handle_array_info(struct carm_host *host,
|
||||
struct carm_request *crq, u8 *mem,
|
||||
int error)
|
||||
blk_status_t error)
|
||||
{
|
||||
struct carm_port *port;
|
||||
u8 *msg_data = mem + sizeof(struct carm_array_info);
|
||||
|
|
@ -997,7 +997,7 @@ out:
|
|||
|
||||
static void carm_handle_scan_chan(struct carm_host *host,
|
||||
struct carm_request *crq, u8 *mem,
|
||||
int error)
|
||||
blk_status_t error)
|
||||
{
|
||||
u8 *msg_data = mem + IOC_SCAN_CHAN_OFFSET;
|
||||
unsigned int i, dev_count = 0;
|
||||
|
|
@ -1029,7 +1029,7 @@ out:
|
|||
}
|
||||
|
||||
static void carm_handle_generic(struct carm_host *host,
|
||||
struct carm_request *crq, int error,
|
||||
struct carm_request *crq, blk_status_t error,
|
||||
int cur_state, int next_state)
|
||||
{
|
||||
DPRINTK("ENTER\n");
|
||||
|
|
@ -1045,7 +1045,7 @@ static void carm_handle_generic(struct carm_host *host,
|
|||
}
|
||||
|
||||
static inline void carm_handle_rw(struct carm_host *host,
|
||||
struct carm_request *crq, int error)
|
||||
struct carm_request *crq, blk_status_t error)
|
||||
{
|
||||
int pci_dir;
|
||||
|
||||
|
|
@ -1067,7 +1067,7 @@ static inline void carm_handle_resp(struct carm_host *host,
|
|||
u32 handle = le32_to_cpu(ret_handle_le);
|
||||
unsigned int msg_idx;
|
||||
struct carm_request *crq;
|
||||
int error = (status == RMSG_OK) ? 0 : -EIO;
|
||||
blk_status_t error = (status == RMSG_OK) ? 0 : BLK_STS_IOERR;
|
||||
u8 *mem;
|
||||
|
||||
VPRINTK("ENTER, handle == 0x%x\n", handle);
|
||||
|
|
@ -1155,7 +1155,7 @@ static inline void carm_handle_resp(struct carm_host *host,
|
|||
err_out:
|
||||
printk(KERN_WARNING DRV_NAME "(%s): BUG: unhandled message type %d/%d\n",
|
||||
pci_name(host->pdev), crq->msg_type, crq->msg_subtype);
|
||||
carm_end_rq(host, crq, -EIO);
|
||||
carm_end_rq(host, crq, BLK_STS_IOERR);
|
||||
}
|
||||
|
||||
static inline void carm_handle_responses(struct carm_host *host)
|
||||
|
|
|
|||
|
|
@ -64,15 +64,15 @@ struct virtblk_req {
|
|||
struct scatterlist sg[];
|
||||
};
|
||||
|
||||
static inline int virtblk_result(struct virtblk_req *vbr)
|
||||
static inline blk_status_t virtblk_result(struct virtblk_req *vbr)
|
||||
{
|
||||
switch (vbr->status) {
|
||||
case VIRTIO_BLK_S_OK:
|
||||
return 0;
|
||||
return BLK_STS_OK;
|
||||
case VIRTIO_BLK_S_UNSUPP:
|
||||
return -ENOTTY;
|
||||
return BLK_STS_NOTSUPP;
|
||||
default:
|
||||
return -EIO;
|
||||
return BLK_STS_IOERR;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -307,7 +307,7 @@ static int virtblk_get_id(struct gendisk *disk, char *id_str)
|
|||
goto out;
|
||||
|
||||
blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
|
||||
err = virtblk_result(blk_mq_rq_to_pdu(req));
|
||||
err = blk_status_to_errno(virtblk_result(blk_mq_rq_to_pdu(req)));
|
||||
out:
|
||||
blk_put_request(req);
|
||||
return err;
|
||||
|
|
|
|||
|
|
@ -1601,14 +1601,18 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
|
|||
continue;
|
||||
}
|
||||
|
||||
blkif_req(req)->error = (bret->status == BLKIF_RSP_OKAY) ? 0 : -EIO;
|
||||
if (bret->status == BLKIF_RSP_OKAY)
|
||||
blkif_req(req)->error = BLK_STS_OK;
|
||||
else
|
||||
blkif_req(req)->error = BLK_STS_IOERR;
|
||||
|
||||
switch (bret->operation) {
|
||||
case BLKIF_OP_DISCARD:
|
||||
if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) {
|
||||
struct request_queue *rq = info->rq;
|
||||
printk(KERN_WARNING "blkfront: %s: %s op failed\n",
|
||||
info->gd->disk_name, op_name(bret->operation));
|
||||
blkif_req(req)->error = -EOPNOTSUPP;
|
||||
blkif_req(req)->error = BLK_STS_NOTSUPP;
|
||||
info->feature_discard = 0;
|
||||
info->feature_secdiscard = 0;
|
||||
queue_flag_clear(QUEUE_FLAG_DISCARD, rq);
|
||||
|
|
@ -1626,11 +1630,11 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
|
|||
rinfo->shadow[id].req.u.rw.nr_segments == 0)) {
|
||||
printk(KERN_WARNING "blkfront: %s: empty %s op failed\n",
|
||||
info->gd->disk_name, op_name(bret->operation));
|
||||
blkif_req(req)->error = -EOPNOTSUPP;
|
||||
blkif_req(req)->error = BLK_STS_NOTSUPP;
|
||||
}
|
||||
if (unlikely(blkif_req(req)->error)) {
|
||||
if (blkif_req(req)->error == -EOPNOTSUPP)
|
||||
blkif_req(req)->error = 0;
|
||||
if (blkif_req(req)->error == BLK_STS_NOTSUPP)
|
||||
blkif_req(req)->error = BLK_STS_OK;
|
||||
info->feature_fua = 0;
|
||||
info->feature_flush = 0;
|
||||
xlvbd_flush(info);
|
||||
|
|
@ -2137,7 +2141,7 @@ static int blkfront_resume(struct xenbus_device *dev)
|
|||
merge_bio.tail = shadow[j].request->biotail;
|
||||
bio_list_merge(&info->bio_list, &merge_bio);
|
||||
shadow[j].request->bio = NULL;
|
||||
blk_mq_end_request(shadow[j].request, 0);
|
||||
blk_mq_end_request(shadow[j].request, BLK_STS_OK);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -471,7 +471,7 @@ static struct request *ace_get_next_request(struct request_queue *q)
|
|||
if (!blk_rq_is_passthrough(req))
|
||||
break;
|
||||
blk_start_request(req);
|
||||
__blk_end_request_all(req, -EIO);
|
||||
__blk_end_request_all(req, BLK_STS_IOERR);
|
||||
}
|
||||
return req;
|
||||
}
|
||||
|
|
@ -499,11 +499,11 @@ static void ace_fsm_dostate(struct ace_device *ace)
|
|||
|
||||
/* Drop all in-flight and pending requests */
|
||||
if (ace->req) {
|
||||
__blk_end_request_all(ace->req, -EIO);
|
||||
__blk_end_request_all(ace->req, BLK_STS_IOERR);
|
||||
ace->req = NULL;
|
||||
}
|
||||
while ((req = blk_fetch_request(ace->queue)) != NULL)
|
||||
__blk_end_request_all(req, -EIO);
|
||||
__blk_end_request_all(req, BLK_STS_IOERR);
|
||||
|
||||
/* Drop back to IDLE state and notify waiters */
|
||||
ace->fsm_state = ACE_FSM_STATE_IDLE;
|
||||
|
|
@ -728,7 +728,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
|
|||
}
|
||||
|
||||
/* bio finished; is there another one? */
|
||||
if (__blk_end_request_cur(ace->req, 0)) {
|
||||
if (__blk_end_request_cur(ace->req, BLK_STS_OK)) {
|
||||
/* dev_dbg(ace->dev, "next block; h=%u c=%u\n",
|
||||
* blk_rq_sectors(ace->req),
|
||||
* blk_rq_cur_sectors(ace->req));
|
||||
|
|
|
|||
|
|
@ -74,14 +74,14 @@ static void do_z2_request(struct request_queue *q)
|
|||
while (req) {
|
||||
unsigned long start = blk_rq_pos(req) << 9;
|
||||
unsigned long len = blk_rq_cur_bytes(req);
|
||||
int err = 0;
|
||||
blk_status_t err = BLK_STS_OK;
|
||||
|
||||
if (start + len > z2ram_size) {
|
||||
pr_err(DEVICE_NAME ": bad access: block=%llu, "
|
||||
"count=%u\n",
|
||||
(unsigned long long)blk_rq_pos(req),
|
||||
blk_rq_cur_sectors(req));
|
||||
err = -EIO;
|
||||
err = BLK_STS_IOERR;
|
||||
goto done;
|
||||
}
|
||||
while (len) {
|
||||
|
|
|
|||
Loading…
Reference in a new issue