lael-labs/linux

block/bio-integrity.c+4−4

@@ -221,7 +221,7 @@ static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi, · 220 unmodified lines
221	* @bio: bio to generate/verify integrity metadata for	221	* @bio: bio to generate/verify integrity metadata for
222	* @proc_fn: Pointer to the relevant processing function	222	* @proc_fn: Pointer to the relevant processing function
223	*/	223	*/
224	static int bio_integrity_process(struct bio *bio,	224	static blk_status_t bio_integrity_process(struct bio *bio,
225	integrity_processing_fn *proc_fn)	225	integrity_processing_fn *proc_fn)
226	{	226	{
227	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);	227	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
@@ -229,7 +229,7 @@ static int bio_integrity_process(struct bio *bio, · 1 unmodified line
229	struct bvec_iter bviter;	229	struct bvec_iter bviter;
230	struct bio_vec bv;	230	struct bio_vec bv;
231	struct bio_integrity_payload *bip = bio_integrity(bio);	231	struct bio_integrity_payload *bip = bio_integrity(bio);
232	unsigned int ret = 0;	232	blk_status_t ret = BLK_STS_OK;
233	void *prot_buf = page_address(bip->bip_vec->bv_page) +	233	void *prot_buf = page_address(bip->bip_vec->bv_page) +
234	bip->bip_vec->bv_offset;	234	bip->bip_vec->bv_offset;
235		235
@@ -366,7 +366,7 @@ static void bio_integrity_verify_fn(struct work_struct *work) · 130 unmodified lines
366	struct bio *bio = bip->bip_bio;	366	struct bio *bio = bip->bip_bio;
367	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);	367	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
368		368
369	bio->bi_error = bio_integrity_process(bio, bi->profile->verify_fn);	369	bio->bi_status = bio_integrity_process(bio, bi->profile->verify_fn);
370		370
371	/* Restore original bio completion handler */	371	/* Restore original bio completion handler */
372	bio->bi_end_io = bip->bip_end_io;	372	bio->bi_end_io = bip->bip_end_io;
@@ -395,7 +395,7 @@ void bio_integrity_endio(struct bio *bio) · 22 unmodified lines
395	* integrity metadata. Restore original bio end_io handler	395	* integrity metadata. Restore original bio end_io handler
396	* and run it.	396	* and run it.
397	*/	397	*/
398	if (bio->bi_error) {	398	if (bio->bi_status) {
399	bio->bi_end_io = bip->bip_end_io;	399	bio->bi_end_io = bip->bip_end_io;
400	bio_endio(bio);	400	bio_endio(bio);
401		401

block/bio.c+4−4

@@ -309,8 +309,8 @@ static struct bio __bio_chain_endio(struct bio bio) · 308 unmodified lines
309	{	309	{
310	struct bio *parent = bio->bi_private;	310	struct bio *parent = bio->bi_private;
311		311
312	if (!parent->bi_error)	312	if (!parent->bi_status)
313	parent->bi_error = bio->bi_error;	313	parent->bi_status = bio->bi_status;
314	bio_put(bio);	314	bio_put(bio);
315	return parent;	315	return parent;
316	}	316	}
@@ -918,7 +918,7 @@ static void submit_bio_wait_endio(struct bio *bio) · 601 unmodified lines
918	{	918	{
919	struct submit_bio_ret *ret = bio->bi_private;	919	struct submit_bio_ret *ret = bio->bi_private;
920		920
921	ret->error = bio->bi_error;	921	ret->error = blk_status_to_errno(bio->bi_status);
922	complete(&ret->event);	922	complete(&ret->event);
923	}	923	}
924		924
@@ -1818,7 +1818,7 @@ again: · 893 unmodified lines
1818		1818
1819	if (bio->bi_bdev && bio_flagged(bio, BIO_TRACE_COMPLETION)) {	1819	if (bio->bi_bdev && bio_flagged(bio, BIO_TRACE_COMPLETION)) {
1820	trace_block_bio_complete(bdev_get_queue(bio->bi_bdev),	1820	trace_block_bio_complete(bdev_get_queue(bio->bi_bdev),
1821	bio, bio->bi_error);	1821	bio, bio->bi_status);
1822	bio_clear_flag(bio, BIO_TRACE_COMPLETION);	1822	bio_clear_flag(bio, BIO_TRACE_COMPLETION);
1823	}	1823	}
1824		1824

block/blk-core.c+13−7

 	[BLK_STS_PROTECTION]	= { -EILSEQ,	"protection" },
 	[BLK_STS_RESOURCE]	= { -ENOMEM,	"kernel resource" },
+	/* device mapper special case, should not leak out: */
+	[BLK_STS_DM_REQUEUE]	= { -EREMCHG, "dm internal retry" },
 	/* everything else not covered above: */
 	[BLK_STS_IOERR]		= { -EIO,	"I/O" },
 };
 			  unsigned int nbytes, blk_status_t error)
 {
 	if (error)
-		bio->bi_error = blk_status_to_errno(error);
+		bio->bi_status = error;
 	if (unlikely(rq->rq_flags & RQF_QUIET))
 		bio_set_flag(bio, BIO_QUIET);
 	blk_queue_split(q, &bio, q->bio_split);
 	if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
-		bio->bi_error = -EIO;
+		bio->bi_status = BLK_STS_IOERR;
 		bio_endio(bio);
 		return BLK_QC_T_NONE;
 	}
 	req = get_request(q, bio->bi_opf, bio, GFP_NOIO);
 	if (IS_ERR(req)) {
 		__wbt_done(q->rq_wb, wb_acct);
-		bio->bi_error = PTR_ERR(req);
+		if (PTR_ERR(req) == -ENOMEM)
+			bio->bi_status = BLK_STS_RESOURCE;
+		else
+			bio->bi_status = BLK_STS_IOERR;
 		bio_endio(bio);
 		goto out_unlock;
 	}
 {
 	struct request_queue *q;
 	int nr_sectors = bio_sectors(bio);
-	int err = -EIO;
+	blk_status_t status = BLK_STS_IOERR;
 	char b[BDEVNAME_SIZE];
 	struct hd_struct *part;
 	    !test_bit(QUEUE_FLAG_WC, &q->queue_flags)) {
 		bio->bi_opf &= ~(REQ_PREFLUSH | REQ_FUA);
 		if (!nr_sectors) {
-			err = 0;
+			status = BLK_STS_OK;
 			goto end_io;
 		}
 	}
 	return true;
 not_supported:
-	err = -EOPNOTSUPP;
+	status = BLK_STS_NOTSUPP;
 end_io:
-	bio->bi_error = err;
+	bio->bi_status = status;
 	bio_endio(bio);
 	return false;
 }

block/blk-integrity.c+2−2

@@ -384,9 +384,9 @@ static struct kobj_type integrity_ktype = { · 383 unmodified lines
384	.sysfs_ops = &integrity_ops,	384	.sysfs_ops = &integrity_ops,
385	};	385	};
386		386
387	static int blk_integrity_nop_fn(struct blk_integrity_iter *iter)	387	static blk_status_t blk_integrity_nop_fn(struct blk_integrity_iter *iter)
388	{	388	{
389	return 0;	389	return BLK_STS_OK;
390	}	390	}
391		391
392	static const struct blk_integrity_profile nop_profile = {	392	static const struct blk_integrity_profile nop_profile = {

block/bounce.c+2−2

@@ -143,7 +143,7 @@ static void bounce_end_io(struct bio bio, mempool_t pool) · 142 unmodified lines
143	mempool_free(bvec->bv_page, pool);	143	mempool_free(bvec->bv_page, pool);
144	}	144	}
145		145
146	bio_orig->bi_error = bio->bi_error;	146	bio_orig->bi_status = bio->bi_status;
147	bio_endio(bio_orig);	147	bio_endio(bio_orig);
148	bio_put(bio);	148	bio_put(bio);
149	}	149	}
@@ -163,7 +163,7 @@ static void __bounce_end_io_read(struct bio bio, mempool_t pool) · 13 unmodified lines
163	{	163	{
164	struct bio *bio_orig = bio->bi_private;	164	struct bio *bio_orig = bio->bi_private;
165		165
166	if (!bio->bi_error)	166	if (!bio->bi_status)
167	copy_to_high_bio_irq(bio_orig, bio);	167	copy_to_high_bio_irq(bio_orig, bio);
168		168
169	bounce_end_io(bio, pool);	169	bounce_end_io(bio, pool);

block/t10-pi.c+15−15

@@ -46,8 +46,8 @@ static __be16 t10_pi_ip_fn(void *data, unsigned int len) · 45 unmodified lines
46	* 16 bit app tag, 32 bit reference tag. Type 3 does not define the ref	46	* 16 bit app tag, 32 bit reference tag. Type 3 does not define the ref
47	* tag.	47	* tag.
48	*/	48	*/
49	static int t10_pi_generate(struct blk_integrity_iter iter, csum_fn fn,	49	static blk_status_t t10_pi_generate(struct blk_integrity_iter *iter,
50	unsigned int type)	50	csum_fn *fn, unsigned int type)
51	{	51	{
52	unsigned int i;	52	unsigned int i;
53		53
@@ -67,11 +67,11 @@ static int t10_pi_generate(struct blk_integrity_iter iter, csum_fn fn, · 13 unmodified lines
67	iter->seed++;	67	iter->seed++;
68	}	68	}
69		69
70	return 0;	70	return BLK_STS_OK;
71	}	71	}
72		72
73	static int t10_pi_verify(struct blk_integrity_iter iter, csum_fn fn,	73	static blk_status_t t10_pi_verify(struct blk_integrity_iter *iter,
74	unsigned int type)	74	csum_fn *fn, unsigned int type)
75	{	75	{
76	unsigned int i;	76	unsigned int i;
77		77
@@ -108,7 +108,7 @@ static int t10_pi_verify(struct blk_integrity_iter iter, csum_fn fn, · 30 unmodified lines
108	"(rcvd %04x, want %04x)\n", iter->disk_name,	108	"(rcvd %04x, want %04x)\n", iter->disk_name,
109	(unsigned long long)iter->seed,	109	(unsigned long long)iter->seed,
110	be16_to_cpu(pi->guard_tag), be16_to_cpu(csum));	110	be16_to_cpu(pi->guard_tag), be16_to_cpu(csum));
111	return -EILSEQ;	111	return BLK_STS_PROTECTION;
112	}	112	}
113		113
114	next:	114	next:
@@ -117,45 +117,45 @@ next: · 2 unmodified lines
117	iter->seed++;	117	iter->seed++;
118	}	118	}
119		119
120	return 0;	120	return BLK_STS_OK;
121	}	121	}
122		122
123	static int t10_pi_type1_generate_crc(struct blk_integrity_iter *iter)	123	static blk_status_t t10_pi_type1_generate_crc(struct blk_integrity_iter *iter)
124	{	124	{
125	return t10_pi_generate(iter, t10_pi_crc_fn, 1);	125	return t10_pi_generate(iter, t10_pi_crc_fn, 1);
126	}	126	}
127		127
128	static int t10_pi_type1_generate_ip(struct blk_integrity_iter *iter)	128	static blk_status_t t10_pi_type1_generate_ip(struct blk_integrity_iter *iter)
129	{	129	{
130	return t10_pi_generate(iter, t10_pi_ip_fn, 1);	130	return t10_pi_generate(iter, t10_pi_ip_fn, 1);
131	}	131	}
132		132
133	static int t10_pi_type1_verify_crc(struct blk_integrity_iter *iter)	133	static blk_status_t t10_pi_type1_verify_crc(struct blk_integrity_iter *iter)
134	{	134	{
135	return t10_pi_verify(iter, t10_pi_crc_fn, 1);	135	return t10_pi_verify(iter, t10_pi_crc_fn, 1);
136	}	136	}
137		137
138	static int t10_pi_type1_verify_ip(struct blk_integrity_iter *iter)	138	static blk_status_t t10_pi_type1_verify_ip(struct blk_integrity_iter *iter)
139	{	139	{
140	return t10_pi_verify(iter, t10_pi_ip_fn, 1);	140	return t10_pi_verify(iter, t10_pi_ip_fn, 1);
141	}	141	}
142		142
143	static int t10_pi_type3_generate_crc(struct blk_integrity_iter *iter)	143	static blk_status_t t10_pi_type3_generate_crc(struct blk_integrity_iter *iter)
144	{	144	{
145	return t10_pi_generate(iter, t10_pi_crc_fn, 3);	145	return t10_pi_generate(iter, t10_pi_crc_fn, 3);
146	}	146	}
147		147
148	static int t10_pi_type3_generate_ip(struct blk_integrity_iter *iter)	148	static blk_status_t t10_pi_type3_generate_ip(struct blk_integrity_iter *iter)
149	{	149	{
150	return t10_pi_generate(iter, t10_pi_ip_fn, 3);	150	return t10_pi_generate(iter, t10_pi_ip_fn, 3);
151	}	151	}
152		152
153	static int t10_pi_type3_verify_crc(struct blk_integrity_iter *iter)	153	static blk_status_t t10_pi_type3_verify_crc(struct blk_integrity_iter *iter)
154	{	154	{
155	return t10_pi_verify(iter, t10_pi_crc_fn, 3);	155	return t10_pi_verify(iter, t10_pi_crc_fn, 3);
156	}	156	}
157		157
158	static int t10_pi_type3_verify_ip(struct blk_integrity_iter *iter)	158	static blk_status_t t10_pi_type3_verify_ip(struct blk_integrity_iter *iter)
159	{	159	{
160	return t10_pi_verify(iter, t10_pi_ip_fn, 3);	160	return t10_pi_verify(iter, t10_pi_ip_fn, 3);
161	}	161	}

drivers/block/aoe/aoecmd.c+5−5

@@ -1070,7 +1070,7 @@ aoe_end_request(struct aoedev d, struct request rq, int fastfail) · 1069 unmodified lines
1070	d->ip.rq = NULL;	1070	d->ip.rq = NULL;
1071	do {	1071	do {
1072	bio = rq->bio;	1072	bio = rq->bio;
1073	bok = !fastfail && !bio->bi_error;	1073	bok = !fastfail && !bio->bi_status;
1074	} while (__blk_end_request(rq, bok ? BLK_STS_OK : BLK_STS_IOERR, bio->bi_iter.bi_size));	1074	} while (__blk_end_request(rq, bok ? BLK_STS_OK : BLK_STS_IOERR, bio->bi_iter.bi_size));
1075		1075
1076	/* cf. http://lkml.org/lkml/2006/10/31/28 */	1076	/* cf. http://lkml.org/lkml/2006/10/31/28 */
@@ -1131,7 +1131,7 @@ ktiocomplete(struct frame *f) · 54 unmodified lines
1131	ahout->cmdstat, ahin->cmdstat,	1131	ahout->cmdstat, ahin->cmdstat,
1132	d->aoemajor, d->aoeminor);	1132	d->aoemajor, d->aoeminor);
1133	noskb: if (buf)	1133	noskb: if (buf)
1134	buf->bio->bi_error = -EIO;	1134	buf->bio->bi_status = BLK_STS_IOERR;
1135	goto out;	1135	goto out;
1136	}	1136	}
1137		1137
@@ -1144,7 +1144,7 @@ noskb: if (buf) · 6 unmodified lines
1144	"aoe: runt data size in read from",	1144	"aoe: runt data size in read from",
1145	(long) d->aoemajor, d->aoeminor,	1145	(long) d->aoemajor, d->aoeminor,
1146	skb->len, n);	1146	skb->len, n);
1147	buf->bio->bi_error = -EIO;	1147	buf->bio->bi_status = BLK_STS_IOERR;
1148	break;	1148	break;
1149	}	1149	}
1150	if (n > f->iter.bi_size) {	1150	if (n > f->iter.bi_size) {
@@ -1152,7 +1152,7 @@ noskb: if (buf) · 1 unmodified line
1152	"aoe: too-large data size in read from",	1152	"aoe: too-large data size in read from",
1153	(long) d->aoemajor, d->aoeminor,	1153	(long) d->aoemajor, d->aoeminor,
1154	n, f->iter.bi_size);	1154	n, f->iter.bi_size);
1155	buf->bio->bi_error = -EIO;	1155	buf->bio->bi_status = BLK_STS_IOERR;
1156	break;	1156	break;
1157	}	1157	}
1158	bvcpy(skb, f->buf->bio, f->iter, n);	1158	bvcpy(skb, f->buf->bio, f->iter, n);
@@ -1654,7 +1654,7 @@ aoe_failbuf(struct aoedev d, struct buf buf) · 495 unmodified lines
1654	if (buf == NULL)	1654	if (buf == NULL)
1655	return;	1655	return;
1656	buf->iter.bi_size = 0;	1656	buf->iter.bi_size = 0;
1657	buf->bio->bi_error = -EIO;	1657	buf->bio->bi_status = BLK_STS_IOERR;
1658	if (buf->nframesout == 0)	1658	if (buf->nframesout == 0)
1659	aoe_end_buf(d, buf);	1659	aoe_end_buf(d, buf);
1660	}	1660	}

drivers/block/aoe/aoedev.c+1−1

