Commit 07560151 authored by Eric Biggers's avatar Eric Biggers Committed by Jens Axboe
Browse files

block: make bio_crypt_clone() able to fail 



bio_crypt_clone() assumes its gfp_mask argument always includes
__GFP_DIRECT_RECLAIM, so that the mempool_alloc() will always succeed.

However, bio_crypt_clone() might be called with GFP_ATOMIC via
setup_clone() in drivers/md/dm-rq.c, or with GFP_NOWAIT via
kcryptd_io_read() in drivers/md/dm-crypt.c.

Neither case is currently reachable with a bio that actually has an
encryption context.  However, it's fragile to rely on this.  Just make
bio_crypt_clone() able to fail, analogous to bio_integrity_clone().

Reported-by: default avatarMiaohe Lin <linmiaohe@huawei.com>
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Reviewed-by: default avatarMike Snitzer <snitzer@redhat.com>
Reviewed-by: default avatarSatya Tangirala <satyat@google.com>
Cc: Satya Tangirala <satyat@google.com>
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 10ed1666

block/bio.c

+9 −11
Original line number Diff line number Diff line
@@ -713,21 +713,19 @@ struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs) 


	__bio_clone_fast(b, bio);



	bio_crypt_clone(b, bio, gfp_mask);

	if (bio_crypt_clone(b, bio, gfp_mask) < 0)

		goto err_put;



	if (bio_integrity(bio)) {

		int ret;

	if (bio_integrity(bio) &&

	    bio_integrity_clone(b, bio, gfp_mask) < 0)

		goto err_put;



		ret = bio_integrity_clone(b, bio, gfp_mask);

	return b;



		if (ret < 0) {

err_put:

	bio_put(b);

	return NULL;

}

	}



	return b;

}

EXPORT_SYMBOL(bio_clone_fast);



const char *bio_devname(struct bio *bio, char *buf)

block/blk-crypto.c

+4 −1
Original line number Diff line number Diff line
@@ -95,10 +95,13 @@ void __bio_crypt_free_ctx(struct bio *bio) 
	bio->bi_crypt_context = NULL;

}



void __bio_crypt_clone(struct bio *dst, struct bio *src, gfp_t gfp_mask)

int __bio_crypt_clone(struct bio *dst, struct bio *src, gfp_t gfp_mask)

{

	dst->bi_crypt_context = mempool_alloc(bio_crypt_ctx_pool, gfp_mask);

	if (!dst->bi_crypt_context)

		return -ENOMEM;

	*dst->bi_crypt_context = *src->bi_crypt_context;

	return 0;

}

EXPORT_SYMBOL_GPL(__bio_crypt_clone);

block/bounce.c

+9 −10
Original line number Diff line number Diff line
@@ -267,22 +267,21 @@ static struct bio *bounce_clone_bio(struct bio *bio_src, gfp_t gfp_mask, 
		break;

	}



	bio_crypt_clone(bio, bio_src, gfp_mask);

	if (bio_crypt_clone(bio, bio_src, gfp_mask) < 0)

		goto err_put;



	if (bio_integrity(bio_src)) {

		int ret;



		ret = bio_integrity_clone(bio, bio_src, gfp_mask);

		if (ret < 0) {

			bio_put(bio);

			return NULL;

		}

	}

	if (bio_integrity(bio_src) &&

	    bio_integrity_clone(bio, bio_src, gfp_mask) < 0)

		goto err_put;



	bio_clone_blkg_association(bio, bio_src);

	blkcg_bio_issue_init(bio);



	return bio;



err_put:

	bio_put(bio);

	return NULL;

}



static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,

drivers/md/dm.c

+4 −3
Original line number Diff line number Diff line
@@ -1326,14 +1326,15 @@ static int clone_bio(struct dm_target_io *tio, struct bio *bio, 
		     sector_t sector, unsigned len)

{

	struct bio *clone = &tio->clone;

	int r;



	__bio_clone_fast(clone, bio);



	bio_crypt_clone(clone, bio, GFP_NOIO);

	r = bio_crypt_clone(clone, bio, GFP_NOIO);

	if (r < 0)

		return r;



	if (bio_integrity(bio)) {

		int r;



		if (unlikely(!dm_target_has_integrity(tio->ti->type) &&

			     !dm_target_passes_integrity(tio->ti->type))) {

			DMWARN("%s: the target %s doesn't support integrity data.",

include/linux/blk-crypto.h

+16 −4
Original line number Diff line number Diff line
@@ -112,12 +112,24 @@ static inline bool bio_has_crypt_ctx(struct bio *bio) 


#endif /* CONFIG_BLK_INLINE_ENCRYPTION */



void __bio_crypt_clone(struct bio *dst, struct bio *src, gfp_t gfp_mask);

static inline void bio_crypt_clone(struct bio *dst, struct bio *src,

int __bio_crypt_clone(struct bio *dst, struct bio *src, gfp_t gfp_mask);

/**

 * bio_crypt_clone - clone bio encryption context

 * @dst: destination bio

 * @src: source bio

 * @gfp_mask: memory allocation flags

 *

 * If @src has an encryption context, clone it to @dst.

 *

 * Return: 0 on success, -ENOMEM if out of memory.  -ENOMEM is only possible if

 *	   @gfp_mask doesn't include %__GFP_DIRECT_RECLAIM.

 */

static inline int bio_crypt_clone(struct bio *dst, struct bio *src,

				  gfp_t gfp_mask)

{

	if (bio_has_crypt_ctx(src))

		__bio_crypt_clone(dst, src, gfp_mask);

		return __bio_crypt_clone(dst, src, gfp_mask);

	return 0;

}



#endif /* __LINUX_BLK_CRYPTO_H */