Skip to contentSkip to conversation

dm-bufio: fix memleak when using a dm_buffer's inline bio

PATCH In review Darrick J. Wong 3 participants 8 messages Nov 26, 2014 – Dec 1, 2014 Device mapper

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 dm-bufio: fix memleak when using a dm_buffer's inline bio

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

Fix is against 3.18-rc6.

---
 drivers/md/dm-bufio.c |   13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)
drivers/md/dm-bufio.c +12 -1
index afe7971..2967ecc 100644
@@ -532,6 +532,16 @@ static void use_dmio(struct dm_buffer *b, int rw, sector_t block,
 		end_io(&b->bio, r);
 }
 
+/* Reset the bio to free attached bio integrity profiles when we're done */
+static void inline_endio(struct bio *bio, int error)
+{
+	bio_end_io_t *end_fn;
+
+	end_fn = bio->bi_private;
+	end_fn(bio, error);
+	bio_reset(bio);
+}
+
 static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
 			   bio_end_io_t *end_io)
 {
@@ -543,7 +553,8 @@ static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
 	b->bio.bi_max_vecs = DM_BUFIO_INLINE_VECS;
 	b->bio.bi_iter.bi_sector = block << b->c->sectors_per_block_bits;
 	b->bio.bi_bdev = b->c->bdev;
-	b->bio.bi_end_io = end_io;
+	b->bio.bi_end_io = inline_endio;
+	b->bio.bi_private = end_io;
 
 	/*
 	 * We assume that if len >= PAGE_SIZE ptr is page-aligned.
#1 lore raw
Quoted 6 lines · Darrick J. Wong

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Quoted 8 lines

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

Fix is against 3.18-rc6.

Thanks for reporting/fixing this.

Alternatively I think we could just call bio_reset() in submit_io(), e.g.:

drivers/md/dm-bufio.c +2 -0
index afe7971..e7036e3 100644
@@ -579,6 +579,8 @@ static void submit_io(struct dm_buffer *b, int rw, sector_t block,
 	if (rw == WRITE && b->c->write_callback)
 		b->c->write_callback(b);
 
+	bio_reset(&b->bio);
+
 	if (b->c->block_size <= DM_BUFIO_INLINE_VECS * PAGE_SIZE &&
 	    b->data_mode != DATA_MODE_VMALLOC)
 		use_inline_bio(b, rw, block, end_io);

What do you think?

#2 lore raw
Quoted 37 lines · Mike Snitzer
Quoted 6 lines · Darrick J. Wong

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Quoted 8 lines

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

Fix is against 3.18-rc6.

Thanks for reporting/fixing this.

Alternatively I think we could just call bio_reset() in submit_io(), e.g.:

drivers/md/dm-bufio.c +2 -0
index afe7971..e7036e3 100644
@@ -579,6 +579,8 @@ static void submit_io(struct dm_buffer *b, int rw, sector_t block,
 	if (rw == WRITE && b->c->write_callback)
 		b->c->write_callback(b);
 
+	bio_reset(&b->bio);
+
 	if (b->c->block_size <= DM_BUFIO_INLINE_VECS * PAGE_SIZE &&
 	    b->data_mode != DATA_MODE_VMALLOC)
 		use_inline_bio(b, rw, block, end_io);
Quoted 1 line

What do you think?

I decided to call bio_reset after calling end_io so that we can free the integrity buffer as soon as we're done with the bio. Calling bio_reset just prior to the next submit_bio as this snippet does means that the integrity buffer remains attached to the bio until just before the next submit_bio call, which could be a while.

Also, I think use_dmio results in a new bio being used instead of the bio embedded in the dm_buffer, so it shouldn't be necessary to reset the bio if the previous IO had use_dmio'd.

--D

Quoted 5 lines

--
dm-devel mailing list
[email protected]
https://www.redhat.com/mailman/listinfo/dm-devel

#3 lore raw
Quoted 46 lines · Darrick J. Wong
Quoted 37 lines · Mike Snitzer
Quoted 6 lines · Darrick J. Wong

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Quoted 8 lines

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

Fix is against 3.18-rc6.

Thanks for reporting/fixing this.

Alternatively I think we could just call bio_reset() in submit_io(), e.g.:

drivers/md/dm-bufio.c +2 -0
index afe7971..e7036e3 100644
@@ -579,6 +579,8 @@ static void submit_io(struct dm_buffer *b, int rw, sector_t block,
 	if (rw == WRITE && b->c->write_callback)
 		b->c->write_callback(b);
 
+	bio_reset(&b->bio);
+
 	if (b->c->block_size <= DM_BUFIO_INLINE_VECS * PAGE_SIZE &&
 	    b->data_mode != DATA_MODE_VMALLOC)
 		use_inline_bio(b, rw, block, end_io);
Quoted 1 line

What do you think?

I decided to call bio_reset after calling end_io so that we can free the integrity buffer as soon as we're done with the bio. Calling bio_reset just prior to the next submit_bio as this snippet does means that the integrity buffer remains attached to the bio until just before the next submit_bio call, which could be a while.

Quoted 3 lines

Also, I think use_dmio results in a new bio being used instead of the bio embedded in the dm_buffer, so it shouldn't be necessary to reset the bio if the previous IO had use_dmio'd.

OK, yeah, a new embedded bio is created as a side-effect of allocating a new dm_buffer. So we have to use bi_end_io like you've done.

I didn't like seeing your use of .bi_private (because in the context of bios that are passed into DM: .bi_private must always be preserved so as not to break upper layers of the IO stack that might be using it).

But in the context of bufio's embedded bio, using .bi_private seems fine. Just needs a comment. I'll fixup and get your patch staged (and will CC stable).

Thanks again,
Mike

#5 lore raw
In reply to Mike Snitzer
Quoted 53 lines · Mike Snitzer
Quoted 46 lines · Darrick J. Wong
Quoted 37 lines · Mike Snitzer
Quoted 6 lines · Darrick J. Wong

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Quoted 8 lines

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

Fix is against 3.18-rc6.

Thanks for reporting/fixing this.

Alternatively I think we could just call bio_reset() in submit_io(), e.g.:

drivers/md/dm-bufio.c +2 -0
index afe7971..e7036e3 100644
@@ -579,6 +579,8 @@ static void submit_io(struct dm_buffer *b, int rw, sector_t block,
 	if (rw == WRITE && b->c->write_callback)
 		b->c->write_callback(b);
 
+	bio_reset(&b->bio);
+
 	if (b->c->block_size <= DM_BUFIO_INLINE_VECS * PAGE_SIZE &&
 	    b->data_mode != DATA_MODE_VMALLOC)
 		use_inline_bio(b, rw, block, end_io);
Quoted 1 line

What do you think?

I decided to call bio_reset after calling end_io so that we can free the integrity buffer as soon as we're done with the bio. Calling bio_reset just prior to the next submit_bio as this snippet does means that the integrity buffer remains attached to the bio until just before the next submit_bio call, which could be a while.

Quoted 3 lines

Also, I think use_dmio results in a new bio being used instead of the bio embedded in the dm_buffer, so it shouldn't be necessary to reset the bio if the previous IO had use_dmio'd.

Quoted 6 lines

OK, yeah, a new embedded bio is created as a side-effect of allocating a new dm_buffer. So we have to use bi_end_io like you've done.

I didn't like seeing your use of .bi_private (because in the context of bios that are passed into DM: .bi_private must always be preserved so as not to break upper layers of the IO stack that might be using it).

<nod> I hadn't considered that not restoring .bi_private without comment would raise eyebrows in a space where the norm is that they must always be preserved. :)

Quoted 3 lines

But in the context of bufio's embedded bio, using .bi_private seems fine. Just needs a comment. I'll fixup and get your patch staged (and will CC stable).

The staged patch looks good, thank you!

--D

Quoted 8 lines

Thanks again,
Mike

--
dm-devel mailing list
[email protected]
https://www.redhat.com/mailman/listinfo/dm-devel

maintainer
#6 lore raw
In reply to Darrick J. Wong
Quoted 13 lines · Darrick J. Wong

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

Fix is against 3.18-rc6.

Review

Quoted 9 lines
(quoted diff) +9 -0
+/* Reset the bio to free attached bio integrity profiles when we're done */
+static void inline_endio(struct bio *bio, int error)
+{
+	bio_end_io_t *end_fn;
+
+	end_fn = bio->bi_private;
+	end_fn(bio, error);
+	bio_reset(bio);
+}

This is wrong - when end_fn clears the B_READING or B_WRITING flag, the buffer may be freed by the background cleanup - so bio_reset may be modifying freed memory here. We need to call bio_reset before end_fn.

From: Mikulas Patocka <[email protected]>

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

---
 drivers/md/dm-bufio.c |   19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)