@@ -170,7 +170,7 @@ aoe_failip(struct aoedev *d) · 169 unmodified lines
170	if (rq == NULL)	170	if (rq == NULL)
171	return;	171	return;
172	while ((bio = d->ip.nxbio)) {	172	while ((bio = d->ip.nxbio)) {
173	bio->bi_error = -EIO;	173	bio->bi_status = BLK_STS_IOERR;
174	d->ip.nxbio = bio->bi_next;	174	d->ip.nxbio = bio->bi_next;
175	n = (unsigned long) rq->special;	175	n = (unsigned long) rq->special;
176	rq->special = (void *) --n;	176	rq->special = (void *) --n;

drivers/block/drbd/drbd_actlog.c+1−1

@@ -178,7 +178,7 @@ static int _drbd_md_sync_page_io(struct drbd_device *device, · 177 unmodified lines
178	else	178	else
179	submit_bio(bio);	179	submit_bio(bio);
180	wait_until_done_or_force_detached(device, bdev, &device->md_io.done);	180	wait_until_done_or_force_detached(device, bdev, &device->md_io.done);
181	if (!bio->bi_error)	181	if (!bio->bi_status)
182	err = device->md_io.error;	182	err = device->md_io.error;
183		183
184	out:	184	out:

drivers/block/drbd/drbd_bitmap.c+3−3

drivers/block/drbd/drbd_int.h+1−1

@@ -1627,7 +1627,7 @@ static inline void drbd_generic_make_request(struct drbd_device *device, · 1626 unmodified lines
1627	__release(local);	1627	__release(local);
1628	if (!bio->bi_bdev) {	1628	if (!bio->bi_bdev) {
1629	drbd_err(device, "drbd_generic_make_request: bio->bi_bdev == NULL\n");	1629	drbd_err(device, "drbd_generic_make_request: bio->bi_bdev == NULL\n");
1630	bio->bi_error = -ENODEV;	1630	bio->bi_status = BLK_STS_IOERR;
1631	bio_endio(bio);	1631	bio_endio(bio);
1632	return;	1632	return;
1633	}	1633	}

drivers/block/drbd/drbd_receiver.c+3−3

@@ -1229,9 +1229,9 @@ void one_flush_endio(struct bio *bio) · 1228 unmodified lines
1229	struct drbd_device *device = octx->device;	1229	struct drbd_device *device = octx->device;
1230	struct issue_flush_context *ctx = octx->ctx;	1230	struct issue_flush_context *ctx = octx->ctx;
1231		1231
1232	if (bio->bi_error) {	1232	if (bio->bi_status) {
1233	ctx->error = bio->bi_error;	1233	ctx->error = blk_status_to_errno(bio->bi_status);
1234	drbd_info(device, "local disk FLUSH FAILED with status %d\n", bio->bi_error);	1234	drbd_info(device, "local disk FLUSH FAILED with status %d\n", bio->bi_status);
1235	}	1235	}
1236	kfree(octx);	1236	kfree(octx);
1237	bio_put(bio);	1237	bio_put(bio);

drivers/block/drbd/drbd_req.c+3−3

@@ -203,7 +203,7 @@ void start_new_tl_epoch(struct drbd_connection *connection) · 202 unmodified lines
203	void complete_master_bio(struct drbd_device *device,	203	void complete_master_bio(struct drbd_device *device,
204	struct bio_and_error *m)	204	struct bio_and_error *m)
205	{	205	{
206	m->bio->bi_error = m->error;	206	m->bio->bi_status = errno_to_blk_status(m->error);
207	bio_endio(m->bio);	207	bio_endio(m->bio);
208	dec_ap_bio(device);	208	dec_ap_bio(device);
209	}	209	}
@@ -1157,7 +1157,7 @@ static void drbd_process_discard_req(struct drbd_request *req) · 947 unmodified lines
1157		1157
1158	if (blkdev_issue_zeroout(bdev, req->i.sector, req->i.size >> 9,	1158	if (blkdev_issue_zeroout(bdev, req->i.sector, req->i.size >> 9,
1159	GFP_NOIO, 0))	1159	GFP_NOIO, 0))
1160	req->private_bio->bi_error = -EIO;	1160	req->private_bio->bi_status = BLK_STS_IOERR;
1161	bio_endio(req->private_bio);	1161	bio_endio(req->private_bio);
1162	}	1162	}
1163		1163
@@ -1225,7 +1225,7 @@ drbd_request_prepare(struct drbd_device device, struct bio bio, unsigned long · 61 unmodified lines
1225	/* only pass the error to the upper layers.	1225	/* only pass the error to the upper layers.
1226	* if user cannot handle io errors, that's not our business. */	1226	* if user cannot handle io errors, that's not our business. */
1227	drbd_err(device, "could not kmalloc() req\n");	1227	drbd_err(device, "could not kmalloc() req\n");
1228	bio->bi_error = -ENOMEM;	1228	bio->bi_status = BLK_STS_RESOURCE;
1229	bio_endio(bio);	1229	bio_endio(bio);
1230	return ERR_PTR(-ENOMEM);	1230	return ERR_PTR(-ENOMEM);
1231	}	1231	}

drivers/block/drbd/drbd_worker.c+8−8

@@ -63,7 +63,7 @@ void drbd_md_endio(struct bio *bio) · 62 unmodified lines
63	struct drbd_device *device;	63	struct drbd_device *device;
64		64
65	device = bio->bi_private;	65	device = bio->bi_private;
66	device->md_io.error = bio->bi_error;	66	device->md_io.error = blk_status_to_errno(bio->bi_status);
67		67
68	/* We grabbed an extra reference in _drbd_md_sync_page_io() to be able	68	/* We grabbed an extra reference in _drbd_md_sync_page_io() to be able
69	* to timeout on the lower level device, and eventually detach from it.	69	* to timeout on the lower level device, and eventually detach from it.
@@ -177,13 +177,13 @@ void drbd_peer_request_endio(struct bio *bio) · 107 unmodified lines
177	bool is_discard = bio_op(bio) == REQ_OP_WRITE_ZEROES \|\|	177	bool is_discard = bio_op(bio) == REQ_OP_WRITE_ZEROES \|\|
178	bio_op(bio) == REQ_OP_DISCARD;	178	bio_op(bio) == REQ_OP_DISCARD;
179		179
180	if (bio->bi_error && __ratelimit(&drbd_ratelimit_state))	180	if (bio->bi_status && __ratelimit(&drbd_ratelimit_state))
181	drbd_warn(device, "%s: error=%d s=%llus\n",	181	drbd_warn(device, "%s: error=%d s=%llus\n",
182	is_write ? (is_discard ? "discard" : "write")	182	is_write ? (is_discard ? "discard" : "write")
183	: "read", bio->bi_error,	183	: "read", bio->bi_status,
184	(unsigned long long)peer_req->i.sector);	184	(unsigned long long)peer_req->i.sector);
185		185
186	if (bio->bi_error)	186	if (bio->bi_status)
187	set_bit(__EE_WAS_ERROR, &peer_req->flags);	187	set_bit(__EE_WAS_ERROR, &peer_req->flags);
188		188
189	bio_put(bio); /* no need for the bio anymore */	189	bio_put(bio); /* no need for the bio anymore */
@@ -243,16 +243,16 @@ void drbd_request_endio(struct bio *bio) · 53 unmodified lines
243	if (__ratelimit(&drbd_ratelimit_state))	243	if (__ratelimit(&drbd_ratelimit_state))
244	drbd_emerg(device, "delayed completion of aborted local request; disk-timeout may be too aggressive\n");	244	drbd_emerg(device, "delayed completion of aborted local request; disk-timeout may be too aggressive\n");
245		245
246	if (!bio->bi_error)	246	if (!bio->bi_status)
247	drbd_panic_after_delayed_completion_of_aborted_request(device);	247	drbd_panic_after_delayed_completion_of_aborted_request(device);
248	}	248	}
249		249
250	/* to avoid recursion in __req_mod */	250	/* to avoid recursion in __req_mod */
251	if (unlikely(bio->bi_error)) {	251	if (unlikely(bio->bi_status)) {
252	switch (bio_op(bio)) {	252	switch (bio_op(bio)) {
253	case REQ_OP_WRITE_ZEROES:	253	case REQ_OP_WRITE_ZEROES:
254	case REQ_OP_DISCARD:	254	case REQ_OP_DISCARD:
255	if (bio->bi_error == -EOPNOTSUPP)	255	if (bio->bi_status == BLK_STS_NOTSUPP)
256	what = DISCARD_COMPLETED_NOTSUPP;	256	what = DISCARD_COMPLETED_NOTSUPP;
257	else	257	else
258	what = DISCARD_COMPLETED_WITH_ERROR;	258	what = DISCARD_COMPLETED_WITH_ERROR;
@@ -272,7 +272,7 @@ void drbd_request_endio(struct bio *bio) · 13 unmodified lines
272	}	272	}
273		273
274	bio_put(req->private_bio);	274	bio_put(req->private_bio);
275	req->private_bio = ERR_PTR(bio->bi_error);	275	req->private_bio = ERR_PTR(blk_status_to_errno(bio->bi_status));
276		276
277	/* not req_mod(), we need irqsave here! */	277	/* not req_mod(), we need irqsave here! */
278	spin_lock_irqsave(&device->resource->req_lock, flags);	278	spin_lock_irqsave(&device->resource->req_lock, flags);

drivers/block/floppy.c+2−2

@@ -3780,9 +3780,9 @@ static void floppy_rb0_cb(struct bio *bio) · 3779 unmodified lines
3780	struct rb0_cbdata cbdata = (struct rb0_cbdata )bio->bi_private;	3780	struct rb0_cbdata cbdata = (struct rb0_cbdata )bio->bi_private;
3781	int drive = cbdata->drive;	3781	int drive = cbdata->drive;
3782		3782
3783	if (bio->bi_error) {	3783	if (bio->bi_status) {
3784	pr_info("floppy: error %d while reading block 0\n",	3784	pr_info("floppy: error %d while reading block 0\n",
3785	bio->bi_error);	3785	bio->bi_status);
3786	set_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);	3786	set_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
3787	}	3787	}
3788	complete(&cbdata->complete);	3788	complete(&cbdata->complete);

drivers/block/pktcdvd.c+9−9

@@ -952,9 +952,9 @@ static void pkt_end_io_read(struct bio *bio) · 951 unmodified lines
952		952
953	pkt_dbg(2, pd, "bio=%p sec0=%llx sec=%llx err=%d\n",	953	pkt_dbg(2, pd, "bio=%p sec0=%llx sec=%llx err=%d\n",
954	bio, (unsigned long long)pkt->sector,	954	bio, (unsigned long long)pkt->sector,
955	(unsigned long long)bio->bi_iter.bi_sector, bio->bi_error);	955	(unsigned long long)bio->bi_iter.bi_sector, bio->bi_status);
956		956
957	if (bio->bi_error)	957	if (bio->bi_status)
958	atomic_inc(&pkt->io_errors);	958	atomic_inc(&pkt->io_errors);
959	if (atomic_dec_and_test(&pkt->io_wait)) {	959	if (atomic_dec_and_test(&pkt->io_wait)) {
960	atomic_inc(&pkt->run_sm);	960	atomic_inc(&pkt->run_sm);
@@ -969,7 +969,7 @@ static void pkt_end_io_packet_write(struct bio *bio) · 8 unmodified lines
969	struct pktcdvd_device *pd = pkt->pd;	969	struct pktcdvd_device *pd = pkt->pd;
970	BUG_ON(!pd);	970	BUG_ON(!pd);
971		971
972	pkt_dbg(2, pd, "id=%d, err=%d\n", pkt->id, bio->bi_error);	972	pkt_dbg(2, pd, "id=%d, err=%d\n", pkt->id, bio->bi_status);
973		973
974	pd->stats.pkt_ended++;	974	pd->stats.pkt_ended++;
975		975
@@ -1305,16 +1305,16 @@ static void pkt_start_write(struct pktcdvd_device pd, struct packet_data pkt) · 329 unmodified lines
1305	pkt_queue_bio(pd, pkt->w_bio);	1305	pkt_queue_bio(pd, pkt->w_bio);
1306	}	1306	}
1307		1307
1308	static void pkt_finish_packet(struct packet_data *pkt, int error)	1308	static void pkt_finish_packet(struct packet_data *pkt, blk_status_t status)
1309	{	1309	{
1310	struct bio *bio;	1310	struct bio *bio;
1311		1311
1312	if (error)	1312	if (status)
1313	pkt->cache_valid = 0;	1313	pkt->cache_valid = 0;
1314		1314
1315	/* Finish all bios corresponding to this packet */	1315	/* Finish all bios corresponding to this packet */
1316	while ((bio = bio_list_pop(&pkt->orig_bios))) {	1316	while ((bio = bio_list_pop(&pkt->orig_bios))) {
1317	bio->bi_error = error;	1317	bio->bi_status = status;
1318	bio_endio(bio);	1318	bio_endio(bio);
1319	}	1319	}
1320	}	1320	}
@@ -1349,7 +1349,7 @@ static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data · 28 unmodified lines
1349	if (atomic_read(&pkt->io_wait) > 0)	1349	if (atomic_read(&pkt->io_wait) > 0)
1350	return;	1350	return;
1351		1351
1352	if (!pkt->w_bio->bi_error) {	1352	if (!pkt->w_bio->bi_status) {
1353	pkt_set_state(pkt, PACKET_FINISHED_STATE);	1353	pkt_set_state(pkt, PACKET_FINISHED_STATE);
1354	} else {	1354	} else {
1355	pkt_set_state(pkt, PACKET_RECOVERY_STATE);	1355	pkt_set_state(pkt, PACKET_RECOVERY_STATE);
@@ -1366,7 +1366,7 @@ static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data · 10 unmodified lines
1366	break;	1366	break;
1367		1367
1368	case PACKET_FINISHED_STATE:	1368	case PACKET_FINISHED_STATE:
1369	pkt_finish_packet(pkt, pkt->w_bio->bi_error);	1369	pkt_finish_packet(pkt, pkt->w_bio->bi_status);
1370	return;	1370	return;
1371		1371
1372	default:	1372	default:
@@ -2301,7 +2301,7 @@ static void pkt_end_io_read_cloned(struct bio *bio) · 928 unmodified lines
2301	struct packet_stacked_data *psd = bio->bi_private;	2301	struct packet_stacked_data *psd = bio->bi_private;
2302	struct pktcdvd_device *pd = psd->pd;	2302	struct pktcdvd_device *pd = psd->pd;
2303		2303
2304	psd->bio->bi_error = bio->bi_error;	2304	psd->bio->bi_status = bio->bi_status;
2305	bio_put(bio);	2305	bio_put(bio);
2306	bio_endio(psd->bio);	2306	bio_endio(psd->bio);
2307	mempool_free(psd, psd_pool);	2307	mempool_free(psd, psd_pool);

drivers/block/ps3vram.c+7−7

@@ -428,7 +428,7 @@ static void ps3vram_cache_cleanup(struct ps3_system_bus_device *dev) · 427 unmodified lines
428	kfree(priv->cache.tags);	428	kfree(priv->cache.tags);
429	}	429	}
430		430
431	static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from,	431	static blk_status_t ps3vram_read(struct ps3_system_bus_device *dev, loff_t from,
432	size_t len, size_t retlen, u_char buf)	432	size_t len, size_t retlen, u_char buf)
433	{	433	{
434	struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);	434	struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
@@ -438,7 +438,7 @@ static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from, · 3 unmodified lines
438	(unsigned int)from, len);	438	(unsigned int)from, len);
439		439
440	if (from >= priv->size)	440	if (from >= priv->size)
441	return -EIO;	441	return BLK_STS_IOERR;
442		442
443	if (len > priv->size - from)	443	if (len > priv->size - from)
444	len = priv->size - from;	444	len = priv->size - from;
@@ -472,14 +472,14 @@ static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from, · 27 unmodified lines
472	return 0;	472	return 0;
473	}	473	}
474		474
475	static int ps3vram_write(struct ps3_system_bus_device *dev, loff_t to,	475	static blk_status_t ps3vram_write(struct ps3_system_bus_device *dev, loff_t to,
476	size_t len, size_t retlen, const u_char buf)	476	size_t len, size_t retlen, const u_char buf)
477	{	477	{
478	struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);	478	struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
479	unsigned int cached, count;	479	unsigned int cached, count;
480		480
481	if (to >= priv->size)	481	if (to >= priv->size)
482	return -EIO;	482	return BLK_STS_IOERR;
483		483
484	if (len > priv->size - to)	484	if (len > priv->size - to)
485	len = priv->size - to;	485	len = priv->size - to;
@@ -554,7 +554,7 @@ static struct bio ps3vram_do_bio(struct ps3_system_bus_device dev, · 68 unmodified lines
554	int write = bio_data_dir(bio) == WRITE;	554	int write = bio_data_dir(bio) == WRITE;
555	const char *op = write ? "write" : "read";	555	const char *op = write ? "write" : "read";
556	loff_t offset = bio->bi_iter.bi_sector << 9;	556	loff_t offset = bio->bi_iter.bi_sector << 9;
557	int error = 0;	557	blk_status_t error = 0;
558	struct bio_vec bvec;	558	struct bio_vec bvec;
559	struct bvec_iter iter;	559	struct bvec_iter iter;
560	struct bio *next;	560	struct bio *next;
@@ -578,7 +578,7 @@ static struct bio ps3vram_do_bio(struct ps3_system_bus_device dev, · 17 unmodified lines
578		578
579	if (retlen != len) {	579	if (retlen != len) {
580	dev_err(&dev->core, "Short %s\n", op);	580	dev_err(&dev->core, "Short %s\n", op);
581	error = -EIO;	581	error = BLK_STS_IOERR;
582	goto out;	582	goto out;
583	}	583	}
584		584
@@ -593,7 +593,7 @@ out: · 8 unmodified lines
593	next = bio_list_peek(&priv->list);	593	next = bio_list_peek(&priv->list);
594	spin_unlock_irq(&priv->lock);	594	spin_unlock_irq(&priv->lock);
595		595
596	bio->bi_error = error;	596	bio->bi_status = error;
597	bio_endio(bio);	597	bio_endio(bio);
598	return next;	598	return next;
599	}	599	}

drivers/block/rsxx/dev.c+5−9

 {
 	struct rsxx_cardinfo *card = q->queuedata;
 	struct rsxx_bio_meta *bio_meta;
-	int st = -EINVAL;
+	blk_status_t st = BLK_STS_IOERR;
 	blk_queue_split(q, &bio, q->bio_split);
 	if (bio_end_sector(bio) > get_capacity(card->gendisk))
 		goto req_err;
-	if (unlikely(card->halt)) {
+	if (unlikely(card->halt))
-		st = -EFAULT;
 		goto req_err;
-	}
-	if (unlikely(card->dma_fault)) {
+	if (unlikely(card->dma_fault))
-		st = (-EFAULT);
 		goto req_err;
-	}
 	if (bio->bi_iter.bi_size == 0) {
 		dev_err(CARD_TO_DEV(card), "size zero BIO!\n");
 	bio_meta = kmem_cache_alloc(bio_meta_pool, GFP_KERNEL);
 	if (!bio_meta) {
-		st = -ENOMEM;
+		st = BLK_STS_RESOURCE;
 		goto req_err;
 	}
 	kmem_cache_free(bio_meta_pool, bio_meta);
 req_err:
 	if (st)
-		bio->bi_error = st;
+		bio->bi_status = st;
 	bio_endio(bio);
 	return BLK_QC_T_NONE;
 }

drivers/block/rsxx/dma.c+6−7

@@ -611,7 +611,7 @@ static void rsxx_schedule_done(struct work_struct *work) · 610 unmodified lines
611	mutex_unlock(&ctrl->work_lock);	611	mutex_unlock(&ctrl->work_lock);
612	}	612	}
613		613
614	static int rsxx_queue_discard(struct rsxx_cardinfo *card,	614	static blk_status_t rsxx_queue_discard(struct rsxx_cardinfo *card,
615	struct list_head *q,	615	struct list_head *q,
616	unsigned int laddr,	616	unsigned int laddr,
617	rsxx_dma_cb cb,	617	rsxx_dma_cb cb,
@@ -621,7 +621,7 @@ static int rsxx_queue_discard(struct rsxx_cardinfo *card, · 3 unmodified lines
621		621
622	dma = kmem_cache_alloc(rsxx_dma_pool, GFP_KERNEL);	622	dma = kmem_cache_alloc(rsxx_dma_pool, GFP_KERNEL);
623	if (!dma)	623	if (!dma)
624	return -ENOMEM;	624	return BLK_STS_RESOURCE;
625		625
626	dma->cmd = HW_CMD_BLK_DISCARD;	626	dma->cmd = HW_CMD_BLK_DISCARD;
627	dma->laddr = laddr;	627	dma->laddr = laddr;
@@ -640,7 +640,7 @@ static int rsxx_queue_discard(struct rsxx_cardinfo *card, · 12 unmodified lines
640	return 0;	640	return 0;
641	}	641	}
642		642
643	static int rsxx_queue_dma(struct rsxx_cardinfo *card,	643	static blk_status_t rsxx_queue_dma(struct rsxx_cardinfo *card,
644	struct list_head *q,	644	struct list_head *q,
645	int dir,	645	int dir,
646	unsigned int dma_off,	646	unsigned int dma_off,
@@ -655,7 +655,7 @@ static int rsxx_queue_dma(struct rsxx_cardinfo *card, · 8 unmodified lines
655		655
656	dma = kmem_cache_alloc(rsxx_dma_pool, GFP_KERNEL);	656	dma = kmem_cache_alloc(rsxx_dma_pool, GFP_KERNEL);
657	if (!dma)	657	if (!dma)
658	return -ENOMEM;	658	return BLK_STS_RESOURCE;
659		659
660	dma->cmd = dir ? HW_CMD_BLK_WRITE : HW_CMD_BLK_READ;	660	dma->cmd = dir ? HW_CMD_BLK_WRITE : HW_CMD_BLK_READ;
661	dma->laddr = laddr;	661	dma->laddr = laddr;
@@ -677,7 +677,7 @@ static int rsxx_queue_dma(struct rsxx_cardinfo *card, · 15 unmodified lines
677	return 0;	677	return 0;
678	}	678	}
679		679
680	int rsxx_dma_queue_bio(struct rsxx_cardinfo *card,	680	blk_status_t rsxx_dma_queue_bio(struct rsxx_cardinfo *card,
681	struct bio *bio,	681	struct bio *bio,
682	atomic_t *n_dmas,	682	atomic_t *n_dmas,
683	rsxx_dma_cb cb,	683	rsxx_dma_cb cb,
@@ -694,7 +694,7 @@ int rsxx_dma_queue_bio(struct rsxx_cardinfo *card, · 10 unmodified lines
694	unsigned int dma_len;	694	unsigned int dma_len;
695	int dma_cnt[RSXX_MAX_TARGETS];	695	int dma_cnt[RSXX_MAX_TARGETS];
696	int tgt;	696	int tgt;
697	int st;	697	blk_status_t st;
698	int i;	698	int i;
699		699
700	addr8 = bio->bi_iter.bi_sector << 9; /* sectors are 512 bytes */	700	addr8 = bio->bi_iter.bi_sector << 9; /* sectors are 512 bytes */
@@ -769,7 +769,6 @@ bvec_err: · 68 unmodified lines
769	for (i = 0; i < card->n_targets; i++)	769	for (i = 0; i < card->n_targets; i++)
770	rsxx_cleanup_dma_queue(&card->ctrl[i], &dma_list[i],	770	rsxx_cleanup_dma_queue(&card->ctrl[i], &dma_list[i],
771	FREE_DMA);	771	FREE_DMA);
772
773	return st;	772	return st;
774	}	773	}
775		774

drivers/block/rsxx/rsxx_priv.h+1−1

@@ -391,7 +391,7 @@ int rsxx_dma_cancel(struct rsxx_dma_ctrl *ctrl); · 390 unmodified lines
391	void rsxx_dma_cleanup(void);	391	void rsxx_dma_cleanup(void);
392	void rsxx_dma_queue_reset(struct rsxx_cardinfo *card);	392	void rsxx_dma_queue_reset(struct rsxx_cardinfo *card);
393	int rsxx_dma_configure(struct rsxx_cardinfo *card);	393	int rsxx_dma_configure(struct rsxx_cardinfo *card);
394	int rsxx_dma_queue_bio(struct rsxx_cardinfo *card,	394	blk_status_t rsxx_dma_queue_bio(struct rsxx_cardinfo *card,
395	struct bio *bio,	395	struct bio *bio,
396	atomic_t *n_dmas,	396	atomic_t *n_dmas,
397	rsxx_dma_cb cb,	397	rsxx_dma_cb cb,

drivers/block/umem.c+1−1

@@ -454,7 +454,7 @@ static void process_page(unsigned long data) · 453 unmodified lines
454	PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);	454	PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
455	if (control & DMASCR_HARD_ERROR) {	455	if (control & DMASCR_HARD_ERROR) {
456	/* error */	456	/* error */
457	bio->bi_error = -EIO;	457	bio->bi_status = BLK_STS_IOERR;
458	dev_printk(KERN_WARNING, &card->dev->dev,	458	dev_printk(KERN_WARNING, &card->dev->dev,
459	"I/O error on sector %d/%d\n",	459	"I/O error on sector %d/%d\n",
460	le32_to_cpu(desc->local_addr)>>9,	460	le32_to_cpu(desc->local_addr)>>9,

drivers/block/xen-blkback/blkback.c+8−11

 	atomic_set(&blkif->drain, 0);
 }
-/*
+static void __end_block_io_op(struct pending_req *pending_req,
- * Completion callback on the bio's. Called as bh->b_end_io()
+		blk_status_t error)
- */
-static void __end_block_io_op(struct pending_req *pending_req, int error)
 {
 	/* An error fails the entire request. */
-	if ((pending_req->operation == BLKIF_OP_FLUSH_DISKCACHE) &&
+	if (pending_req->operation == BLKIF_OP_FLUSH_DISKCACHE &&
-	    (error == -EOPNOTSUPP)) {
+	    error == BLK_STS_NOTSUPP) {
 		pr_debug("flush diskcache op failed, not supported\n");
 		xen_blkbk_flush_diskcache(XBT_NIL, pending_req->ring->blkif->be, 0);
 		pending_req->status = BLKIF_RSP_EOPNOTSUPP;
-	} else if ((pending_req->operation == BLKIF_OP_WRITE_BARRIER) &&
+	} else if (pending_req->operation == BLKIF_OP_WRITE_BARRIER &&
-		    (error == -EOPNOTSUPP)) {
+		   error == BLK_STS_NOTSUPP) {
 		pr_debug("write barrier op failed, not supported\n");
 		xen_blkbk_barrier(XBT_NIL, pending_req->ring->blkif->be, 0);
 		pending_req->status = BLKIF_RSP_EOPNOTSUPP;
  */
 static void end_block_io_op(struct bio *bio)
 {
-	__end_block_io_op(bio->bi_private, bio->bi_error);
+	__end_block_io_op(bio->bi_private, bio->bi_status);
 	bio_put(bio);
 }
 	for (i = 0; i < nbio; i++)
 		bio_put(biolist[i]);
 	atomic_set(&pending_req->pendcnt, 1);
-	__end_block_io_op(pending_req, -EINVAL);
+	__end_block_io_op(pending_req, BLK_STS_RESOURCE);
 	msleep(1); /* back off a bit */
 	return -EIO;
 }

drivers/block/xen-blkfront.c+1−1

@@ -2006,7 +2006,7 @@ static void split_bio_end(struct bio *bio) · 2005 unmodified lines
2006		2006
2007	if (atomic_dec_and_test(&split_bio->pending)) {	2007	if (atomic_dec_and_test(&split_bio->pending)) {
2008	split_bio->bio->bi_phys_segments = 0;	2008	split_bio->bio->bi_phys_segments = 0;
2009	split_bio->bio->bi_error = bio->bi_error;	2009	split_bio->bio->bi_status = bio->bi_status;
2010	bio_endio(split_bio->bio);	2010	bio_endio(split_bio->bio);
2011	kfree(split_bio);	2011	kfree(split_bio);
2012	}	2012	}

drivers/lightnvm/pblk-core.c+2−2

@@ -296,8 +296,8 @@ void pblk_flush_writer(struct pblk *pblk) · 295 unmodified lines
296	pr_err("pblk: tear down bio failed\n");	296	pr_err("pblk: tear down bio failed\n");
297	}	297	}
298		298
299	if (bio->bi_error)	299	if (bio->bi_status)
300	pr_err("pblk: flush sync write failed (%u)\n", bio->bi_error);	300	pr_err("pblk: flush sync write failed (%u)\n", bio->bi_status);
301		301
302	bio_put(bio);	302	bio_put(bio);
303	}	303	}

drivers/lightnvm/pblk-read.c+2−2

@@ -114,7 +114,7 @@ static void pblk_end_io_read(struct nvm_rq *rqd) · 113 unmodified lines
114	pblk_log_read_err(pblk, rqd);	114	pblk_log_read_err(pblk, rqd);
115	#ifdef CONFIG_NVM_DEBUG	115	#ifdef CONFIG_NVM_DEBUG
116	else	116	else
117	WARN_ONCE(bio->bi_error, "pblk: corrupted read error\n");	117	WARN_ONCE(bio->bi_status, "pblk: corrupted read error\n");
118	#endif	118	#endif
119		119
120	if (rqd->nr_ppas > 1)	120	if (rqd->nr_ppas > 1)
@@ -123,7 +123,7 @@ static void pblk_end_io_read(struct nvm_rq *rqd) · 2 unmodified lines
123	bio_put(bio);	123	bio_put(bio);
124	if (r_ctx->orig_bio) {	124	if (r_ctx->orig_bio) {
125	#ifdef CONFIG_NVM_DEBUG	125	#ifdef CONFIG_NVM_DEBUG
126	WARN_ONCE(r_ctx->orig_bio->bi_error,	126	WARN_ONCE(r_ctx->orig_bio->bi_status,
127	"pblk: corrupted read bio\n");	127	"pblk: corrupted read bio\n");
128	#endif	128	#endif
129	bio_endio(r_ctx->orig_bio);	129	bio_endio(r_ctx->orig_bio);

drivers/lightnvm/pblk-write.c+1−1

@@ -186,7 +186,7 @@ static void pblk_end_io_write(struct nvm_rq *rqd) · 185 unmodified lines
186	}	186	}
187	#ifdef CONFIG_NVM_DEBUG	187	#ifdef CONFIG_NVM_DEBUG
188	else	188	else
189	WARN_ONCE(rqd->bio->bi_error, "pblk: corrupted write error\n");	189	WARN_ONCE(rqd->bio->bi_status, "pblk: corrupted write error\n");
190	#endif	190	#endif
191		191
192	pblk_complete_write(pblk, rqd, c_ctx);	192	pblk_complete_write(pblk, rqd, c_ctx);

drivers/lightnvm/rrpc.c+4−4

@@ -279,8 +279,8 @@ static void rrpc_end_sync_bio(struct bio *bio) · 278 unmodified lines
279	{	279	{
280	struct completion *waiting = bio->bi_private;	280	struct completion *waiting = bio->bi_private;
281		281
282	if (bio->bi_error)	282	if (bio->bi_status)
283	pr_err("nvm: gc request failed (%u).\n", bio->bi_error);	283	pr_err("nvm: gc request failed (%u).\n", bio->bi_status);
284		284
285	complete(waiting);	285	complete(waiting);
286	}	286	}
@@ -359,7 +359,7 @@ try: · 72 unmodified lines
359	goto finished;	359	goto finished;
360	}	360	}
361	wait_for_completion_io(&wait);	361	wait_for_completion_io(&wait);
362	if (bio->bi_error) {	362	if (bio->bi_status) {
363	rrpc_inflight_laddr_release(rrpc, rqd);	363	rrpc_inflight_laddr_release(rrpc, rqd);
364	goto finished;	364	goto finished;
365	}	365	}
@@ -385,7 +385,7 @@ try: · 19 unmodified lines
385	wait_for_completion_io(&wait);	385	wait_for_completion_io(&wait);
386		386
387	rrpc_inflight_laddr_release(rrpc, rqd);	387	rrpc_inflight_laddr_release(rrpc, rqd);
388	if (bio->bi_error)	388	if (bio->bi_status)
389	goto finished;	389	goto finished;
390		390
391	bio_reset(bio);	391	bio_reset(bio);

drivers/md/bcache/bcache.h+4−3

 /* Forward declarations */
-void bch_count_io_errors(struct cache *, int, const char *);
+void bch_count_io_errors(struct cache *, blk_status_t, const char *);
 void bch_bbio_count_io_errors(struct cache_set *, struct bio *,
-			      int, const char *);
+			      blk_status_t, const char *);
-void bch_bbio_endio(struct cache_set *, struct bio *, int, const char *);
+void bch_bbio_endio(struct cache_set *, struct bio *, blk_status_t,
+		const char *);
 void bch_bbio_free(struct bio *, struct cache_set *);
 struct bio *bch_bbio_alloc(struct cache_set *);

drivers/md/bcache/btree.c+3−3

@@ -307,7 +307,7 @@ static void bch_btree_node_read(struct btree *b) · 306 unmodified lines
307	bch_submit_bbio(bio, b->c, &b->key, 0);	307	bch_submit_bbio(bio, b->c, &b->key, 0);
308	closure_sync(&cl);	308	closure_sync(&cl);
309		309
310	if (bio->bi_error)	310	if (bio->bi_status)
311	set_btree_node_io_error(b);	311	set_btree_node_io_error(b);
312		312
313	bch_bbio_free(bio, b->c);	313	bch_bbio_free(bio, b->c);
@@ -374,10 +374,10 @@ static void btree_node_write_endio(struct bio *bio) · 60 unmodified lines
374	struct closure *cl = bio->bi_private;	374	struct closure *cl = bio->bi_private;
375	struct btree *b = container_of(cl, struct btree, io);	375	struct btree *b = container_of(cl, struct btree, io);
376		376
377	if (bio->bi_error)	377	if (bio->bi_status)
378	set_btree_node_io_error(b);	378	set_btree_node_io_error(b);
379		379
380	bch_bbio_count_io_errors(b->c, bio, bio->bi_error, "writing btree");	380	bch_bbio_count_io_errors(b->c, bio, bio->bi_status, "writing btree");
381	closure_put(cl);	381	closure_put(cl);
382	}	382	}
383		383

drivers/md/bcache/io.c+3−3

@@ -50,7 +50,7 @@ void bch_submit_bbio(struct bio bio, struct cache_set c, · 49 unmodified lines
50		50
51	/* IO errors */	51	/* IO errors */
52		52
53	void bch_count_io_errors(struct cache ca, int error, const char m)	53	void bch_count_io_errors(struct cache ca, blk_status_t error, const char m)
54	{	54	{
55	/*	55	/*
56	* The halflife of an error is:	56	* The halflife of an error is:
@@ -103,7 +103,7 @@ void bch_count_io_errors(struct cache ca, int error, const char m) · 46 unmodified lines
103	}	103	}
104		104
105	void bch_bbio_count_io_errors(struct cache_set c, struct bio bio,	105	void bch_bbio_count_io_errors(struct cache_set c, struct bio bio,
106	int error, const char *m)	106	blk_status_t error, const char *m)
107	{	107	{
108	struct bbio *b = container_of(bio, struct bbio, bio);	108	struct bbio *b = container_of(bio, struct bbio, bio);
109	struct cache *ca = PTR_CACHE(c, &b->key, 0);	109	struct cache *ca = PTR_CACHE(c, &b->key, 0);
@@ -132,7 +132,7 @@ void bch_bbio_count_io_errors(struct cache_set c, struct bio bio, · 22 unmodified lines
132	}	132	}
133		133
134	void bch_bbio_endio(struct cache_set c, struct bio bio,	134	void bch_bbio_endio(struct cache_set c, struct bio bio,
135	int error, const char *m)	135	blk_status_t error, const char *m)
136	{	136	{
137	struct closure *cl = bio->bi_private;	137	struct closure *cl = bio->bi_private;
138		138

drivers/md/bcache/journal.c+1−1

@@ -549,7 +549,7 @@ static void journal_write_endio(struct bio *bio) · 548 unmodified lines
549	{	549	{
550	struct journal_write *w = bio->bi_private;	550	struct journal_write *w = bio->bi_private;
551		551
552	cache_set_err_on(bio->bi_error, w->c, "journal io error");	552	cache_set_err_on(bio->bi_status, w->c, "journal io error");
553	closure_put(&w->c->journal.io);	553	closure_put(&w->c->journal.io);
554	}	554	}
555		555

drivers/md/bcache/movinggc.c+5−5

@@ -63,14 +63,14 @@ static void read_moving_endio(struct bio *bio) · 62 unmodified lines
63	struct moving_io *io = container_of(bio->bi_private,	63	struct moving_io *io = container_of(bio->bi_private,
64	struct moving_io, cl);	64	struct moving_io, cl);
65		65
66	if (bio->bi_error)	66	if (bio->bi_status)
67	io->op.error = bio->bi_error;	67	io->op.status = bio->bi_status;
68	else if (!KEY_DIRTY(&b->key) &&	68	else if (!KEY_DIRTY(&b->key) &&
69	ptr_stale(io->op.c, &b->key, 0)) {	69	ptr_stale(io->op.c, &b->key, 0)) {
70	io->op.error = -EINTR;	70	io->op.status = BLK_STS_IOERR;
71	}	71	}
72		72
73	bch_bbio_endio(io->op.c, bio, bio->bi_error, "reading data to move");	73	bch_bbio_endio(io->op.c, bio, bio->bi_status, "reading data to move");
74	}	74	}
75		75
76	static void moving_init(struct moving_io *io)	76	static void moving_init(struct moving_io *io)
@@ -92,7 +92,7 @@ static void write_moving(struct closure *cl) · 15 unmodified lines
92	struct moving_io *io = container_of(cl, struct moving_io, cl);	92	struct moving_io *io = container_of(cl, struct moving_io, cl);
93	struct data_insert_op *op = &io->op;	93	struct data_insert_op *op = &io->op;
94		94
95	if (!op->error) {	95	if (!op->status) {
96	moving_init(io);	96	moving_init(io);
97		97
98	io->bio.bio.bi_iter.bi_sector = KEY_START(&io->w->key);	98	io->bio.bio.bi_iter.bi_sector = KEY_START(&io->w->key);

drivers/md/bcache/request.c+14−14

@@ -81,7 +81,7 @@ static void bch_data_insert_keys(struct closure *cl) · 80 unmodified lines
81	if (ret == -ESRCH) {	81	if (ret == -ESRCH) {
82	op->replace_collision = true;	82	op->replace_collision = true;
83	} else if (ret) {	83	} else if (ret) {
84	op->error = -ENOMEM;	84	op->status = BLK_STS_RESOURCE;
85	op->insert_data_done = true;	85	op->insert_data_done = true;
86	}	86	}
87		87
@@ -178,17 +178,17 @@ static void bch_data_insert_endio(struct bio *bio) · 90 unmodified lines
178	struct closure *cl = bio->bi_private;	178	struct closure *cl = bio->bi_private;
179	struct data_insert_op *op = container_of(cl, struct data_insert_op, cl);	179	struct data_insert_op *op = container_of(cl, struct data_insert_op, cl);
180		180
181	if (bio->bi_error) {	181	if (bio->bi_status) {
182	/* TODO: We could try to recover from this. */	182	/* TODO: We could try to recover from this. */
183	if (op->writeback)	183	if (op->writeback)
184	op->error = bio->bi_error;	184	op->status = bio->bi_status;
185	else if (!op->replace)	185	else if (!op->replace)
186	set_closure_fn(cl, bch_data_insert_error, op->wq);	186	set_closure_fn(cl, bch_data_insert_error, op->wq);
187	else	187	else
188	set_closure_fn(cl, NULL, NULL);	188	set_closure_fn(cl, NULL, NULL);
189	}	189	}
190		190
191	bch_bbio_endio(op->c, bio, bio->bi_error, "writing data to cache");	191	bch_bbio_endio(op->c, bio, bio->bi_status, "writing data to cache");
192	}	192	}
193		193
194	static void bch_data_insert_start(struct closure *cl)	194	static void bch_data_insert_start(struct closure *cl)
@@ -488,15 +488,15 @@ static void bch_cache_read_endio(struct bio *bio) · 293 unmodified lines
488	* from the backing device.	488	* from the backing device.
489	*/	489	*/
490		490
491	if (bio->bi_error)	491	if (bio->bi_status)
492	s->iop.error = bio->bi_error;	492	s->iop.status = bio->bi_status;
493	else if (!KEY_DIRTY(&b->key) &&	493	else if (!KEY_DIRTY(&b->key) &&
494	ptr_stale(s->iop.c, &b->key, 0)) {	494	ptr_stale(s->iop.c, &b->key, 0)) {
495	atomic_long_inc(&s->iop.c->cache_read_races);	495	atomic_long_inc(&s->iop.c->cache_read_races);
496	s->iop.error = -EINTR;	496	s->iop.status = BLK_STS_IOERR;
497	}	497	}
498		498
499	bch_bbio_endio(s->iop.c, bio, bio->bi_error, "reading from cache");	499	bch_bbio_endio(s->iop.c, bio, bio->bi_status, "reading from cache");
500	}	500	}
501		501
502	/*	502	/*
@@ -593,9 +593,9 @@ static void request_endio(struct bio *bio) · 90 unmodified lines
593	{	593	{
594	struct closure *cl = bio->bi_private;	594	struct closure *cl = bio->bi_private;
595		595
596	if (bio->bi_error) {	596	if (bio->bi_status) {
597	struct search *s = container_of(cl, struct search, cl);	597	struct search *s = container_of(cl, struct search, cl);
598	s->iop.error = bio->bi_error;	598	s->iop.status = bio->bi_status;
599	/* Only cache read errors are recoverable */	599	/* Only cache read errors are recoverable */
600	s->recoverable = false;	600	s->recoverable = false;
601	}	601	}
@@ -611,7 +611,7 @@ static void bio_complete(struct search *s) · 9 unmodified lines
611	&s->d->disk->part0, s->start_time);	611	&s->d->disk->part0, s->start_time);
612		612
613	trace_bcache_request_end(s->d, s->orig_bio);	613	trace_bcache_request_end(s->d, s->orig_bio);
614	s->orig_bio->bi_error = s->iop.error;	614	s->orig_bio->bi_status = s->iop.status;
615	bio_endio(s->orig_bio);	615	bio_endio(s->orig_bio);
616	s->orig_bio = NULL;	616	s->orig_bio = NULL;
617	}	617	}
@@ -664,7 +664,7 @@ static inline struct search search_alloc(struct bio bio, · 46 unmodified lines
664	s->iop.inode = d->id;	664	s->iop.inode = d->id;
665	s->iop.write_point = hash_long((unsigned long) current, 16);	665	s->iop.write_point = hash_long((unsigned long) current, 16);
666	s->iop.write_prio = 0;	666	s->iop.write_prio = 0;
667	s->iop.error = 0;	667	s->iop.status = 0;
668	s->iop.flags = 0;	668	s->iop.flags = 0;
669	s->iop.flush_journal = op_is_flush(bio->bi_opf);	669	s->iop.flush_journal = op_is_flush(bio->bi_opf);
670	s->iop.wq = bcache_wq;	670	s->iop.wq = bcache_wq;
@@ -707,7 +707,7 @@ static void cached_dev_read_error(struct closure *cl) · 36 unmodified lines
707	/* Retry from the backing device: */	707	/* Retry from the backing device: */
708	trace_bcache_read_retry(s->orig_bio);	708	trace_bcache_read_retry(s->orig_bio);
709		709
710	s->iop.error = 0;	710	s->iop.status = 0;
711	do_bio_hook(s, s->orig_bio);	711	do_bio_hook(s, s->orig_bio);
712		712
713	/* XXX: invalidate cache */	713	/* XXX: invalidate cache */
@@ -767,7 +767,7 @@ static void cached_dev_read_done_bh(struct closure *cl) · 53 unmodified lines
767	!s->cache_miss, s->iop.bypass);	767	!s->cache_miss, s->iop.bypass);
768	trace_bcache_read(s->orig_bio, !s->cache_miss, s->iop.bypass);	768	trace_bcache_read(s->orig_bio, !s->cache_miss, s->iop.bypass);
769		769
770	if (s->iop.error)	770	if (s->iop.status)
771	continue_at_nobarrier(cl, cached_dev_read_error, bcache_wq);	771	continue_at_nobarrier(cl, cached_dev_read_error, bcache_wq);
772	else if (s->iop.bio \|\| verify(dc, &s->bio.bio))	772	else if (s->iop.bio \|\| verify(dc, &s->bio.bio))
773	continue_at_nobarrier(cl, cached_dev_read_done, bcache_wq);	773	continue_at_nobarrier(cl, cached_dev_read_done, bcache_wq);

