[PATCH v2] dm init: ensure block device is ready before creating mapped device

[PATCH v2] dm init: ensure block device is ready before creating mapped device

[jaeyuel.im]

From: "jaeyuel.im" <jaeyuel.im@lge.com>

The current implementation of dm_init_init() uses early_lookup_bdev() to
wait for the device node to appear. However, early_lookup_bdev() only
verifies that the device node exists and returns the dev_t. It does not
guarantee that the underlying block device structure is fully initialized
and ready for I/O operations or to be opened.

On certain platforms (e.g., embedded systems with specific storage
drivers), this can lead to a race condition where dm_early_create()
attempts to open the device immediately after early_lookup_bdev() returns,
but fails because the device is not yet fully ready. This results in boot
failures as the mapped device cannot be created.

This patch adds an additional check using blkdev_get_no_open() after
early_lookup_bdev() returns. This ensures that the struct block_device is
actually available and the device is ready to be opened, effectively
preventing the race condition.

Changes in v2:
- Pass autoload parameter for new blkdev_get_no_open()

Signed-off-by: jaeyuel.im <jaeyuel.im@lge.com>
---
 drivers/md/dm-init.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/drivers/md/dm-init.c b/drivers/md/dm-init.c
index b37bbe762500..b3905e094ffc 100644
--- a/drivers/md/dm-init.c
+++ b/drivers/md/dm-init.c
@@ -296,10 +296,24 @@ static int __init dm_init_init(void)
 	for (i = 0; i < ARRAY_SIZE(waitfor); i++) {
 		if (waitfor[i]) {
 			dev_t dev;
+			struct block_device *bdev;
 
 			DMINFO("waiting for device %s ...", waitfor[i]);
 			while (early_lookup_bdev(waitfor[i], &dev))
 				fsleep(5000);
+
+			/*
+			 * early_lookup_bdev() only checks if the device node exists and
+			 * returns the dev_t. It does not guarantee that the underlying
+			 * block device is fully initialized and ready to be opened. On
+			 * some platforms, this can lead to a race condition where
+			 * dm_early_create() fails because the device is not yet ready.
+			 * Ensure the block device is truly available by attempting to
+			 * get it.
+			 */
+			while (!(bdev = blkdev_get_no_open(dev, false)))
+				fsleep(5000);
+			blkdev_put_no_open(bdev);
 		}
 	}
 
-- 
2.34.1

Re: [PATCH v2] dm init: ensure block device is ready before creating mapped device

[Sasha Levin]