drivers/md/dm-bufio.c +18 -1
Index: linux-3.18-rc6/drivers/md/dm-bufio.c
===================================================================
@@ -565,6 +565,18 @@ static void use_dmio(struct dm_buffer *b
 		end_io(&b->bio, r);
 }
 
+static void inline_endio(struct bio *bio, int error)
+{
+	bio_end_io_t *end_fn = bio->bi_private;
+	/*
+	 * Reset the bio to free any attached resources
+	 * (e.g. bio integrity profiles).
+	 */
+	bio_reset(bio);
+
+	end_fn(bio, error);
+}
+
 static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
 			   bio_end_io_t *end_io)
 {
@@ -576,7 +588,12 @@ static void use_inline_bio(struct dm_buf
 	b->bio.bi_max_vecs = DM_BUFIO_INLINE_VECS;
 	b->bio.bi_iter.bi_sector = block << b->c->sectors_per_block_bits;
 	b->bio.bi_bdev = b->c->bdev;
-	b->bio.bi_end_io = end_io;
+	b->bio.bi_end_io = inline_endio;
+	/*
+	 * Use of .bi_private isn't a problem here because
+	 * the dm_buffer's inline bio is local to bufio.
+	 */
+	b->bio.bi_private = end_io;
 
 	/*
 	 * We assume that if len >= PAGE_SIZE ptr is page-aligned.
#7 lore raw
Quoted 17 lines · Mikulas Patocka
Quoted 13 lines · Darrick J. Wong

When dm-bufio sets out to use the bio built into a struct dm_buffer to issue an IO, it needs to call bio_reset after it's done with the bio so that we can free things attached to the bio such as the integrity payload. Therefore, inject our own endio callback to take care of the bio_reset after calling submit_io's end_io callback.

Test case:
1. modprobe scsi_debug delay=0 dif=1 dix=199 ato=1 dev_size_mb=300
2. Set up a dm-bufio client, e.g. dm-verity, on the scsi_debug device
3. Repeatedly read metadata and watch kmalloc-192 leak!

Fix is against 3.18-rc6.

Quoted 13 lines

drivers/md/dm-bufio.c static void use_dmio(struct dm_buffer *b · line 578

Quoted 9 lines
drivers/md/dm-bufio.c +9 -0
+/* Reset the bio to free attached bio integrity profiles when we're done */
+static void inline_endio(struct bio *bio, int error)
+{
+	bio_end_io_t *end_fn;
+
+	end_fn = bio->bi_private;
+	end_fn(bio, error);
+	bio_reset(bio);
+}

This is wrong - when end_fn clears the B_READING or B_WRITING flag, the buffer may be freed by the background cleanup - so bio_reset may be modifying freed memory here. We need to call bio_reset before end_fn.

OK, I'll fold your fix in.