drivers/md/bcache/request.h+1−1

@@ -10,7 +10,7 @@ struct data_insert_op { · 9 unmodified lines
10	unsigned inode;	10	unsigned inode;
11	uint16_t write_point;	11	uint16_t write_point;
12	uint16_t write_prio;	12	uint16_t write_prio;
13	short error;	13	blk_status_t status;
14		14
15	union {	15	union {
16	uint16_t flags;	16	uint16_t flags;

drivers/md/bcache/super.c+3−3

@@ -271,7 +271,7 @@ static void write_super_endio(struct bio *bio) · 270 unmodified lines
271	{	271	{
272	struct cache *ca = bio->bi_private;	272	struct cache *ca = bio->bi_private;
273		273
274	bch_count_io_errors(ca, bio->bi_error, "writing superblock");	274	bch_count_io_errors(ca, bio->bi_status, "writing superblock");
275	closure_put(&ca->set->sb_write);	275	closure_put(&ca->set->sb_write);
276	}	276	}
277		277
@@ -321,7 +321,7 @@ static void uuid_endio(struct bio *bio) · 43 unmodified lines
321	struct closure *cl = bio->bi_private;	321	struct closure *cl = bio->bi_private;
322	struct cache_set *c = container_of(cl, struct cache_set, uuid_write);	322	struct cache_set *c = container_of(cl, struct cache_set, uuid_write);
323		323
324	cache_set_err_on(bio->bi_error, c, "accessing uuids");	324	cache_set_err_on(bio->bi_status, c, "accessing uuids");
325	bch_bbio_free(bio, c);	325	bch_bbio_free(bio, c);
326	closure_put(cl);	326	closure_put(cl);
327	}	327	}
@@ -494,7 +494,7 @@ static void prio_endio(struct bio *bio) · 166 unmodified lines
494	{	494	{
495	struct cache *ca = bio->bi_private;	495	struct cache *ca = bio->bi_private;
496		496
497	cache_set_err_on(bio->bi_error, ca->set, "accessing priorities");	497	cache_set_err_on(bio->bi_status, ca->set, "accessing priorities");
498	bch_bbio_free(bio, ca->set);	498	bch_bbio_free(bio, ca->set);
499	closure_put(&ca->prio);	499	closure_put(&ca->prio);
500	}	500	}

drivers/md/bcache/writeback.c+2−2

@@ -167,7 +167,7 @@ static void dirty_endio(struct bio *bio) · 166 unmodified lines
167	struct keybuf_key *w = bio->bi_private;	167	struct keybuf_key *w = bio->bi_private;
168	struct dirty_io *io = w->private;	168	struct dirty_io *io = w->private;
169		169
170	if (bio->bi_error)	170	if (bio->bi_status)
171	SET_KEY_DIRTY(&w->key, false);	171	SET_KEY_DIRTY(&w->key, false);
172		172
173	closure_put(&io->cl);	173	closure_put(&io->cl);
@@ -195,7 +195,7 @@ static void read_dirty_endio(struct bio *bio) · 21 unmodified lines
195	struct dirty_io *io = w->private;	195	struct dirty_io *io = w->private;
196		196
197	bch_count_io_errors(PTR_CACHE(io->dc->disk.c, &w->key, 0),	197	bch_count_io_errors(PTR_CACHE(io->dc->disk.c, &w->key, 0),
198	bio->bi_error, "reading dirty data from cache");	198	bio->bi_status, "reading dirty data from cache");
199		199
200	dirty_endio(bio);	200	dirty_endio(bio);
201	}	201	}

drivers/md/dm-bio-prison-v1.c+2−2

