mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-29 03:01:39 -04:00
block: add a bi_error field to struct bio
Currently we have two different ways to signal an I/O error on a BIO: (1) by clearing the BIO_UPTODATE flag (2) by returning a Linux errno value to the bi_end_io callback The first one has the drawback of only communicating a single possible error (-EIO), and the second one has the drawback of not beeing persistent when bios are queued up, and are not passed along from child to parent bio in the ever more popular chaining scenario. Having both mechanisms available has the additional drawback of utterly confusing driver authors and introducing bugs where various I/O submitters only deal with one of them, and the others have to add boilerplate code to deal with both kinds of error returns. So add a new bi_error field to store an errno value directly in struct bio and remove the existing mechanisms to clean all this up. Signed-off-by: Christoph Hellwig <[email protected]> Reviewed-by: Hannes Reinecke <[email protected]> Reviewed-by: NeilBrown <[email protected]> Signed-off-by: Jens Axboe <[email protected]>
This commit is contained in:
Christoph Hellwig
Jens Axboe
parent
0034af0365
commit
4246a0b63b
95 changed files with 622 additions and 682 deletions
|
|
@ -1110,7 +1110,7 @@ aoe_end_request(struct aoedev *d, struct request *rq, int fastfail)
|
|||
d->ip.rq = NULL;
|
||||
do {
|
||||
bio = rq->bio;
|
||||
bok = !fastfail && test_bit(BIO_UPTODATE, &bio->bi_flags);
|
||||
bok = !fastfail && !bio->bi_error;
|
||||
} while (__blk_end_request(rq, bok ? 0 : -EIO, bio->bi_iter.bi_size));
|
||||
|
||||
/* cf. http://lkml.org/lkml/2006/10/31/28 */
|
||||
|
|
@ -1172,7 +1172,7 @@ ktiocomplete(struct frame *f)
|
|||
ahout->cmdstat, ahin->cmdstat,
|
||||
d->aoemajor, d->aoeminor);
|
||||
noskb: if (buf)
|
||||
clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
|
||||
buf->bio->bi_error = -EIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
|
|
@ -1185,7 +1185,7 @@ noskb: if (buf)
|
|||
"aoe: runt data size in read from",
|
||||
(long) d->aoemajor, d->aoeminor,
|
||||
skb->len, n);
|
||||
clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
|
||||
buf->bio->bi_error = -EIO;
|
||||
break;
|
||||
}
|
||||
if (n > f->iter.bi_size) {
|
||||
|
|
@ -1193,7 +1193,7 @@ noskb: if (buf)
|
|||
"aoe: too-large data size in read from",
|
||||
(long) d->aoemajor, d->aoeminor,
|
||||
n, f->iter.bi_size);
|
||||
clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
|
||||
buf->bio->bi_error = -EIO;
|
||||
break;
|
||||
}
|
||||
bvcpy(skb, f->buf->bio, f->iter, n);
|
||||
|
|
@ -1695,7 +1695,7 @@ aoe_failbuf(struct aoedev *d, struct buf *buf)
|
|||
if (buf == NULL)
|
||||
return;
|
||||
buf->iter.bi_size = 0;
|
||||
clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
|
||||
buf->bio->bi_error = -EIO;
|
||||
if (buf->nframesout == 0)
|
||||
aoe_end_buf(d, buf);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -170,7 +170,7 @@ aoe_failip(struct aoedev *d)
|
|||
if (rq == NULL)
|
||||
return;
|
||||
while ((bio = d->ip.nxbio)) {
|
||||
clear_bit(BIO_UPTODATE, &bio->bi_flags);
|
||||
bio->bi_error = -EIO;
|
||||
d->ip.nxbio = bio->bi_next;
|
||||
n = (unsigned long) rq->special;
|
||||
rq->special = (void *) --n;
|
||||
|
|
|
|||
|
|
@ -331,14 +331,12 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
|
|||
struct bio_vec bvec;
|
||||
sector_t sector;
|
||||
struct bvec_iter iter;
|
||||
int err = -EIO;
|
||||
|
||||
sector = bio->bi_iter.bi_sector;
|
||||
if (bio_end_sector(bio) > get_capacity(bdev->bd_disk))
|
||||
goto out;
|
||||
goto io_error;
|
||||
|
||||
if (unlikely(bio->bi_rw & REQ_DISCARD)) {
|
||||
err = 0;
|
||||
discard_from_brd(brd, sector, bio->bi_iter.bi_size);
|
||||
goto out;
|
||||
}
|
||||
|
|
@ -349,15 +347,20 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
|
|||
|
||||
bio_for_each_segment(bvec, bio, iter) {
|
||||
unsigned int len = bvec.bv_len;
|
||||
int err;
|
||||
|
||||
err = brd_do_bvec(brd, bvec.bv_page, len,
|
||||
bvec.bv_offset, rw, sector);
|
||||
if (err)
|
||||
break;
|
||||
goto io_error;
|
||||
sector += len >> SECTOR_SHIFT;
|
||||
}
|
||||
|
||||
out:
|
||||
bio_endio(bio, err);
|
||||
bio_endio(bio);
|
||||
return;
|
||||
io_error:
|
||||
bio_io_error(bio);
|
||||
}
|
||||
|
||||
static int brd_rw_page(struct block_device *bdev, sector_t sector,
|
||||
|
|
|
|||
|
|
@ -175,11 +175,11 @@ static int _drbd_md_sync_page_io(struct drbd_device *device,
|
|||
atomic_inc(&device->md_io.in_use); /* drbd_md_put_buffer() is in the completion handler */
|
||||
device->md_io.submit_jif = jiffies;
|
||||
if (drbd_insert_fault(device, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD))
|
||||
bio_endio(bio, -EIO);
|
||||
bio_io_error(bio);
|
||||
else
|
||||
submit_bio(rw, bio);
|
||||
wait_until_done_or_force_detached(device, bdev, &device->md_io.done);
|
||||
if (bio_flagged(bio, BIO_UPTODATE))
|
||||
if (!bio->bi_error)
|
||||
err = device->md_io.error;
|
||||
|
||||
out:
|
||||
|
|
|
|||
|
|
@ -941,36 +941,27 @@ static void drbd_bm_aio_ctx_destroy(struct kref *kref)
|
|||
}
|
||||
|
||||
/* bv_page may be a copy, or may be the original */
|
||||
static void drbd_bm_endio(struct bio *bio, int error)
|
||||
static void drbd_bm_endio(struct bio *bio)
|
||||
{
|
||||
struct drbd_bm_aio_ctx *ctx = bio->bi_private;
|
||||
struct drbd_device *device = ctx->device;
|
||||
struct drbd_bitmap *b = device->bitmap;
|
||||
unsigned int idx = bm_page_to_idx(bio->bi_io_vec[0].bv_page);
|
||||
int uptodate = bio_flagged(bio, BIO_UPTODATE);
|
||||
|
||||
|
||||
/* strange behavior of some lower level drivers...
|
||||
* fail the request by clearing the uptodate flag,
|
||||
* but do not return any error?!
|
||||
* do we want to WARN() on this? */
|
||||
if (!error && !uptodate)
|
||||
error = -EIO;
|
||||
|
||||
if ((ctx->flags & BM_AIO_COPY_PAGES) == 0 &&
|
||||
!bm_test_page_unchanged(b->bm_pages[idx]))
|
||||
drbd_warn(device, "bitmap page idx %u changed during IO!\n", idx);
|
||||
|
||||
if (error) {
|
||||
if (bio->bi_error) {
|
||||
/* ctx error will hold the completed-last non-zero error code,
|
||||
* in case error codes differ. */
|
||||
ctx->error = error;
|
||||
ctx->error = bio->bi_error;
|
||||
bm_set_page_io_err(b->bm_pages[idx]);
|
||||
/* Not identical to on disk version of it.
|
||||
* Is BM_PAGE_IO_ERROR enough? */
|
||||
if (__ratelimit(&drbd_ratelimit_state))
|
||||
drbd_err(device, "IO ERROR %d on bitmap page idx %u\n",
|
||||
error, idx);
|
||||
bio->bi_error, idx);
|
||||
} else {
|
||||
bm_clear_page_io_err(b->bm_pages[idx]);
|
||||
dynamic_drbd_dbg(device, "bitmap page idx %u completed\n", idx);
|
||||
|
|
@ -1031,7 +1022,7 @@ static void bm_page_io_async(struct drbd_bm_aio_ctx *ctx, int page_nr) __must_ho
|
|||
|
||||
if (drbd_insert_fault(device, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD)) {
|
||||
bio->bi_rw |= rw;
|
||||
bio_endio(bio, -EIO);
|
||||
bio_io_error(bio);
|
||||
} else {
|
||||
submit_bio(rw, bio);
|
||||
/* this should not count as user activity and cause the
|
||||
|
|
|
|||
|
|
@ -1481,9 +1481,9 @@ extern int drbd_khelper(struct drbd_device *device, char *cmd);
|
|||
|
||||
/* drbd_worker.c */
|
||||
/* bi_end_io handlers */
|
||||
extern void drbd_md_endio(struct bio *bio, int error);
|
||||
extern void drbd_peer_request_endio(struct bio *bio, int error);
|
||||
extern void drbd_request_endio(struct bio *bio, int error);
|
||||
extern void drbd_md_endio(struct bio *bio);
|
||||
extern void drbd_peer_request_endio(struct bio *bio);
|
||||
extern void drbd_request_endio(struct bio *bio);
|
||||
extern int drbd_worker(struct drbd_thread *thi);
|
||||
enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor);
|
||||
void drbd_resync_after_changed(struct drbd_device *device);
|
||||
|
|
@ -1604,12 +1604,13 @@ static inline void drbd_generic_make_request(struct drbd_device *device,
|
|||
__release(local);
|
||||
if (!bio->bi_bdev) {
|
||||
drbd_err(device, "drbd_generic_make_request: bio->bi_bdev == NULL\n");
|
||||
bio_endio(bio, -ENODEV);
|
||||
bio->bi_error = -ENODEV;
|
||||
bio_endio(bio);
|
||||
return;
|
||||
}
|
||||
|
||||
if (drbd_insert_fault(device, fault_type))
|
||||
bio_endio(bio, -EIO);
|
||||
bio_io_error(bio);
|
||||
else
|
||||
generic_make_request(bio);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -201,7 +201,8 @@ void start_new_tl_epoch(struct drbd_connection *connection)
|
|||
void complete_master_bio(struct drbd_device *device,
|
||||
struct bio_and_error *m)
|
||||
{
|
||||
bio_endio(m->bio, m->error);
|
||||
m->bio->bi_error = m->error;
|
||||
bio_endio(m->bio);
|
||||
dec_ap_bio(device);
|
||||
}
|
||||
|
||||
|
|
@ -1153,12 +1154,12 @@ drbd_submit_req_private_bio(struct drbd_request *req)
|
|||
rw == WRITE ? DRBD_FAULT_DT_WR
|
||||
: rw == READ ? DRBD_FAULT_DT_RD
|
||||
: DRBD_FAULT_DT_RA))
|
||||
bio_endio(bio, -EIO);
|
||||
bio_io_error(bio);
|
||||
else
|
||||
generic_make_request(bio);
|
||||
put_ldev(device);
|
||||
} else
|
||||
bio_endio(bio, -EIO);
|
||||
bio_io_error(bio);
|
||||
}
|
||||
|
||||
static void drbd_queue_write(struct drbd_device *device, struct drbd_request *req)
|
||||
|
|
@ -1191,7 +1192,8 @@ drbd_request_prepare(struct drbd_device *device, struct bio *bio, unsigned long
|
|||
/* only pass the error to the upper layers.
|
||||
* if user cannot handle io errors, that's not our business. */
|
||||
drbd_err(device, "could not kmalloc() req\n");
|
||||
bio_endio(bio, -ENOMEM);
|
||||
bio->bi_error = -ENOMEM;
|
||||
bio_endio(bio);
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
req->start_jif = start_jif;
|
||||
|
|
|
|||
|
|
@ -65,12 +65,12 @@ rwlock_t global_state_lock;
|
|||
/* used for synchronous meta data and bitmap IO
|
||||
* submitted by drbd_md_sync_page_io()
|
||||
*/
|
||||
void drbd_md_endio(struct bio *bio, int error)
|
||||
void drbd_md_endio(struct bio *bio)
|
||||
{
|
||||
struct drbd_device *device;
|
||||
|
||||
device = bio->bi_private;
|
||||
device->md_io.error = error;
|
||||
device->md_io.error = bio->bi_error;
|
||||
|
||||
/* We grabbed an extra reference in _drbd_md_sync_page_io() to be able
|
||||
* to timeout on the lower level device, and eventually detach from it.
|
||||
|
|
@ -170,31 +170,20 @@ void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(l
|
|||
/* writes on behalf of the partner, or resync writes,
|
||||
* "submitted" by the receiver.
|
||||
*/
|
||||
void drbd_peer_request_endio(struct bio *bio, int error)
|
||||
void drbd_peer_request_endio(struct bio *bio)
|
||||
{
|
||||
struct drbd_peer_request *peer_req = bio->bi_private;
|
||||
struct drbd_device *device = peer_req->peer_device->device;
|
||||
int uptodate = bio_flagged(bio, BIO_UPTODATE);
|
||||
int is_write = bio_data_dir(bio) == WRITE;
|
||||
int is_discard = !!(bio->bi_rw & REQ_DISCARD);
|
||||
|
||||
if (error && __ratelimit(&drbd_ratelimit_state))
|
||||
if (bio->bi_error && __ratelimit(&drbd_ratelimit_state))
|
||||
drbd_warn(device, "%s: error=%d s=%llus\n",
|
||||
is_write ? (is_discard ? "discard" : "write")
|
||||
: "read", error,
|
||||
: "read", bio->bi_error,
|
||||
(unsigned long long)peer_req->i.sector);
|
||||
if (!error && !uptodate) {
|
||||
if (__ratelimit(&drbd_ratelimit_state))
|
||||
drbd_warn(device, "%s: setting error to -EIO s=%llus\n",
|
||||
is_write ? "write" : "read",
|
||||
(unsigned long long)peer_req->i.sector);
|
||||
/* strange behavior of some lower level drivers...
|
||||
* fail the request by clearing the uptodate flag,
|
||||
* but do not return any error?! */
|
||||
error = -EIO;
|
||||
}
|
||||
|
||||
if (error)
|
||||
if (bio->bi_error)
|
||||
set_bit(__EE_WAS_ERROR, &peer_req->flags);
|
||||
|
||||
bio_put(bio); /* no need for the bio anymore */
|
||||
|
|
@ -208,24 +197,13 @@ void drbd_peer_request_endio(struct bio *bio, int error)
|
|||
|
||||
/* read, readA or write requests on R_PRIMARY coming from drbd_make_request
|
||||
*/
|
||||
void drbd_request_endio(struct bio *bio, int error)
|
||||
void drbd_request_endio(struct bio *bio)
|
||||
{
|
||||
unsigned long flags;
|
||||
struct drbd_request *req = bio->bi_private;
|
||||
struct drbd_device *device = req->device;
|
||||
struct bio_and_error m;
|
||||
enum drbd_req_event what;
|
||||
int uptodate = bio_flagged(bio, BIO_UPTODATE);
|
||||
|
||||
if (!error && !uptodate) {
|
||||
drbd_warn(device, "p %s: setting error to -EIO\n",
|
||||
bio_data_dir(bio) == WRITE ? "write" : "read");
|
||||
/* strange behavior of some lower level drivers...
|
||||
* fail the request by clearing the uptodate flag,
|
||||
* but do not return any error?! */
|
||||
error = -EIO;
|
||||
}
|
||||
|
||||
|
||||
/* If this request was aborted locally before,
|
||||
* but now was completed "successfully",
|
||||
|
|
@ -259,14 +237,14 @@ void drbd_request_endio(struct bio *bio, int error)
|
|||
if (__ratelimit(&drbd_ratelimit_state))
|
||||
drbd_emerg(device, "delayed completion of aborted local request; disk-timeout may be too aggressive\n");
|
||||
|
||||
if (!error)
|
||||
if (!bio->bi_error)
|
||||
panic("possible random memory corruption caused by delayed completion of aborted local request\n");
|
||||
}
|
||||
|
||||
/* to avoid recursion in __req_mod */
|
||||
if (unlikely(error)) {
|
||||
if (unlikely(bio->bi_error)) {
|
||||
if (bio->bi_rw & REQ_DISCARD)
|
||||
what = (error == -EOPNOTSUPP)
|
||||
what = (bio->bi_error == -EOPNOTSUPP)
|
||||
? DISCARD_COMPLETED_NOTSUPP
|
||||
: DISCARD_COMPLETED_WITH_ERROR;
|
||||
else
|
||||
|
|
@ -279,7 +257,7 @@ void drbd_request_endio(struct bio *bio, int error)
|
|||
what = COMPLETED_OK;
|
||||
|
||||
bio_put(req->private_bio);
|
||||
req->private_bio = ERR_PTR(error);
|
||||
req->private_bio = ERR_PTR(bio->bi_error);
|
||||
|
||||
/* not req_mod(), we need irqsave here! */
|
||||
spin_lock_irqsave(&device->resource->req_lock, flags);
|
||||
|
|
|
|||
|
|
@ -3771,13 +3771,14 @@ struct rb0_cbdata {
|
|||
struct completion complete;
|
||||
};
|
||||
|
||||
static void floppy_rb0_cb(struct bio *bio, int err)
|
||||
static void floppy_rb0_cb(struct bio *bio)
|
||||
{
|
||||
struct rb0_cbdata *cbdata = (struct rb0_cbdata *)bio->bi_private;
|
||||
int drive = cbdata->drive;
|
||||
|
||||
if (err) {
|
||||
pr_info("floppy: error %d while reading block 0\n", err);
|
||||
if (bio->bi_error) {
|
||||
pr_info("floppy: error %d while reading block 0\n",
|
||||
bio->bi_error);
|
||||
set_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
|
||||
}
|
||||
complete(&cbdata->complete);
|
||||
|
|
|
|||
|
|
@ -222,7 +222,7 @@ static void end_cmd(struct nullb_cmd *cmd)
|
|||
blk_end_request_all(cmd->rq, 0);
|
||||
break;
|
||||
case NULL_Q_BIO:
|
||||
bio_endio(cmd->bio, 0);
|
||||
bio_endio(cmd->bio);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -977,7 +977,7 @@ static void pkt_make_local_copy(struct packet_data *pkt, struct bio_vec *bvec)
|
|||
}
|
||||
}
|
||||
|
||||
static void pkt_end_io_read(struct bio *bio, int err)
|
||||
static void pkt_end_io_read(struct bio *bio)
|
||||
{
|
||||
struct packet_data *pkt = bio->bi_private;
|
||||
struct pktcdvd_device *pd = pkt->pd;
|
||||
|
|
@ -985,9 +985,9 @@ static void pkt_end_io_read(struct bio *bio, int err)
|
|||
|
||||
pkt_dbg(2, pd, "bio=%p sec0=%llx sec=%llx err=%d\n",
|
||||
bio, (unsigned long long)pkt->sector,
|
||||
(unsigned long long)bio->bi_iter.bi_sector, err);
|
||||
(unsigned long long)bio->bi_iter.bi_sector, bio->bi_error);
|
||||
|
||||
if (err)
|
||||
if (bio->bi_error)
|
||||
atomic_inc(&pkt->io_errors);
|
||||
if (atomic_dec_and_test(&pkt->io_wait)) {
|
||||
atomic_inc(&pkt->run_sm);
|
||||
|
|
@ -996,13 +996,13 @@ static void pkt_end_io_read(struct bio *bio, int err)
|
|||
pkt_bio_finished(pd);
|
||||
}
|
||||
|
||||
static void pkt_end_io_packet_write(struct bio *bio, int err)
|
||||
static void pkt_end_io_packet_write(struct bio *bio)
|
||||
{
|
||||
struct packet_data *pkt = bio->bi_private;
|
||||
struct pktcdvd_device *pd = pkt->pd;
|
||||
BUG_ON(!pd);
|
||||
|
||||
pkt_dbg(2, pd, "id=%d, err=%d\n", pkt->id, err);
|
||||
pkt_dbg(2, pd, "id=%d, err=%d\n", pkt->id, bio->bi_error);
|
||||
|
||||
pd->stats.pkt_ended++;
|
||||
|
||||
|
|
@ -1340,22 +1340,22 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
|
|||
pkt_queue_bio(pd, pkt->w_bio);
|
||||
}
|
||||
|
||||
static void pkt_finish_packet(struct packet_data *pkt, int uptodate)
|
||||
static void pkt_finish_packet(struct packet_data *pkt, int error)
|
||||
{
|
||||
struct bio *bio;
|
||||
|
||||
if (!uptodate)
|
||||
if (error)
|
||||
pkt->cache_valid = 0;
|
||||
|
||||
/* Finish all bios corresponding to this packet */
|
||||
while ((bio = bio_list_pop(&pkt->orig_bios)))
|
||||
bio_endio(bio, uptodate ? 0 : -EIO);
|
||||
while ((bio = bio_list_pop(&pkt->orig_bios))) {
|
||||
bio->bi_error = error;
|
||||
bio_endio(bio);
|
||||
}
|
||||
}
|
||||
|
||||
static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt)
|
||||
{
|
||||
int uptodate;
|
||||
|
||||
pkt_dbg(2, pd, "pkt %d\n", pkt->id);
|
||||
|
||||
for (;;) {
|
||||
|
|
@ -1384,7 +1384,7 @@ static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data
|
|||
if (atomic_read(&pkt->io_wait) > 0)
|
||||
return;
|
||||
|
||||
if (test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags)) {
|
||||
if (!pkt->w_bio->bi_error) {
|
||||
pkt_set_state(pkt, PACKET_FINISHED_STATE);
|
||||
} else {
|
||||
pkt_set_state(pkt, PACKET_RECOVERY_STATE);
|
||||
|
|
@ -1401,8 +1401,7 @@ static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data
|
|||
break;
|
||||
|
||||
case PACKET_FINISHED_STATE:
|
||||
uptodate = test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags);
|
||||
pkt_finish_packet(pkt, uptodate);
|
||||
pkt_finish_packet(pkt, pkt->w_bio->bi_error);
|
||||
return;
|
||||
|
||||
default:
|
||||
|
|
@ -2332,13 +2331,14 @@ static void pkt_close(struct gendisk *disk, fmode_t mode)
|
|||
}
|
||||
|
||||
|
||||
static void pkt_end_io_read_cloned(struct bio *bio, int err)
|
||||
static void pkt_end_io_read_cloned(struct bio *bio)
|
||||
{
|
||||
struct packet_stacked_data *psd = bio->bi_private;
|
||||
struct pktcdvd_device *pd = psd->pd;
|
||||
|
||||
psd->bio->bi_error = bio->bi_error;
|
||||
bio_put(bio);
|
||||
bio_endio(psd->bio, err);
|
||||
bio_endio(psd->bio);
|
||||
mempool_free(psd, psd_pool);
|
||||
pkt_bio_finished(pd);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -593,7 +593,8 @@ out:
|
|||
next = bio_list_peek(&priv->list);
|
||||
spin_unlock_irq(&priv->lock);
|
||||
|
||||
bio_endio(bio, error);
|
||||
bio->bi_error = error;
|
||||
bio_endio(bio);
|
||||
return next;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -137,7 +137,10 @@ static void bio_dma_done_cb(struct rsxx_cardinfo *card,
|
|||
if (!card->eeh_state && card->gendisk)
|
||||
disk_stats_complete(card, meta->bio, meta->start_time);
|
||||
|
||||
bio_endio(meta->bio, atomic_read(&meta->error) ? -EIO : 0);
|
||||
if (atomic_read(&meta->error))
|
||||
bio_io_error(meta->bio);
|
||||
else
|
||||
bio_endio(meta->bio);
|
||||
kmem_cache_free(bio_meta_pool, meta);
|
||||
}
|
||||
}
|
||||
|
|
@ -199,7 +202,9 @@ static void rsxx_make_request(struct request_queue *q, struct bio *bio)
|
|||
queue_err:
|
||||
kmem_cache_free(bio_meta_pool, bio_meta);
|
||||
req_err:
|
||||
bio_endio(bio, st);
|
||||
if (st)
|
||||
bio->bi_error = st;
|
||||
bio_endio(bio);
|
||||
}
|
||||
|
||||
/*----------------- Device Setup -------------------*/
|
||||
|
|
|
|||
|
|
@ -456,7 +456,7 @@ static void process_page(unsigned long data)
|
|||
PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
|
||||
if (control & DMASCR_HARD_ERROR) {
|
||||
/* error */
|
||||
clear_bit(BIO_UPTODATE, &bio->bi_flags);
|
||||
bio->bi_error = -EIO;
|
||||
dev_printk(KERN_WARNING, &card->dev->dev,
|
||||
"I/O error on sector %d/%d\n",
|
||||
le32_to_cpu(desc->local_addr)>>9,
|
||||
|
|
@ -505,7 +505,7 @@ static void process_page(unsigned long data)
|
|||
|
||||
return_bio = bio->bi_next;
|
||||
bio->bi_next = NULL;
|
||||
bio_endio(bio, 0);
|
||||
bio_endio(bio);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1078,9 +1078,9 @@ static void __end_block_io_op(struct pending_req *pending_req, int error)
|
|||
/*
|
||||
* bio callback.
|
||||
*/
|
||||
static void end_block_io_op(struct bio *bio, int error)
|
||||
static void end_block_io_op(struct bio *bio)
|
||||
{
|
||||
__end_block_io_op(bio->bi_private, error);
|
||||
__end_block_io_op(bio->bi_private, bio->bi_error);
|
||||
bio_put(bio);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -82,7 +82,6 @@ struct blk_shadow {
|
|||
struct split_bio {
|
||||
struct bio *bio;
|
||||
atomic_t pending;
|
||||
int err;
|
||||
};
|
||||
|
||||
static DEFINE_MUTEX(blkfront_mutex);
|
||||
|
|
@ -1478,16 +1477,14 @@ static int blkfront_probe(struct xenbus_device *dev,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void split_bio_end(struct bio *bio, int error)
|
||||
static void split_bio_end(struct bio *bio)
|
||||
{
|
||||
struct split_bio *split_bio = bio->bi_private;
|
||||
|
||||
if (error)
|
||||
split_bio->err = error;
|
||||
|
||||
if (atomic_dec_and_test(&split_bio->pending)) {
|
||||
split_bio->bio->bi_phys_segments = 0;
|
||||
bio_endio(split_bio->bio, split_bio->err);
|
||||
split_bio->bio->bi_error = bio->bi_error;
|
||||
bio_endio(split_bio->bio);
|
||||
kfree(split_bio);
|
||||
}
|
||||
bio_put(bio);
|
||||
|
|
|
|||
|
|
@ -850,7 +850,7 @@ static void __zram_make_request(struct zram *zram, struct bio *bio)
|
|||
|
||||
if (unlikely(bio->bi_rw & REQ_DISCARD)) {
|
||||
zram_bio_discard(zram, index, offset, bio);
|
||||
bio_endio(bio, 0);
|
||||
bio_endio(bio);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -883,8 +883,7 @@ static void __zram_make_request(struct zram *zram, struct bio *bio)
|
|||
update_position(&index, &offset, &bvec);
|
||||
}
|
||||
|
||||
set_bit(BIO_UPTODATE, &bio->bi_flags);
|
||||
bio_endio(bio, 0);
|
||||
bio_endio(bio);
|
||||
return;
|
||||
|
||||
out:
|
||||
|
|
|
|||
Loading…
Reference in a new issue