On Fri, Dec 12, 2025 at 12:09:55AM +0000, jaeyuel.im@lge.com wrote:
>From: "jaeyuel.im" <jaeyuel.im@lge.com>
>
>The current implementation of dm_init_init() uses early_lookup_bdev() to
>wait for the device node to appear. However, early_lookup_bdev() only
>verifies that the device node exists and returns the dev_t. It does not
>guarantee that the underlying block device structure is fully initialized
>and ready for I/O operations or to be opened.
>
>On certain platforms (e.g., embedded systems with specific storage
>drivers), this can lead to a race condition where dm_early_create()
>attempts to open the device immediately after early_lookup_bdev() returns,
>but fails because the device is not yet fully ready. This results in boot
>failures as the mapped device cannot be created.
>
>This patch adds an additional check using blkdev_get_no_open() after
>early_lookup_bdev() returns. This ensures that the struct block_device is
>actually available and the device is ready to be opened, effectively
>preventing the race condition.
>
>Changes in v2:
>- Pass autoload parameter for new blkdev_get_no_open()
>
>Signed-off-by: jaeyuel.im <jaeyuel.im@lge.com>
>---
> drivers/md/dm-init.c | 14 ++++++++++++++
> 1 file changed, 14 insertions(+)
>
>diff --git a/drivers/md/dm-init.c b/drivers/md/dm-init.c
>index b37bbe762500..b3905e094ffc 100644
>--- a/drivers/md/dm-init.c
>+++ b/drivers/md/dm-init.c
>@@ -296,10 +296,24 @@ static int __init dm_init_init(void)
> 	for (i = 0; i < ARRAY_SIZE(waitfor); i++) {
> 		if (waitfor[i]) {
> 			dev_t dev;
>+			struct block_device *bdev;
>
> 			DMINFO("waiting for device %s ...", waitfor[i]);
> 			while (early_lookup_bdev(waitfor[i], &dev))
> 				fsleep(5000);
>+
>+			/*
>+			 * early_lookup_bdev() only checks if the device node exists and
>+			 * returns the dev_t. It does not guarantee that the underlying
>+			 * block device is fully initialized and ready to be opened. On
>+			 * some platforms, this can lead to a race condition where
>+			 * dm_early_create() fails because the device is not yet ready.
>+			 * Ensure the block device is truly available by attempting to
>+			 * get it.
>+			 */
>+			while (!(bdev = blkdev_get_no_open(dev, false)))

This breaks the build when CONFIG_DM_INIT=y:

   drivers/md/dm-init.c:314:41: error: implicit declaration of function 'blkdev_get_no_open'; did you mean 'blkdev_get_zone_info'? [-Wimplicit-function-declaration]
     314 |                         while (!(bdev = blkdev_get_no_open(dev, false)))
   drivers/md/dm-init.c:316:25: error: implicit declaration of function 'blkdev_put_no_open' [-Wimplicit-function-declaration]
     316 |                         blkdev_put_no_open(bdev);

The problem is that blkdev_get_no_open() and blkdev_put_no_open() are declared
in block/blk.h, which is internal to the block layer and not accessible from
drivers/md/. These functions need to be exported to a public header, or
dm-init.c needs to use a different API.

-- 
Thanks,
Sasha

[PATCH] dm init: ensure block device is ready before creating mapped device

[jaeyuel.im]

From: "jaeyuel.im" <jaeyuel.im@lge.com>

The current implementation of dm_init_init() uses early_lookup_bdev() to
wait for the device node to appear. However, early_lookup_bdev() only
verifies that the device node exists and returns the dev_t. It does not
guarantee that the underlying block device structure is fully initialized
and ready for I/O operations or to be opened.

On certain platforms (e.g., embedded systems with specific storage
drivers), this can lead to a race condition where dm_early_create()
attempts to open the device immediately after early_lookup_bdev() returns,
but fails because the device is not yet fully ready. This results in boot
failures as the mapped device cannot be created.

This patch adds an additional check using blkdev_get_no_open() after
early_lookup_bdev() returns. This ensures that the struct block_device is
actually available and the device is ready to be opened, effectively
preventing the race condition.

Changes in v2:
- Pass autoload parameter for new blkdev_get_no_open()

Changes in v3:
- Exported to a public header for both blkdev_get_no_open() and
  blkdev_put_no_open()

Link: https://patchwork.kernel.org/project/dm-devel/patch/20251212000955.171808-1-jaeyuel.im@lge.com/
Signed-off-by: jaeyuel.im <jaeyuel.im@lge.com>
---
 drivers/md/dm-init.c   | 14 ++++++++++++++
 include/linux/blkdev.h |  3 +++
 2 files changed, 17 insertions(+)

diff --git a/drivers/md/dm-init.c b/drivers/md/dm-init.c
index b37bbe762500..b3905e094ffc 100644
--- a/drivers/md/dm-init.c
+++ b/drivers/md/dm-init.c
@@ -296,10 +296,24 @@ static int __init dm_init_init(void)
 	for (i = 0; i < ARRAY_SIZE(waitfor); i++) {
 		if (waitfor[i]) {
 			dev_t dev;
+			struct block_device *bdev;
 
 			DMINFO("waiting for device %s ...", waitfor[i]);
 			while (early_lookup_bdev(waitfor[i], &dev))
 				fsleep(5000);
+
+			/*
+			 * early_lookup_bdev() only checks if the device node exists and
+			 * returns the dev_t. It does not guarantee that the underlying
+			 * block device is fully initialized and ready to be opened. On
+			 * some platforms, this can lead to a race condition where
+			 * dm_early_create() fails because the device is not yet ready.
+			 * Ensure the block device is truly available by attempting to
+			 * get it.
+			 */
+			while (!(bdev = blkdev_get_no_open(dev, false)))
+				fsleep(5000);
+			blkdev_put_no_open(bdev);
 		}
 	}
 
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 72e34acd439c..7f4a05b536ca 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1873,4 +1873,7 @@ static inline int bio_split_rw_at(struct bio *bio,
 
 #define DEFINE_IO_COMP_BATCH(name)	struct io_comp_batch name = { }
 
+struct block_device *blkdev_get_no_open(dev_t dev, bool autoload);
+void blkdev_put_no_open(struct block_device *bdev);
+
 #endif /* _LINUX_BLKDEV_H */
-- 
2.34.1

Re: [PATCH] dm init: ensure block device is ready before creating mapped device

[Benjamin Marzinski]

On Fri, Feb 06, 2026 at 05:05:26AM +0000, jaeyuel.im@lge.com wrote:
> From: "jaeyuel.im" <jaeyuel.im@lge.com>
> 
> The current implementation of dm_init_init() uses early_lookup_bdev() to
> wait for the device node to appear. However, early_lookup_bdev() only
> verifies that the device node exists and returns the dev_t. It does not
> guarantee that the underlying block device structure is fully initialized
> and ready for I/O operations or to be opened.
> 
> On certain platforms (e.g., embedded systems with specific storage
> drivers), this can lead to a race condition where dm_early_create()
> attempts to open the device immediately after early_lookup_bdev() returns,
> but fails because the device is not yet fully ready. This results in boot
> failures as the mapped device cannot be created.
> 
> This patch adds an additional check using blkdev_get_no_open() after
> early_lookup_bdev() returns. This ensures that the struct block_device is
> actually available and the device is ready to be opened, effectively
> preventing the race condition.
> 
> Changes in v2:
> - Pass autoload parameter for new blkdev_get_no_open()
> 
> Changes in v3:
> - Exported to a public header for both blkdev_get_no_open() and
>   blkdev_put_no_open()
> 
> Link: https://patchwork.kernel.org/project/dm-devel/patch/20251212000955.171808-1-jaeyuel.im@lge.com/
> Signed-off-by: jaeyuel.im <jaeyuel.im@lge.com>
> ---

You should put the description of your version changes here, after the
triple dash, so that they aren't part of the actual commit message. 

>  drivers/md/dm-init.c   | 14 ++++++++++++++
>  include/linux/blkdev.h |  3 +++
>  2 files changed, 17 insertions(+)
> 
> [snip] 
> diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
> index 72e34acd439c..7f4a05b536ca 100644
> --- a/include/linux/blkdev.h
> +++ b/include/linux/blkdev.h
> @@ -1873,4 +1873,7 @@ static inline int bio_split_rw_at(struct bio *bio,
>  
>  #define DEFINE_IO_COMP_BATCH(name)	struct io_comp_batch name = { }

If you're adding declarations linux/blkdev.h, you should remove them
from block/blk.h, so the functions aren't declared twice.

Also, IMHO it seems more natural for these declarions to placed near the
related bdev_file_open_by_dev() and bdev_file_open_by_path() ones
earlier in this file.

Finally I Added Jens and linux-block to the CCs, since the patch
includes changes to the block files. FYI, scripts/get_maintainer.pl can
help you send your patches the right people and lists.

-Ben
  
> +struct block_device *blkdev_get_no_open(dev_t dev, bool autoload);
> +void blkdev_put_no_open(struct block_device *bdev);
> +
>  #endif /* _LINUX_BLKDEV_H */
> -- 
> 2.34.1
> 

[PATCH] dm init: ensure block device is ready before creating mapped device

[jaeyuel.im]

From: "jaeyuel.im" <jaeyuel.im@lge.com>

The current implementation of dm_init_init() uses early_lookup_bdev() to
wait for the device node to appear. However, early_lookup_bdev() only
verifies that the device node exists and returns the dev_t. It does not
guarantee that the underlying block device structure is fully initialized
and ready for I/O operations or to be opened.

On certain platforms (e.g., embedded systems with specific storage
drivers), this can lead to a race condition where dm_early_create()
attempts to open the device immediately after early_lookup_bdev() returns,
but fails because the device is not yet fully ready. This results in boot
failures as the mapped device cannot be created.

This patch adds an additional check using blkdev_get_no_open() after
early_lookup_bdev() returns. This ensures that the struct block_device is
actually available and the device is ready to be opened, effectively
preventing the race condition.

Signed-off-by: jaeyuel.im <jaeyuel.im@lge.com>
---
 drivers/md/dm-init.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/drivers/md/dm-init.c b/drivers/md/dm-init.c
index ff9420f06483..76b84ca39906 100644
--- a/drivers/md/dm-init.c
+++ b/drivers/md/dm-init.c
@@ -299,10 +299,24 @@ static int __init dm_init_init(void)
 	for (i = 0; i < ARRAY_SIZE(waitfor); i++) {
 		if (waitfor[i]) {
 			dev_t dev;
+			struct block_device *bdev;
 
 			DMINFO("waiting for device %s ...", waitfor[i]);
 			while (early_lookup_bdev(waitfor[i], &dev))
 				fsleep(5000);
+
+			/*
+			 * early_lookup_bdev() only checks if the device node exists and
+			 * returns the dev_t. It does not guarantee that the underlying
+			 * block device is fully initialized and ready to be opened. On
+			 * some platforms, this can lead to a race condition where
+			 * dm_early_create() fails because the device is not yet ready.
+			 * Ensure the block device is truly available by attempting to
+			 * get it.
+			 */
+			while (!(bdev = blkdev_get_no_open(dev)))
+				fsleep(5000);
+			blkdev_put_no_open(bdev);
 		}
 	}
 
-- 
2.34.1

Re: [PATCH] dm init: ensure block device is ready before creating mapped device

[Dongsheng Yang]

在 12/11/2025 3:34 PM, jaeyuel.im@lge.com 写道:
> From: "jaeyuel.im" <jaeyuel.im@lge.com>
>
> The current implementation of dm_init_init() uses early_lookup_bdev() to
> wait for the device node to appear. However, early_lookup_bdev() only
> verifies that the device node exists and returns the dev_t. It does not
> guarantee that the underlying block device structure is fully initialized
> and ready for I/O operations or to be opened.
>
> On certain platforms (e.g., embedded systems with specific storage
> drivers), this can lead to a race condition where dm_early_create()
> attempts to open the device immediately after early_lookup_bdev() returns,
> but fails because the device is not yet fully ready. This results in boot
> failures as the mapped device cannot be created.
>
> This patch adds an additional check using blkdev_get_no_open() after
> early_lookup_bdev() returns. This ensures that the struct block_device is
> actually available and the device is ready to be opened, effectively
> preventing the race condition.
>
> Signed-off-by: jaeyuel.im <jaeyuel.im@lge.com>
> ---
>   drivers/md/dm-init.c | 14 ++++++++++++++
>   1 file changed, 14 insertions(+)
>
> diff --git a/drivers/md/dm-init.c b/drivers/md/dm-init.c
> index ff9420f06483..76b84ca39906 100644
> --- a/drivers/md/dm-init.c
> +++ b/drivers/md/dm-init.c
> @@ -299,10 +299,24 @@ static int __init dm_init_init(void)
>   	for (i = 0; i < ARRAY_SIZE(waitfor); i++) {
>   		if (waitfor[i]) {
>   			dev_t dev;
> +			struct block_device *bdev;
>   
>   			DMINFO("waiting for device %s ...", waitfor[i]);
>   			while (early_lookup_bdev(waitfor[i], &dev))
>   				fsleep(5000);
> +
> +			/*
> +			 * early_lookup_bdev() only checks if the device node exists and
> +			 * returns the dev_t. It does not guarantee that the underlying
> +			 * block device is fully initialized and ready to be opened. On
> +			 * some platforms, this can lead to a race condition where
> +			 * dm_early_create() fails because the device is not yet ready.
> +			 * Ensure the block device is truly available by attempting to
> +			 * get it.
> +			 */
> +			while (!(bdev = blkdev_get_no_open(dev)))

You need to pass autoload parameter for new blkdev_get_no_open()

"struct block_device *blkdev_get_no_open(dev_t dev, bool autoload)"


Thanx

> +				fsleep(5000);
> +			blkdev_put_no_open(bdev);
>   		}
>   	}
>