@@ -229,7 +229,7 @@ void dm_cell_release_no_holder(struct dm_bio_prison *prison, · 228 unmodified lines
229	EXPORT_SYMBOL_GPL(dm_cell_release_no_holder);	229	EXPORT_SYMBOL_GPL(dm_cell_release_no_holder);
230		230
231	void dm_cell_error(struct dm_bio_prison *prison,	231	void dm_cell_error(struct dm_bio_prison *prison,
232	struct dm_bio_prison_cell *cell, int error)	232	struct dm_bio_prison_cell *cell, blk_status_t error)
233	{	233	{
234	struct bio_list bios;	234	struct bio_list bios;
235	struct bio *bio;	235	struct bio *bio;
@@ -238,7 +238,7 @@ void dm_cell_error(struct dm_bio_prison *prison, · 2 unmodified lines
238	dm_cell_release(prison, cell, &bios);	238	dm_cell_release(prison, cell, &bios);
239		239
240	while ((bio = bio_list_pop(&bios))) {	240	while ((bio = bio_list_pop(&bios))) {
241	bio->bi_error = error;	241	bio->bi_status = error;
242	bio_endio(bio);	242	bio_endio(bio);
243	}	243	}
244	}	244	}

drivers/md/dm-bio-prison-v1.h+1−1

@@ -91,7 +91,7 @@ void dm_cell_release_no_holder(struct dm_bio_prison *prison, · 90 unmodified lines
91	struct dm_bio_prison_cell *cell,	91	struct dm_bio_prison_cell *cell,
92	struct bio_list *inmates);	92	struct bio_list *inmates);
93	void dm_cell_error(struct dm_bio_prison *prison,	93	void dm_cell_error(struct dm_bio_prison *prison,
94	struct dm_bio_prison_cell *cell, int error);	94	struct dm_bio_prison_cell *cell, blk_status_t error);
95		95
96	/*	96	/*
97	* Visits the cell and then releases. Guarantees no new inmates are	97	* Visits the cell and then releases. Guarantees no new inmates are

drivers/md/dm-bufio.c+15−13

@@ -145,8 +145,8 @@ struct dm_buffer { · 144 unmodified lines
145	enum data_mode data_mode;	145	enum data_mode data_mode;
146	unsigned char list_mode; /* LIST_* */	146	unsigned char list_mode; /* LIST_* */
147	unsigned hold_count;	147	unsigned hold_count;
148	int read_error;	148	blk_status_t read_error;
149	int write_error;	149	blk_status_t write_error;
150	unsigned long state;	150	unsigned long state;
151	unsigned long last_accessed;	151	unsigned long last_accessed;
152	struct dm_bufio_client *c;	152	struct dm_bufio_client *c;
@@ -555,7 +555,7 @@ static void dmio_complete(unsigned long error, void *context) · 402 unmodified lines
555	{	555	{
556	struct dm_buffer *b = context;	556	struct dm_buffer *b = context;
557		557
558	b->bio.bi_error = error ? -EIO : 0;	558	b->bio.bi_status = error ? BLK_STS_IOERR : 0;
559	b->bio.bi_end_io(&b->bio);	559	b->bio.bi_end_io(&b->bio);
560	}	560	}
561		561
@@ -588,7 +588,7 @@ static void use_dmio(struct dm_buffer *b, int rw, sector_t sector, · 26 unmodified lines
588		588
589	r = dm_io(&io_req, 1, &region, NULL);	589	r = dm_io(&io_req, 1, &region, NULL);
590	if (r) {	590	if (r) {
591	b->bio.bi_error = r;	591	b->bio.bi_status = errno_to_blk_status(r);
592	end_io(&b->bio);	592	end_io(&b->bio);
593	}	593	}
594	}	594	}
@@ -596,7 +596,7 @@ static void use_dmio(struct dm_buffer *b, int rw, sector_t sector, · 1 unmodified line
596	static void inline_endio(struct bio *bio)	596	static void inline_endio(struct bio *bio)
597	{	597	{
598	bio_end_io_t *end_fn = bio->bi_private;	598	bio_end_io_t *end_fn = bio->bi_private;
599	int error = bio->bi_error;	599	blk_status_t status = bio->bi_status;
600		600
601	/*	601	/*
602	* Reset the bio to free any attached resources	602	* Reset the bio to free any attached resources
@@ -604,7 +604,7 @@ static void inline_endio(struct bio *bio) · 1 unmodified line
604	*/	604	*/
605	bio_reset(bio);	605	bio_reset(bio);
606		606
607	bio->bi_error = error;	607	bio->bi_status = status;
608	end_fn(bio);	608	end_fn(bio);
609	}	609	}
610		610
@@ -685,11 +685,12 @@ static void write_endio(struct bio *bio) · 74 unmodified lines
685	{	685	{
686	struct dm_buffer *b = container_of(bio, struct dm_buffer, bio);	686	struct dm_buffer *b = container_of(bio, struct dm_buffer, bio);
687		687
688	b->write_error = bio->bi_error;	688	b->write_error = bio->bi_status;
689	if (unlikely(bio->bi_error)) {	689	if (unlikely(bio->bi_status)) {
690	struct dm_bufio_client *c = b->c;	690	struct dm_bufio_client *c = b->c;
691	int error = bio->bi_error;	691
692	(void)cmpxchg(&c->async_write_error, 0, error);	692	(void)cmpxchg(&c->async_write_error, 0,
		693	blk_status_to_errno(bio->bi_status));
693	}	694	}
694		695
695	BUG_ON(!test_bit(B_WRITING, &b->state));	696	BUG_ON(!test_bit(B_WRITING, &b->state));
@@ -1063,7 +1064,7 @@ static void read_endio(struct bio *bio) · 367 unmodified lines
1063	{	1064	{
1064	struct dm_buffer *b = container_of(bio, struct dm_buffer, bio);	1065	struct dm_buffer *b = container_of(bio, struct dm_buffer, bio);
1065		1066
1066	b->read_error = bio->bi_error;	1067	b->read_error = bio->bi_status;
1067		1068
1068	BUG_ON(!test_bit(B_READING, &b->state));	1069	BUG_ON(!test_bit(B_READING, &b->state));
1069		1070
@@ -1107,7 +1108,7 @@ static void new_read(struct dm_bufio_client c, sector_t block, · 37 unmodified lines
1107	wait_on_bit_io(&b->state, B_READING, TASK_UNINTERRUPTIBLE);	1108	wait_on_bit_io(&b->state, B_READING, TASK_UNINTERRUPTIBLE);
1108		1109
1109	if (b->read_error) {	1110	if (b->read_error) {
1110	int error = b->read_error;	1111	int error = blk_status_to_errno(b->read_error);
1111		1112
1112	dm_bufio_release(b);	1113	dm_bufio_release(b);
1113		1114
@@ -1257,7 +1258,8 @@ EXPORT_SYMBOL_GPL(dm_bufio_write_dirty_buffers_async); · 143 unmodified lines
1257	*/	1258	*/
1258	int dm_bufio_write_dirty_buffers(struct dm_bufio_client *c)	1259	int dm_bufio_write_dirty_buffers(struct dm_bufio_client *c)
1259	{	1260	{
1260	int a, f;	1261	blk_status_t a;
		1262	int f;
1261	unsigned long buffers_processed = 0;	1263	unsigned long buffers_processed = 0;
1262	struct dm_buffer b, tmp;	1264	struct dm_buffer b, tmp;
1263		1265

drivers/md/dm-cache-target.c+18−16

@@ -119,7 +119,7 @@ static void iot_io_end(struct io_tracker *iot, sector_t len) · 118 unmodified lines
119	*/	119	*/
120	struct continuation {	120	struct continuation {
121	struct work_struct ws;	121	struct work_struct ws;
122	int input;	122	blk_status_t input;
123	};	123	};
124		124
125	static inline void init_continuation(struct continuation *k,	125	static inline void init_continuation(struct continuation *k,
@@ -145,7 +145,7 @@ struct batcher { · 19 unmodified lines
145	/*	145	/*
146	* The operation that everyone is waiting for.	146	* The operation that everyone is waiting for.
147	*/	147	*/
148	int (commit_op)(void context);	148	blk_status_t (commit_op)(void context);
149	void *commit_context;	149	void *commit_context;
150		150
151	/*	151	/*
@@ -171,8 +171,7 @@ struct batcher { · 19 unmodified lines
171	static void __commit(struct work_struct *_ws)	171	static void __commit(struct work_struct *_ws)
172	{	172	{
173	struct batcher *b = container_of(_ws, struct batcher, commit_work);	173	struct batcher *b = container_of(_ws, struct batcher, commit_work);
174		174	blk_status_t r;
175	int r;
176	unsigned long flags;	175	unsigned long flags;
177	struct list_head work_items;	176	struct list_head work_items;
178	struct work_struct ws, tmp;	177	struct work_struct ws, tmp;
@@ -205,7 +204,7 @@ static void __commit(struct work_struct *_ws) · 26 unmodified lines
205		204
206	while ((bio = bio_list_pop(&bios))) {	205	while ((bio = bio_list_pop(&bios))) {
207	if (r) {	206	if (r) {
208	bio->bi_error = r;	207	bio->bi_status = r;
209	bio_endio(bio);	208	bio_endio(bio);
210	} else	209	} else
211	b->issue_op(bio, b->issue_context);	210	b->issue_op(bio, b->issue_context);
@@ -213,7 +212,7 @@ static void __commit(struct work_struct *_ws) · 1 unmodified line
213	}	212	}
214		213
215	static void batcher_init(struct batcher *b,	214	static void batcher_init(struct batcher *b,
216	int (commit_op)(void ),	215	blk_status_t (commit_op)(void ),
217	void *commit_context,	216	void *commit_context,
218	void (issue_op)(struct bio bio, void *),	217	void (issue_op)(struct bio bio, void *),
219	void *issue_context,	218	void *issue_context,
@@ -955,7 +954,7 @@ static void writethrough_endio(struct bio *bio) · 735 unmodified lines
955		954
956	dm_unhook_bio(&pb->hook_info, bio);	955	dm_unhook_bio(&pb->hook_info, bio);
957		956
958	if (bio->bi_error) {	957	if (bio->bi_status) {
959	bio_endio(bio);	958	bio_endio(bio);
960	return;	959	return;
961	}	960	}
@@ -1220,7 +1219,7 @@ static void copy_complete(int read_err, unsigned long write_err, void *context) · 258 unmodified lines
1220	struct dm_cache_migration *mg = container_of(context, struct dm_cache_migration, k);	1219	struct dm_cache_migration *mg = container_of(context, struct dm_cache_migration, k);
1221		1220
1222	if (read_err \|\| write_err)	1221	if (read_err \|\| write_err)
1223	mg->k.input = -EIO;	1222	mg->k.input = BLK_STS_IOERR;
1224		1223
1225	queue_continuation(mg->cache->wq, &mg->k);	1224	queue_continuation(mg->cache->wq, &mg->k);
1226	}	1225	}
@@ -1266,8 +1265,8 @@ static void overwrite_endio(struct bio *bio) · 39 unmodified lines
1266		1265
1267	dm_unhook_bio(&pb->hook_info, bio);	1266	dm_unhook_bio(&pb->hook_info, bio);
1268		1267
1269	if (bio->bi_error)	1268	if (bio->bi_status)
1270	mg->k.input = bio->bi_error;	1269	mg->k.input = bio->bi_status;
1271		1270
1272	queue_continuation(mg->cache->wq, &mg->k);	1271	queue_continuation(mg->cache->wq, &mg->k);
1273	}	1272	}
@@ -1323,8 +1322,10 @@ static void mg_complete(struct dm_cache_migration *mg, bool success) · 49 unmodified lines
1323	if (mg->overwrite_bio) {	1322	if (mg->overwrite_bio) {
1324	if (success)	1323	if (success)
1325	force_set_dirty(cache, cblock);	1324	force_set_dirty(cache, cblock);
		1325	else if (mg->k.input)
		1326	mg->overwrite_bio->bi_status = mg->k.input;
1326	else	1327	else
1327	mg->overwrite_bio->bi_error = (mg->k.input ? : -EIO);	1328	mg->overwrite_bio->bi_status = BLK_STS_IOERR;
1328	bio_endio(mg->overwrite_bio);	1329	bio_endio(mg->overwrite_bio);
1329	} else {	1330	} else {
1330	if (success)	1331	if (success)
@@ -1504,7 +1505,7 @@ static void mg_copy(struct work_struct *ws) · 173 unmodified lines
1504	r = copy(mg, is_policy_promote);	1505	r = copy(mg, is_policy_promote);
1505	if (r) {	1506	if (r) {
1506	DMERR_LIMIT("%s: migration copy failed", cache_device_name(cache));	1507	DMERR_LIMIT("%s: migration copy failed", cache_device_name(cache));
1507	mg->k.input = -EIO;	1508	mg->k.input = BLK_STS_IOERR;
1508	mg_complete(mg, false);	1509	mg_complete(mg, false);
1509	}	1510	}
1510	}	1511	}
@@ -1907,12 +1908,12 @@ static int commit(struct cache *cache, bool clean_shutdown) · 396 unmodified lines
1907	/*	1908	/*
1908	* Used by the batcher.	1909	* Used by the batcher.
1909	*/	1910	*/
1910	static int commit_op(void *context)	1911	static blk_status_t commit_op(void *context)
1911	{	1912	{
1912	struct cache *cache = context;	1913	struct cache *cache = context;
1913		1914
1914	if (dm_cache_changed_this_transaction(cache->cmd))	1915	if (dm_cache_changed_this_transaction(cache->cmd))
1915	return commit(cache, false);	1916	return errno_to_blk_status(commit(cache, false));
1916		1917
1917	return 0;	1918	return 0;
1918	}	1919	}
@@ -2018,7 +2019,7 @@ static void requeue_deferred_bios(struct cache *cache) · 99 unmodified lines
2018	bio_list_init(&cache->deferred_bios);	2019	bio_list_init(&cache->deferred_bios);
2019		2020
2020	while ((bio = bio_list_pop(&bios))) {	2021	while ((bio = bio_list_pop(&bios))) {
2021	bio->bi_error = DM_ENDIO_REQUEUE;	2022	bio->bi_status = BLK_STS_DM_REQUEUE;
2022	bio_endio(bio);	2023	bio_endio(bio);
2023	}	2024	}
2024	}	2025	}
@@ -2820,7 +2821,8 @@ static int cache_map(struct dm_target ti, struct bio bio) · 795 unmodified lines
2820	return r;	2821	return r;
2821	}	2822	}
2822		2823
2823	static int cache_end_io(struct dm_target ti, struct bio bio, int *error)	2824	static int cache_end_io(struct dm_target ti, struct bio bio,
		2825	blk_status_t *error)
2824	{	2826	{
2825	struct cache *cache = ti->private;	2827	struct cache *cache = ti->private;
2826	unsigned long flags;	2828	unsigned long flags;

drivers/md/dm-crypt.c+17−17

@@ -71,7 +71,7 @@ struct dm_crypt_io { · 70 unmodified lines
71	struct convert_context ctx;	71	struct convert_context ctx;
72		72
73	atomic_t io_pending;	73	atomic_t io_pending;
74	int error;	74	blk_status_t error;
75	sector_t sector;	75	sector_t sector;
76		76
77	struct rb_node rb_node;	77	struct rb_node rb_node;
@@ -1292,7 +1292,7 @@ static void crypt_free_req(struct crypt_config cc, void req, struct bio *base_ · 1214 unmodified lines
1292	/*	1292	/*
1293	* Encrypt / decrypt data from one bio to another one (can be the same one)	1293	* Encrypt / decrypt data from one bio to another one (can be the same one)
1294	*/	1294	*/
1295	static int crypt_convert(struct crypt_config *cc,	1295	static blk_status_t crypt_convert(struct crypt_config *cc,
1296	struct convert_context *ctx)	1296	struct convert_context *ctx)
1297	{	1297	{
1298	unsigned int tag_offset = 0;	1298	unsigned int tag_offset = 0;
@@ -1343,13 +1343,13 @@ static int crypt_convert(struct crypt_config *cc, · 44 unmodified lines
1343	*/	1343	*/
1344	case -EBADMSG:	1344	case -EBADMSG:
1345	atomic_dec(&ctx->cc_pending);	1345	atomic_dec(&ctx->cc_pending);
1346	return -EILSEQ;	1346	return BLK_STS_PROTECTION;
1347	/*	1347	/*
1348	* There was an error while processing the request.	1348	* There was an error while processing the request.
1349	*/	1349	*/
1350	default:	1350	default:
1351	atomic_dec(&ctx->cc_pending);	1351	atomic_dec(&ctx->cc_pending);
1352	return -EIO;	1352	return BLK_STS_IOERR;
1353	}	1353	}
1354	}	1354	}
1355		1355
@@ -1463,7 +1463,7 @@ static void crypt_dec_pending(struct dm_crypt_io *io) · 107 unmodified lines
1463	{	1463	{
1464	struct crypt_config *cc = io->cc;	1464	struct crypt_config *cc = io->cc;
1465	struct bio *base_bio = io->base_bio;	1465	struct bio *base_bio = io->base_bio;
1466	int error = io->error;	1466	blk_status_t error = io->error;
1467		1467
1468	if (!atomic_dec_and_test(&io->io_pending))	1468	if (!atomic_dec_and_test(&io->io_pending))
1469	return;	1469	return;
@@ -1476,7 +1476,7 @@ static void crypt_dec_pending(struct dm_crypt_io *io) · 6 unmodified lines
1476	else	1476	else
1477	kfree(io->integrity_metadata);	1477	kfree(io->integrity_metadata);
1478		1478
1479	base_bio->bi_error = error;	1479	base_bio->bi_status = error;
1480	bio_endio(base_bio);	1480	bio_endio(base_bio);
1481	}	1481	}
1482		1482
@@ -1502,7 +1502,7 @@ static void crypt_endio(struct bio *clone) · 19 unmodified lines
1502	struct dm_crypt_io *io = clone->bi_private;	1502	struct dm_crypt_io *io = clone->bi_private;
1503	struct crypt_config *cc = io->cc;	1503	struct crypt_config *cc = io->cc;
1504	unsigned rw = bio_data_dir(clone);	1504	unsigned rw = bio_data_dir(clone);
1505	int error;	1505	blk_status_t error;
1506		1506
1507	/*	1507	/*
1508	* free the processed pages	1508	* free the processed pages
@@ -1510,7 +1510,7 @@ static void crypt_endio(struct bio *clone) · 1 unmodified line
1510	if (rw == WRITE)	1510	if (rw == WRITE)
1511	crypt_free_buffer_pages(cc, clone);	1511	crypt_free_buffer_pages(cc, clone);
1512		1512
1513	error = clone->bi_error;	1513	error = clone->bi_status;
1514	bio_put(clone);	1514	bio_put(clone);
1515		1515
1516	if (rw == READ && !error) {	1516	if (rw == READ && !error) {
@@ -1570,7 +1570,7 @@ static void kcryptd_io_read_work(struct work_struct *work) · 53 unmodified lines
1570		1570
1571	crypt_inc_pending(io);	1571	crypt_inc_pending(io);
1572	if (kcryptd_io_read(io, GFP_NOIO))	1572	if (kcryptd_io_read(io, GFP_NOIO))
1573	io->error = -ENOMEM;	1573	io->error = BLK_STS_RESOURCE;
1574	crypt_dec_pending(io);	1574	crypt_dec_pending(io);
1575	}	1575	}
1576		1576
@@ -1656,7 +1656,7 @@ static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async) · 79 unmodified lines
1656	sector_t sector;	1656	sector_t sector;
1657	struct rb_node *rbp, parent;	1657	struct rb_node *rbp, parent;
1658		1658
1659	if (unlikely(io->error < 0)) {	1659	if (unlikely(io->error)) {
1660	crypt_free_buffer_pages(cc, clone);	1660	crypt_free_buffer_pages(cc, clone);
1661	bio_put(clone);	1661	bio_put(clone);
1662	crypt_dec_pending(io);	1662	crypt_dec_pending(io);
@@ -1697,7 +1697,7 @@ static void kcryptd_crypt_write_convert(struct dm_crypt_io *io) · 34 unmodified lines
1697	struct bio *clone;	1697	struct bio *clone;
1698	int crypt_finished;	1698	int crypt_finished;
1699	sector_t sector = io->sector;	1699	sector_t sector = io->sector;
1700	int r;	1700	blk_status_t r;
1701		1701
1702	/*	1702	/*
1703	* Prevent io from disappearing until this function completes.	1703	* Prevent io from disappearing until this function completes.
@@ -1707,7 +1707,7 @@ static void kcryptd_crypt_write_convert(struct dm_crypt_io *io) · 3 unmodified lines
1707		1707
1708	clone = crypt_alloc_buffer(io, io->base_bio->bi_iter.bi_size);	1708	clone = crypt_alloc_buffer(io, io->base_bio->bi_iter.bi_size);
1709	if (unlikely(!clone)) {	1709	if (unlikely(!clone)) {
1710	io->error = -EIO;	1710	io->error = BLK_STS_IOERR;
1711	goto dec;	1711	goto dec;
1712	}	1712	}
1713		1713
@@ -1718,7 +1718,7 @@ static void kcryptd_crypt_write_convert(struct dm_crypt_io *io) · 4 unmodified lines
1718		1718
1719	crypt_inc_pending(io);	1719	crypt_inc_pending(io);
1720	r = crypt_convert(cc, &io->ctx);	1720	r = crypt_convert(cc, &io->ctx);
1721	if (r < 0)	1721	if (r)
1722	io->error = r;	1722	io->error = r;
1723	crypt_finished = atomic_dec_and_test(&io->ctx.cc_pending);	1723	crypt_finished = atomic_dec_and_test(&io->ctx.cc_pending);
1724		1724
@@ -1740,7 +1740,7 @@ static void kcryptd_crypt_read_done(struct dm_crypt_io *io) · 15 unmodified lines
1740	static void kcryptd_crypt_read_convert(struct dm_crypt_io *io)	1740	static void kcryptd_crypt_read_convert(struct dm_crypt_io *io)
1741	{	1741	{
1742	struct crypt_config *cc = io->cc;	1742	struct crypt_config *cc = io->cc;
1743	int r = 0;	1743	blk_status_t r;
1744		1744
1745	crypt_inc_pending(io);	1745	crypt_inc_pending(io);
1746		1746
@@ -1748,7 +1748,7 @@ static void kcryptd_crypt_read_convert(struct dm_crypt_io *io) · 1 unmodified line
1748	io->sector);	1748	io->sector);
1749		1749
1750	r = crypt_convert(cc, &io->ctx);	1750	r = crypt_convert(cc, &io->ctx);
1751	if (r < 0)	1751	if (r)
1752	io->error = r;	1752	io->error = r;
1753		1753
1754	if (atomic_dec_and_test(&io->ctx.cc_pending))	1754	if (atomic_dec_and_test(&io->ctx.cc_pending))
@@ -1781,9 +1781,9 @@ static void kcryptd_async_done(struct crypto_async_request *async_req, · 26 unmodified lines
1781	if (error == -EBADMSG) {	1781	if (error == -EBADMSG) {
1782	DMERR_LIMIT("INTEGRITY AEAD ERROR, sector %llu",	1782	DMERR_LIMIT("INTEGRITY AEAD ERROR, sector %llu",
1783	(unsigned long long)le64_to_cpu(*org_sector_of_dmreq(cc, dmreq)));	1783	(unsigned long long)le64_to_cpu(*org_sector_of_dmreq(cc, dmreq)));
1784	io->error = -EILSEQ;	1784	io->error = BLK_STS_PROTECTION;
1785	} else if (error < 0)	1785	} else if (error < 0)
1786	io->error = -EIO;	1786	io->error = BLK_STS_IOERR;
1787		1787
1788	crypt_free_req(cc, req_of_dmreq(cc, dmreq), io->base_bio);	1788	crypt_free_req(cc, req_of_dmreq(cc, dmreq), io->base_bio);
1789		1789

drivers/md/dm-flakey.c+3−2

 	return DM_MAPIO_REMAPPED;
 }
-static int flakey_end_io(struct dm_target *ti, struct bio *bio, int *error)
+static int flakey_end_io(struct dm_target *ti, struct bio *bio,
+		blk_status_t *error)
 {
 	struct flakey_c *fc = ti->private;
 	struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data));
 			 * Error read during the down_interval if drop_writes
 			 * and error_writes were not configured.
 			 */
-			*error = -EIO;
+			*error = BLK_STS_IOERR;
 		}
 	}

drivers/md/dm-integrity.c+9−9

@@ -246,7 +246,7 @@ struct dm_integrity_io { · 245 unmodified lines
246	unsigned metadata_offset;	246	unsigned metadata_offset;
247		247
248	atomic_t in_flight;	248	atomic_t in_flight;
249	int bi_error;	249	blk_status_t bi_status;
250		250
251	struct completion *completion;	251	struct completion *completion;
252		252
@@ -1114,8 +1114,8 @@ static void submit_flush_bio(struct dm_integrity_c ic, struct dm_integrity_io · 861 unmodified lines
1114	static void do_endio(struct dm_integrity_c ic, struct bio bio)	1114	static void do_endio(struct dm_integrity_c ic, struct bio bio)
1115	{	1115	{
1116	int r = dm_integrity_failed(ic);	1116	int r = dm_integrity_failed(ic);
1117	if (unlikely(r) && !bio->bi_error)	1117	if (unlikely(r) && !bio->bi_status)
1118	bio->bi_error = r;	1118	bio->bi_status = errno_to_blk_status(r);
1119	bio_endio(bio);	1119	bio_endio(bio);
1120	}	1120	}
1121		1121
@@ -1123,7 +1123,7 @@ static void do_endio_flush(struct dm_integrity_c ic, struct dm_integrity_io di · 1 unmodified line
1123	{	1123	{
1124	struct bio *bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));	1124	struct bio *bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));
1125		1125
1126	if (unlikely(dio->fua) && likely(!bio->bi_error) && likely(!dm_integrity_failed(ic)))	1126	if (unlikely(dio->fua) && likely(!bio->bi_status) && likely(!dm_integrity_failed(ic)))
1127	submit_flush_bio(ic, dio);	1127	submit_flush_bio(ic, dio);
1128	else	1128	else
1129	do_endio(ic, bio);	1129	do_endio(ic, bio);
@@ -1142,9 +1142,9 @@ static void dec_in_flight(struct dm_integrity_io *dio) · 12 unmodified lines
1142		1142
1143	bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));	1143	bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));
1144		1144
1145	if (unlikely(dio->bi_error) && !bio->bi_error)	1145	if (unlikely(dio->bi_status) && !bio->bi_status)
1146	bio->bi_error = dio->bi_error;	1146	bio->bi_status = dio->bi_status;
1147	if (likely(!bio->bi_error) && unlikely(bio_sectors(bio) != dio->range.n_sectors)) {	1147	if (likely(!bio->bi_status) && unlikely(bio_sectors(bio) != dio->range.n_sectors)) {
1148	dio->range.logical_sector += dio->range.n_sectors;	1148	dio->range.logical_sector += dio->range.n_sectors;
1149	bio_advance(bio, dio->range.n_sectors << SECTOR_SHIFT);	1149	bio_advance(bio, dio->range.n_sectors << SECTOR_SHIFT);
1150	INIT_WORK(&dio->work, integrity_bio_wait);	1150	INIT_WORK(&dio->work, integrity_bio_wait);
@@ -1318,7 +1318,7 @@ skip_io: · 167 unmodified lines
1318	dec_in_flight(dio);	1318	dec_in_flight(dio);
1319	return;	1319	return;
1320	error:	1320	error:
1321	dio->bi_error = r;	1321	dio->bi_status = errno_to_blk_status(r);
1322	dec_in_flight(dio);	1322	dec_in_flight(dio);
1323	}	1323	}
1324		1324
@@ -1331,7 +1331,7 @@ static int dm_integrity_map(struct dm_target ti, struct bio bio) · 6 unmodified lines
1331	sector_t area, offset;	1331	sector_t area, offset;
1332		1332
1333	dio->ic = ic;	1333	dio->ic = ic;
1334	dio->bi_error = 0;	1334	dio->bi_status = 0;
1335		1335
1336	if (unlikely(bio->bi_opf & REQ_PREFLUSH)) {	1336	if (unlikely(bio->bi_opf & REQ_PREFLUSH)) {
1337	submit_flush_bio(ic, dio);	1337	submit_flush_bio(ic, dio);

drivers/md/dm-io.c+5−5

@@ -124,7 +124,7 @@ static void complete_io(struct io *io) · 123 unmodified lines
124	fn(error_bits, context);	124	fn(error_bits, context);
125	}	125	}
126		126
127	static void dec_count(struct io *io, unsigned int region, int error)	127	static void dec_count(struct io *io, unsigned int region, blk_status_t error)
128	{	128	{
129	if (error)	129	if (error)
130	set_bit(region, &io->error_bits);	130	set_bit(region, &io->error_bits);
@@ -137,9 +137,9 @@ static void endio(struct bio *bio) · 6 unmodified lines
137	{	137	{
138	struct io *io;	138	struct io *io;
139	unsigned region;	139	unsigned region;
140	int error;	140	blk_status_t error;
141		141
142	if (bio->bi_error && bio_data_dir(bio) == READ)	142	if (bio->bi_status && bio_data_dir(bio) == READ)
143	zero_fill_bio(bio);	143	zero_fill_bio(bio);
144		144
145	/*	145	/*
@@ -147,7 +147,7 @@ static void endio(struct bio *bio) · 1 unmodified line
147	*/	147	*/
148	retrieve_io_and_region_from_bio(bio, &io, &region);	148	retrieve_io_and_region_from_bio(bio, &io, &region);
149		149
150	error = bio->bi_error;	150	error = bio->bi_status;
151	bio_put(bio);	151	bio_put(bio);
152		152
153	dec_count(io, region, error);	153	dec_count(io, region, error);
@@ -319,7 +319,7 @@ static void do_region(int op, int op_flags, unsigned region, · 165 unmodified lines
319	if ((op == REQ_OP_DISCARD \|\| op == REQ_OP_WRITE_ZEROES \|\|	319	if ((op == REQ_OP_DISCARD \|\| op == REQ_OP_WRITE_ZEROES \|\|
320	op == REQ_OP_WRITE_SAME) &&	320	op == REQ_OP_WRITE_SAME) &&
321	special_cmd_max_sectors == 0) {	321	special_cmd_max_sectors == 0) {
322	dec_count(io, region, -EOPNOTSUPP);	322	dec_count(io, region, BLK_STS_NOTSUPP);
323	return;	323	return;
324	}	324	}
325		325

drivers/md/dm-log-writes.c+4−3

 {
 	struct log_writes_c *lc = bio->bi_private;
-	if (bio->bi_error) {
+	if (bio->bi_status) {
 		unsigned long flags;
-		DMERR("Error writing log block, error=%d", bio->bi_error);
+		DMERR("Error writing log block, error=%d", bio->bi_status);
 		spin_lock_irqsave(&lc->blocks_lock, flags);
 		lc->logging_enabled = false;
 		spin_unlock_irqrestore(&lc->blocks_lock, flags);
 	return DM_MAPIO_REMAPPED;
 }
-static int normal_end_io(struct dm_target *ti, struct bio *bio, int *error)
+static int normal_end_io(struct dm_target *ti, struct bio *bio,
+		blk_status_t *error)
 {
 	struct log_writes_c *lc = ti->private;
 	struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data));

drivers/md/dm-mpath.c+8−7

 	mpio->pgpath = pgpath;
 	mpio->nr_bytes = nr_bytes;
-	bio->bi_error = 0;
+	bio->bi_status = 0;
 	bio->bi_bdev = pgpath->path.dev->bdev;
 	bio->bi_opf |= REQ_FAILFAST_TRANSPORT;
 		r = __multipath_map_bio(m, bio, get_mpio_from_bio(bio));
 		switch (r) {
 		case DM_MAPIO_KILL:
-			r = -EIO;
+			bio->bi_status = BLK_STS_IOERR;
-			/*FALLTHRU*/
+			bio_endio(bio);
 		case DM_MAPIO_REQUEUE:
-			bio->bi_error = r;
+			bio->bi_status = BLK_STS_DM_REQUEUE;
 			bio_endio(bio);
 			break;
 		case DM_MAPIO_REMAPPED:
 	return r;
 }
-static int multipath_end_io_bio(struct dm_target *ti, struct bio *clone, int *error)
+static int multipath_end_io_bio(struct dm_target *ti, struct bio *clone,
+		blk_status_t *error)
 {
 	struct multipath *m = ti->private;
 	struct dm_mpath_io *mpio = get_mpio_from_bio(clone);
 	unsigned long flags;
 	int r = DM_ENDIO_DONE;
-	if (!*error || noretry_error(errno_to_blk_status(*error)))
+	if (!*error || noretry_error(*error))
 		goto done;
 	if (pgpath)
 	if (atomic_read(&m->nr_valid_paths) == 0 &&
 	    !test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags)) {
 		dm_report_EIO(m);
-		*error = -EIO;
+		*error = BLK_STS_IOERR;
 		goto done;
 	}

drivers/md/dm-raid1.c+7−6

 		 * If device is suspended, complete the bio.
 		 */
 		if (dm_noflush_suspending(ms->ti))
-			bio->bi_error = DM_ENDIO_REQUEUE;
+			bio->bi_status = BLK_STS_DM_REQUEUE;
 		else
-			bio->bi_error = -EIO;
+			bio->bi_status = BLK_STS_IOERR;
 		bio_endio(bio);
 		return;
 	 * degrade the array.
 	 */
 	if (bio_op(bio) == REQ_OP_DISCARD) {
-		bio->bi_error = -EOPNOTSUPP;
+		bio->bi_status = BLK_STS_NOTSUPP;
 		bio_endio(bio);
 		return;
 	}
 	return DM_MAPIO_REMAPPED;
 }
-static int mirror_end_io(struct dm_target *ti, struct bio *bio, int *error)
+static int mirror_end_io(struct dm_target *ti, struct bio *bio,
+		blk_status_t *error)
 {
 	int rw = bio_data_dir(bio);
 	struct mirror_set *ms = (struct mirror_set *) ti->private;
 		return DM_ENDIO_DONE;
 	}
-	if (*error == -EOPNOTSUPP)
+	if (*error == BLK_STS_NOTSUPP)
 		return DM_ENDIO_DONE;
 	if (bio->bi_opf & REQ_RAHEAD)
 			bd = &bio_record->details;
 			dm_bio_restore(bd, bio);
-			bio->bi_error = 0;
+			bio->bi_status = 0;
 			queue_bio(ms, bio, rw);
 			return DM_ENDIO_INCOMPLETE;

drivers/md/dm-rq.c+1−1

@@ -119,7 +119,7 @@ static void end_clone_bio(struct bio *clone) · 118 unmodified lines
119	struct dm_rq_target_io *tio = info->tio;	119	struct dm_rq_target_io *tio = info->tio;
120	struct bio *bio = info->orig;	120	struct bio *bio = info->orig;
121	unsigned int nr_bytes = info->orig->bi_iter.bi_size;	121	unsigned int nr_bytes = info->orig->bi_iter.bi_size;
122	blk_status_t error = errno_to_blk_status(clone->bi_error);	122	blk_status_t error = clone->bi_status;
123		123
124	bio_put(clone);	124	bio_put(clone);
125		125

drivers/md/dm-snap.c+3−2

 {
 	void *callback_data = bio->bi_private;
-	dm_kcopyd_do_callback(callback_data, 0, bio->bi_error ? 1 : 0);
+	dm_kcopyd_do_callback(callback_data, 0, bio->bi_status ? 1 : 0);
 }
 static void start_full_bio(struct dm_snap_pending_exception *pe,
 	return r;
 }
-static int snapshot_end_io(struct dm_target *ti, struct bio *bio, int *error)
+static int snapshot_end_io(struct dm_target *ti, struct bio *bio,
+		blk_status_t *error)
 {
 	struct dm_snapshot *s = ti->private;

drivers/md/dm-stripe.c+3−2

 	}
 }
-static int stripe_end_io(struct dm_target *ti, struct bio *bio, int *error)
+static int stripe_end_io(struct dm_target *ti, struct bio *bio,
+		blk_status_t *error)
 {
 	unsigned i;
 	char major_minor[16];
 	if (bio->bi_opf & REQ_RAHEAD)
 		return DM_ENDIO_DONE;
-	if (*error == -EOPNOTSUPP)
+	if (*error == BLK_STS_NOTSUPP)
 		return DM_ENDIO_DONE;
 	memset(major_minor, 0, sizeof(major_minor));

drivers/md/dm-thin.c+32−33

 	 * Even if r is set, there could be sub discards in flight that we
 	 * need to wait for.
 	 */
-	if (r && !op->parent_bio->bi_error)
+	if (r && !op->parent_bio->bi_status)
-		op->parent_bio->bi_error = r;
+		op->parent_bio->bi_status = errno_to_blk_status(r);
 	bio_endio(op->parent_bio);
 }
 }
 static void cell_error_with_code(struct pool *pool,
-				 struct dm_bio_prison_cell *cell, int error_code)
+		struct dm_bio_prison_cell *cell, blk_status_t error_code)
 {
 	dm_cell_error(pool->prison, cell, error_code);
 	dm_bio_prison_free_cell(pool->prison, cell);
 }
-static int get_pool_io_error_code(struct pool *pool)
+static blk_status_t get_pool_io_error_code(struct pool *pool)
 {
-	return pool->out_of_data_space ? -ENOSPC : -EIO;
+	return pool->out_of_data_space ? BLK_STS_NOSPC : BLK_STS_IOERR;
 }
 static void cell_error(struct pool *pool, struct dm_bio_prison_cell *cell)
 {
-	int error = get_pool_io_error_code(pool);
+	cell_error_with_code(pool, cell, get_pool_io_error_code(pool));
-	cell_error_with_code(pool, cell, error);
 }
 static void cell_success(struct pool *pool, struct dm_bio_prison_cell *cell)
 static void cell_requeue(struct pool *pool, struct dm_bio_prison_cell *cell)
 {
-	cell_error_with_code(pool, cell, DM_ENDIO_REQUEUE);
+	cell_error_with_code(pool, cell, BLK_STS_DM_REQUEUE);
 }
 /*----------------------------------------------------------------*/
 	bio_list_init(master);
 }
-static void error_bio_list(struct bio_list *bios, int error)
+static void error_bio_list(struct bio_list *bios, blk_status_t error)
 {
 	struct bio *bio;
 	while ((bio = bio_list_pop(bios))) {
-		bio->bi_error = error;
+		bio->bi_status = error;
 		bio_endio(bio);
 	}
 }
-static void error_thin_bio_list(struct thin_c *tc, struct bio_list *master, int error)
+static void error_thin_bio_list(struct thin_c *tc, struct bio_list *master,
+		blk_status_t error)
 {
 	struct bio_list bios;
 	unsigned long flags;
 	__merge_bio_list(&bios, &tc->retry_on_resume_list);
 	spin_unlock_irqrestore(&tc->lock, flags);
-	error_bio_list(&bios, DM_ENDIO_REQUEUE);
+	error_bio_list(&bios, BLK_STS_DM_REQUEUE);
 	requeue_deferred_cells(tc);
 }
-static void error_retry_list_with_code(struct pool *pool, int error)
+static void error_retry_list_with_code(struct pool *pool, blk_status_t error)
 {
 	struct thin_c *tc;
 static void error_retry_list(struct pool *pool)
 {
-	int error = get_pool_io_error_code(pool);
+	error_retry_list_with_code(pool, get_pool_io_error_code(pool));
-	error_retry_list_with_code(pool, error);
 }
 /*
 	 */
 	atomic_t prepare_actions;
-	int err;
+	blk_status_t status;
 	struct thin_c *tc;
 	dm_block_t virt_begin, virt_end;
 	dm_block_t data_block;
 {
 	struct dm_thin_new_mapping *m = context;
-	m->err = read_err || write_err ? -EIO : 0;
+	m->status = read_err || write_err ? BLK_STS_IOERR : 0;
 	complete_mapping_preparation(m);
 }
 	bio->bi_end_io = m->saved_bi_end_io;
-	m->err = bio->bi_error;
+	m->status = bio->bi_status;
 	complete_mapping_preparation(m);
 }
 	struct bio *bio = m->bio;
 	int r;
-	if (m->err) {
+	if (m->status) {
 		cell_error(pool, m->cell);
 		goto out;
 	}
 	spin_unlock_irqrestore(&tc->lock, flags);
 }
-static int should_error_unserviceable_bio(struct pool *pool)
+static blk_status_t should_error_unserviceable_bio(struct pool *pool)
 {
 	enum pool_mode m = get_pool_mode(pool);
 	case PM_WRITE:
 		/* Shouldn't get here */
 		DMERR_LIMIT("bio unserviceable, yet pool is in PM_WRITE mode");
-		return -EIO;
+		return BLK_STS_IOERR;
 	case PM_OUT_OF_DATA_SPACE:
-		return pool->pf.error_if_no_space ? -ENOSPC : 0;
+		return pool->pf.error_if_no_space ? BLK_STS_NOSPC : 0;
 	case PM_READ_ONLY:
 	case PM_FAIL:
-		return -EIO;
+		return BLK_STS_IOERR;
 	default:
 		/* Shouldn't get here */
 		DMERR_LIMIT("bio unserviceable, yet pool has an unknown mode");
-		return -EIO;
+		return BLK_STS_IOERR;
 	}
 }
 static void handle_unserviceable_bio(struct pool *pool, struct bio *bio)
 {
-	int error = should_error_unserviceable_bio(pool);
+	blk_status_t error = should_error_unserviceable_bio(pool);
 	if (error) {
-		bio->bi_error = error;
+		bio->bi_status = error;
 		bio_endio(bio);
 	} else
 		retry_on_resume(bio);
 {
 	struct bio *bio;
 	struct bio_list bios;
-	int error;
+	blk_status_t error;
 	error = should_error_unserviceable_bio(pool);
 	if (error) {
 	unsigned count = 0;
 	if (tc->requeue_mode) {
-		error_thin_bio_list(tc, &tc->deferred_bio_list, DM_ENDIO_REQUEUE);
+		error_thin_bio_list(tc, &tc->deferred_bio_list,
+				BLK_STS_DM_REQUEUE);
 		return;
 	}
 	if (get_pool_mode(pool) == PM_OUT_OF_DATA_SPACE && !pool->pf.error_if_no_space) {
 		pool->pf.error_if_no_space = true;
 		notify_of_pool_mode_change_to_oods(pool);
-		error_retry_list_with_code(pool, -ENOSPC);
+		error_retry_list_with_code(pool, BLK_STS_NOSPC);
 	}
 }
 	thin_hook_bio(tc, bio);
 	if (tc->requeue_mode) {
-		bio->bi_error = DM_ENDIO_REQUEUE;
+		bio->bi_status = BLK_STS_DM_REQUEUE;
 		bio_endio(bio);
 		return DM_MAPIO_SUBMITTED;
 	}
 	return thin_bio_map(ti, bio);
 }
-static int thin_endio(struct dm_target *ti, struct bio *bio, int *err)
+static int thin_endio(struct dm_target *ti, struct bio *bio,
+		blk_status_t *err)
 {
 	unsigned long flags;
 	struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));

drivers/md/dm-verity-target.c+5−5

@@ -538,13 +538,13 @@ static int verity_verify_io(struct dm_verity_io *io) · 537 unmodified lines
538	/*	538	/*
539	* End one "io" structure with a given error.	539	* End one "io" structure with a given error.
540	*/	540	*/
541	static void verity_finish_io(struct dm_verity_io *io, int error)	541	static void verity_finish_io(struct dm_verity_io *io, blk_status_t status)
542	{	542	{
543	struct dm_verity *v = io->v;	543	struct dm_verity *v = io->v;
544	struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);	544	struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);
545		545
546	bio->bi_end_io = io->orig_bi_end_io;	546	bio->bi_end_io = io->orig_bi_end_io;
547	bio->bi_error = error;	547	bio->bi_status = status;
548		548
549	verity_fec_finish_io(io);	549	verity_fec_finish_io(io);
550		550
@@ -555,15 +555,15 @@ static void verity_work(struct work_struct *w) · 4 unmodified lines
555	{	555	{
556	struct dm_verity_io *io = container_of(w, struct dm_verity_io, work);	556	struct dm_verity_io *io = container_of(w, struct dm_verity_io, work);
557		557
558	verity_finish_io(io, verity_verify_io(io));	558	verity_finish_io(io, errno_to_blk_status(verity_verify_io(io)));
559	}	559	}
560		560
561	static void verity_end_io(struct bio *bio)	561	static void verity_end_io(struct bio *bio)
562	{	562	{
563	struct dm_verity_io *io = bio->bi_private;	563	struct dm_verity_io *io = bio->bi_private;
564		564
565	if (bio->bi_error && !verity_fec_is_enabled(io->v)) {	565	if (bio->bi_status && !verity_fec_is_enabled(io->v)) {
566	verity_finish_io(io, bio->bi_error);	566	verity_finish_io(io, bio->bi_status);
567	return;	567	return;
568	}	568	}
569		569

drivers/md/dm.c+20−20

  */
 struct dm_io {
 	struct mapped_device *md;
-	int error;
+	blk_status_t status;
 	atomic_t io_count;
 	struct bio *bio;
 	unsigned long start_time;
  * Decrements the number of outstanding ios that a bio has been
  * cloned into, completing the original io if necc.
  */
-static void dec_pending(struct dm_io *io, int error)
+static void dec_pending(struct dm_io *io, blk_status_t error)
 {
 	unsigned long flags;
-	int io_error;
+	blk_status_t io_error;
 	struct bio *bio;
 	struct mapped_device *md = io->md;
 	/* Push-back supersedes any I/O errors */
 	if (unlikely(error)) {
 		spin_lock_irqsave(&io->endio_lock, flags);
-		if (!(io->error > 0 && __noflush_suspending(md)))
+		if (!(io->status == BLK_STS_DM_REQUEUE &&
-			io->error = error;
+				__noflush_suspending(md)))
+			io->status = error;
 		spin_unlock_irqrestore(&io->endio_lock, flags);
 	}
 	if (atomic_dec_and_test(&io->io_count)) {
-		if (io->error == DM_ENDIO_REQUEUE) {
+		if (io->status == BLK_STS_DM_REQUEUE) {
 			/*
 			 * Target requested pushing back the I/O.
 			 */
 				bio_list_add_head(&md->deferred, io->bio);
 			else
 				/* noflush suspend was interrupted. */
-				io->error = -EIO;
+				io->status = BLK_STS_IOERR;
 			spin_unlock_irqrestore(&md->deferred_lock, flags);
 		}
-		io_error = io->error;
+		io_error = io->status;
 		bio = io->bio;
 		end_io_acct(io);
 		free_io(md, io);
-		if (io_error == DM_ENDIO_REQUEUE)
+		if (io_error == BLK_STS_DM_REQUEUE)
 			return;
 		if ((bio->bi_opf & REQ_PREFLUSH) && bio->bi_iter.bi_size) {
 			queue_io(md, bio);
 		} else {
 			/* done with normal IO or empty flush */
-			bio->bi_error = io_error;
+			bio->bi_status = io_error;
 			bio_endio(bio);
 		}
 	}
 static void clone_endio(struct bio *bio)
 {
-	int error = bio->bi_error;
+	blk_status_t error = bio->bi_status;
-	int r = error;
 	struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
 	struct dm_io *io = tio->io;
 	struct mapped_device *md = tio->io->md;
 	dm_endio_fn endio = tio->ti->type->end_io;
-	if (unlikely(error == -EREMOTEIO)) {
+	if (unlikely(error == BLK_STS_TARGET)) {
 		if (bio_op(bio) == REQ_OP_WRITE_SAME &&
 		    !bdev_get_queue(bio->bi_bdev)->limits.max_write_same_sectors)
 			disable_write_same(md);
 	}
 	if (endio) {
-		r = endio(tio->ti, bio, &error);
+		int r = endio(tio->ti, bio, &error);
 		switch (r) {
 		case DM_ENDIO_REQUEUE:
-			error = DM_ENDIO_REQUEUE;
+			error = BLK_STS_DM_REQUEUE;
 			/*FALLTHRU*/
 		case DM_ENDIO_DONE:
 			break;
 		generic_make_request(clone);
 		break;
 	case DM_MAPIO_KILL:
-		r = -EIO;
+		dec_pending(tio->io, BLK_STS_IOERR);
-		/*FALLTHRU*/
+		free_tio(tio);
+		break;
 	case DM_MAPIO_REQUEUE:
-		/* error the io and bail out, or requeue it if needed */
+		dec_pending(tio->io, BLK_STS_DM_REQUEUE);
-		dec_pending(tio->io, r);
 		free_tio(tio);
 		break;
 	default:
 	ci.map = map;
 	ci.md = md;
 	ci.io = alloc_io(md);
-	ci.io->error = 0;
+	ci.io->status = 0;
 	atomic_set(&ci.io->io_count, 1);
 	ci.io->bio = bio;
 	ci.io->md = md;

drivers/md/md.c+4−4

@@ -273,7 +273,7 @@ static blk_qc_t md_make_request(struct request_queue q, struct bio bio) · 272 unmodified lines
273	}	273	}
274	if (mddev->ro == 1 && unlikely(rw == WRITE)) {	274	if (mddev->ro == 1 && unlikely(rw == WRITE)) {
275	if (bio_sectors(bio) != 0)	275	if (bio_sectors(bio) != 0)
276	bio->bi_error = -EROFS;	276	bio->bi_status = BLK_STS_IOERR;
277	bio_endio(bio);	277	bio_endio(bio);
278	return BLK_QC_T_NONE;	278	return BLK_QC_T_NONE;
279	}	279	}
@@ -719,8 +719,8 @@ static void super_written(struct bio *bio) · 439 unmodified lines
719	struct md_rdev *rdev = bio->bi_private;	719	struct md_rdev *rdev = bio->bi_private;
720	struct mddev *mddev = rdev->mddev;	720	struct mddev *mddev = rdev->mddev;
721		721
722	if (bio->bi_error) {	722	if (bio->bi_status) {
723	pr_err("md: super_written gets error=%d\n", bio->bi_error);	723	pr_err("md: super_written gets error=%d\n", bio->bi_status);
724	md_error(mddev, rdev);	724	md_error(mddev, rdev);
725	if (!test_bit(Faulty, &rdev->flags)	725	if (!test_bit(Faulty, &rdev->flags)
726	&& (bio->bi_opf & MD_FAILFAST)) {	726	&& (bio->bi_opf & MD_FAILFAST)) {
@@ -801,7 +801,7 @@ int sync_page_io(struct md_rdev *rdev, sector_t sector, int size, · 74 unmodified lines
801		801
802	submit_bio_wait(bio);	802	submit_bio_wait(bio);
803		803
804	ret = !bio->bi_error;	804	ret = !bio->bi_status;
805	bio_put(bio);	805	bio_put(bio);
806	return ret;	806	return ret;
807	}	807	}

drivers/md/multipath.c+5−5

@@ -73,12 +73,12 @@ static void multipath_reschedule_retry (struct multipath_bh *mp_bh) · 72 unmodified lines
73	* operation and are ready to return a success/failure code to the buffer	73	* operation and are ready to return a success/failure code to the buffer
74	* cache layer.	74	* cache layer.
75	*/	75	*/
76	static void multipath_end_bh_io (struct multipath_bh *mp_bh, int err)	76	static void multipath_end_bh_io(struct multipath_bh *mp_bh, blk_status_t status)
77	{	77	{
78	struct bio *bio = mp_bh->master_bio;	78	struct bio *bio = mp_bh->master_bio;
79	struct mpconf *conf = mp_bh->mddev->private;	79	struct mpconf *conf = mp_bh->mddev->private;
80		80
81	bio->bi_error = err;	81	bio->bi_status = status;
82	bio_endio(bio);	82	bio_endio(bio);
83	mempool_free(mp_bh, conf->pool);	83	mempool_free(mp_bh, conf->pool);
84	}	84	}
@@ -89,7 +89,7 @@ static void multipath_end_request(struct bio *bio) · 4 unmodified lines
89	struct mpconf *conf = mp_bh->mddev->private;	89	struct mpconf *conf = mp_bh->mddev->private;
90	struct md_rdev *rdev = conf->multipaths[mp_bh->path].rdev;	90	struct md_rdev *rdev = conf->multipaths[mp_bh->path].rdev;
91		91
92	if (!bio->bi_error)	92	if (!bio->bi_status)
93	multipath_end_bh_io(mp_bh, 0);	93	multipath_end_bh_io(mp_bh, 0);
94	else if (!(bio->bi_opf & REQ_RAHEAD)) {	94	else if (!(bio->bi_opf & REQ_RAHEAD)) {
95	/*	95	/*
@@ -102,7 +102,7 @@ static void multipath_end_request(struct bio *bio) · 6 unmodified lines
102	(unsigned long long)bio->bi_iter.bi_sector);	102	(unsigned long long)bio->bi_iter.bi_sector);
103	multipath_reschedule_retry(mp_bh);	103	multipath_reschedule_retry(mp_bh);
104	} else	104	} else
105	multipath_end_bh_io(mp_bh, bio->bi_error);	105	multipath_end_bh_io(mp_bh, bio->bi_status);
106	rdev_dec_pending(rdev, conf->mddev);	106	rdev_dec_pending(rdev, conf->mddev);
107	}	107	}
108		108
@@ -347,7 +347,7 @@ static void multipathd(struct md_thread *thread) · 238 unmodified lines
347	pr_err("multipath: %s: unrecoverable IO read error for block %llu\n",	347	pr_err("multipath: %s: unrecoverable IO read error for block %llu\n",
348	bdevname(bio->bi_bdev,b),	348	bdevname(bio->bi_bdev,b),
349	(unsigned long long)bio->bi_iter.bi_sector);	349	(unsigned long long)bio->bi_iter.bi_sector);
350	multipath_end_bh_io(mp_bh, -EIO);	350	multipath_end_bh_io(mp_bh, BLK_STS_IOERR);
351	} else {	351	} else {
352	pr_err("multipath: %s: redirecting sector %llu to another IO path\n",	352	pr_err("multipath: %s: redirecting sector %llu to another IO path\n",
353	bdevname(bio->bi_bdev,b),	353	bdevname(bio->bi_bdev,b),

drivers/md/raid1.c+18−18

@@ -277,7 +277,7 @@ static void call_bio_endio(struct r1bio *r1_bio) · 276 unmodified lines
277	struct r1conf *conf = r1_bio->mddev->private;	277	struct r1conf *conf = r1_bio->mddev->private;
278		278
279	if (!test_bit(R1BIO_Uptodate, &r1_bio->state))	279	if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
280	bio->bi_error = -EIO;	280	bio->bi_status = BLK_STS_IOERR;
281		281
282	bio_endio(bio);	282	bio_endio(bio);
283	/*	283	/*
@@ -335,7 +335,7 @@ static int find_bio_disk(struct r1bio r1_bio, struct bio bio) · 51 unmodified lines
335		335
336	static void raid1_end_read_request(struct bio *bio)	336	static void raid1_end_read_request(struct bio *bio)
337	{	337	{
338	int uptodate = !bio->bi_error;	338	int uptodate = !bio->bi_status;
339	struct r1bio *r1_bio = bio->bi_private;	339	struct r1bio *r1_bio = bio->bi_private;
340	struct r1conf *conf = r1_bio->mddev->private;	340	struct r1conf *conf = r1_bio->mddev->private;
341	struct md_rdev *rdev = conf->mirrors[r1_bio->read_disk].rdev;	341	struct md_rdev *rdev = conf->mirrors[r1_bio->read_disk].rdev;
@@ -426,12 +426,12 @@ static void raid1_end_write_request(struct bio *bio) · 84 unmodified lines
426	struct md_rdev *rdev = conf->mirrors[mirror].rdev;	426	struct md_rdev *rdev = conf->mirrors[mirror].rdev;
427	bool discard_error;	427	bool discard_error;
428		428
429	discard_error = bio->bi_error && bio_op(bio) == REQ_OP_DISCARD;	429	discard_error = bio->bi_status && bio_op(bio) == REQ_OP_DISCARD;
430		430
431	/*	431	/*
432	* 'one mirror IO has finished' event handler:	432	* 'one mirror IO has finished' event handler:
433	*/	433	*/
434	if (bio->bi_error && !discard_error) {	434	if (bio->bi_status && !discard_error) {
435	set_bit(WriteErrorSeen, &rdev->flags);	435	set_bit(WriteErrorSeen, &rdev->flags);
436	if (!test_and_set_bit(WantReplacement, &rdev->flags))	436	if (!test_and_set_bit(WantReplacement, &rdev->flags))
437	set_bit(MD_RECOVERY_NEEDED, &	437	set_bit(MD_RECOVERY_NEEDED, &
@@ -802,7 +802,7 @@ static void flush_bio_list(struct r1conf conf, struct bio bio) · 364 unmodified lines
802	bio->bi_next = NULL;	802	bio->bi_next = NULL;
803	bio->bi_bdev = rdev->bdev;	803	bio->bi_bdev = rdev->bdev;
804	if (test_bit(Faulty, &rdev->flags)) {	804	if (test_bit(Faulty, &rdev->flags)) {
805	bio->bi_error = -EIO;	805	bio->bi_status = BLK_STS_IOERR;
806	bio_endio(bio);	806	bio_endio(bio);
807	} else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&	807	} else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
808	!blk_queue_discard(bdev_get_queue(bio->bi_bdev))))	808	!blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
@@ -1856,7 +1856,7 @@ static void end_sync_read(struct bio *bio) · 1047 unmodified lines
1856	* or re-read if the read failed.	1856	* or re-read if the read failed.
1857	* We don't do much here, just schedule handling by raid1d	1857	* We don't do much here, just schedule handling by raid1d
1858	*/	1858	*/
1859	if (!bio->bi_error)	1859	if (!bio->bi_status)
1860	set_bit(R1BIO_Uptodate, &r1_bio->state);	1860	set_bit(R1BIO_Uptodate, &r1_bio->state);
1861		1861
1862	if (atomic_dec_and_test(&r1_bio->remaining))	1862	if (atomic_dec_and_test(&r1_bio->remaining))
@@ -1865,7 +1865,7 @@ static void end_sync_read(struct bio *bio) · 2 unmodified lines
1865		1865
1866	static void end_sync_write(struct bio *bio)	1866	static void end_sync_write(struct bio *bio)
1867	{	1867	{
1868	int uptodate = !bio->bi_error;	1868	int uptodate = !bio->bi_status;
1869	struct r1bio *r1_bio = get_resync_r1bio(bio);	1869	struct r1bio *r1_bio = get_resync_r1bio(bio);
1870	struct mddev *mddev = r1_bio->mddev;	1870	struct mddev *mddev = r1_bio->mddev;
1871	struct r1conf *conf = mddev->private;	1871	struct r1conf *conf = mddev->private;
@@ -2058,7 +2058,7 @@ static int fix_sync_read_error(struct r1bio *r1_bio) · 186 unmodified lines
2058	idx ++;	2058	idx ++;
2059	}	2059	}
2060	set_bit(R1BIO_Uptodate, &r1_bio->state);	2060	set_bit(R1BIO_Uptodate, &r1_bio->state);
2061	bio->bi_error = 0;	2061	bio->bi_status = 0;
2062	return 1;	2062	return 1;
2063	}	2063	}
2064		2064
@@ -2082,16 +2082,16 @@ static void process_checks(struct r1bio *r1_bio) · 17 unmodified lines
2082	for (i = 0; i < conf->raid_disks * 2; i++) {	2082	for (i = 0; i < conf->raid_disks * 2; i++) {
2083	int j;	2083	int j;
2084	int size;	2084	int size;
2085	int error;	2085	blk_status_t status;
2086	struct bio_vec *bi;	2086	struct bio_vec *bi;
2087	struct bio *b = r1_bio->bios[i];	2087	struct bio *b = r1_bio->bios[i];
2088	struct resync_pages *rp = get_resync_pages(b);	2088	struct resync_pages *rp = get_resync_pages(b);
2089	if (b->bi_end_io != end_sync_read)	2089	if (b->bi_end_io != end_sync_read)
2090	continue;	2090	continue;
2091	/* fixup the bio for reuse, but preserve errno */	2091	/* fixup the bio for reuse, but preserve errno */
2092	error = b->bi_error;	2092	status = b->bi_status;
2093	bio_reset(b);	2093	bio_reset(b);
2094	b->bi_error = error;	2094	b->bi_status = status;
2095	b->bi_vcnt = vcnt;	2095	b->bi_vcnt = vcnt;
2096	b->bi_iter.bi_size = r1_bio->sectors << 9;	2096	b->bi_iter.bi_size = r1_bio->sectors << 9;
2097	b->bi_iter.bi_sector = r1_bio->sector +	2097	b->bi_iter.bi_sector = r1_bio->sector +
@@ -2113,7 +2113,7 @@ static void process_checks(struct r1bio *r1_bio) · 15 unmodified lines
2113	}	2113	}
2114	for (primary = 0; primary < conf->raid_disks * 2; primary++)	2114	for (primary = 0; primary < conf->raid_disks * 2; primary++)
2115	if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&	2115	if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
2116	!r1_bio->bios[primary]->bi_error) {	2116	!r1_bio->bios[primary]->bi_status) {
2117	r1_bio->bios[primary]->bi_end_io = NULL;	2117	r1_bio->bios[primary]->bi_end_io = NULL;
2118	rdev_dec_pending(conf->mirrors[primary].rdev, mddev);	2118	rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
2119	break;	2119	break;
@@ -2123,7 +2123,7 @@ static void process_checks(struct r1bio *r1_bio) · 3 unmodified lines
2123	int j;	2123	int j;
2124	struct bio *pbio = r1_bio->bios[primary];	2124	struct bio *pbio = r1_bio->bios[primary];
2125	struct bio *sbio = r1_bio->bios[i];	2125	struct bio *sbio = r1_bio->bios[i];
2126	int error = sbio->bi_error;	2126	blk_status_t status = sbio->bi_status;
2127	struct page **ppages = get_resync_pages(pbio)->pages;	2127	struct page **ppages = get_resync_pages(pbio)->pages;
2128	struct page **spages = get_resync_pages(sbio)->pages;	2128	struct page **spages = get_resync_pages(sbio)->pages;
2129	struct bio_vec *bi;	2129	struct bio_vec *bi;
@@ -2132,12 +2132,12 @@ static void process_checks(struct r1bio *r1_bio) · 2 unmodified lines
2132	if (sbio->bi_end_io != end_sync_read)	2132	if (sbio->bi_end_io != end_sync_read)
2133	continue;	2133	continue;
2134	/* Now we can 'fixup' the error value */	2134	/* Now we can 'fixup' the error value */
2135	sbio->bi_error = 0;	2135	sbio->bi_status = 0;
2136		2136
2137	bio_for_each_segment_all(bi, sbio, j)	2137	bio_for_each_segment_all(bi, sbio, j)
2138	page_len[j] = bi->bv_len;	2138	page_len[j] = bi->bv_len;
2139		2139
2140	if (!error) {	2140	if (!status) {
2141	for (j = vcnt; j-- ; ) {	2141	for (j = vcnt; j-- ; ) {
2142	if (memcmp(page_address(ppages[j]),	2142	if (memcmp(page_address(ppages[j]),
2143	page_address(spages[j]),	2143	page_address(spages[j]),
@@ -2149,7 +2149,7 @@ static void process_checks(struct r1bio *r1_bio) · 5 unmodified lines
2149	if (j >= 0)	2149	if (j >= 0)
2150	atomic64_add(r1_bio->sectors, &mddev->resync_mismatches);	2150	atomic64_add(r1_bio->sectors, &mddev->resync_mismatches);
2151	if (j < 0 \|\| (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)	2151	if (j < 0 \|\| (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
2152	&& !error)) {	2152	&& !status)) {
2153	/* No need to write to this device. */	2153	/* No need to write to this device. */
2154	sbio->bi_end_io = NULL;	2154	sbio->bi_end_io = NULL;
2155	rdev_dec_pending(conf->mirrors[i].rdev, mddev);	2155	rdev_dec_pending(conf->mirrors[i].rdev, mddev);
@@ -2400,11 +2400,11 @@ static void handle_sync_write_finished(struct r1conf conf, struct r1bio r1_bio · 244 unmodified lines
2400	struct bio *bio = r1_bio->bios[m];	2400	struct bio *bio = r1_bio->bios[m];
2401	if (bio->bi_end_io == NULL)	2401	if (bio->bi_end_io == NULL)
2402	continue;	2402	continue;
2403	if (!bio->bi_error &&	2403	if (!bio->bi_status &&
2404	test_bit(R1BIO_MadeGood, &r1_bio->state)) {	2404	test_bit(R1BIO_MadeGood, &r1_bio->state)) {
2405	rdev_clear_badblocks(rdev, r1_bio->sector, s, 0);	2405	rdev_clear_badblocks(rdev, r1_bio->sector, s, 0);
2406	}	2406	}
2407	if (bio->bi_error &&	2407	if (bio->bi_status &&
2408	test_bit(R1BIO_WriteError, &r1_bio->state)) {	2408	test_bit(R1BIO_WriteError, &r1_bio->state)) {
2409	if (!rdev_set_badblocks(rdev, r1_bio->sector, s, 0))	2409	if (!rdev_set_badblocks(rdev, r1_bio->sector, s, 0))
2410	md_error(conf->mddev, rdev);	2410	md_error(conf->mddev, rdev);

drivers/md/raid10.c+18−18

@@ -336,7 +336,7 @@ static void raid_end_bio_io(struct r10bio *r10_bio) · 335 unmodified lines
336	struct r10conf *conf = r10_bio->mddev->private;	336	struct r10conf *conf = r10_bio->mddev->private;
337		337
338	if (!test_bit(R10BIO_Uptodate, &r10_bio->state))	338	if (!test_bit(R10BIO_Uptodate, &r10_bio->state))
339	bio->bi_error = -EIO;	339	bio->bi_status = BLK_STS_IOERR;
340		340
341	bio_endio(bio);	341	bio_endio(bio);
342	/*	342	/*
@@ -389,7 +389,7 @@ static int find_bio_disk(struct r10conf conf, struct r10bio r10_bio, · 46 unmodified lines
389		389
390	static void raid10_end_read_request(struct bio *bio)	390	static void raid10_end_read_request(struct bio *bio)
391	{	391	{
392	int uptodate = !bio->bi_error;	392	int uptodate = !bio->bi_status;
393	struct r10bio *r10_bio = bio->bi_private;	393	struct r10bio *r10_bio = bio->bi_private;
394	int slot, dev;	394	int slot, dev;
395	struct md_rdev *rdev;	395	struct md_rdev *rdev;
@@ -477,7 +477,7 @@ static void raid10_end_write_request(struct bio *bio) · 81 unmodified lines
477	struct bio *to_put = NULL;	477	struct bio *to_put = NULL;
478	bool discard_error;	478	bool discard_error;
479		479
480	discard_error = bio->bi_error && bio_op(bio) == REQ_OP_DISCARD;	480	discard_error = bio->bi_status && bio_op(bio) == REQ_OP_DISCARD;
481		481
482	dev = find_bio_disk(conf, r10_bio, bio, &slot, &repl);	482	dev = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
483		483
@@ -491,7 +491,7 @@ static void raid10_end_write_request(struct bio *bio) · 7 unmodified lines
491	/*	491	/*
492	* this branch is our 'one mirror IO has finished' event handler:	492	* this branch is our 'one mirror IO has finished' event handler:
493	*/	493	*/
494	if (bio->bi_error && !discard_error) {	494	if (bio->bi_status && !discard_error) {
495	if (repl)	495	if (repl)
496	/* Never record new bad blocks to replacement,	496	/* Never record new bad blocks to replacement,
497	* just fail it.	497	* just fail it.
@@ -913,7 +913,7 @@ static void flush_pending_writes(struct r10conf *conf) · 415 unmodified lines
913	bio->bi_next = NULL;	913	bio->bi_next = NULL;
914	bio->bi_bdev = rdev->bdev;	914	bio->bi_bdev = rdev->bdev;
915	if (test_bit(Faulty, &rdev->flags)) {	915	if (test_bit(Faulty, &rdev->flags)) {
916	bio->bi_error = -EIO;	916	bio->bi_status = BLK_STS_IOERR;
917	bio_endio(bio);	917	bio_endio(bio);
918	} else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&	918	} else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
919	!blk_queue_discard(bdev_get_queue(bio->bi_bdev))))	919	!blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
@@ -1098,7 +1098,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule) · 178 unmodified lines
1098	bio->bi_next = NULL;	1098	bio->bi_next = NULL;
1099	bio->bi_bdev = rdev->bdev;	1099	bio->bi_bdev = rdev->bdev;
1100	if (test_bit(Faulty, &rdev->flags)) {	1100	if (test_bit(Faulty, &rdev->flags)) {
1101	bio->bi_error = -EIO;	1101	bio->bi_status = BLK_STS_IOERR;
1102	bio_endio(bio);	1102	bio_endio(bio);
1103	} else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&	1103	} else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
1104	!blk_queue_discard(bdev_get_queue(bio->bi_bdev))))	1104	!blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
@@ -1888,7 +1888,7 @@ static void __end_sync_read(struct r10bio r10_bio, struct bio bio, int d) · 783 unmodified lines
1888	{	1888	{
1889	struct r10conf *conf = r10_bio->mddev->private;	1889	struct r10conf *conf = r10_bio->mddev->private;
1890		1890
1891	if (!bio->bi_error)	1891	if (!bio->bi_status)
1892	set_bit(R10BIO_Uptodate, &r10_bio->state);	1892	set_bit(R10BIO_Uptodate, &r10_bio->state);
1893	else	1893	else
1894	/* The write handler will notice the lack of	1894	/* The write handler will notice the lack of
@@ -1972,7 +1972,7 @@ static void end_sync_write(struct bio *bio) · 77 unmodified lines
1972	else	1972	else
1973	rdev = conf->mirrors[d].rdev;	1973	rdev = conf->mirrors[d].rdev;
1974		1974
1975	if (bio->bi_error) {	1975	if (bio->bi_status) {
1976	if (repl)	1976	if (repl)
1977	md_error(mddev, rdev);	1977	md_error(mddev, rdev);
1978	else {	1978	else {
@@ -2021,7 +2021,7 @@ static void sync_request_write(struct mddev mddev, struct r10bio r10_bio) · 42 unmodified lines
2021		2021
2022	/* find the first device with a block */	2022	/* find the first device with a block */
2023	for (i=0; i<conf->copies; i++)	2023	for (i=0; i<conf->copies; i++)
2024	if (!r10_bio->devs[i].bio->bi_error)	2024	if (!r10_bio->devs[i].bio->bi_status)
2025	break;	2025	break;
2026		2026
2027	if (i == conf->copies)	2027	if (i == conf->copies)
@@ -2050,7 +2050,7 @@ static void sync_request_write(struct mddev mddev, struct r10bio r10_bio) · 22 unmodified lines
2050	tpages = get_resync_pages(tbio)->pages;	2050	tpages = get_resync_pages(tbio)->pages;
2051	d = r10_bio->devs[i].devnum;	2051	d = r10_bio->devs[i].devnum;
2052	rdev = conf->mirrors[d].rdev;	2052	rdev = conf->mirrors[d].rdev;
2053	if (!r10_bio->devs[i].bio->bi_error) {	2053	if (!r10_bio->devs[i].bio->bi_status) {
2054	/* We know that the bi_io_vec layout is the same for	2054	/* We know that the bi_io_vec layout is the same for
2055	* both 'first' and 'i', so we just compare them.	2055	* both 'first' and 'i', so we just compare them.
2056	* All vec entries are PAGE_SIZE;	2056	* All vec entries are PAGE_SIZE;
@@ -2633,7 +2633,7 @@ static void handle_write_completed(struct r10conf conf, struct r10bio r10_bio) · 576 unmodified lines
2633	rdev = conf->mirrors[dev].rdev;	2633	rdev = conf->mirrors[dev].rdev;
2634	if (r10_bio->devs[m].bio == NULL)	2634	if (r10_bio->devs[m].bio == NULL)
2635	continue;	2635	continue;
2636	if (!r10_bio->devs[m].bio->bi_error) {	2636	if (!r10_bio->devs[m].bio->bi_status) {
2637	rdev_clear_badblocks(	2637	rdev_clear_badblocks(
2638	rdev,	2638	rdev,
2639	r10_bio->devs[m].addr,	2639	r10_bio->devs[m].addr,
@@ -2649,7 +2649,7 @@ static void handle_write_completed(struct r10conf conf, struct r10bio r10_bio) · 9 unmodified lines
2649	if (r10_bio->devs[m].repl_bio == NULL)	2649	if (r10_bio->devs[m].repl_bio == NULL)
2650	continue;	2650	continue;
2651		2651
2652	if (!r10_bio->devs[m].repl_bio->bi_error) {	2652	if (!r10_bio->devs[m].repl_bio->bi_status) {
2653	rdev_clear_badblocks(	2653	rdev_clear_badblocks(
2654	rdev,	2654	rdev,
2655	r10_bio->devs[m].addr,	2655	r10_bio->devs[m].addr,
@@ -2675,7 +2675,7 @@ static void handle_write_completed(struct r10conf conf, struct r10bio r10_bio) · 19 unmodified lines
2675	r10_bio->devs[m].addr,	2675	r10_bio->devs[m].addr,
2676	r10_bio->sectors, 0);	2676	r10_bio->sectors, 0);
2677	rdev_dec_pending(rdev, conf->mddev);	2677	rdev_dec_pending(rdev, conf->mddev);
2678	} else if (bio != NULL && bio->bi_error) {	2678	} else if (bio != NULL && bio->bi_status) {
2679	fail = true;	2679	fail = true;
2680	if (!narrow_write_error(r10_bio, m)) {	2680	if (!narrow_write_error(r10_bio, m)) {
2681	md_error(conf->mddev, rdev);	2681	md_error(conf->mddev, rdev);
@@ -3267,7 +3267,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr, · 585 unmodified lines
3267	r10_bio->devs[i].repl_bio->bi_end_io = NULL;	3267	r10_bio->devs[i].repl_bio->bi_end_io = NULL;
3268		3268
3269	bio = r10_bio->devs[i].bio;	3269	bio = r10_bio->devs[i].bio;
3270	bio->bi_error = -EIO;	3270	bio->bi_status = BLK_STS_IOERR;
3271	rcu_read_lock();	3271	rcu_read_lock();
3272	rdev = rcu_dereference(conf->mirrors[d].rdev);	3272	rdev = rcu_dereference(conf->mirrors[d].rdev);
3273	if (rdev == NULL \|\| test_bit(Faulty, &rdev->flags)) {	3273	if (rdev == NULL \|\| test_bit(Faulty, &rdev->flags)) {
@@ -3309,7 +3309,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr, · 35 unmodified lines
3309		3309
3310	/* Need to set up for writing to the replacement */	3310	/* Need to set up for writing to the replacement */
3311	bio = r10_bio->devs[i].repl_bio;	3311	bio = r10_bio->devs[i].repl_bio;
3312	bio->bi_error = -EIO;	3312	bio->bi_status = BLK_STS_IOERR;
3313		3313
3314	sector = r10_bio->devs[i].addr;	3314	sector = r10_bio->devs[i].addr;
3315	bio->bi_next = biolist;	3315	bio->bi_next = biolist;
@@ -3375,7 +3375,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr, · 59 unmodified lines
3375		3375
3376	if (bio->bi_end_io == end_sync_read) {	3376	if (bio->bi_end_io == end_sync_read) {
3377	md_sync_acct(bio->bi_bdev, nr_sectors);	3377	md_sync_acct(bio->bi_bdev, nr_sectors);
3378	bio->bi_error = 0;	3378	bio->bi_status = 0;
3379	generic_make_request(bio);	3379	generic_make_request(bio);
3380	}	3380	}
3381	}	3381	}
@@ -4394,7 +4394,7 @@ read_more: · 1012 unmodified lines
4394	read_bio->bi_end_io = end_reshape_read;	4394	read_bio->bi_end_io = end_reshape_read;
4395	bio_set_op_attrs(read_bio, REQ_OP_READ, 0);	4395	bio_set_op_attrs(read_bio, REQ_OP_READ, 0);
4396	read_bio->bi_flags &= (~0UL << BIO_RESET_BITS);	4396	read_bio->bi_flags &= (~0UL << BIO_RESET_BITS);
4397	read_bio->bi_error = 0;	4397	read_bio->bi_status = 0;
4398	read_bio->bi_vcnt = 0;	4398	read_bio->bi_vcnt = 0;
4399	read_bio->bi_iter.bi_size = 0;	4399	read_bio->bi_iter.bi_size = 0;
4400	r10_bio->master_bio = read_bio;	4400	r10_bio->master_bio = read_bio;
@@ -4638,7 +4638,7 @@ static void end_reshape_write(struct bio *bio) · 237 unmodified lines
4638	rdev = conf->mirrors[d].rdev;	4638	rdev = conf->mirrors[d].rdev;
4639	}	4639	}
4640		4640
4641	if (bio->bi_error) {	4641	if (bio->bi_status) {
4642	/* FIXME should record badblock */	4642	/* FIXME should record badblock */
4643	md_error(mddev, rdev);	4643	md_error(mddev, rdev);
4644	}	4644	}

drivers/md/raid5-cache.c+2−2

@@ -572,7 +572,7 @@ static void r5l_log_endio(struct bio *bio) · 571 unmodified lines
572	struct r5l_log *log = io->log;	572	struct r5l_log *log = io->log;
573	unsigned long flags;	573	unsigned long flags;
574		574
575	if (bio->bi_error)	575	if (bio->bi_status)
576	md_error(log->rdev->mddev, log->rdev);	576	md_error(log->rdev->mddev, log->rdev);
577		577
578	bio_put(bio);	578	bio_put(bio);
@@ -1247,7 +1247,7 @@ static void r5l_log_flush_endio(struct bio *bio) · 668 unmodified lines
1247	unsigned long flags;	1247	unsigned long flags;
1248	struct r5l_io_unit *io;	1248	struct r5l_io_unit *io;
1249		1249
1250	if (bio->bi_error)	1250	if (bio->bi_status)
1251	md_error(log->rdev->mddev, log->rdev);	1251	md_error(log->rdev->mddev, log->rdev);
1252		1252
1253	spin_lock_irqsave(&log->io_list_lock, flags);	1253	spin_lock_irqsave(&log->io_list_lock, flags);

drivers/md/raid5-ppl.c+1−1

@@ -397,7 +397,7 @@ static void ppl_log_endio(struct bio *bio) · 396 unmodified lines
397		397
398	pr_debug("%s: seq: %llu\n", __func__, io->seq);	398	pr_debug("%s: seq: %llu\n", __func__, io->seq);
399		399
400	if (bio->bi_error)	400	if (bio->bi_status)
401	md_error(ppl_conf->mddev, log->rdev);	401	md_error(ppl_conf->mddev, log->rdev);
402		402
403	list_for_each_entry_safe(sh, next, &io->stripe_list, log_list) {	403	list_for_each_entry_safe(sh, next, &io->stripe_list, log_list) {

drivers/md/raid5.c+11−11

@@ -2476,7 +2476,7 @@ static void raid5_end_read_request(struct bio * bi) · 2475 unmodified lines
2476		2476
2477	pr_debug("end_read_request %llu/%d, count: %d, error %d.\n",	2477	pr_debug("end_read_request %llu/%d, count: %d, error %d.\n",
2478	(unsigned long long)sh->sector, i, atomic_read(&sh->count),	2478	(unsigned long long)sh->sector, i, atomic_read(&sh->count),
2479	bi->bi_error);	2479	bi->bi_status);
2480	if (i == disks) {	2480	if (i == disks) {
2481	bio_reset(bi);	2481	bio_reset(bi);
2482	BUG();	2482	BUG();
@@ -2496,7 +2496,7 @@ static void raid5_end_read_request(struct bio * bi) · 13 unmodified lines
2496	s = sh->sector + rdev->new_data_offset;	2496	s = sh->sector + rdev->new_data_offset;
2497	else	2497	else
2498	s = sh->sector + rdev->data_offset;	2498	s = sh->sector + rdev->data_offset;
2499	if (!bi->bi_error) {	2499	if (!bi->bi_status) {
2500	set_bit(R5_UPTODATE, &sh->dev[i].flags);	2500	set_bit(R5_UPTODATE, &sh->dev[i].flags);
2501	if (test_bit(R5_ReadError, &sh->dev[i].flags)) {	2501	if (test_bit(R5_ReadError, &sh->dev[i].flags)) {
2502	/* Note that this cannot happen on a	2502	/* Note that this cannot happen on a
@@ -2613,7 +2613,7 @@ static void raid5_end_write_request(struct bio *bi) · 110 unmodified lines
2613	}	2613	}
2614	pr_debug("end_write_request %llu/%d, count %d, error: %d.\n",	2614	pr_debug("end_write_request %llu/%d, count %d, error: %d.\n",
2615	(unsigned long long)sh->sector, i, atomic_read(&sh->count),	2615	(unsigned long long)sh->sector, i, atomic_read(&sh->count),
2616	bi->bi_error);	2616	bi->bi_status);
2617	if (i == disks) {	2617	if (i == disks) {
2618	bio_reset(bi);	2618	bio_reset(bi);
2619	BUG();	2619	BUG();
@@ -2621,14 +2621,14 @@ static void raid5_end_write_request(struct bio *bi) · 1 unmodified line
2621	}	2621	}
2622		2622
2623	if (replacement) {	2623	if (replacement) {
2624	if (bi->bi_error)	2624	if (bi->bi_status)
2625	md_error(conf->mddev, rdev);	2625	md_error(conf->mddev, rdev);
2626	else if (is_badblock(rdev, sh->sector,	2626	else if (is_badblock(rdev, sh->sector,
2627	STRIPE_SECTORS,	2627	STRIPE_SECTORS,
2628	&first_bad, &bad_sectors))	2628	&first_bad, &bad_sectors))
2629	set_bit(R5_MadeGoodRepl, &sh->dev[i].flags);	2629	set_bit(R5_MadeGoodRepl, &sh->dev[i].flags);
2630	} else {	2630	} else {
2631	if (bi->bi_error) {	2631	if (bi->bi_status) {
2632	set_bit(STRIPE_DEGRADED, &sh->state);	2632	set_bit(STRIPE_DEGRADED, &sh->state);
2633	set_bit(WriteErrorSeen, &rdev->flags);	2633	set_bit(WriteErrorSeen, &rdev->flags);
2634	set_bit(R5_WriteError, &sh->dev[i].flags);	2634	set_bit(R5_WriteError, &sh->dev[i].flags);
@@ -2649,7 +2649,7 @@ static void raid5_end_write_request(struct bio *bi) · 14 unmodified lines
2649	}	2649	}
2650	rdev_dec_pending(rdev, conf->mddev);	2650	rdev_dec_pending(rdev, conf->mddev);
2651		2651
2652	if (sh->batch_head && bi->bi_error && !replacement)	2652	if (sh->batch_head && bi->bi_status && !replacement)
2653	set_bit(STRIPE_BATCH_ERR, &sh->batch_head->state);	2653	set_bit(STRIPE_BATCH_ERR, &sh->batch_head->state);
2654		2654
2655	bio_reset(bi);	2655	bio_reset(bi);
@@ -3381,7 +3381,7 @@ handle_failed_stripe(struct r5conf conf, struct stripe_head sh, · 725 unmodified lines
3381	sh->dev[i].sector + STRIPE_SECTORS) {	3381	sh->dev[i].sector + STRIPE_SECTORS) {
3382	struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);	3382	struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
3383		3383
3384	bi->bi_error = -EIO;	3384	bi->bi_status = BLK_STS_IOERR;
3385	md_write_end(conf->mddev);	3385	md_write_end(conf->mddev);
3386	bio_endio(bi);	3386	bio_endio(bi);
3387	bi = nextbi;	3387	bi = nextbi;
@@ -3403,7 +3403,7 @@ handle_failed_stripe(struct r5conf conf, struct stripe_head sh, · 15 unmodified lines
3403	sh->dev[i].sector + STRIPE_SECTORS) {	3403	sh->dev[i].sector + STRIPE_SECTORS) {
3404	struct bio *bi2 = r5_next_bio(bi, sh->dev[i].sector);	3404	struct bio *bi2 = r5_next_bio(bi, sh->dev[i].sector);
3405		3405
3406	bi->bi_error = -EIO;	3406	bi->bi_status = BLK_STS_IOERR;
3407	md_write_end(conf->mddev);	3407	md_write_end(conf->mddev);
3408	bio_endio(bi);	3408	bio_endio(bi);
3409	bi = bi2;	3409	bi = bi2;
@@ -3429,7 +3429,7 @@ handle_failed_stripe(struct r5conf conf, struct stripe_head sh, · 19 unmodified lines
3429	struct bio *nextbi =	3429	struct bio *nextbi =
3430	r5_next_bio(bi, sh->dev[i].sector);	3430	r5_next_bio(bi, sh->dev[i].sector);
3431		3431
3432	bi->bi_error = -EIO;	3432	bi->bi_status = BLK_STS_IOERR;
3433	bio_endio(bi);	3433	bio_endio(bi);
3434	bi = nextbi;	3434	bi = nextbi;
3435	}	3435	}
@@ -5144,7 +5144,7 @@ static void raid5_align_endio(struct bio *bi) · 1708 unmodified lines
5144	struct mddev *mddev;	5144	struct mddev *mddev;
5145	struct r5conf *conf;	5145	struct r5conf *conf;
5146	struct md_rdev *rdev;	5146	struct md_rdev *rdev;
5147	int error = bi->bi_error;	5147	blk_status_t error = bi->bi_status;
5148		5148
5149	bio_put(bi);	5149	bio_put(bi);
5150		5150
@@ -5721,7 +5721,7 @@ static void raid5_make_request(struct mddev mddev, struct bio bi) · 570 unmodified lines
5721	release_stripe_plug(mddev, sh);	5721	release_stripe_plug(mddev, sh);
5722	} else {	5722	} else {
5723	/* cannot get stripe for read-ahead, just give-up */	5723	/* cannot get stripe for read-ahead, just give-up */
5724	bi->bi_error = -EIO;	5724	bi->bi_status = BLK_STS_IOERR;
5725	break;	5725	break;
5726	}	5726	}
5727	}	5727	}

drivers/nvdimm/blk.c+2−2

@@ -186,7 +186,7 @@ static blk_qc_t nd_blk_make_request(struct request_queue q, struct bio bio) · 185 unmodified lines
186	* another kernel subsystem, and we just pass it through.	186	* another kernel subsystem, and we just pass it through.
187	*/	187	*/
188	if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {	188	if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
189	bio->bi_error = -EIO;	189	bio->bi_status = BLK_STS_IOERR;
190	goto out;	190	goto out;
191	}	191	}
192		192
@@ -205,7 +205,7 @@ static blk_qc_t nd_blk_make_request(struct request_queue q, struct bio bio) · 12 unmodified lines
205	"io error in %s sector %lld, len %d,\n",	205	"io error in %s sector %lld, len %d,\n",
206	(rw == READ) ? "READ" : "WRITE",	206	(rw == READ) ? "READ" : "WRITE",
207	(unsigned long long) iter.bi_sector, len);	207	(unsigned long long) iter.bi_sector, len);
208	bio->bi_error = err;	208	bio->bi_status = errno_to_blk_status(err);
209	break;	209	break;
210	}	210	}
211	}	211	}

drivers/nvdimm/btt.c+2−2

@@ -1210,7 +1210,7 @@ static blk_qc_t btt_make_request(struct request_queue q, struct bio bio) · 1209 unmodified lines
1210	* another kernel subsystem, and we just pass it through.	1210	* another kernel subsystem, and we just pass it through.
1211	*/	1211	*/
1212	if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {	1212	if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
1213	bio->bi_error = -EIO;	1213	bio->bi_status = BLK_STS_IOERR;
1214	goto out;	1214	goto out;
1215	}	1215	}
1216		1216
@@ -1232,7 +1232,7 @@ static blk_qc_t btt_make_request(struct request_queue q, struct bio bio) · 15 unmodified lines
1232	(op_is_write(bio_op(bio))) ? "WRITE" :	1232	(op_is_write(bio_op(bio))) ? "WRITE" :
1233	"READ",	1233	"READ",
1234	(unsigned long long) iter.bi_sector, len);	1234	(unsigned long long) iter.bi_sector, len);
1235	bio->bi_error = err;	1235	bio->bi_status = errno_to_blk_status(err);
1236	break;	1236	break;
1237	}	1237	}
1238	}	1238	}

drivers/nvdimm/pmem.c+14−14

@@ -49,19 +49,19 @@ static struct nd_region to_region(struct pmem_device pmem) · 48 unmodified lines
49	return to_nd_region(to_dev(pmem)->parent);	49	return to_nd_region(to_dev(pmem)->parent);
50	}	50	}
51		51
52	static int pmem_clear_poison(struct pmem_device *pmem, phys_addr_t offset,	52	static blk_status_t pmem_clear_poison(struct pmem_device *pmem,
53	unsigned int len)	53	phys_addr_t offset, unsigned int len)
54	{	54	{
55	struct device *dev = to_dev(pmem);	55	struct device *dev = to_dev(pmem);
56	sector_t sector;	56	sector_t sector;
57	long cleared;	57	long cleared;
58	int rc = 0;	58	blk_status_t rc = BLK_STS_OK;
59		59
60	sector = (offset - pmem->data_offset) / 512;	60	sector = (offset - pmem->data_offset) / 512;
61		61
62	cleared = nvdimm_clear_poison(dev, pmem->phys_addr + offset, len);	62	cleared = nvdimm_clear_poison(dev, pmem->phys_addr + offset, len);
63	if (cleared < len)	63	if (cleared < len)
64	rc = -EIO;	64	rc = BLK_STS_IOERR;
65	if (cleared > 0 && cleared / 512) {	65	if (cleared > 0 && cleared / 512) {
66	cleared /= 512;	66	cleared /= 512;
67	dev_dbg(dev, "%s: %#llx clear %ld sector%s\n", __func__,	67	dev_dbg(dev, "%s: %#llx clear %ld sector%s\n", __func__,
@@ -84,7 +84,7 @@ static void write_pmem(void pmem_addr, struct page page, · 16 unmodified lines
84	kunmap_atomic(mem);	84	kunmap_atomic(mem);
85	}	85	}
86		86
87	static int read_pmem(struct page *page, unsigned int off,	87	static blk_status_t read_pmem(struct page *page, unsigned int off,
88	void *pmem_addr, unsigned int len)	88	void *pmem_addr, unsigned int len)
89	{	89	{
90	int rc;	90	int rc;
@@ -93,15 +93,15 @@ static int read_pmem(struct page *page, unsigned int off, · 2 unmodified lines
93	rc = memcpy_mcsafe(mem + off, pmem_addr, len);	93	rc = memcpy_mcsafe(mem + off, pmem_addr, len);
94	kunmap_atomic(mem);	94	kunmap_atomic(mem);
95	if (rc)	95	if (rc)
96	return -EIO;	96	return BLK_STS_IOERR;
97	return 0;	97	return BLK_STS_OK;
98	}	98	}
99		99
100	static int pmem_do_bvec(struct pmem_device pmem, struct page page,	100	static blk_status_t pmem_do_bvec(struct pmem_device pmem, struct page page,
101	unsigned int len, unsigned int off, bool is_write,	101	unsigned int len, unsigned int off, bool is_write,
102	sector_t sector)	102	sector_t sector)
103	{	103	{
104	int rc = 0;	104	blk_status_t rc = BLK_STS_OK;
105	bool bad_pmem = false;	105	bool bad_pmem = false;
106	phys_addr_t pmem_off = sector * 512 + pmem->data_offset;	106	phys_addr_t pmem_off = sector * 512 + pmem->data_offset;
107	void *pmem_addr = pmem->virt_addr + pmem_off;	107	void *pmem_addr = pmem->virt_addr + pmem_off;
@@ -111,7 +111,7 @@ static int pmem_do_bvec(struct pmem_device pmem, struct page page, · 3 unmodified lines
111		111
112	if (!is_write) {	112	if (!is_write) {
113	if (unlikely(bad_pmem))	113	if (unlikely(bad_pmem))
114	rc = -EIO;	114	rc = BLK_STS_IOERR;
115	else {	115	else {
116	rc = read_pmem(page, off, pmem_addr, len);	116	rc = read_pmem(page, off, pmem_addr, len);
117	flush_dcache_page(page);	117	flush_dcache_page(page);
@@ -149,7 +149,7 @@ static int pmem_do_bvec(struct pmem_device pmem, struct page page, · 31 unmodified lines
149		149
150	static blk_qc_t pmem_make_request(struct request_queue q, struct bio bio)	150	static blk_qc_t pmem_make_request(struct request_queue q, struct bio bio)
151	{	151	{
152	int rc = 0;	152	blk_status_t rc = 0;
153	bool do_acct;	153	bool do_acct;
154	unsigned long start;	154	unsigned long start;
155	struct bio_vec bvec;	155	struct bio_vec bvec;
@@ -166,7 +166,7 @@ static blk_qc_t pmem_make_request(struct request_queue q, struct bio bio) · 10 unmodified lines
166	bvec.bv_offset, op_is_write(bio_op(bio)),	166	bvec.bv_offset, op_is_write(bio_op(bio)),
167	iter.bi_sector);	167	iter.bi_sector);
168	if (rc) {	168	if (rc) {
169	bio->bi_error = rc;	169	bio->bi_status = rc;
170	break;	170	break;
171	}	171	}
172	}	172	}
@@ -184,7 +184,7 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector, · 11 unmodified lines
184	struct page *page, bool is_write)	184	struct page *page, bool is_write)
185	{	185	{
186	struct pmem_device *pmem = bdev->bd_queue->queuedata;	186	struct pmem_device *pmem = bdev->bd_queue->queuedata;
187	int rc;	187	blk_status_t rc;
188		188
189	rc = pmem_do_bvec(pmem, page, PAGE_SIZE, 0, is_write, sector);	189	rc = pmem_do_bvec(pmem, page, PAGE_SIZE, 0, is_write, sector);
190		190
@@ -197,7 +197,7 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector, · 6 unmodified lines
197	if (rc == 0)	197	if (rc == 0)
198	page_endio(page, is_write, 0);	198	page_endio(page, is_write, 0);
199		199
200	return rc;	200	return blk_status_to_errno(rc);
201	}	201	}
202		202
203	/* see "strong" declaration in tools/testing/nvdimm/pmem-dax.c */	203	/* see "strong" declaration in tools/testing/nvdimm/pmem-dax.c */

drivers/nvme/target/io-cmd.c+2−2

@@ -21,7 +21,7 @@ static void nvmet_bio_done(struct bio *bio) · 20 unmodified lines
21	struct nvmet_req *req = bio->bi_private;	21	struct nvmet_req *req = bio->bi_private;
22		22
23	nvmet_req_complete(req,	23	nvmet_req_complete(req,
24	bio->bi_error ? NVME_SC_INTERNAL \| NVME_SC_DNR : 0);	24	bio->bi_status ? NVME_SC_INTERNAL \| NVME_SC_DNR : 0);
25		25
26	if (bio != &req->inline_bio)	26	if (bio != &req->inline_bio)
27	bio_put(bio);	27	bio_put(bio);
@@ -145,7 +145,7 @@ static void nvmet_execute_discard(struct nvmet_req *req) · 117 unmodified lines
145	bio->bi_private = req;	145	bio->bi_private = req;
146	bio->bi_end_io = nvmet_bio_done;	146	bio->bi_end_io = nvmet_bio_done;
147	if (status) {	147	if (status) {
148	bio->bi_error = -EIO;	148	bio->bi_status = BLK_STS_IOERR;
149	bio_endio(bio);	149	bio_endio(bio);
150	} else {	150	} else {
151	submit_bio(bio);	151	submit_bio(bio);

drivers/target/target_core_iblock.c+5−5

@@ -296,8 +296,8 @@ static void iblock_bio_done(struct bio *bio) · 295 unmodified lines
296	struct se_cmd *cmd = bio->bi_private;	296	struct se_cmd *cmd = bio->bi_private;
297	struct iblock_req *ibr = cmd->priv;	297	struct iblock_req *ibr = cmd->priv;
298		298
299	if (bio->bi_error) {	299	if (bio->bi_status) {
300	pr_err("bio error: %p, err: %d\n", bio, bio->bi_error);	300	pr_err("bio error: %p, err: %d\n", bio, bio->bi_status);
301	/*	301	/*
302	* Bump the ib_bio_err_cnt and release bio.	302	* Bump the ib_bio_err_cnt and release bio.
303	*/	303	*/
@@ -354,11 +354,11 @@ static void iblock_end_io_flush(struct bio *bio) · 50 unmodified lines
354	{	354	{
355	struct se_cmd *cmd = bio->bi_private;	355	struct se_cmd *cmd = bio->bi_private;
356		356
357	if (bio->bi_error)	357	if (bio->bi_status)
358	pr_err("IBLOCK: cache flush failed: %d\n", bio->bi_error);	358	pr_err("IBLOCK: cache flush failed: %d\n", bio->bi_status);
359		359
360	if (cmd) {	360	if (cmd) {
361	if (bio->bi_error)	361	if (bio->bi_status)
362	target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);	362	target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
363	else	363	else
364	target_complete_cmd(cmd, SAM_STAT_GOOD);	364	target_complete_cmd(cmd, SAM_STAT_GOOD);

fs/block_dev.c+10−8

 	if (vecs != inline_vecs)
 		kfree(vecs);
-	if (unlikely(bio.bi_error))
+	if (unlikely(bio.bi_status))
-		return bio.bi_error;
+		return blk_status_to_errno(bio.bi_status);
 	return ret;
 }
 	bool should_dirty = dio->should_dirty;
 	if (dio->multi_bio && !atomic_dec_and_test(&dio->ref)) {
-		if (bio->bi_error && !dio->bio.bi_error)
+		if (bio->bi_status && !dio->bio.bi_status)
-			dio->bio.bi_error = bio->bi_error;
+			dio->bio.bi_status = bio->bi_status;
 	} else {
 		if (!dio->is_sync) {
 			struct kiocb *iocb = dio->iocb;
-			ssize_t ret = dio->bio.bi_error;
+			ssize_t ret;
-			if (likely(!ret)) {
+			if (likely(!dio->bio.bi_status)) {
 				ret = dio->size;
 				iocb->ki_pos += ret;
+			} else {
+				ret = blk_status_to_errno(dio->bio.bi_status);
 			}
 			dio->iocb->ki_complete(iocb, ret, 0);
 		ret = bio_iov_iter_get_pages(bio, iter);
 		if (unlikely(ret)) {
-			bio->bi_error = -EIO;
+			bio->bi_status = BLK_STS_IOERR;
 			bio_endio(bio);
 			break;
 		}
 	__set_current_state(TASK_RUNNING);
 	if (!ret)
-		ret = dio->bio.bi_error;
+		ret = blk_status_to_errno(dio->bio.bi_status);
 	if (likely(!ret))
 		ret = dio->size;

fs/btrfs/btrfs_inode.h+2−1

@@ -310,7 +310,8 @@ struct btrfs_dio_private { · 309 unmodified lines
310	* The original bio may be split to several sub-bios, this is	310	* The original bio may be split to several sub-bios, this is
311	* done during endio of sub-bios	311	* done during endio of sub-bios
312	*/	312	*/
313	int (subio_endio)(struct inode , struct btrfs_io_bio *, int);	313	blk_status_t (subio_endio)(struct inode , struct btrfs_io_bio *,
		314	blk_status_t);
314	};	315	};
315		316
316	/*	317	/*

fs/btrfs/check-integrity.c+2−2

@@ -2129,7 +2129,7 @@ static void btrfsic_bio_end_io(struct bio *bp) · 2128 unmodified lines
2129	/* mutex is not held! This is not save if IO is not yet completed	2129	/* mutex is not held! This is not save if IO is not yet completed
2130	* on umount */	2130	* on umount */
2131	iodone_w_error = 0;	2131	iodone_w_error = 0;
2132	if (bp->bi_error)	2132	if (bp->bi_status)
2133	iodone_w_error = 1;	2133	iodone_w_error = 1;
2134		2134
2135	BUG_ON(NULL == block);	2135	BUG_ON(NULL == block);
@@ -2143,7 +2143,7 @@ static void btrfsic_bio_end_io(struct bio *bp) · 7 unmodified lines
2143	if ((dev_state->state->print_mask &	2143	if ((dev_state->state->print_mask &
2144	BTRFSIC_PRINT_MASK_END_IO_BIO_BH))	2144	BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
2145	pr_info("bio_end_io(err=%d) for %c @%llu (%s/%llu/%d)\n",	2145	pr_info("bio_end_io(err=%d) for %c @%llu (%s/%llu/%d)\n",
2146	bp->bi_error,	2146	bp->bi_status,
2147	btrfsic_get_block_type(dev_state->state, block),	2147	btrfsic_get_block_type(dev_state->state, block),
2148	block->logical_bytenr, dev_state->name,	2148	block->logical_bytenr, dev_state->name,
2149	block->dev_bytenr, block->mirror_num);	2149	block->dev_bytenr, block->mirror_num);

fs/btrfs/compression.c+22−22

 	unsigned long index;
 	int ret;
-	if (bio->bi_error)
+	if (bio->bi_status)
 		cb->errors = 1;
 	/* if there are more bios still pending for this compressed
 	struct page *page;
 	unsigned long index;
-	if (bio->bi_error)
+	if (bio->bi_status)
 		cb->errors = 1;
 	/* if there are more bios still pending for this compressed
 					 cb->start,
 					 cb->start + cb->len - 1,
 					 NULL,
-					 bio->bi_error ? 0 : 1);
+					 bio->bi_status ? 0 : 1);
 	cb->compressed_pages[0]->mapping = NULL;
 	end_compressed_writeback(inode, cb);
  * This also checksums the file bytes and gets things ready for
  * the end io hooks.
  */
-int btrfs_submit_compressed_write(struct inode *inode, u64 start,
+blk_status_t btrfs_submit_compressed_write(struct inode *inode, u64 start,
 				 unsigned long len, u64 disk_start,
 				 unsigned long compressed_len,
 				 struct page **compressed_pages,
 	struct page *page;
 	u64 first_byte = disk_start;
 	struct block_device *bdev;
-	int ret;
+	blk_status_t ret;
 	int skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 	WARN_ON(start & ((u64)PAGE_SIZE - 1));
 	cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
 	if (!cb)
-		return -ENOMEM;
+		return BLK_STS_RESOURCE;
 	refcount_set(&cb->pending_bios, 0);
 	cb->errors = 0;
 	cb->inode = inode;
 	bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);
 	if (!bio) {
 		kfree(cb);
-		return -ENOMEM;
+		return BLK_STS_RESOURCE;
 	}
 	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
 	bio->bi_private = cb;
 	/* create and submit bios for the compressed pages */
 	bytes_left = compressed_len;
 	for (pg_index = 0; pg_index < cb->nr_pages; pg_index++) {
+		int submit = 0;
 		page = compressed_pages[pg_index];
 		page->mapping = inode->i_mapping;
 		if (bio->bi_iter.bi_size)
-			ret = io_tree->ops->merge_bio_hook(page, 0,
+			submit = io_tree->ops->merge_bio_hook(page, 0,
 							   PAGE_SIZE,
 							   bio, 0);
-		else
-			ret = 0;
 		page->mapping = NULL;
-		if (ret || bio_add_page(bio, page, PAGE_SIZE, 0) <
+		if (submit || bio_add_page(bio, page, PAGE_SIZE, 0) <
 		    PAGE_SIZE) {
 			bio_get(bio);
 			ret = btrfs_map_bio(fs_info, bio, 0, 1);
 			if (ret) {
-				bio->bi_error = ret;
+				bio->bi_status = ret;
 				bio_endio(bio);
 			}
 	ret = btrfs_map_bio(fs_info, bio, 0, 1);
 	if (ret) {
-		bio->bi_error = ret;
+		bio->bi_status = ret;
 		bio_endio(bio);
 	}
  * After the compressed pages are read, we copy the bytes into the
  * bio we were passed and then call the bio end_io calls
  */
-int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
+blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 				 int mirror_num, unsigned long bio_flags)
 {
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	u64 em_len;
 	u64 em_start;
 	struct extent_map *em;
-	int ret = -ENOMEM;
+	blk_status_t ret = BLK_STS_RESOURCE;
 	int faili = 0;
 	u32 *sums;
 				   PAGE_SIZE);
 	read_unlock(&em_tree->lock);
 	if (!em)
-		return -EIO;
+		return BLK_STS_IOERR;
 	compressed_len = em->block_len;
 	cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
 	refcount_set(&cb->pending_bios, 1);
 	for (pg_index = 0; pg_index < nr_pages; pg_index++) {
+		int submit = 0;
 		page = cb->compressed_pages[pg_index];
 		page->mapping = inode->i_mapping;
 		page->index = em_start >> PAGE_SHIFT;
 		if (comp_bio->bi_iter.bi_size)
-			ret = tree->ops->merge_bio_hook(page, 0,
+			submit = tree->ops->merge_bio_hook(page, 0,
 							PAGE_SIZE,
 							comp_bio, 0);
-		else
-			ret = 0;
 		page->mapping = NULL;
-		if (ret || bio_add_page(comp_bio, page, PAGE_SIZE, 0) <
+		if (submit || bio_add_page(comp_bio, page, PAGE_SIZE, 0) <
 		    PAGE_SIZE) {
 			bio_get(comp_bio);
 			ret = btrfs_map_bio(fs_info, comp_bio, mirror_num, 0);
 			if (ret) {
-				comp_bio->bi_error = ret;
+				comp_bio->bi_status = ret;
 				bio_endio(comp_bio);
 			}
 	ret = btrfs_map_bio(fs_info, comp_bio, mirror_num, 0);
 	if (ret) {
-		comp_bio->bi_error = ret;
+		comp_bio->bi_status = ret;
 		bio_endio(comp_bio);
 	}

fs/btrfs/compression.h+2−2

@@ -48,12 +48,12 @@ int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start, · 47 unmodified lines
48	unsigned long total_out, u64 disk_start,	48	unsigned long total_out, u64 disk_start,
49	struct bio *bio);	49	struct bio *bio);
50		50
51	int btrfs_submit_compressed_write(struct inode *inode, u64 start,	51	blk_status_t btrfs_submit_compressed_write(struct inode *inode, u64 start,
52	unsigned long len, u64 disk_start,	52	unsigned long len, u64 disk_start,
53	unsigned long compressed_len,	53	unsigned long compressed_len,
54	struct page **compressed_pages,	54	struct page **compressed_pages,
55	unsigned long nr_pages);	55	unsigned long nr_pages);
56	int btrfs_submit_compressed_read(struct inode inode, struct bio bio,	56	blk_status_t btrfs_submit_compressed_read(struct inode inode, struct bio bio,
57	int mirror_num, unsigned long bio_flags);	57	int mirror_num, unsigned long bio_flags);
58		58
59	enum btrfs_compression_type {	59	enum btrfs_compression_type {

fs/btrfs/ctree.h+3−3

@@ -3078,8 +3078,8 @@ int btrfs_find_name_in_ext_backref(struct btrfs_path *path, · 3077 unmodified lines
3078	struct btrfs_dio_private;	3078	struct btrfs_dio_private;
3079	int btrfs_del_csums(struct btrfs_trans_handle *trans,	3079	int btrfs_del_csums(struct btrfs_trans_handle *trans,
3080	struct btrfs_fs_info *fs_info, u64 bytenr, u64 len);	3080	struct btrfs_fs_info *fs_info, u64 bytenr, u64 len);
3081	int btrfs_lookup_bio_sums(struct inode inode, struct bio bio, u32 *dst);	3081	blk_status_t btrfs_lookup_bio_sums(struct inode inode, struct bio bio, u32 *dst);
3082	int btrfs_lookup_bio_sums_dio(struct inode inode, struct bio bio,	3082	blk_status_t btrfs_lookup_bio_sums_dio(struct inode inode, struct bio bio,
3083	u64 logical_offset);	3083	u64 logical_offset);
3084	int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,	3084	int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
3085	struct btrfs_root *root,	3085	struct btrfs_root *root,
@@ -3094,7 +3094,7 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, · 8 unmodified lines
3094	int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,	3094	int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3095	struct btrfs_root *root,	3095	struct btrfs_root *root,
3096	struct btrfs_ordered_sum *sums);	3096	struct btrfs_ordered_sum *sums);
3097	int btrfs_csum_one_bio(struct inode inode, struct bio bio,	3097	blk_status_t btrfs_csum_one_bio(struct inode inode, struct bio bio,
3098	u64 file_start, int contig);	3098	u64 file_start, int contig);
3099	int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,	3099	int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3100	struct list_head *list, int search_commit);	3100	struct list_head *list, int search_commit);

fs/btrfs/disk-io.c+37−38

 	bio_end_io_t *end_io;
 	void *private;
 	struct btrfs_fs_info *info;
-	int error;
+	blk_status_t status;
 	enum btrfs_wq_endio_type metadata;
 	struct list_head list;
 	struct btrfs_work work;
 	 */
 	u64 bio_offset;
 	struct btrfs_work work;
-	int error;
+	blk_status_t status;
 };
 /*
 	btrfs_work_func_t func;
 	fs_info = end_io_wq->info;
-	end_io_wq->error = bio->bi_error;
+	end_io_wq->status = bio->bi_status;
 	if (bio_op(bio) == REQ_OP_WRITE) {
 		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {
 	btrfs_queue_work(wq, &end_io_wq->work);
 }
-int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
+blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
 			enum btrfs_wq_endio_type metadata)
 {
 	struct btrfs_end_io_wq *end_io_wq;
 	end_io_wq = kmem_cache_alloc(btrfs_end_io_wq_cache, GFP_NOFS);
 	if (!end_io_wq)
-		return -ENOMEM;
+		return BLK_STS_RESOURCE;
 	end_io_wq->private = bio->bi_private;
 	end_io_wq->end_io = bio->bi_end_io;
 	end_io_wq->info = info;
-	end_io_wq->error = 0;
+	end_io_wq->status = 0;
 	end_io_wq->bio = bio;
 	end_io_wq->metadata = metadata;
 static void run_one_async_start(struct btrfs_work *work)
 {
 	struct async_submit_bio *async;
-	int ret;
+	blk_status_t ret;
 	async = container_of(work, struct  async_submit_bio, work);
 	ret = async->submit_bio_start(async->inode, async->bio,
 				      async->mirror_num, async->bio_flags,
 				      async->bio_offset);
 	if (ret)
-		async->error = ret;
+		async->status = ret;
 }
 static void run_one_async_done(struct btrfs_work *work)
 		wake_up(&fs_info->async_submit_wait);
 	/* If an error occurred we just want to clean up the bio and move on */
-	if (async->error) {
+	if (async->status) {
-		async->bio->bi_error = async->error;
+		async->bio->bi_status = async->status;
 		bio_endio(async->bio);
 		return;
 	}
 	kfree(async);
 }
-int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
+blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info,
-			struct bio *bio, int mirror_num,
+		struct inode *inode, struct bio *bio, int mirror_num,
-			unsigned long bio_flags,
+		unsigned long bio_flags, u64 bio_offset,
-			u64 bio_offset,
+		extent_submit_bio_hook_t *submit_bio_start,
-			extent_submit_bio_hook_t *submit_bio_start,
+		extent_submit_bio_hook_t *submit_bio_done)
-			extent_submit_bio_hook_t *submit_bio_done)
 {
 	struct async_submit_bio *async;
 	async = kmalloc(sizeof(*async), GFP_NOFS);
 	if (!async)
-		return -ENOMEM;
+		return BLK_STS_RESOURCE;
 	async->inode = inode;
 	async->bio = bio;
 	async->bio_flags = bio_flags;
 	async->bio_offset = bio_offset;
-	async->error = 0;
+	async->status = 0;
 	atomic_inc(&fs_info->nr_async_submits);
 	return 0;
 }
-static int btree_csum_one_bio(struct bio *bio)
+static blk_status_t btree_csum_one_bio(struct bio *bio)
 {
 	struct bio_vec *bvec;
 	struct btrfs_root *root;
 			break;
 	}
-	return ret;
+	return errno_to_blk_status(ret);
 }
-static int __btree_submit_bio_start(struct inode *inode, struct bio *bio,
+static blk_status_t __btree_submit_bio_start(struct inode *inode,
-				    int mirror_num, unsigned long bio_flags,
+		struct bio *bio, int mirror_num, unsigned long bio_flags,
-				    u64 bio_offset)
+		u64 bio_offset)
 {
 	/*
 	 * when we're called for a write, we're already in the async
 	return btree_csum_one_bio(bio);
 }
-static int __btree_submit_bio_done(struct inode *inode, struct bio *bio,
+static blk_status_t __btree_submit_bio_done(struct inode *inode,
-				 int mirror_num, unsigned long bio_flags,
+		struct bio *bio, int mirror_num, unsigned long bio_flags,
-				 u64 bio_offset)
+		u64 bio_offset)
 {
-	int ret;
+	blk_status_t ret;
 	/*
 	 * when we're called for a write, we're already in the async
 	 */
 	ret = btrfs_map_bio(btrfs_sb(inode->i_sb), bio, mirror_num, 1);
 	if (ret) {
-		bio->bi_error = ret;
+		bio->bi_status = ret;
 		bio_endio(bio);
 	}
 	return ret;
 	return 1;
 }
-static int btree_submit_bio_hook(struct inode *inode, struct bio *bio,
+static blk_status_t btree_submit_bio_hook(struct inode *inode, struct bio *bio,
 				 int mirror_num, unsigned long bio_flags,
 				 u64 bio_offset)
 {
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	int async = check_async_write(bio_flags);
-	int ret;
+	blk_status_t ret;
 	if (bio_op(bio) != REQ_OP_WRITE) {
 		/*
 	return 0;
 out_w_error:
-	bio->bi_error = ret;
+	bio->bi_status = ret;
 	bio_endio(bio);
 	return ret;
 }
 	end_io_wq = container_of(work, struct btrfs_end_io_wq, work);
 	bio = end_io_wq->bio;
-	bio->bi_error = end_io_wq->error;
+	bio->bi_status = end_io_wq->status;
 	bio->bi_private = end_io_wq->private;
 	bio->bi_end_io = end_io_wq->end_io;
 	kmem_cache_free(btrfs_end_io_wq_cache, end_io_wq);
  * any device where the flush fails with eopnotsupp are flagged as not-barrier
  * capable
  */
-static int write_dev_flush(struct btrfs_device *device, int wait)
+static blk_status_t write_dev_flush(struct btrfs_device *device, int wait)
 {
 	struct request_queue *q = bdev_get_queue(device->bdev);
 	struct bio *bio;
-	int ret = 0;
+	blk_status_t ret = 0;
 	if (!test_bit(QUEUE_FLAG_WC, &q->queue_flags))
 		return 0;
 		wait_for_completion(&device->flush_wait);
-		if (bio->bi_error) {
+		if (bio->bi_status) {
-			ret = bio->bi_error;
+			ret = bio->bi_status;
 			btrfs_dev_stat_inc_and_print(device,
 				BTRFS_DEV_STAT_FLUSH_ERRS);
 		}
 	device->flush_bio = NULL;
 	bio = btrfs_io_bio_alloc(GFP_NOFS, 0);
 	if (!bio)
-		return -ENOMEM;
+		return BLK_STS_RESOURCE;
 	bio->bi_end_io = btrfs_end_empty_barrier;
 	bio->bi_bdev = device->bdev;
 	struct btrfs_device *dev;
 	int errors_send = 0;
 	int errors_wait = 0;
-	int ret;
+	blk_status_t ret;
 	/* send down all the barriers */
 	head = &info->fs_devices->devices;

fs/btrfs/disk-io.h+6−6

@@ -118,13 +118,13 @@ int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid, · 117 unmodified lines
118	int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid);	118	int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid);
119	u32 btrfs_csum_data(const char *data, u32 seed, size_t len);	119	u32 btrfs_csum_data(const char *data, u32 seed, size_t len);
120	void btrfs_csum_final(u32 crc, u8 *result);	120	void btrfs_csum_final(u32 crc, u8 *result);
121	int btrfs_bio_wq_end_io(struct btrfs_fs_info info, struct bio bio,	121	blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info info, struct bio bio,
122	enum btrfs_wq_endio_type metadata);	122	enum btrfs_wq_endio_type metadata);
123	int btrfs_wq_submit_bio(struct btrfs_fs_info fs_info, struct inode inode,	123	blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info,
124	struct bio *bio, int mirror_num,	124	struct inode inode, struct bio bio, int mirror_num,
125	unsigned long bio_flags, u64 bio_offset,	125	unsigned long bio_flags, u64 bio_offset,
126	extent_submit_bio_hook_t *submit_bio_start,	126	extent_submit_bio_hook_t *submit_bio_start,
127	extent_submit_bio_hook_t *submit_bio_done);	127	extent_submit_bio_hook_t *submit_bio_done);
128	unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info);	128	unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info);
129	int btrfs_write_tree_block(struct extent_buffer *buf);	129	int btrfs_write_tree_block(struct extent_buffer *buf);
130	int btrfs_wait_tree_block_writeback(struct extent_buffer *buf);	130	int btrfs_wait_tree_block_writeback(struct extent_buffer *buf);

fs/btrfs/extent_io.c+13−10

 	struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
 	struct bio *bio;
 	int read_mode = 0;
+	blk_status_t status;
 	int ret;
 	BUG_ON(bio_op(failed_bio) == REQ_OP_WRITE);
 		"Repair Read Error: submitting new read[%#x] to this_mirror=%d, in_validation=%d",
 		read_mode, failrec->this_mirror, failrec->in_validation);
-	ret = tree->ops->submit_bio_hook(inode, bio, failrec->this_mirror,
+	status = tree->ops->submit_bio_hook(inode, bio, failrec->this_mirror,
 					 failrec->bio_flags, 0);
-	if (ret) {
+	if (status) {
 		free_io_failure(BTRFS_I(inode), failrec);
 		bio_put(bio);
+		ret = blk_status_to_errno(status);
 	}
 	return ret;
  */
 static void end_bio_extent_writepage(struct bio *bio)
 {
+	int error = blk_status_to_errno(bio->bi_status);
 	struct bio_vec *bvec;
 	u64 start;
 	u64 end;
 		start = page_offset(page);
 		end = start + bvec->bv_offset + bvec->bv_len - 1;
-		end_extent_writepage(page, bio->bi_error, start, end);
+		end_extent_writepage(page, error, start, end);
 		end_page_writeback(page);
 	}
 static void end_bio_extent_readpage(struct bio *bio)
 {
 	struct bio_vec *bvec;
-	int uptodate = !bio->bi_error;
+	int uptodate = !bio->bi_status;
 	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
 	struct extent_io_tree *tree;
 	u64 offset = 0;
 		btrfs_debug(fs_info,
 			"end_bio_extent_readpage: bi_sector=%llu, err=%d, mirror=%u",
-			(u64)bio->bi_iter.bi_sector, bio->bi_error,
+			(u64)bio->bi_iter.bi_sector, bio->bi_status,
 			io_bio->mirror_num);
 		tree = &BTRFS_I(inode)->io_tree;
 				ret = bio_readpage_error(bio, offset, page,
 							 start, end, mirror);
 				if (ret == 0) {
-					uptodate = !bio->bi_error;
+					uptodate = !bio->bi_status;
 					offset += len;
 					continue;
 				}
 		endio_readpage_release_extent(tree, extent_start, extent_len,
 					      uptodate);
 	if (io_bio->end_io)
-		io_bio->end_io(io_bio, bio->bi_error);
+		io_bio->end_io(io_bio, blk_status_to_errno(bio->bi_status));
 	bio_put(bio);
 }
 static int __must_check submit_one_bio(struct bio *bio, int mirror_num,
 				       unsigned long bio_flags)
 {
-	int ret = 0;
+	blk_status_t ret = 0;
 	struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
 	struct page *page = bvec->bv_page;
 	struct extent_io_tree *tree = bio->bi_private;
 		btrfsic_submit_bio(bio);
 	bio_put(bio);
-	return ret;
+	return blk_status_to_errno(ret);
 }
 static int merge_bio(struct extent_io_tree *tree, struct page *page,
 		BUG_ON(!eb);
 		done = atomic_dec_and_test(&eb->io_pages);
-		if (bio->bi_error ||
+		if (bio->bi_status ||
 		    test_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags)) {
 			ClearPageUptodate(page);
 			set_btree_ioerr(page);

fs/btrfs/extent_io.h+3−3

@@ -92,9 +92,9 @@ struct btrfs_inode; · 91 unmodified lines
92	struct btrfs_io_bio;	92	struct btrfs_io_bio;
93	struct io_failure_record;	93	struct io_failure_record;
94		94
95	typedef int (extent_submit_bio_hook_t)(struct inode inode, struct bio bio,	95	typedef blk_status_t (extent_submit_bio_hook_t)(struct inode *inode,
96	int mirror_num, unsigned long bio_flags,	96	struct bio *bio, int mirror_num, unsigned long bio_flags,
97	u64 bio_offset);	97	u64 bio_offset);
98	struct extent_io_ops {	98	struct extent_io_ops {
99	/*	99	/*
100	* The following callbacks must be allways defined, the function	100	* The following callbacks must be allways defined, the function

fs/btrfs/file-item.c+7−7

@@ -160,7 +160,7 @@ static void btrfs_io_bio_endio_readpage(struct btrfs_io_bio *bio, int err) · 159 unmodified lines
160	kfree(bio->csum_allocated);	160	kfree(bio->csum_allocated);
161	}	161	}
162		162
163	static int __btrfs_lookup_bio_sums(struct inode inode, struct bio bio,	163	static blk_status_t __btrfs_lookup_bio_sums(struct inode inode, struct bio bio,
164	u64 logical_offset, u32 *dst, int dio)	164	u64 logical_offset, u32 *dst, int dio)
165	{	165	{
166	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	166	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@@ -182,7 +182,7 @@ static int __btrfs_lookup_bio_sums(struct inode inode, struct bio bio, · 15 unmodified lines
182		182
183	path = btrfs_alloc_path();	183	path = btrfs_alloc_path();
184	if (!path)	184	if (!path)
185	return -ENOMEM;	185	return BLK_STS_RESOURCE;
186		186
187	nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;	187	nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;
188	if (!dst) {	188	if (!dst) {
@@ -191,7 +191,7 @@ static int __btrfs_lookup_bio_sums(struct inode inode, struct bio bio, · 2 unmodified lines
191	csum_size, GFP_NOFS);	191	csum_size, GFP_NOFS);
192	if (!btrfs_bio->csum_allocated) {	192	if (!btrfs_bio->csum_allocated) {
193	btrfs_free_path(path);	193	btrfs_free_path(path);
194	return -ENOMEM;	194	return BLK_STS_RESOURCE;
195	}	195	}
196	btrfs_bio->csum = btrfs_bio->csum_allocated;	196	btrfs_bio->csum = btrfs_bio->csum_allocated;
197	btrfs_bio->end_io = btrfs_io_bio_endio_readpage;	197	btrfs_bio->end_io = btrfs_io_bio_endio_readpage;
@@ -303,12 +303,12 @@ next: · 105 unmodified lines
303	return 0;	303	return 0;
304	}	304	}
305		305
306	int btrfs_lookup_bio_sums(struct inode inode, struct bio bio, u32 *dst)	306	blk_status_t btrfs_lookup_bio_sums(struct inode inode, struct bio bio, u32 *dst)
307	{	307	{
308	return __btrfs_lookup_bio_sums(inode, bio, 0, dst, 0);	308	return __btrfs_lookup_bio_sums(inode, bio, 0, dst, 0);
309	}	309	}
310		310
311	int btrfs_lookup_bio_sums_dio(struct inode inode, struct bio bio, u64 offset)	311	blk_status_t btrfs_lookup_bio_sums_dio(struct inode inode, struct bio bio, u64 offset)
312	{	312	{
313	return __btrfs_lookup_bio_sums(inode, bio, offset, NULL, 1);	313	return __btrfs_lookup_bio_sums(inode, bio, offset, NULL, 1);
314	}	314	}
@@ -433,7 +433,7 @@ fail: · 118 unmodified lines
433	return ret;	433	return ret;
434	}	434	}
435		435
436	int btrfs_csum_one_bio(struct inode inode, struct bio bio,	436	blk_status_t btrfs_csum_one_bio(struct inode inode, struct bio bio,
437	u64 file_start, int contig)	437	u64 file_start, int contig)
438	{	438	{
439	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	439	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@@ -452,7 +452,7 @@ int btrfs_csum_one_bio(struct inode inode, struct bio bio, · 12 unmodified lines
452	sums = kzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),	452	sums = kzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
453	GFP_NOFS);	453	GFP_NOFS);
454	if (!sums)	454	if (!sums)
455	return -ENOMEM;	455	return BLK_STS_RESOURCE;
456		456
457	sums->len = bio->bi_iter.bi_size;	457	sums->len = bio->bi_iter.bi_size;
458	INIT_LIST_HEAD(&sums->list);	458	INIT_LIST_HEAD(&sums->list);

fs/btrfs/inode.c+36−37

 				NULL, EXTENT_LOCKED | EXTENT_DELALLOC,
 				PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
 				PAGE_SET_WRITEBACK);
-		ret = btrfs_submit_compressed_write(inode,
+		if (btrfs_submit_compressed_write(inode,
 				    async_extent->start,
 				    async_extent->ram_size,
 				    ins.objectid,
 				    ins.offset, async_extent->pages,
-				    async_extent->nr_pages);
+				    async_extent->nr_pages)) {
-		if (ret) {
 			struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
 			struct page *p = async_extent->pages[0];
 			const u64 start = async_extent->start;
  * At IO completion time the cums attached on the ordered extent record
  * are inserted into the btree
  */
-static int __btrfs_submit_bio_start(struct inode *inode, struct bio *bio,
+static blk_status_t __btrfs_submit_bio_start(struct inode *inode,
-				    int mirror_num, unsigned long bio_flags,
+		struct bio *bio, int mirror_num, unsigned long bio_flags,
-				    u64 bio_offset)
+		u64 bio_offset)
 {
-	int ret = 0;
+	blk_status_t ret = 0;
 	ret = btrfs_csum_one_bio(inode, bio, 0, 0);
 	BUG_ON(ret); /* -ENOMEM */
  * At IO completion time the cums attached on the ordered extent record
  * are inserted into the btree
  */
-static int __btrfs_submit_bio_done(struct inode *inode, struct bio *bio,
+static blk_status_t __btrfs_submit_bio_done(struct inode *inode,
-			  int mirror_num, unsigned long bio_flags,
+		struct bio *bio, int mirror_num, unsigned long bio_flags,
-			  u64 bio_offset)
+		u64 bio_offset)
 {
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-	int ret;
+	blk_status_t ret;
 	ret = btrfs_map_bio(fs_info, bio, mirror_num, 1);
 	if (ret) {
-		bio->bi_error = ret;
+		bio->bi_status = ret;
 		bio_endio(bio);
 	}
 	return ret;
  * extent_io.c submission hook. This does the right thing for csum calculation
  * on write, or reading the csums from the tree before a read
  */
-static int btrfs_submit_bio_hook(struct inode *inode, struct bio *bio,
+static blk_status_t btrfs_submit_bio_hook(struct inode *inode, struct bio *bio,
 			  int mirror_num, unsigned long bio_flags,
 			  u64 bio_offset)
 {
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	struct btrfs_root *root = BTRFS_I(inode)->root;
 	enum btrfs_wq_endio_type metadata = BTRFS_WQ_ENDIO_DATA;
-	int ret = 0;
+	blk_status_t ret = 0;
 	int skip_sum;
 	int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
 	ret = btrfs_map_bio(fs_info, bio, mirror_num, 0);
 out:
-	if (ret < 0) {
+	if (ret) {
-		bio->bi_error = ret;
+		bio->bi_status = ret;
 		bio_endio(bio);
 	}
 	return ret;
 	struct bio_vec *bvec;
 	int i;
-	if (bio->bi_error)
+	if (bio->bi_status)
 		goto end;
 	ASSERT(bio->bi_vcnt == 1);
 	int ret;
 	int i;
-	if (bio->bi_error)
+	if (bio->bi_status)
 		goto end;
 	uptodate = 1;
 	bio_put(bio);
 }
-static int __btrfs_subio_endio_read(struct inode *inode,
+static blk_status_t __btrfs_subio_endio_read(struct inode *inode,
-				    struct btrfs_io_bio *io_bio, int err)
+		struct btrfs_io_bio *io_bio, blk_status_t err)
 {
 	struct btrfs_fs_info *fs_info;
 	struct bio_vec *bvec;
 				io_bio->mirror_num,
 				btrfs_retry_endio, &done);
 		if (ret) {
-			err = ret;
+			err = errno_to_blk_status(ret);
 			goto next;
 		}
 	return err;
 }
-static int btrfs_subio_endio_read(struct inode *inode,
+static blk_status_t btrfs_subio_endio_read(struct inode *inode,
-				  struct btrfs_io_bio *io_bio, int err)
+		struct btrfs_io_bio *io_bio, blk_status_t err)
 {
 	bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 	struct inode *inode = dip->inode;
 	struct bio *dio_bio;
 	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
-	int err = bio->bi_error;
+	blk_status_t err = bio->bi_status;
 	if (dip->flags & BTRFS_DIO_ORIG_BIO_SUBMITTED)
 		err = btrfs_subio_endio_read(inode, io_bio, err);
 	kfree(dip);
-	dio_bio->bi_error = bio->bi_error;
+	dio_bio->bi_status = bio->bi_status;
 	dio_end_io(dio_bio);
 	if (io_bio->end_io)
-		io_bio->end_io(io_bio, err);
+		io_bio->end_io(io_bio, blk_status_to_errno(err));
 	bio_put(bio);
 }
 	struct bio *dio_bio = dip->dio_bio;
 	__endio_write_update_ordered(dip->inode, dip->logical_offset,
-				     dip->bytes, !bio->bi_error);
+				     dip->bytes, !bio->bi_status);
 	kfree(dip);
-	dio_bio->bi_error = bio->bi_error;
+	dio_bio->bi_status = bio->bi_status;
 	dio_end_io(dio_bio);
 	bio_put(bio);
 }
-static int __btrfs_submit_bio_start_direct_io(struct inode *inode,
+static blk_status_t __btrfs_submit_bio_start_direct_io(struct inode *inode,
 				    struct bio *bio, int mirror_num,
 				    unsigned long bio_flags, u64 offset)
 {
-	int ret;
+	blk_status_t ret;
 	ret = btrfs_csum_one_bio(inode, bio, offset, 1);
 	BUG_ON(ret); /* -ENOMEM */
 	return 0;
 static void btrfs_end_dio_bio(struct bio *bio)
 {
 	struct btrfs_dio_private *dip = bio->bi_private;
-	int err = bio->bi_error;
+	blk_status_t err = bio->bi_status;
 	if (err)
 		btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,
 	if (dip->errors) {
 		bio_io_error(dip->orig_bio);
 	} else {
-		dip->dio_bio->bi_error = 0;
+		dip->dio_bio->bi_status = 0;
 		bio_endio(dip->orig_bio);
 	}
 out:
 	return bio;
 }
-static inline int btrfs_lookup_and_bind_dio_csum(struct inode *inode,
+static inline blk_status_t btrfs_lookup_and_bind_dio_csum(struct inode *inode,
 						 struct btrfs_dio_private *dip,
 						 struct bio *bio,
 						 u64 file_offset)
 {
 	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
 	struct btrfs_io_bio *orig_io_bio = btrfs_io_bio(dip->orig_bio);
-	int ret;
+	blk_status_t ret;
 	/*
 	 * We load all the csum data we need when we submit
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	struct btrfs_dio_private *dip = bio->bi_private;
 	bool write = bio_op(bio) == REQ_OP_WRITE;
-	int ret;
+	blk_status_t ret;
 	if (async_submit)
 		async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);
 	 * callbacks - they require an allocated dip and a clone of dio_bio.
 	 */
 	if (io_bio && dip) {
-		io_bio->bi_error = -EIO;
+		io_bio->bi_status = BLK_STS_IOERR;
 		bio_endio(io_bio);
 		/*
 		 * The end io callbacks free our dip, do the final put on io_bio
 			unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
 			      file_offset + dio_bio->bi_iter.bi_size - 1);
-		dio_bio->bi_error = -EIO;
+		dio_bio->bi_status = BLK_STS_IOERR;
 		/*
 		 * Releases and cleans up our dio_bio, no need to bio_put()
 		 * nor bio_endio()/bio_io_error() against dio_bio.

fs/btrfs/raid56.c+8−8

@@ -871,7 +871,7 @@ static void free_raid_bio(struct btrfs_raid_bio *rbio) · 870 unmodified lines
871	* this frees the rbio and runs through all the bios in the	871	* this frees the rbio and runs through all the bios in the
872	* bio_list and calls end_io on them	872	* bio_list and calls end_io on them
873	*/	873	*/
874	static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err)	874	static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, blk_status_t err)
875	{	875	{
876	struct bio *cur = bio_list_get(&rbio->bio_list);	876	struct bio *cur = bio_list_get(&rbio->bio_list);
877	struct bio *next;	877	struct bio *next;
@@ -884,7 +884,7 @@ static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err) · 6 unmodified lines
884	while (cur) {	884	while (cur) {
885	next = cur->bi_next;	885	next = cur->bi_next;
886	cur->bi_next = NULL;	886	cur->bi_next = NULL;
887	cur->bi_error = err;	887	cur->bi_status = err;
888	bio_endio(cur);	888	bio_endio(cur);
889	cur = next;	889	cur = next;
890	}	890	}
@@ -897,7 +897,7 @@ static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err) · 6 unmodified lines
897	static void raid_write_end_io(struct bio *bio)	897	static void raid_write_end_io(struct bio *bio)
898	{	898	{
899	struct btrfs_raid_bio *rbio = bio->bi_private;	899	struct btrfs_raid_bio *rbio = bio->bi_private;
900	int err = bio->bi_error;	900	blk_status_t err = bio->bi_status;
901	int max_errors;	901	int max_errors;
902		902
903	if (err)	903	if (err)
@@ -914,7 +914,7 @@ static void raid_write_end_io(struct bio *bio) · 10 unmodified lines
914	max_errors = (rbio->operation == BTRFS_RBIO_PARITY_SCRUB) ?	914	max_errors = (rbio->operation == BTRFS_RBIO_PARITY_SCRUB) ?
915	0 : rbio->bbio->max_errors;	915	0 : rbio->bbio->max_errors;
916	if (atomic_read(&rbio->error) > max_errors)	916	if (atomic_read(&rbio->error) > max_errors)
917	err = -EIO;	917	err = BLK_STS_IOERR;
918		918
919	rbio_orig_end_io(rbio, err);	919	rbio_orig_end_io(rbio, err);
920	}	920	}
@@ -1092,7 +1092,7 @@ static int rbio_add_io_page(struct btrfs_raid_bio *rbio, · 171 unmodified lines
1092	* devices or if they are not contiguous	1092	* devices or if they are not contiguous
1093	*/	1093	*/
1094	if (last_end == disk_start && stripe->dev->bdev &&	1094	if (last_end == disk_start && stripe->dev->bdev &&
1095	!last->bi_error &&	1095	!last->bi_status &&
1096	last->bi_bdev == stripe->dev->bdev) {	1096	last->bi_bdev == stripe->dev->bdev) {
1097	ret = bio_add_page(last, page, PAGE_SIZE, 0);	1097	ret = bio_add_page(last, page, PAGE_SIZE, 0);
1098	if (ret == PAGE_SIZE)	1098	if (ret == PAGE_SIZE)
@@ -1448,7 +1448,7 @@ static void raid_rmw_end_io(struct bio *bio) · 349 unmodified lines
1448	{	1448	{
1449	struct btrfs_raid_bio *rbio = bio->bi_private;	1449	struct btrfs_raid_bio *rbio = bio->bi_private;
1450		1450
1451	if (bio->bi_error)	1451	if (bio->bi_status)
1452	fail_bio_stripe(rbio, bio);	1452	fail_bio_stripe(rbio, bio);
1453	else	1453	else
1454	set_bio_pages_uptodate(bio);	1454	set_bio_pages_uptodate(bio);
@@ -1991,7 +1991,7 @@ static void raid_recover_end_io(struct bio *bio) · 536 unmodified lines
1991	* we only read stripe pages off the disk, set them	1991	* we only read stripe pages off the disk, set them
1992	* up to date if there were no errors	1992	* up to date if there were no errors
1993	*/	1993	*/
1994	if (bio->bi_error)	1994	if (bio->bi_status)
1995	fail_bio_stripe(rbio, bio);	1995	fail_bio_stripe(rbio, bio);
1996	else	1996	else
1997	set_bio_pages_uptodate(bio);	1997	set_bio_pages_uptodate(bio);
@@ -2530,7 +2530,7 @@ static void raid56_parity_scrub_end_io(struct bio *bio) · 532 unmodified lines
2530	{	2530	{
2531	struct btrfs_raid_bio *rbio = bio->bi_private;	2531	struct btrfs_raid_bio *rbio = bio->bi_private;
2532		2532
2533	if (bio->bi_error)	2533	if (bio->bi_status)
2534	fail_bio_stripe(rbio, bio);	2534	fail_bio_stripe(rbio, bio);
2535	else	2535	else
2536	set_bio_pages_uptodate(bio);	2536	set_bio_pages_uptodate(bio);

fs/btrfs/scrub.c+13−13

@@ -95,7 +95,7 @@ struct scrub_bio { · 94 unmodified lines
95	struct scrub_ctx *sctx;	95	struct scrub_ctx *sctx;
96	struct btrfs_device *dev;	96	struct btrfs_device *dev;
97	struct bio *bio;	97	struct bio *bio;
98	int err;	98	blk_status_t status;
99	u64 logical;	99	u64 logical;
100	u64 physical;	100	u64 physical;
101	#if SCRUB_PAGES_PER_WR_BIO >= SCRUB_PAGES_PER_RD_BIO	101	#if SCRUB_PAGES_PER_WR_BIO >= SCRUB_PAGES_PER_RD_BIO
@@ -1668,14 +1668,14 @@ leave_nomem: · 1566 unmodified lines
1668		1668
1669	struct scrub_bio_ret {	1669	struct scrub_bio_ret {
1670	struct completion event;	1670	struct completion event;
1671	int error;	1671	blk_status_t status;
1672	};	1672	};
1673		1673
1674	static void scrub_bio_wait_endio(struct bio *bio)	1674	static void scrub_bio_wait_endio(struct bio *bio)
1675	{	1675	{
1676	struct scrub_bio_ret *ret = bio->bi_private;	1676	struct scrub_bio_ret *ret = bio->bi_private;
1677		1677
1678	ret->error = bio->bi_error;	1678	ret->status = bio->bi_status;
1679	complete(&ret->event);	1679	complete(&ret->event);
1680	}	1680	}
1681		1681
@@ -1693,7 +1693,7 @@ static int scrub_submit_raid56_bio_wait(struct btrfs_fs_info *fs_info, · 11 unmodified lines
1693	int ret;	1693	int ret;
1694		1694
1695	init_completion(&done.event);	1695	init_completion(&done.event);
1696	done.error = 0;	1696	done.status = 0;
1697	bio->bi_iter.bi_sector = page->logical >> 9;	1697	bio->bi_iter.bi_sector = page->logical >> 9;
1698	bio->bi_private = &done;	1698	bio->bi_private = &done;
1699	bio->bi_end_io = scrub_bio_wait_endio;	1699	bio->bi_end_io = scrub_bio_wait_endio;
@@ -1705,7 +1705,7 @@ static int scrub_submit_raid56_bio_wait(struct btrfs_fs_info *fs_info, · 5 unmodified lines
1705	return ret;	1705	return ret;
1706		1706
1707	wait_for_completion(&done.event);	1707	wait_for_completion(&done.event);
1708	if (done.error)	1708	if (done.status)
1709	return -EIO;	1709	return -EIO;
1710		1710
1711	return 0;	1711	return 0;
@@ -1937,7 +1937,7 @@ again: · 225 unmodified lines
1937	bio->bi_bdev = sbio->dev->bdev;	1937	bio->bi_bdev = sbio->dev->bdev;
1938	bio->bi_iter.bi_sector = sbio->physical >> 9;	1938	bio->bi_iter.bi_sector = sbio->physical >> 9;
1939	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);	1939	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
1940	sbio->err = 0;	1940	sbio->status = 0;
1941	} else if (sbio->physical + sbio->page_count * PAGE_SIZE !=	1941	} else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
1942	spage->physical_for_dev_replace \|\|	1942	spage->physical_for_dev_replace \|\|
1943	sbio->logical + sbio->page_count * PAGE_SIZE !=	1943	sbio->logical + sbio->page_count * PAGE_SIZE !=
@@ -1992,7 +1992,7 @@ static void scrub_wr_bio_end_io(struct bio *bio) · 48 unmodified lines
1992	struct scrub_bio *sbio = bio->bi_private;	1992	struct scrub_bio *sbio = bio->bi_private;
1993	struct btrfs_fs_info *fs_info = sbio->dev->fs_info;	1993	struct btrfs_fs_info *fs_info = sbio->dev->fs_info;
1994		1994
1995	sbio->err = bio->bi_error;	1995	sbio->status = bio->bi_status;
1996	sbio->bio = bio;	1996	sbio->bio = bio;
1997		1997
1998	btrfs_init_work(&sbio->work, btrfs_scrubwrc_helper,	1998	btrfs_init_work(&sbio->work, btrfs_scrubwrc_helper,
@@ -2007,7 +2007,7 @@ static void scrub_wr_bio_end_io_worker(struct btrfs_work *work) · 8 unmodified lines
2007	int i;	2007	int i;
2008		2008
2009	WARN_ON(sbio->page_count > SCRUB_PAGES_PER_WR_BIO);	2009	WARN_ON(sbio->page_count > SCRUB_PAGES_PER_WR_BIO);
2010	if (sbio->err) {	2010	if (sbio->status) {
2011	struct btrfs_dev_replace *dev_replace =	2011	struct btrfs_dev_replace *dev_replace =
2012	&sbio->sctx->fs_info->dev_replace;	2012	&sbio->sctx->fs_info->dev_replace;
2013		2013
@@ -2341,7 +2341,7 @@ again: · 327 unmodified lines
2341	bio->bi_bdev = sbio->dev->bdev;	2341	bio->bi_bdev = sbio->dev->bdev;
2342	bio->bi_iter.bi_sector = sbio->physical >> 9;	2342	bio->bi_iter.bi_sector = sbio->physical >> 9;
2343	bio_set_op_attrs(bio, REQ_OP_READ, 0);	2343	bio_set_op_attrs(bio, REQ_OP_READ, 0);
2344	sbio->err = 0;	2344	sbio->status = 0;
2345	} else if (sbio->physical + sbio->page_count * PAGE_SIZE !=	2345	} else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
2346	spage->physical \|\|	2346	spage->physical \|\|
2347	sbio->logical + sbio->page_count * PAGE_SIZE !=	2347	sbio->logical + sbio->page_count * PAGE_SIZE !=
@@ -2377,7 +2377,7 @@ static void scrub_missing_raid56_end_io(struct bio *bio) · 29 unmodified lines
2377	struct scrub_block *sblock = bio->bi_private;	2377	struct scrub_block *sblock = bio->bi_private;
2378	struct btrfs_fs_info *fs_info = sblock->sctx->fs_info;	2378	struct btrfs_fs_info *fs_info = sblock->sctx->fs_info;
2379		2379
2380	if (bio->bi_error)	2380	if (bio->bi_status)
2381	sblock->no_io_error_seen = 0;	2381	sblock->no_io_error_seen = 0;
2382		2382
2383	bio_put(bio);	2383	bio_put(bio);
@@ -2588,7 +2588,7 @@ static void scrub_bio_end_io(struct bio *bio) · 204 unmodified lines
2588	struct scrub_bio *sbio = bio->bi_private;	2588	struct scrub_bio *sbio = bio->bi_private;
2589	struct btrfs_fs_info *fs_info = sbio->dev->fs_info;	2589	struct btrfs_fs_info *fs_info = sbio->dev->fs_info;
2590		2590
2591	sbio->err = bio->bi_error;	2591	sbio->status = bio->bi_status;
2592	sbio->bio = bio;	2592	sbio->bio = bio;
2593		2593
2594	btrfs_queue_work(fs_info->scrub_workers, &sbio->work);	2594	btrfs_queue_work(fs_info->scrub_workers, &sbio->work);
@@ -2601,7 +2601,7 @@ static void scrub_bio_end_io_worker(struct btrfs_work *work) · 6 unmodified lines
2601	int i;	2601	int i;
2602		2602
2603	BUG_ON(sbio->page_count > SCRUB_PAGES_PER_RD_BIO);	2603	BUG_ON(sbio->page_count > SCRUB_PAGES_PER_RD_BIO);
2604	if (sbio->err) {	2604	if (sbio->status) {
2605	for (i = 0; i < sbio->page_count; i++) {	2605	for (i = 0; i < sbio->page_count; i++) {
2606	struct scrub_page *spage = sbio->pagev[i];	2606	struct scrub_page *spage = sbio->pagev[i];
2607		2607
@@ -3004,7 +3004,7 @@ static void scrub_parity_bio_endio(struct bio *bio) · 396 unmodified lines
3004	struct scrub_parity sparity = (struct scrub_parity )bio->bi_private;	3004	struct scrub_parity sparity = (struct scrub_parity )bio->bi_private;
3005	struct btrfs_fs_info *fs_info = sparity->sctx->fs_info;	3005	struct btrfs_fs_info *fs_info = sparity->sctx->fs_info;
3006		3006
3007	if (bio->bi_error)	3007	if (bio->bi_status)
3008	bitmap_or(sparity->ebitmap, sparity->ebitmap, sparity->dbitmap,	3008	bitmap_or(sparity->ebitmap, sparity->ebitmap, sparity->dbitmap,
3009	sparity->nsectors);	3009	sparity->nsectors);
3010		3010

fs/btrfs/volumes.c+6−5

 	struct btrfs_bio *bbio = bio->bi_private;
 	int is_orig_bio = 0;
-	if (bio->bi_error) {
+	if (bio->bi_status) {
 		atomic_inc(&bbio->error);
-		if (bio->bi_error == -EIO || bio->bi_error == -EREMOTEIO) {
+		if (bio->bi_status == BLK_STS_IOERR ||
+		    bio->bi_status == BLK_STS_TARGET) {
 			unsigned int stripe_index =
 				btrfs_io_bio(bio)->stripe_index;
 			struct btrfs_device *dev;
 		 * beyond the tolerance of the btrfs bio
 		 */
 		if (atomic_read(&bbio->error) > bbio->max_errors) {
-			bio->bi_error = -EIO;
+			bio->bi_status = BLK_STS_IOERR;
 		} else {
 			/*
 			 * this bio is actually up to date, we didn't
 			 * go over the max number of errors
 			 */
-			bio->bi_error = 0;
+			bio->bi_status = 0;
 		}
 		btrfs_end_bbio(bbio, bio);
 		btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
 		bio->bi_iter.bi_sector = logical >> 9;
-		bio->bi_error = -EIO;
+		bio->bi_status = BLK_STS_IOERR;
 		btrfs_end_bbio(bbio, bio);
 	}
 }

fs/buffer.c+1−1

@@ -3038,7 +3038,7 @@ static void end_bio_bh_io_sync(struct bio *bio) · 3037 unmodified lines
3038	if (unlikely(bio_flagged(bio, BIO_QUIET)))	3038	if (unlikely(bio_flagged(bio, BIO_QUIET)))
3039	set_bit(BH_Quiet, &bh->b_state);	3039	set_bit(BH_Quiet, &bh->b_state);
3040		3040
3041	bh->b_end_io(bh, !bio->bi_error);	3041	bh->b_end_io(bh, !bio->bi_status);
3042	bio_put(bio);	3042	bio_put(bio);
3043	}	3043	}
3044		3044

fs/crypto/bio.c+1−1

@@ -129,7 +129,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk, · 128 unmodified lines
129	goto errout;	129	goto errout;
130	}	130	}
131	err = submit_bio_wait(bio);	131	err = submit_bio_wait(bio);
132	if ((err == 0) && bio->bi_error)	132	if (err == 0 && bio->bi_status)
133	err = -EIO;	133	err = -EIO;
134	bio_put(bio);	134	bio_put(bio);
135	if (err)	135	if (err)

fs/direct-io.c+4−4

@@ -294,7 +294,7 @@ static void dio_aio_complete_work(struct work_struct *work) · 293 unmodified lines
294	dio_complete(dio, 0, true);	294	dio_complete(dio, 0, true);
295	}	295	}
296		296
297	static int dio_bio_complete(struct dio dio, struct bio bio);	297	static blk_status_t dio_bio_complete(struct dio dio, struct bio bio);
298		298
299	/*	299	/*
300	* Asynchronous IO callback.	300	* Asynchronous IO callback.
@@ -473,11 +473,11 @@ static struct bio dio_await_one(struct dio dio) · 172 unmodified lines
473	/*	473	/*
474	* Process one completed BIO. No locks are held.	474	* Process one completed BIO. No locks are held.
475	*/	475	*/
476	static int dio_bio_complete(struct dio dio, struct bio bio)	476	static blk_status_t dio_bio_complete(struct dio dio, struct bio bio)
477	{	477	{
478	struct bio_vec *bvec;	478	struct bio_vec *bvec;
479	unsigned i;	479	unsigned i;
480	int err = bio->bi_error;	480	blk_status_t err = bio->bi_status;
481		481
482	if (err)	482	if (err)
483	dio->io_error = -EIO;	483	dio->io_error = -EIO;
@@ -536,7 +536,7 @@ static inline int dio_bio_reap(struct dio dio, struct dio_submit sdio) · 52 unmodified lines
536	bio = dio->bio_list;	536	bio = dio->bio_list;
537	dio->bio_list = bio->bi_private;	537	dio->bio_list = bio->bi_private;
538	spin_unlock_irqrestore(&dio->bio_lock, flags);	538	spin_unlock_irqrestore(&dio->bio_lock, flags);
539	ret2 = dio_bio_complete(dio, bio);	539	ret2 = blk_status_to_errno(dio_bio_complete(dio, bio));
540	if (ret == 0)	540	if (ret == 0)
541	ret = ret2;	541	ret = ret2;
542	}	542	}

fs/ext4/page-io.c+7−6

 		}
 #endif
-		if (bio->bi_error) {
+		if (bio->bi_status) {
 			SetPageError(page);
 			mapping_set_error(page->mapping, -EIO);
 		}
 				continue;
 			}
 			clear_buffer_async_write(bh);
-			if (bio->bi_error)
+			if (bio->bi_status)
 				buffer_io_error(bh);
 		} while ((bh = bh->b_this_page) != head);
 		bit_spin_unlock(BH_Uptodate_Lock, &head->b_state);
 		      bdevname(bio->bi_bdev, b),
 		      (long long) bio->bi_iter.bi_sector,
 		      (unsigned) bio_sectors(bio),
-		      bio->bi_error)) {
+		      bio->bi_status)) {
 		ext4_finish_bio(bio);
 		bio_put(bio);
 		return;
 	}
 	bio->bi_end_io = NULL;
-	if (bio->bi_error) {
+	if (bio->bi_status) {
 		struct inode *inode = io_end->inode;
 		ext4_warning(inode->i_sb, "I/O error %d writing to inode %lu "
 			     "(offset %llu size %ld starting block %llu)",
-			     bio->bi_error, inode->i_ino,
+			     bio->bi_status, inode->i_ino,
 			     (unsigned long long) io_end->offset,
 			     (long) io_end->size,
 			     (unsigned long long)
 			     bi_sector >> (inode->i_blkbits - 9));
-		mapping_set_error(inode->i_mapping, bio->bi_error);
+		mapping_set_error(inode->i_mapping,
+				blk_status_to_errno(bio->bi_status));
 	}
 	if (io_end->flag & EXT4_IO_END_UNWRITTEN) {

fs/ext4/readpage.c+2−2

@@ -73,7 +73,7 @@ static void mpage_end_io(struct bio *bio) · 72 unmodified lines
73	int i;	73	int i;
74		74
75	if (ext4_bio_encrypted(bio)) {	75	if (ext4_bio_encrypted(bio)) {
76	if (bio->bi_error) {	76	if (bio->bi_status) {
77	fscrypt_release_ctx(bio->bi_private);	77	fscrypt_release_ctx(bio->bi_private);
78	} else {	78	} else {
79	fscrypt_decrypt_bio_pages(bio->bi_private, bio);	79	fscrypt_decrypt_bio_pages(bio->bi_private, bio);
@@ -83,7 +83,7 @@ static void mpage_end_io(struct bio *bio) · 3 unmodified lines
83	bio_for_each_segment_all(bv, bio, i) {	83	bio_for_each_segment_all(bv, bio, i) {
84	struct page *page = bv->bv_page;	84	struct page *page = bv->bv_page;
85		85
86	if (!bio->bi_error) {	86	if (!bio->bi_status) {
87	SetPageUptodate(page);	87	SetPageUptodate(page);
88	} else {	88	} else {
89	ClearPageUptodate(page);	89	ClearPageUptodate(page);

fs/f2fs/data.c+5−5

@@ -58,12 +58,12 @@ static void f2fs_read_end_io(struct bio *bio) · 57 unmodified lines
58	#ifdef CONFIG_F2FS_FAULT_INJECTION	58	#ifdef CONFIG_F2FS_FAULT_INJECTION
59	if (time_to_inject(F2FS_P_SB(bio->bi_io_vec->bv_page), FAULT_IO)) {	59	if (time_to_inject(F2FS_P_SB(bio->bi_io_vec->bv_page), FAULT_IO)) {
60	f2fs_show_injection_info(FAULT_IO);	60	f2fs_show_injection_info(FAULT_IO);
61	bio->bi_error = -EIO;	61	bio->bi_status = BLK_STS_IOERR;
62	}	62	}
63	#endif	63	#endif
64		64
65	if (f2fs_bio_encrypted(bio)) {	65	if (f2fs_bio_encrypted(bio)) {
66	if (bio->bi_error) {	66	if (bio->bi_status) {
67	fscrypt_release_ctx(bio->bi_private);	67	fscrypt_release_ctx(bio->bi_private);
68	} else {	68	} else {
69	fscrypt_decrypt_bio_pages(bio->bi_private, bio);	69	fscrypt_decrypt_bio_pages(bio->bi_private, bio);
@@ -74,7 +74,7 @@ static void f2fs_read_end_io(struct bio *bio) · 4 unmodified lines
74	bio_for_each_segment_all(bvec, bio, i) {	74	bio_for_each_segment_all(bvec, bio, i) {
75	struct page *page = bvec->bv_page;	75	struct page *page = bvec->bv_page;
76		76
77	if (!bio->bi_error) {	77	if (!bio->bi_status) {
78	if (!PageUptodate(page))	78	if (!PageUptodate(page))
79	SetPageUptodate(page);	79	SetPageUptodate(page);
80	} else {	80	} else {
@@ -102,14 +102,14 @@ static void f2fs_write_end_io(struct bio *bio) · 21 unmodified lines
102	unlock_page(page);	102	unlock_page(page);
103	mempool_free(page, sbi->write_io_dummy);	103	mempool_free(page, sbi->write_io_dummy);
104		104
105	if (unlikely(bio->bi_error))	105	if (unlikely(bio->bi_status))
106	f2fs_stop_checkpoint(sbi, true);	106	f2fs_stop_checkpoint(sbi, true);
107	continue;	107	continue;
108	}	108	}
109		109
110	fscrypt_pullback_bio_page(&page, true);	110	fscrypt_pullback_bio_page(&page, true);
111		111
112	if (unlikely(bio->bi_error)) {	112	if (unlikely(bio->bi_status)) {
113	mapping_set_error(page->mapping, -EIO);	113	mapping_set_error(page->mapping, -EIO);
114	f2fs_stop_checkpoint(sbi, true);	114	f2fs_stop_checkpoint(sbi, true);
115	}	115	}

fs/f2fs/segment.c+1−1

@@ -749,7 +749,7 @@ static void f2fs_submit_discard_endio(struct bio *bio) · 748 unmodified lines
749	{	749	{
750	struct discard_cmd dc = (struct discard_cmd )bio->bi_private;	750	struct discard_cmd dc = (struct discard_cmd )bio->bi_private;
751		751
752	dc->error = bio->bi_error;	752	dc->error = blk_status_to_errno(bio->bi_status);
753	dc->state = D_DONE;	753	dc->state = D_DONE;
754	complete(&dc->wait);	754	complete(&dc->wait);
755	bio_put(bio);	755	bio_put(bio);

fs/gfs2/lops.c+4−4

@@ -170,7 +170,7 @@ static u64 gfs2_log_bmap(struct gfs2_sbd *sdp) · 169 unmodified lines
170	*/	170	*/
171		171
172	static void gfs2_end_log_write_bh(struct gfs2_sbd sdp, struct bio_vec bvec,	172	static void gfs2_end_log_write_bh(struct gfs2_sbd sdp, struct bio_vec bvec,
173	int error)	173	blk_status_t error)
174	{	174	{
175	struct buffer_head bh, next;	175	struct buffer_head bh, next;
176	struct page *page = bvec->bv_page;	176	struct page *page = bvec->bv_page;
@@ -209,13 +209,13 @@ static void gfs2_end_log_write(struct bio *bio) · 32 unmodified lines
209	struct page *page;	209	struct page *page;
210	int i;	210	int i;
211		211
212	if (bio->bi_error)	212	if (bio->bi_status)
213	fs_err(sdp, "Error %d writing to log\n", bio->bi_error);	213	fs_err(sdp, "Error %d writing to log\n", bio->bi_status);
214		214
215	bio_for_each_segment_all(bvec, bio, i) {	215	bio_for_each_segment_all(bvec, bio, i) {
216	page = bvec->bv_page;	216	page = bvec->bv_page;
217	if (page_has_buffers(page))	217	if (page_has_buffers(page))
218	gfs2_end_log_write_bh(sdp, bvec, bio->bi_error);	218	gfs2_end_log_write_bh(sdp, bvec, bio->bi_status);
219	else	219	else
220	mempool_free(page, gfs2_page_pool);	220	mempool_free(page, gfs2_page_pool);
221	}	221	}

fs/gfs2/meta_io.c+1−1

@@ -201,7 +201,7 @@ static void gfs2_meta_read_endio(struct bio *bio) · 200 unmodified lines
201	do {	201	do {
202	struct buffer_head *next = bh->b_this_page;	202	struct buffer_head *next = bh->b_this_page;
203	len -= bh->b_size;	203	len -= bh->b_size;
204	bh->b_end_io(bh, !bio->bi_error);	204	bh->b_end_io(bh, !bio->bi_status);
205	bh = next;	205	bh = next;
206	} while (bh && len);	206	} while (bh && len);
207	}	207	}

fs/gfs2/ops_fstype.c+2−2

@@ -176,10 +176,10 @@ static void end_bio_io_page(struct bio *bio) · 175 unmodified lines
176	{	176	{
177	struct page *page = bio->bi_private;	177	struct page *page = bio->bi_private;
178		178
179	if (!bio->bi_error)	179	if (!bio->bi_status)
180	SetPageUptodate(page);	180	SetPageUptodate(page);
181	else	181	else
182	pr_warn("error %d reading superblock\n", bio->bi_error);	182	pr_warn("error %d reading superblock\n", bio->bi_status);
183	unlock_page(page);	183	unlock_page(page);
184	}	184	}
185		185

fs/iomap.c+2−2

@@ -672,8 +672,8 @@ static void iomap_dio_bio_end_io(struct bio *bio) · 671 unmodified lines
672	struct iomap_dio *dio = bio->bi_private;	672	struct iomap_dio *dio = bio->bi_private;
673	bool should_dirty = (dio->flags & IOMAP_DIO_DIRTY);	673	bool should_dirty = (dio->flags & IOMAP_DIO_DIRTY);
674		674
675	if (bio->bi_error)	675	if (bio->bi_status)
676	iomap_dio_set_error(dio, bio->bi_error);	676	iomap_dio_set_error(dio, blk_status_to_errno(bio->bi_status));
677		677
678	if (atomic_dec_and_test(&dio->ref)) {	678	if (atomic_dec_and_test(&dio->ref)) {
679	if (is_sync_kiocb(dio->iocb)) {	679	if (is_sync_kiocb(dio->iocb)) {

fs/jfs/jfs_logmgr.c+1−1

@@ -2205,7 +2205,7 @@ static void lbmIODone(struct bio *bio) · 2204 unmodified lines
2205		2205
2206	bp->l_flag \|= lbmDONE;	2206	bp->l_flag \|= lbmDONE;
2207		2207
2208	if (bio->bi_error) {	2208	if (bio->bi_status) {
2209	bp->l_flag \|= lbmERROR;	2209	bp->l_flag \|= lbmERROR;
2210		2210
2211	jfs_err("lbmIODone: I/O error in JFS log");	2211	jfs_err("lbmIODone: I/O error in JFS log");

fs/jfs/jfs_metapage.c+2−2

@@ -280,7 +280,7 @@ static void metapage_read_end_io(struct bio *bio) · 279 unmodified lines
280	{	280	{
281	struct page *page = bio->bi_private;	281	struct page *page = bio->bi_private;
282		282
283	if (bio->bi_error) {	283	if (bio->bi_status) {
284	printk(KERN_ERR "metapage_read_end_io: I/O error\n");	284	printk(KERN_ERR "metapage_read_end_io: I/O error\n");
285	SetPageError(page);	285	SetPageError(page);
286	}	286	}
@@ -337,7 +337,7 @@ static void metapage_write_end_io(struct bio *bio) · 50 unmodified lines
337		337
338	BUG_ON(!PagePrivate(page));	338	BUG_ON(!PagePrivate(page));
339		339
340	if (bio->bi_error) {	340	if (bio->bi_status) {
341	printk(KERN_ERR "metapage_write_end_io: I/O error\n");	341	printk(KERN_ERR "metapage_write_end_io: I/O error\n");
342	SetPageError(page);	342	SetPageError(page);
343	}	343	}

fs/mpage.c+2−1

@@ -50,7 +50,8 @@ static void mpage_end_io(struct bio *bio) · 49 unmodified lines
50		50
51	bio_for_each_segment_all(bv, bio, i) {	51	bio_for_each_segment_all(bv, bio, i) {
52	struct page *page = bv->bv_page;	52	struct page *page = bv->bv_page;
53	page_endio(page, op_is_write(bio_op(bio)), bio->bi_error);	53	page_endio(page, op_is_write(bio_op(bio)),
		54	blk_status_to_errno(bio->bi_status));
54	}	55	}
55		56
56	bio_put(bio);	57	bio_put(bio);

fs/nfs/blocklayout/blocklayout.c+2−2

@@ -188,7 +188,7 @@ static void bl_end_io_read(struct bio *bio) · 187 unmodified lines
188	{	188	{
189	struct parallel_io *par = bio->bi_private;	189	struct parallel_io *par = bio->bi_private;
190		190
191	if (bio->bi_error) {	191	if (bio->bi_status) {
192	struct nfs_pgio_header *header = par->data;	192	struct nfs_pgio_header *header = par->data;
193		193
194	if (!header->pnfs_error)	194	if (!header->pnfs_error)
@@ -319,7 +319,7 @@ static void bl_end_io_write(struct bio *bio) · 124 unmodified lines
319	struct parallel_io *par = bio->bi_private;	319	struct parallel_io *par = bio->bi_private;
320	struct nfs_pgio_header *header = par->data;	320	struct nfs_pgio_header *header = par->data;
321		321
322	if (bio->bi_error) {	322	if (bio->bi_status) {
323	if (!header->pnfs_error)	323	if (!header->pnfs_error)
324	header->pnfs_error = -EIO;	324	header->pnfs_error = -EIO;
325	pnfs_set_lo_fail(header->lseg);	325	pnfs_set_lo_fail(header->lseg);

fs/nilfs2/segbuf.c+1−1

@@ -338,7 +338,7 @@ static void nilfs_end_bio_write(struct bio *bio) · 337 unmodified lines
338	{	338	{
339	struct nilfs_segment_buffer *segbuf = bio->bi_private;	339	struct nilfs_segment_buffer *segbuf = bio->bi_private;
340		340
341	if (bio->bi_error)	341	if (bio->bi_status)
342	atomic_inc(&segbuf->sb_err);	342	atomic_inc(&segbuf->sb_err);
343		343
344	bio_put(bio);	344	bio_put(bio);

fs/ocfs2/cluster/heartbeat.c+3−3

@@ -516,9 +516,9 @@ static void o2hb_bio_end_io(struct bio *bio) · 515 unmodified lines
516	{	516	{
517	struct o2hb_bio_wait_ctxt *wc = bio->bi_private;	517	struct o2hb_bio_wait_ctxt *wc = bio->bi_private;
518		518
519	if (bio->bi_error) {	519	if (bio->bi_status) {
520	mlog(ML_ERROR, "IO Error %d\n", bio->bi_error);	520	mlog(ML_ERROR, "IO Error %d\n", bio->bi_status);
521	wc->wc_error = bio->bi_error;	521	wc->wc_error = blk_status_to_errno(bio->bi_status);
522	}	522	}
523		523
524	o2hb_bio_wait_dec(wc, 1);	524	o2hb_bio_wait_dec(wc, 1);

fs/xfs/xfs_aops.c+4−3

 	struct xfs_inode	*ip = XFS_I(ioend->io_inode);
 	xfs_off_t		offset = ioend->io_offset;
 	size_t			size = ioend->io_size;
-	int			error = ioend->io_bio->bi_error;
+	int			error;
 	/*
 	 * Just clean up the in-memory strutures if the fs has been shut down.
 	/*
 	 * Clean up any COW blocks on an I/O error.
 	 */
+	error = blk_status_to_errno(ioend->io_bio->bi_status);
 	if (unlikely(error)) {
 		switch (ioend->io_type) {
 		case XFS_IO_COW:
 	else if (ioend->io_append_trans)
 		queue_work(mp->m_data_workqueue, &ioend->io_work);
 	else
-		xfs_destroy_ioend(ioend, bio->bi_error);
+		xfs_destroy_ioend(ioend, blk_status_to_errno(bio->bi_status));
 }
 STATIC int
 	 * time.
 	 */
 	if (status) {
-		ioend->io_bio->bi_error = status;
+		ioend->io_bio->bi_status = errno_to_blk_status(status);
 		bio_endio(ioend->io_bio);
 		return status;
 	}

fs/xfs/xfs_buf.c+5−2

 	 * don't overwrite existing errors - otherwise we can lose errors on
 	 * buffers that require multiple bios to complete.
 	 */
-	if (bio->bi_error)
+	if (bio->bi_status) {
-		cmpxchg(&bp->b_io_error, 0, bio->bi_error);
+		int error = blk_status_to_errno(bio->bi_status);
+		cmpxchg(&bp->b_io_error, 0, error);
+	}
 	if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
 		invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));

include/linux/bio.h+1−1

@@ -414,7 +414,7 @@ extern void bio_endio(struct bio *); · 413 unmodified lines
414		414
415	static inline void bio_io_error(struct bio *bio)	415	static inline void bio_io_error(struct bio *bio)
416	{	416	{
417	bio->bi_error = -EIO;	417	bio->bi_status = BLK_STS_IOERR;
418	bio_endio(bio);	418	bio_endio(bio);
419	}	419	}
420		420

include/linux/blk_types.h+4−1

 #define BLK_STS_RESOURCE	((__force blk_status_t)9)
 #define BLK_STS_IOERR		((__force blk_status_t)10)
+/* hack for device mapper, don't use elsewhere: */
+#define BLK_STS_DM_REQUEUE    ((__force blk_status_t)11)
 struct blk_issue_stat {
 	u64 stat;
 };
 struct bio {
 	struct bio		*bi_next;	/* request queue link */
 	struct block_device	*bi_bdev;
-	int			bi_error;
+	blk_status_t		bi_status;
 	unsigned int		bi_opf;		/* bottom bits req flags,
 						 * top bits REQ_OP. Use
 						 * accessors.

include/linux/blkdev.h+1−1

@@ -1782,7 +1782,7 @@ struct blk_integrity_iter { · 1781 unmodified lines
1782	const char *disk_name;	1782	const char *disk_name;
1783	};	1783	};
1784		1784
1785	typedef int (integrity_processing_fn) (struct blk_integrity_iter *);	1785	typedef blk_status_t (integrity_processing_fn) (struct blk_integrity_iter *);
1786		1786
1787	struct blk_integrity_profile {	1787	struct blk_integrity_profile {
1788	integrity_processing_fn *generate_fn;	1788	integrity_processing_fn *generate_fn;

include/linux/device-mapper.h+1−1

@@ -72,7 +72,7 @@ typedef void (dm_release_clone_request_fn) (struct request clone); · 71 unmodified lines
72	* 2 : The target wants to push back the io	72	* 2 : The target wants to push back the io
73	*/	73	*/
74	typedef int (dm_endio_fn) (struct dm_target ti,	74	typedef int (dm_endio_fn) (struct dm_target ti,
75	struct bio bio, int error);	75	struct bio bio, blk_status_t error);
76	typedef int (dm_request_endio_fn) (struct dm_target ti,	76	typedef int (dm_request_endio_fn) (struct dm_target ti,
77	struct request *clone, blk_status_t error,	77	struct request *clone, blk_status_t error,
78	union map_info *map_context);	78	union map_info *map_context);

kernel/power/swap.c+7−7

@@ -225,14 +225,14 @@ static struct block_device *hib_resume_bdev; · 224 unmodified lines
225	struct hib_bio_batch {	225	struct hib_bio_batch {
226	atomic_t count;	226	atomic_t count;
227	wait_queue_head_t wait;	227	wait_queue_head_t wait;
228	int error;	228	blk_status_t error;
229	};	229	};
230		230
231	static void hib_init_batch(struct hib_bio_batch *hb)	231	static void hib_init_batch(struct hib_bio_batch *hb)
232	{	232	{
233	atomic_set(&hb->count, 0);	233	atomic_set(&hb->count, 0);
234	init_waitqueue_head(&hb->wait);	234	init_waitqueue_head(&hb->wait);
235	hb->error = 0;	235	hb->error = BLK_STS_OK;
236	}	236	}
237		237
238	static void hib_end_io(struct bio *bio)	238	static void hib_end_io(struct bio *bio)
@@ -240,7 +240,7 @@ static void hib_end_io(struct bio *bio) · 1 unmodified line
240	struct hib_bio_batch *hb = bio->bi_private;	240	struct hib_bio_batch *hb = bio->bi_private;
241	struct page *page = bio->bi_io_vec[0].bv_page;	241	struct page *page = bio->bi_io_vec[0].bv_page;
242		242
243	if (bio->bi_error) {	243	if (bio->bi_status) {
244	printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",	244	printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
245	imajor(bio->bi_bdev->bd_inode),	245	imajor(bio->bi_bdev->bd_inode),
246	iminor(bio->bi_bdev->bd_inode),	246	iminor(bio->bi_bdev->bd_inode),
@@ -253,8 +253,8 @@ static void hib_end_io(struct bio *bio) · 6 unmodified lines
253	flush_icache_range((unsigned long)page_address(page),	253	flush_icache_range((unsigned long)page_address(page),
254	(unsigned long)page_address(page) + PAGE_SIZE);	254	(unsigned long)page_address(page) + PAGE_SIZE);
255		255
256	if (bio->bi_error && !hb->error)	256	if (bio->bi_status && !hb->error)
257	hb->error = bio->bi_error;	257	hb->error = bio->bi_status;
258	if (atomic_dec_and_test(&hb->count))	258	if (atomic_dec_and_test(&hb->count))
259	wake_up(&hb->wait);	259	wake_up(&hb->wait);
260		260
@@ -293,10 +293,10 @@ static int hib_submit_io(int op, int op_flags, pgoff_t page_off, void *addr, · 32 unmodified lines
293	return error;	293	return error;
294	}	294	}
295		295
296	static int hib_wait_io(struct hib_bio_batch *hb)	296	static blk_status_t hib_wait_io(struct hib_bio_batch *hb)
297	{	297	{
298	wait_event(hb->wait, atomic_read(&hb->count) == 0);	298	wait_event(hb->wait, atomic_read(&hb->count) == 0);
299	return hb->error;	299	return blk_status_to_errno(hb->error);
300	}	300	}
301		301
302	/*	302	/*

kernel/trace/blktrace.c+2−2

@@ -867,7 +867,7 @@ static void blk_add_trace_split(void *ignore, · 866 unmodified lines
867		867
868	__blk_add_trace(bt, bio->bi_iter.bi_sector,	868	__blk_add_trace(bt, bio->bi_iter.bi_sector,
869	bio->bi_iter.bi_size, bio_op(bio), bio->bi_opf,	869	bio->bi_iter.bi_size, bio_op(bio), bio->bi_opf,
870	BLK_TA_SPLIT, bio->bi_error, sizeof(rpdu),	870	BLK_TA_SPLIT, bio->bi_status, sizeof(rpdu),
871	&rpdu);	871	&rpdu);
872	}	872	}
873	}	873	}
@@ -900,7 +900,7 @@ static void blk_add_trace_bio_remap(void *ignore, · 26 unmodified lines
900	r.sector_from = cpu_to_be64(from);	900	r.sector_from = cpu_to_be64(from);
901		901
902	__blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,	902	__blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
903	bio_op(bio), bio->bi_opf, BLK_TA_REMAP, bio->bi_error,	903	bio_op(bio), bio->bi_opf, BLK_TA_REMAP, bio->bi_status,
904	sizeof(r), &r);	904	sizeof(r), &r);
905	}	905	}
906		906

mm/page_io.c+2−2

@@ -45,7 +45,7 @@ void end_swap_bio_write(struct bio *bio) · 44 unmodified lines
45	{	45	{
46	struct page *page = bio->bi_io_vec[0].bv_page;	46	struct page *page = bio->bi_io_vec[0].bv_page;
47		47
48	if (bio->bi_error) {	48	if (bio->bi_status) {
49	SetPageError(page);	49	SetPageError(page);
50	/*	50	/*
51	* We failed to write the page out to swap-space.	51	* We failed to write the page out to swap-space.
@@ -118,7 +118,7 @@ static void end_swap_bio_read(struct bio *bio) · 66 unmodified lines
118	{	118	{
119	struct page *page = bio->bi_io_vec[0].bv_page;	119	struct page *page = bio->bi_io_vec[0].bv_page;
120		120
121	if (bio->bi_error) {	121	if (bio->bi_status) {
122	SetPageError(page);	122	SetPageError(page);
123	ClearPageUptodate(page);	123	ClearPageUptodate(page);
124	pr_alert("Read-error on swap-device (%u:%u:%llu)\n",	124	pr_alert("Read-error on swap-device (%u:%u:%llu)\n",

@@ -959,16 +959,16 @@ static void drbd_bm_endio(struct bio *bio) · 958 unmodified lines
959	!bm_test_page_unchanged(b->bm_pages[idx]))	959	!bm_test_page_unchanged(b->bm_pages[idx]))
960	drbd_warn(device, "bitmap page idx %u changed during IO!\n", idx);	960	drbd_warn(device, "bitmap page idx %u changed during IO!\n", idx);
961		961
962	if (bio->bi_error) {	962	if (bio->bi_status) {
963	/* ctx error will hold the completed-last non-zero error code,	963	/* ctx error will hold the completed-last non-zero error code,
964	* in case error codes differ. */	964	* in case error codes differ. */
965	ctx->error = bio->bi_error;	965	ctx->error = blk_status_to_errno(bio->bi_status);
966	bm_set_page_io_err(b->bm_pages[idx]);	966	bm_set_page_io_err(b->bm_pages[idx]);
967	/* Not identical to on disk version of it.	967	/* Not identical to on disk version of it.
968	* Is BM_PAGE_IO_ERROR enough? */	968	* Is BM_PAGE_IO_ERROR enough? */
969	if (__ratelimit(&drbd_ratelimit_state))	969	if (__ratelimit(&drbd_ratelimit_state))
970	drbd_err(device, "IO ERROR %d on bitmap page idx %u\n",	970	drbd_err(device, "IO ERROR %d on bitmap page idx %u\n",
971	bio->bi_error, idx);	971	bio->bi_status, idx);
972	} else {	972	} else {
973	bm_clear_page_io_err(b->bm_pages[idx]);	973	bm_clear_page_io_err(b->bm_pages[idx]);
974	dynamic_drbd_dbg(device, "bitmap page idx %u completed\n", idx);	974	dynamic_drbd_dbg(device, "bitmap page idx %u completed\n", idx);