diff --git a/include/spdk/bdev.h b/include/spdk/bdev.h
index 22e12ffea..476ae9928 100644
--- a/include/spdk/bdev.h
+++ b/include/spdk/bdev.h
@@ -60,7 +60,7 @@ struct spdk_bdev_fn_table;
 struct spdk_io_channel;
 struct spdk_json_write_ctx;
 
-/** Blockdev status */
+/** bdev status */
 enum spdk_bdev_status {
 	SPDK_BDEV_STATUS_INVALID,
 	SPDK_BDEV_STATUS_READY,
@@ -79,7 +79,7 @@ struct spdk_bdev;
  */
 struct spdk_bdev_desc;
 
-/** Blockdev I/O type */
+/** bdev I/O type */
 enum spdk_bdev_io_type {
 	SPDK_BDEV_IO_TYPE_READ = 1,
 	SPDK_BDEV_IO_TYPE_WRITE,
diff --git a/include/spdk/scsi.h b/include/spdk/scsi.h
index 1ce4d0536..b6d31db80 100644
--- a/include/spdk/scsi.h
+++ b/include/spdk/scsi.h
@@ -33,7 +33,7 @@
 
 /**
  * \file
- * SCSI to blockdev translation layer
+ * SCSI to bdev translation layer
  */
 
 #ifndef SPDK_SCSI_H
@@ -134,7 +134,7 @@ struct spdk_scsi_task {
 	uint8_t sense_data[32];
 	size_t sense_data_len;
 
-	void *blockdev_io;
+	void *bdev_io;
 
 	TAILQ_ENTRY(spdk_scsi_task) scsi_link;
 
diff --git a/include/spdk_internal/bdev.h b/include/spdk_internal/bdev.h
index 83d1a731d..9427375f9 100644
--- a/include/spdk_internal/bdev.h
+++ b/include/spdk_internal/bdev.h
@@ -158,7 +158,7 @@ struct spdk_bdev_fn_table {
 	int (*dump_config_json)(void *ctx, struct spdk_json_write_ctx *w);
 };
 
-/** Blockdev I/O completion status */
+/** bdev I/O completion status */
 enum spdk_bdev_io_status {
 	SPDK_BDEV_IO_STATUS_SCSI_ERROR = -3,
 	SPDK_BDEV_IO_STATUS_NVME_ERROR = -2,
@@ -275,7 +275,7 @@ struct spdk_bdev_io {
 			/** Total size of data to be transferred. */
 			size_t len;
 
-			/** Starting offset (in bytes) of the blockdev for this I/O. */
+			/** Starting offset (in bytes) of the bdev for this I/O. */
 			uint64_t offset;
 		} read;
 		struct {
@@ -291,7 +291,7 @@ struct spdk_bdev_io {
 			/** Total size of data to be transferred. */
 			size_t len;
 
-			/** Starting offset (in bytes) of the blockdev for this I/O. */
+			/** Starting offset (in bytes) of the bdev for this I/O. */
 			uint64_t offset;
 		} write;
 		struct {
@@ -366,7 +366,7 @@ struct spdk_bdev_io {
 	TAILQ_ENTRY(spdk_bdev_io) module_link;
 
 	/**
-	 * Per I/O context for use by the blockdev module.
+	 * Per I/O context for use by the bdev module.
 	 *
 	 * Note that vbdev modules may not use this field if modifying a bdev_io and resubmitting
 	 * to the next lower bdev.
diff --git a/lib/bdev/aio/Makefile b/lib/bdev/aio/Makefile
index 45982efc3..e1f2c3fbf 100644
--- a/lib/bdev/aio/Makefile
+++ b/lib/bdev/aio/Makefile
@@ -35,7 +35,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
 CFLAGS += -I$(SPDK_ROOT_DIR)/lib/bdev/
-C_SRCS = blockdev_aio.c blockdev_aio_rpc.c
+C_SRCS = bdev_aio.c bdev_aio_rpc.c
 LIBNAME = bdev_aio
 
 include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk
diff --git a/lib/bdev/aio/blockdev_aio.c b/lib/bdev/aio/bdev_aio.c
similarity index 68%
rename from lib/bdev/aio/blockdev_aio.c
rename to lib/bdev/aio/bdev_aio.c
index f75909574..bef5b62dc 100644
--- a/lib/bdev/aio/blockdev_aio.c
+++ b/lib/bdev/aio/bdev_aio.c
@@ -31,7 +31,7 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "blockdev_aio.h"
+#include "bdev_aio.h"
 
 #include "spdk/stdinc.h"
 
@@ -43,19 +43,19 @@
 
 #include "spdk_internal/log.h"
 
-static void blockdev_aio_initialize(void);
+static void bdev_aio_initialize(void);
 static void aio_free_disk(struct file_disk *fdisk);
 
 static int
-blockdev_aio_get_ctx_size(void)
+bdev_aio_get_ctx_size(void)
 {
-	return sizeof(struct blockdev_aio_task);
+	return sizeof(struct bdev_aio_task);
 }
 
-SPDK_BDEV_MODULE_REGISTER(aio, blockdev_aio_initialize, NULL, NULL, blockdev_aio_get_ctx_size)
+SPDK_BDEV_MODULE_REGISTER(aio, bdev_aio_initialize, NULL, NULL, bdev_aio_get_ctx_size)
 
 static int
-blockdev_aio_open(struct file_disk *disk)
+bdev_aio_open(struct file_disk *disk)
 {
 	int fd;
 
@@ -72,7 +72,7 @@ blockdev_aio_open(struct file_disk *disk)
 }
 
 static int
-blockdev_aio_close(struct file_disk *disk)
+bdev_aio_close(struct file_disk *disk)
 {
 	int rc;
 
@@ -92,12 +92,12 @@ blockdev_aio_close(struct file_disk *disk)
 }
 
 static int64_t
-blockdev_aio_readv(struct file_disk *fdisk, struct spdk_io_channel *ch,
-		   struct blockdev_aio_task *aio_task,
-		   struct iovec *iov, int iovcnt, uint64_t nbytes, uint64_t offset)
+bdev_aio_readv(struct file_disk *fdisk, struct spdk_io_channel *ch,
+	       struct bdev_aio_task *aio_task,
+	       struct iovec *iov, int iovcnt, uint64_t nbytes, uint64_t offset)
 {
 	struct iocb *iocb = &aio_task->iocb;
-	struct blockdev_aio_io_channel *aio_ch = spdk_io_channel_get_ctx(ch);
+	struct bdev_aio_io_channel *aio_ch = spdk_io_channel_get_ctx(ch);
 	int rc;
 
 	io_prep_preadv(iocb, fdisk->fd, iov, iovcnt, offset);
@@ -118,12 +118,12 @@ blockdev_aio_readv(struct file_disk *fdisk, struct spdk_io_channel *ch,
 }
 
 static int64_t
-blockdev_aio_writev(struct file_disk *fdisk, struct spdk_io_channel *ch,
-		    struct blockdev_aio_task *aio_task,
-		    struct iovec *iov, int iovcnt, size_t len, uint64_t offset)
+bdev_aio_writev(struct file_disk *fdisk, struct spdk_io_channel *ch,
+		struct bdev_aio_task *aio_task,
+		struct iovec *iov, int iovcnt, size_t len, uint64_t offset)
 {
 	struct iocb *iocb = &aio_task->iocb;
-	struct blockdev_aio_io_channel *aio_ch = spdk_io_channel_get_ctx(ch);
+	struct bdev_aio_io_channel *aio_ch = spdk_io_channel_get_ctx(ch);
 	int rc;
 
 	io_prep_pwritev(iocb, fdisk->fd, iov, iovcnt, offset);
@@ -144,8 +144,8 @@ blockdev_aio_writev(struct file_disk *fdisk, struct spdk_io_channel *ch,
 }
 
 static void
-blockdev_aio_flush(struct file_disk *fdisk, struct blockdev_aio_task *aio_task,
-		   uint64_t offset, uint64_t nbytes)
+bdev_aio_flush(struct file_disk *fdisk, struct bdev_aio_task *aio_task,
+	       uint64_t offset, uint64_t nbytes)
 {
 	int rc = fsync(fdisk->fd);
 
@@ -154,21 +154,21 @@ blockdev_aio_flush(struct file_disk *fdisk, struct blockdev_aio_task *aio_task,
 }
 
 static int
-blockdev_aio_destruct(void *ctx)
+bdev_aio_destruct(void *ctx)
 {
 	struct file_disk *fdisk = ctx;
 	int rc = 0;
 
-	rc = blockdev_aio_close(fdisk);
+	rc = bdev_aio_close(fdisk);
 	if (rc < 0) {
-		SPDK_ERRLOG("blockdev_aio_close() failed\n");
+		SPDK_ERRLOG("bdev_aio_close() failed\n");
 	}
 	aio_free_disk(fdisk);
 	return rc;
 }
 
 static int
-blockdev_aio_initialize_io_channel(struct blockdev_aio_io_channel *ch)
+bdev_aio_initialize_io_channel(struct bdev_aio_io_channel *ch)
 {
 	ch->queue_depth = 128;
 
@@ -187,12 +187,12 @@ blockdev_aio_initialize_io_channel(struct blockdev_aio_io_channel *ch)
 }
 
 static void
-blockdev_aio_poll(void *arg)
+bdev_aio_poll(void *arg)
 {
-	struct blockdev_aio_io_channel *ch = arg;
+	struct bdev_aio_io_channel *ch = arg;
 	int nr, i;
 	enum spdk_bdev_io_status status;
-	struct blockdev_aio_task *aio_task;
+	struct bdev_aio_task *aio_task;
 	struct timespec timeout;
 
 	timeout.tv_sec = 0;
@@ -219,63 +219,63 @@ blockdev_aio_poll(void *arg)
 }
 
 static void
-blockdev_aio_reset(struct file_disk *fdisk, struct blockdev_aio_task *aio_task)
+bdev_aio_reset(struct file_disk *fdisk, struct bdev_aio_task *aio_task)
 {
 	spdk_bdev_io_complete(spdk_bdev_io_from_ctx(aio_task), SPDK_BDEV_IO_STATUS_SUCCESS);
 }
 
-static void blockdev_aio_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static void bdev_aio_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
-	blockdev_aio_readv((struct file_disk *)bdev_io->bdev->ctxt,
-			   ch,
-			   (struct blockdev_aio_task *)bdev_io->driver_ctx,
-			   bdev_io->u.read.iovs,
-			   bdev_io->u.read.iovcnt,
-			   bdev_io->u.read.len,
-			   bdev_io->u.read.offset);
+	bdev_aio_readv((struct file_disk *)bdev_io->bdev->ctxt,
+		       ch,
+		       (struct bdev_aio_task *)bdev_io->driver_ctx,
+		       bdev_io->u.read.iovs,
+		       bdev_io->u.read.iovcnt,
+		       bdev_io->u.read.len,
+		       bdev_io->u.read.offset);
 }
 
-static int _blockdev_aio_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static int _bdev_aio_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
 	switch (bdev_io->type) {
 	case SPDK_BDEV_IO_TYPE_READ:
-		spdk_bdev_io_get_buf(bdev_io, blockdev_aio_get_buf_cb);
+		spdk_bdev_io_get_buf(bdev_io, bdev_aio_get_buf_cb);
 		return 0;
 
 	case SPDK_BDEV_IO_TYPE_WRITE:
-		blockdev_aio_writev((struct file_disk *)bdev_io->bdev->ctxt,
-				    ch,
-				    (struct blockdev_aio_task *)bdev_io->driver_ctx,
-				    bdev_io->u.write.iovs,
-				    bdev_io->u.write.iovcnt,
-				    bdev_io->u.write.len,
-				    bdev_io->u.write.offset);
+		bdev_aio_writev((struct file_disk *)bdev_io->bdev->ctxt,
+				ch,
+				(struct bdev_aio_task *)bdev_io->driver_ctx,
+				bdev_io->u.write.iovs,
+				bdev_io->u.write.iovcnt,
+				bdev_io->u.write.len,
+				bdev_io->u.write.offset);
 		return 0;
 	case SPDK_BDEV_IO_TYPE_FLUSH:
-		blockdev_aio_flush((struct file_disk *)bdev_io->bdev->ctxt,
-				   (struct blockdev_aio_task *)bdev_io->driver_ctx,
-				   bdev_io->u.flush.offset,
-				   bdev_io->u.flush.length);
+		bdev_aio_flush((struct file_disk *)bdev_io->bdev->ctxt,
+			       (struct bdev_aio_task *)bdev_io->driver_ctx,
+			       bdev_io->u.flush.offset,
+			       bdev_io->u.flush.length);
 		return 0;
 
 	case SPDK_BDEV_IO_TYPE_RESET:
-		blockdev_aio_reset((struct file_disk *)bdev_io->bdev->ctxt,
-				   (struct blockdev_aio_task *)bdev_io->driver_ctx);
+		bdev_aio_reset((struct file_disk *)bdev_io->bdev->ctxt,
+			       (struct bdev_aio_task *)bdev_io->driver_ctx);
 		return 0;
 	default:
 		return -1;
 	}
 }
 
-static void blockdev_aio_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static void bdev_aio_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
-	if (_blockdev_aio_submit_request(ch, bdev_io) < 0) {
+	if (_bdev_aio_submit_request(ch, bdev_io) < 0) {
 		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
 	}
 }
 
 static bool
-blockdev_aio_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
+bdev_aio_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 {
 	switch (io_type) {
 	case SPDK_BDEV_IO_TYPE_READ:
@@ -290,23 +290,23 @@ blockdev_aio_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 }
 
 static int
-blockdev_aio_create_cb(void *io_device, void *ctx_buf)
+bdev_aio_create_cb(void *io_device, void *ctx_buf)
 {
-	struct blockdev_aio_io_channel *ch = ctx_buf;
+	struct bdev_aio_io_channel *ch = ctx_buf;
 
-	if (blockdev_aio_initialize_io_channel(ch) != 0) {
+	if (bdev_aio_initialize_io_channel(ch) != 0) {
 		return -1;
 	}
 
-	spdk_bdev_poller_start(&ch->poller, blockdev_aio_poll, ch,
+	spdk_bdev_poller_start(&ch->poller, bdev_aio_poll, ch,
 			       spdk_env_get_current_core(), 0);
 	return 0;
 }
 
 static void
-blockdev_aio_destroy_cb(void *io_device, void *ctx_buf)
+bdev_aio_destroy_cb(void *io_device, void *ctx_buf)
 {
-	struct blockdev_aio_io_channel *io_channel = ctx_buf;
+	struct bdev_aio_io_channel *io_channel = ctx_buf;
 
 	io_destroy(io_channel->io_ctx);
 	free(io_channel->events);
@@ -314,7 +314,7 @@ blockdev_aio_destroy_cb(void *io_device, void *ctx_buf)
 }
 
 static struct spdk_io_channel *
-blockdev_aio_get_io_channel(void *ctx)
+bdev_aio_get_io_channel(void *ctx)
 {
 	struct file_disk *fdisk = ctx;
 
@@ -322,10 +322,10 @@ blockdev_aio_get_io_channel(void *ctx)
 }
 
 static const struct spdk_bdev_fn_table aio_fn_table = {
-	.destruct		= blockdev_aio_destruct,
-	.submit_request		= blockdev_aio_submit_request,
-	.io_type_supported	= blockdev_aio_io_type_supported,
-	.get_io_channel		= blockdev_aio_get_io_channel,
+	.destruct		= bdev_aio_destruct,
+	.submit_request		= bdev_aio_submit_request,
+	.io_type_supported	= bdev_aio_io_type_supported,
+	.get_io_channel		= bdev_aio_get_io_channel,
 };
 
 static void aio_free_disk(struct file_disk *fdisk)
@@ -348,7 +348,7 @@ create_aio_disk(const char *name, const char *fname)
 	}
 
 	fdisk->file = fname;
-	if (blockdev_aio_open(fdisk)) {
+	if (bdev_aio_open(fdisk)) {
 		SPDK_ERRLOG("Unable to open file %s. fd: %d errno: %d\n", fname, fdisk->fd, errno);
 		goto error_return;
 	}
@@ -371,19 +371,19 @@ create_aio_disk(const char *name, const char *fname)
 
 	fdisk->disk.fn_table = &aio_fn_table;
 
-	spdk_io_device_register(&fdisk->fd, blockdev_aio_create_cb, blockdev_aio_destroy_cb,
-				sizeof(struct blockdev_aio_io_channel));
+	spdk_io_device_register(&fdisk->fd, bdev_aio_create_cb, bdev_aio_destroy_cb,
+				sizeof(struct bdev_aio_io_channel));
 	spdk_bdev_register(&fdisk->disk);
 	return &fdisk->disk;
 
 error_return:
-	blockdev_aio_close(fdisk);
+	bdev_aio_close(fdisk);
 	aio_free_disk(fdisk);
 	return NULL;
 }
 
 static void
-blockdev_aio_initialize(void)
+bdev_aio_initialize(void)
 {
 	size_t i;
 	struct spdk_conf_section *sp;
diff --git a/lib/bdev/aio/blockdev_aio.h b/lib/bdev/aio/bdev_aio.h
similarity index 90%
rename from lib/bdev/aio/blockdev_aio.h
rename to lib/bdev/aio/bdev_aio.h
index b315a13da..cee60b1ac 100644
--- a/lib/bdev/aio/blockdev_aio.h
+++ b/lib/bdev/aio/bdev_aio.h
@@ -31,8 +31,8 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SPDK_BLOCKDEV_AIO_H
-#define SPDK_BLOCKDEV_AIO_H
+#ifndef SPDK_BDEV_AIO_H
+#define SPDK_BDEV_AIO_H
 
 #include "spdk/stdinc.h"
 
@@ -43,13 +43,13 @@
 
 #include "spdk_internal/bdev.h"
 
-struct blockdev_aio_task {
+struct bdev_aio_task {
 	struct iocb			iocb;
 	uint64_t			len;
-	TAILQ_ENTRY(blockdev_aio_task)	link;
+	TAILQ_ENTRY(bdev_aio_task)	link;
 };
 
-struct blockdev_aio_io_channel {
+struct bdev_aio_io_channel {
 	io_context_t		io_ctx;
 	long			queue_depth;
 	struct io_event		*events;
@@ -66,9 +66,9 @@ struct file_disk {
 	 * For storing I/O that were completed synchronously, and will be
 	 *   completed during next check_io call.
 	 */
-	TAILQ_HEAD(, blockdev_aio_task) sync_completion_list;
+	TAILQ_HEAD(, bdev_aio_task) sync_completion_list;
 };
 
 struct spdk_bdev *create_aio_disk(const char *name, const char *fname);
 
-#endif // SPDK_BLOCKDEV_AIO_H
+#endif // SPDK_BDEV_AIO_H
diff --git a/lib/bdev/aio/blockdev_aio_rpc.c b/lib/bdev/aio/bdev_aio_rpc.c
similarity index 99%
rename from lib/bdev/aio/blockdev_aio_rpc.c
rename to lib/bdev/aio/bdev_aio_rpc.c
index 9ea363cd7..9f59d7fe3 100644
--- a/lib/bdev/aio/blockdev_aio_rpc.c
+++ b/lib/bdev/aio/bdev_aio_rpc.c
@@ -31,7 +31,7 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "blockdev_aio.h"
+#include "bdev_aio.h"
 #include "spdk/rpc.h"
 #include "spdk/util.h"
 
diff --git a/lib/bdev/bdev.c b/lib/bdev/bdev.c
index a8ae347a7..03a3761ad 100644
--- a/lib/bdev/bdev.c
+++ b/lib/bdev/bdev.c
@@ -475,7 +475,7 @@ spdk_bdev_initialize(spdk_bdev_init_cb cb_fn, void *cb_arg,
 	g_bdev_mgr.start_poller_fn = start_poller_fn;
 	g_bdev_mgr.stop_poller_fn = stop_poller_fn;
 
-	g_bdev_mgr.bdev_io_pool = spdk_mempool_create("blockdev_io",
+	g_bdev_mgr.bdev_io_pool = spdk_mempool_create("bdev_io",
 				  SPDK_BDEV_IO_POOL_SIZE,
 				  sizeof(struct spdk_bdev_io) +
 				  spdk_bdev_module_get_max_ctx_size(),
@@ -805,7 +805,7 @@ spdk_bdev_io_valid(struct spdk_bdev *bdev, uint64_t offset, uint64_t nbytes)
 		return -1;
 	}
 
-	/* Return failure if offset + nbytes exceeds the size of the blockdev */
+	/* Return failure if offset + nbytes exceeds the size of the bdev */
 	if (offset + nbytes > bdev->blockcnt * bdev->blocklen) {
 		return -1;
 	}
@@ -903,7 +903,7 @@ spdk_bdev_write(struct spdk_bdev *bdev, struct spdk_io_channel *ch,
 
 	bdev_io = spdk_bdev_get_io();
 	if (!bdev_io) {
-		SPDK_ERRLOG("blockdev_io memory allocation failed duing write\n");
+		SPDK_ERRLOG("bdev_io memory allocation failed duing write\n");
 		return -ENOMEM;
 	}
 
@@ -1238,7 +1238,7 @@ spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status sta
 	if (bdev_io->type == SPDK_BDEV_IO_TYPE_RESET) {
 		/* Successful reset */
 		if (status == SPDK_BDEV_IO_STATUS_SUCCESS) {
-			/* Increase the blockdev generation */
+			/* Increase the bdev generation */
 			bdev_io->bdev->gencnt++;
 		}
 		bdev_io->bdev->reset_in_progress = false;
diff --git a/lib/bdev/error/vbdev_error.c b/lib/bdev/error/vbdev_error.c
index 24aae4da6..fd12370fe 100644
--- a/lib/bdev/error/vbdev_error.c
+++ b/lib/bdev/error/vbdev_error.c
@@ -316,7 +316,7 @@ vbdev_error_examine(struct spdk_bdev *bdev)
 
 		base_bdev_name = spdk_conf_section_get_nmval(sp, "BdevError", i, 0);
 		if (!base_bdev_name) {
-			SPDK_ERRLOG("ErrorInjection configuration missing blockdev name\n");
+			SPDK_ERRLOG("ErrorInjection configuration missing bdev name\n");
 			break;
 		}
 
diff --git a/lib/bdev/error/vbdev_error.h b/lib/bdev/error/vbdev_error.h
index 6e7be6512..f43ef386b 100644
--- a/lib/bdev/error/vbdev_error.h
+++ b/lib/bdev/error/vbdev_error.h
@@ -31,8 +31,8 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SPDK_BLOCKDEV_ERROR_H
-#define SPDK_BLOCKDEV_ERROR_H
+#ifndef SPDK_VBDEV_ERROR_H
+#define SPDK_VBDEV_ERROR_H
 
 #include "spdk/stdinc.h"
 #include "spdk/bdev.h"
@@ -46,4 +46,4 @@ int spdk_vbdev_error_create(struct spdk_bdev *base_bdev);
 int spdk_vbdev_inject_error(char *name, uint32_t io_type, uint32_t error_type,
 			    uint32_t error_num);
 
-#endif // SPDK_BLOCKDEV_ERROR_H
+#endif // SPDK_VBDEV_ERROR_H
diff --git a/lib/bdev/malloc/Makefile b/lib/bdev/malloc/Makefile
index b971e88c0..a434755de 100644
--- a/lib/bdev/malloc/Makefile
+++ b/lib/bdev/malloc/Makefile
@@ -35,7 +35,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
 CFLAGS += $(ENV_CFLAGS) -I$(SPDK_ROOT_DIR)/lib/bdev/
-C_SRCS = blockdev_malloc.c blockdev_malloc_rpc.c
+C_SRCS = bdev_malloc.c bdev_malloc_rpc.c
 LIBNAME = bdev_malloc
 
 include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk
diff --git a/lib/bdev/malloc/blockdev_malloc.c b/lib/bdev/malloc/bdev_malloc.c
similarity index 77%
rename from lib/bdev/malloc/blockdev_malloc.c
rename to lib/bdev/malloc/bdev_malloc.c
index cafa1b35b..f9ae37e1f 100644
--- a/lib/bdev/malloc/blockdev_malloc.c
+++ b/lib/bdev/malloc/bdev_malloc.c
@@ -34,7 +34,7 @@
 
 #include "spdk/stdinc.h"
 
-#include "blockdev_malloc.h"
+#include "bdev_malloc.h"
 #include "spdk/bdev.h"
 #include "spdk/conf.h"
 #include "spdk/endian.h"
@@ -89,21 +89,21 @@ static struct malloc_disk *g_malloc_disk_head = NULL;
 
 int malloc_disk_count = 0;
 
-static void blockdev_malloc_initialize(void);
-static void blockdev_malloc_finish(void);
-static void blockdev_malloc_get_spdk_running_config(FILE *fp);
+static void bdev_malloc_initialize(void);
+static void bdev_malloc_finish(void);
+static void bdev_malloc_get_spdk_running_config(FILE *fp);
 
 static int
-blockdev_malloc_get_ctx_size(void)
+bdev_malloc_get_ctx_size(void)
 {
 	return sizeof(struct malloc_task) + spdk_copy_task_size();
 }
 
-SPDK_BDEV_MODULE_REGISTER(malloc, blockdev_malloc_initialize, blockdev_malloc_finish,
-			  blockdev_malloc_get_spdk_running_config, blockdev_malloc_get_ctx_size)
+SPDK_BDEV_MODULE_REGISTER(malloc, bdev_malloc_initialize, bdev_malloc_finish,
+			  bdev_malloc_get_spdk_running_config, bdev_malloc_get_ctx_size)
 
 static void
-blockdev_malloc_delete_from_list(struct malloc_disk *malloc_disk)
+bdev_malloc_delete_from_list(struct malloc_disk *malloc_disk)
 {
 	struct malloc_disk *prev = NULL;
 	struct malloc_disk *node = g_malloc_disk_head;
@@ -138,16 +138,16 @@ malloc_disk_free(struct malloc_disk *malloc_disk)
 }
 
 static int
-blockdev_malloc_destruct(void *ctx)
+bdev_malloc_destruct(void *ctx)
 {
 	struct malloc_disk *malloc_disk = ctx;
-	blockdev_malloc_delete_from_list(malloc_disk);
+	bdev_malloc_delete_from_list(malloc_disk);
 	malloc_disk_free(malloc_disk);
 	return 0;
 }
 
 static int
-blockdev_malloc_check_iov_len(struct iovec *iovs, int iovcnt, size_t nbytes)
+bdev_malloc_check_iov_len(struct iovec *iovs, int iovcnt, size_t nbytes)
 {
 	int i;
 
@@ -162,15 +162,15 @@ blockdev_malloc_check_iov_len(struct iovec *iovs, int iovcnt, size_t nbytes)
 }
 
 static void
-blockdev_malloc_readv(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
-		      struct malloc_task *task,
-		      struct iovec *iov, int iovcnt, size_t len, uint64_t offset)
+bdev_malloc_readv(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
+		  struct malloc_task *task,
+		  struct iovec *iov, int iovcnt, size_t len, uint64_t offset)
 {
 	int64_t res = 0;
 	void *src = mdisk->malloc_buf + offset;
 	int i;
 
-	if (blockdev_malloc_check_iov_len(iov, iovcnt, len)) {
+	if (bdev_malloc_check_iov_len(iov, iovcnt, len)) {
 		spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task),
 				      SPDK_BDEV_IO_STATUS_FAILED);
 		return;
@@ -197,15 +197,15 @@ blockdev_malloc_readv(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
 }
 
 static void
-blockdev_malloc_writev(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
-		       struct malloc_task *task,
-		       struct iovec *iov, int iovcnt, size_t len, uint64_t offset)
+bdev_malloc_writev(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
+		   struct malloc_task *task,
+		   struct iovec *iov, int iovcnt, size_t len, uint64_t offset)
 {
 	int64_t res = 0;
 	void *dst = mdisk->malloc_buf + offset;
 	int i;
 
-	if (blockdev_malloc_check_iov_len(iov, iovcnt, len)) {
+	if (bdev_malloc_check_iov_len(iov, iovcnt, len)) {
 		spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task),
 				      SPDK_BDEV_IO_STATUS_FAILED);
 		return;
@@ -232,11 +232,11 @@ blockdev_malloc_writev(struct malloc_disk *mdisk, struct spdk_io_channel *ch,
 }
 
 static int
-blockdev_malloc_unmap(struct malloc_disk *mdisk,
-		      struct spdk_io_channel *ch,
-		      struct malloc_task *task,
-		      struct spdk_scsi_unmap_bdesc *unmap_d,
-		      uint16_t bdesc_count)
+bdev_malloc_unmap(struct malloc_disk *mdisk,
+		  struct spdk_io_channel *ch,
+		  struct malloc_task *task,
+		  struct spdk_scsi_unmap_bdesc *unmap_d,
+		  uint16_t bdesc_count)
 {
 	uint64_t lba, offset, byte_count;
 	uint32_t block_count;
@@ -266,8 +266,8 @@ blockdev_malloc_unmap(struct malloc_disk *mdisk,
 }
 
 static int64_t
-blockdev_malloc_flush(struct malloc_disk *mdisk, struct malloc_task *task,
-		      uint64_t offset, uint64_t nbytes)
+bdev_malloc_flush(struct malloc_disk *mdisk, struct malloc_task *task,
+		  uint64_t offset, uint64_t nbytes)
 {
 	spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task), SPDK_BDEV_IO_STATUS_SUCCESS);
 
@@ -275,14 +275,14 @@ blockdev_malloc_flush(struct malloc_disk *mdisk, struct malloc_task *task,
 }
 
 static int
-blockdev_malloc_reset(struct malloc_disk *mdisk, struct malloc_task *task)
+bdev_malloc_reset(struct malloc_disk *mdisk, struct malloc_task *task)
 {
 	spdk_bdev_io_complete(spdk_bdev_io_from_ctx(task), SPDK_BDEV_IO_STATUS_SUCCESS);
 
 	return 0;
 }
 
-static int _blockdev_malloc_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static int _bdev_malloc_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
 	switch (bdev_io->type) {
 	case SPDK_BDEV_IO_TYPE_READ:
@@ -297,56 +297,56 @@ static int _blockdev_malloc_submit_request(struct spdk_io_channel *ch, struct sp
 			return 0;
 		}
 
-		blockdev_malloc_readv((struct malloc_disk *)bdev_io->bdev->ctxt,
-				      ch,
-				      (struct malloc_task *)bdev_io->driver_ctx,
-				      bdev_io->u.read.iovs,
-				      bdev_io->u.read.iovcnt,
-				      bdev_io->u.read.len,
-				      bdev_io->u.read.offset);
+		bdev_malloc_readv((struct malloc_disk *)bdev_io->bdev->ctxt,
+				  ch,
+				  (struct malloc_task *)bdev_io->driver_ctx,
+				  bdev_io->u.read.iovs,
+				  bdev_io->u.read.iovcnt,
+				  bdev_io->u.read.len,
+				  bdev_io->u.read.offset);
 		return 0;
 
 	case SPDK_BDEV_IO_TYPE_WRITE:
-		blockdev_malloc_writev((struct malloc_disk *)bdev_io->bdev->ctxt,
-				       ch,
-				       (struct malloc_task *)bdev_io->driver_ctx,
-				       bdev_io->u.write.iovs,
-				       bdev_io->u.write.iovcnt,
-				       bdev_io->u.write.len,
-				       bdev_io->u.write.offset);
+		bdev_malloc_writev((struct malloc_disk *)bdev_io->bdev->ctxt,
+				   ch,
+				   (struct malloc_task *)bdev_io->driver_ctx,
+				   bdev_io->u.write.iovs,
+				   bdev_io->u.write.iovcnt,
+				   bdev_io->u.write.len,
+				   bdev_io->u.write.offset);
 		return 0;
 
 	case SPDK_BDEV_IO_TYPE_RESET:
-		return blockdev_malloc_reset((struct malloc_disk *)bdev_io->bdev->ctxt,
-					     (struct malloc_task *)bdev_io->driver_ctx);
+		return bdev_malloc_reset((struct malloc_disk *)bdev_io->bdev->ctxt,
+					 (struct malloc_task *)bdev_io->driver_ctx);
 
 	case SPDK_BDEV_IO_TYPE_FLUSH:
-		return blockdev_malloc_flush((struct malloc_disk *)bdev_io->bdev->ctxt,
-					     (struct malloc_task *)bdev_io->driver_ctx,
-					     bdev_io->u.flush.offset,
-					     bdev_io->u.flush.length);
+		return bdev_malloc_flush((struct malloc_disk *)bdev_io->bdev->ctxt,
+					 (struct malloc_task *)bdev_io->driver_ctx,
+					 bdev_io->u.flush.offset,
+					 bdev_io->u.flush.length);
 
 	case SPDK_BDEV_IO_TYPE_UNMAP:
-		return blockdev_malloc_unmap((struct malloc_disk *)bdev_io->bdev->ctxt,
-					     ch,
-					     (struct malloc_task *)bdev_io->driver_ctx,
-					     bdev_io->u.unmap.unmap_bdesc,
-					     bdev_io->u.unmap.bdesc_count);
+		return bdev_malloc_unmap((struct malloc_disk *)bdev_io->bdev->ctxt,
+					 ch,
+					 (struct malloc_task *)bdev_io->driver_ctx,
+					 bdev_io->u.unmap.unmap_bdesc,
+					 bdev_io->u.unmap.bdesc_count);
 	default:
 		return -1;
 	}
 	return 0;
 }
 
-static void blockdev_malloc_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static void bdev_malloc_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
-	if (_blockdev_malloc_submit_request(ch, bdev_io) < 0) {
+	if (_bdev_malloc_submit_request(ch, bdev_io) < 0) {
 		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
 	}
 }
 
 static bool
-blockdev_malloc_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
+bdev_malloc_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 {
 	switch (io_type) {
 	case SPDK_BDEV_IO_TYPE_READ:
@@ -362,16 +362,16 @@ blockdev_malloc_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 }
 
 static struct spdk_io_channel *
-blockdev_malloc_get_io_channel(void *ctx)
+bdev_malloc_get_io_channel(void *ctx)
 {
 	return spdk_copy_engine_get_io_channel();
 }
 
 static const struct spdk_bdev_fn_table malloc_fn_table = {
-	.destruct		= blockdev_malloc_destruct,
-	.submit_request		= blockdev_malloc_submit_request,
-	.io_type_supported	= blockdev_malloc_io_type_supported,
-	.get_io_channel		= blockdev_malloc_get_io_channel,
+	.destruct		= bdev_malloc_destruct,
+	.submit_request		= bdev_malloc_submit_request,
+	.io_type_supported	= bdev_malloc_io_type_supported,
+	.get_io_channel		= bdev_malloc_get_io_channel,
 };
 
 struct spdk_bdev *create_malloc_disk(uint64_t num_blocks, uint32_t block_size)
@@ -439,7 +439,7 @@ static void free_malloc_disk(struct malloc_disk *mdisk)
 	spdk_dma_free(mdisk);
 }
 
-static void blockdev_malloc_initialize(void)
+static void bdev_malloc_initialize(void)
 {
 	struct spdk_conf_section *sp = spdk_conf_find_section(NULL, "Malloc");
 	int NumberOfLuns, LunSizeInMB, BlockSize, i, rc = 0;
@@ -474,7 +474,7 @@ end:
 	spdk_bdev_module_init_next(rc);
 }
 
-static void blockdev_malloc_finish(void)
+static void bdev_malloc_finish(void)
 {
 	struct malloc_disk *mdisk;
 
@@ -486,7 +486,7 @@ static void blockdev_malloc_finish(void)
 }
 
 static void
-blockdev_malloc_get_spdk_running_config(FILE *fp)
+bdev_malloc_get_spdk_running_config(FILE *fp)
 {
 	int num_malloc_luns = 0;
 	uint64_t malloc_lun_size = 0;
diff --git a/lib/bdev/malloc/blockdev_malloc.h b/lib/bdev/malloc/bdev_malloc.h
similarity index 94%
rename from lib/bdev/malloc/blockdev_malloc.h
rename to lib/bdev/malloc/bdev_malloc.h
index e88c4a6d9..8f1c9a14c 100644
--- a/lib/bdev/malloc/blockdev_malloc.h
+++ b/lib/bdev/malloc/bdev_malloc.h
@@ -31,8 +31,8 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SPDK_BLOCKDEV_MALLOC_H
-#define SPDK_BLOCKDEV_MALLOC_H
+#ifndef SPDK_BDEV_MALLOC_H
+#define SPDK_BDEV_MALLOC_H
 
 #include "spdk/stdinc.h"
 
@@ -40,4 +40,4 @@
 
 struct spdk_bdev *create_malloc_disk(uint64_t num_blocks, uint32_t block_size);
 
-#endif /* SPDK_BLOCKDEV_MALLOC_H */
+#endif /* SPDK_BDEV_MALLOC_H */
diff --git a/lib/bdev/malloc/blockdev_malloc_rpc.c b/lib/bdev/malloc/bdev_malloc_rpc.c
similarity index 99%
rename from lib/bdev/malloc/blockdev_malloc_rpc.c
rename to lib/bdev/malloc/bdev_malloc_rpc.c
index 4f9ea70ba..43e3afd74 100644
--- a/lib/bdev/malloc/blockdev_malloc_rpc.c
+++ b/lib/bdev/malloc/bdev_malloc_rpc.c
@@ -31,7 +31,7 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "blockdev_malloc.h"
+#include "bdev_malloc.h"
 #include "spdk/rpc.h"
 #include "spdk/util.h"
 
diff --git a/lib/bdev/null/Makefile b/lib/bdev/null/Makefile
index c30b9d5a5..6dca7acec 100644
--- a/lib/bdev/null/Makefile
+++ b/lib/bdev/null/Makefile
@@ -35,7 +35,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
 CFLAGS += $(ENV_CFLAGS) -I$(SPDK_ROOT_DIR)/lib/bdev/
-C_SRCS = blockdev_null.c blockdev_null_rpc.c
+C_SRCS = bdev_null.c bdev_null_rpc.c
 LIBNAME = bdev_null
 
 include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk
diff --git a/lib/bdev/null/blockdev_null.c b/lib/bdev/null/bdev_null.c
similarity index 90%
rename from lib/bdev/null/blockdev_null.c
rename to lib/bdev/null/bdev_null.c
index dbc687661..dbdf1ed41 100644
--- a/lib/bdev/null/blockdev_null.c
+++ b/lib/bdev/null/bdev_null.c
@@ -41,7 +41,7 @@
 #include "spdk_internal/bdev.h"
 #include "spdk_internal/log.h"
 
-#include "blockdev_null.h"
+#include "bdev_null.h"
 
 SPDK_DECLARE_BDEV_MODULE(null);
 
@@ -54,13 +54,13 @@ static TAILQ_HEAD(, null_bdev) g_null_bdev_head;
 static void *g_null_read_buf;
 
 static int
-blockdev_null_get_ctx_size(void)
+bdev_null_get_ctx_size(void)
 {
 	return 0;
 }
 
 static int
-blockdev_null_destruct(void *ctx)
+bdev_null_destruct(void *ctx)
 {
 	struct null_bdev *bdev = ctx;
 
@@ -72,7 +72,7 @@ blockdev_null_destruct(void *ctx)
 }
 
 static void
-blockdev_null_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+bdev_null_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
 	switch (bdev_io->type) {
 	case SPDK_BDEV_IO_TYPE_READ:
@@ -96,7 +96,7 @@ blockdev_null_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bd
 }
 
 static bool
-blockdev_null_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
+bdev_null_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 {
 	switch (io_type) {
 	case SPDK_BDEV_IO_TYPE_READ:
@@ -111,16 +111,16 @@ blockdev_null_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 }
 
 static struct spdk_io_channel *
-blockdev_null_get_io_channel(void *ctx)
+bdev_null_get_io_channel(void *ctx)
 {
 	return spdk_get_io_channel(&g_null_bdev_head);
 }
 
 static const struct spdk_bdev_fn_table null_fn_table = {
-	.destruct		= blockdev_null_destruct,
-	.submit_request		= blockdev_null_submit_request,
-	.io_type_supported	= blockdev_null_io_type_supported,
-	.get_io_channel		= blockdev_null_get_io_channel,
+	.destruct		= bdev_null_destruct,
+	.submit_request		= bdev_null_submit_request,
+	.io_type_supported	= bdev_null_io_type_supported,
+	.get_io_channel		= bdev_null_get_io_channel,
 };
 
 struct spdk_bdev *
@@ -179,7 +179,7 @@ null_bdev_destroy_cb(void *io_device, void *ctx_buf)
 }
 
 static void
-blockdev_null_initialize(void)
+bdev_null_initialize(void)
 {
 	struct spdk_conf_section *sp = spdk_conf_find_section(NULL, "Null");
 	uint64_t size_in_mb, num_blocks;
@@ -261,7 +261,7 @@ end:
 }
 
 static void
-blockdev_null_finish(void)
+bdev_null_finish(void)
 {
 	struct null_bdev *bdev, *tmp;
 
@@ -272,7 +272,7 @@ blockdev_null_finish(void)
 }
 
 static void
-blockdev_null_get_spdk_running_config(FILE *fp)
+bdev_null_get_spdk_running_config(FILE *fp)
 {
 	struct null_bdev *bdev;
 	uint64_t null_bdev_size;
@@ -287,7 +287,7 @@ blockdev_null_get_spdk_running_config(FILE *fp)
 	}
 }
 
-SPDK_BDEV_MODULE_REGISTER(null, blockdev_null_initialize, blockdev_null_finish,
-			  blockdev_null_get_spdk_running_config, blockdev_null_get_ctx_size)
+SPDK_BDEV_MODULE_REGISTER(null, bdev_null_initialize, bdev_null_finish,
+			  bdev_null_get_spdk_running_config, bdev_null_get_ctx_size)
 
 SPDK_LOG_REGISTER_TRACE_FLAG("bdev_null", SPDK_TRACE_BDEV_NULL)
diff --git a/lib/bdev/null/blockdev_null.h b/lib/bdev/null/bdev_null.h
similarity index 95%
rename from lib/bdev/null/blockdev_null.h
rename to lib/bdev/null/bdev_null.h
index c96d49a57..0626a2608 100644
--- a/lib/bdev/null/blockdev_null.h
+++ b/lib/bdev/null/bdev_null.h
@@ -31,8 +31,8 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SPDK_BLOCKDEV_NULL_H
-#define SPDK_BLOCKDEV_NULL_H
+#ifndef SPDK_BDEV_NULL_H
+#define SPDK_BDEV_NULL_H
 
 #include "spdk/stdinc.h"
 
@@ -40,4 +40,4 @@ struct spdk_bdev;
 
 struct spdk_bdev *create_null_bdev(const char *name, uint64_t num_blocks, uint32_t block_size);
 
-#endif /* SPDK_BLOCKDEV_NULL_H */
+#endif /* SPDK_BDEV_NULL_H */
diff --git a/lib/bdev/null/blockdev_null_rpc.c b/lib/bdev/null/bdev_null_rpc.c
similarity index 99%
rename from lib/bdev/null/blockdev_null_rpc.c
rename to lib/bdev/null/bdev_null_rpc.c
index 89c8bc480..3af418043 100644
--- a/lib/bdev/null/blockdev_null_rpc.c
+++ b/lib/bdev/null/bdev_null_rpc.c
@@ -37,7 +37,7 @@
 #include "spdk_internal/bdev.h"
 #include "spdk_internal/log.h"
 
-#include "blockdev_null.h"
+#include "bdev_null.h"
 
 struct rpc_construct_null {
 	char *name;
diff --git a/lib/bdev/nvme/Makefile b/lib/bdev/nvme/Makefile
index e4251c261..9b259be3d 100644
--- a/lib/bdev/nvme/Makefile
+++ b/lib/bdev/nvme/Makefile
@@ -35,7 +35,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
 CFLAGS += $(ENV_CFLAGS) -I$(SPDK_ROOT_DIR)/lib/bdev/
-C_SRCS = blockdev_nvme.c blockdev_nvme_rpc.c
+C_SRCS = bdev_nvme.c bdev_nvme_rpc.c
 LIBNAME = bdev_nvme
 
 include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk
diff --git a/lib/bdev/nvme/blockdev_nvme.c b/lib/bdev/nvme/bdev_nvme.c
similarity index 99%
rename from lib/bdev/nvme/blockdev_nvme.c
rename to lib/bdev/nvme/bdev_nvme.c
index c39d49358..74569f865 100644
--- a/lib/bdev/nvme/blockdev_nvme.c
+++ b/lib/bdev/nvme/bdev_nvme.c
@@ -34,7 +34,7 @@
 
 #include "spdk/stdinc.h"
 
-#include "blockdev_nvme.h"
+#include "bdev_nvme.h"
 
 #include "spdk/conf.h"
 #include "spdk/endian.h"
@@ -783,7 +783,7 @@ remove_cb(void *cb_ctx, struct spdk_nvme_ctrlr *ctrlr)
 }
 
 static void
-blockdev_nvme_hotplug(void *arg)
+bdev_nvme_hotplug(void *arg)
 {
 	if (spdk_nvme_probe(NULL, NULL, hotplug_probe_cb, attach_cb, remove_cb) != 0) {
 		SPDK_ERRLOG("spdk_nvme_probe() failed\n");
@@ -984,7 +984,7 @@ bdev_nvme_library_init(void)
 	}
 
 	if (g_nvme_hotplug_enabled) {
-		spdk_bdev_poller_start(&g_hotplug_poller, blockdev_nvme_hotplug, NULL,
+		spdk_bdev_poller_start(&g_hotplug_poller, bdev_nvme_hotplug, NULL,
 				       g_nvme_hotplug_poll_core,
 				       g_nvme_hotplug_poll_timeout_us);
 	}
diff --git a/lib/bdev/nvme/blockdev_nvme.h b/lib/bdev/nvme/bdev_nvme.h
similarity index 95%
rename from lib/bdev/nvme/blockdev_nvme.h
rename to lib/bdev/nvme/bdev_nvme.h
index 4532f7d71..dec9eb799 100644
--- a/lib/bdev/nvme/blockdev_nvme.h
+++ b/lib/bdev/nvme/bdev_nvme.h
@@ -31,8 +31,8 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SPDK_BLOCKDEV_NVME_H
-#define SPDK_BLOCKDEV_NVME_H
+#ifndef SPDK_BDEV_NVME_H
+#define SPDK_BDEV_NVME_H
 
 #include "spdk/stdinc.h"
 
@@ -44,4 +44,4 @@ int spdk_bdev_nvme_create(struct spdk_nvme_transport_id *trid,
 			  const char *base_name,
 			  const char **names, size_t *count);
 
-#endif // SPDK_BLOCKDEV_NVME_H
+#endif // SPDK_BDEV_NVME_H
diff --git a/lib/bdev/nvme/blockdev_nvme_rpc.c b/lib/bdev/nvme/bdev_nvme_rpc.c
similarity index 96%
rename from lib/bdev/nvme/blockdev_nvme_rpc.c
rename to lib/bdev/nvme/bdev_nvme_rpc.c
index 8623cf13d..a2dd916f4 100644
--- a/lib/bdev/nvme/blockdev_nvme_rpc.c
+++ b/lib/bdev/nvme/bdev_nvme_rpc.c
@@ -33,7 +33,7 @@
 
 #include "spdk/stdinc.h"
 
-#include "blockdev_nvme.h"
+#include "bdev_nvme.h"
 
 #include "spdk/string.h"
 #include "spdk/rpc.h"
@@ -71,7 +71,7 @@ static const struct spdk_json_object_decoder rpc_construct_nvme_decoders[] = {
 	{"subnqn", offsetof(struct rpc_construct_nvme, subnqn), spdk_json_decode_string, true},
 };
 
-#define NVME_MAX_BLOCKDEVS_PER_RPC 32
+#define NVME_MAX_BDEVS_PER_RPC 32
 
 static void
 spdk_rpc_construct_nvme_bdev(struct spdk_jsonrpc_request *request,
@@ -80,7 +80,7 @@ spdk_rpc_construct_nvme_bdev(struct spdk_jsonrpc_request *request,
 	struct rpc_construct_nvme req = {};
 	struct spdk_json_write_ctx *w;
 	struct spdk_nvme_transport_id trid = {};
-	const char *names[NVME_MAX_BLOCKDEVS_PER_RPC];
+	const char *names[NVME_MAX_BDEVS_PER_RPC];
 	size_t count;
 	size_t i;
 	int rc;
@@ -121,7 +121,7 @@ spdk_rpc_construct_nvme_bdev(struct spdk_jsonrpc_request *request,
 		snprintf(trid.subnqn, sizeof(trid.subnqn), "%s", req.subnqn);
 	}
 
-	count = NVME_MAX_BLOCKDEVS_PER_RPC;
+	count = NVME_MAX_BDEVS_PER_RPC;
 	if (spdk_bdev_nvme_create(&trid, req.name, names, &count)) {
 		goto invalid;
 	}
diff --git a/lib/bdev/rbd/Makefile b/lib/bdev/rbd/Makefile
index f35785d24..aab57f808 100644
--- a/lib/bdev/rbd/Makefile
+++ b/lib/bdev/rbd/Makefile
@@ -35,7 +35,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
 CFLAGS += -I$(SPDK_ROOT_DIR)/lib/bdev/
-C_SRCS = blockdev_rbd.c blockdev_rbd_rpc.c
+C_SRCS = bdev_rbd.c bdev_rbd_rpc.c
 LIBNAME = bdev_rbd
 
 include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk
diff --git a/lib/bdev/rbd/blockdev_rbd.c b/lib/bdev/rbd/bdev_rbd.c
similarity index 65%
rename from lib/bdev/rbd/blockdev_rbd.c
rename to lib/bdev/rbd/bdev_rbd.c
index 1df08b715..3c45261c8 100644
--- a/lib/bdev/rbd/blockdev_rbd.c
+++ b/lib/bdev/rbd/bdev_rbd.c
@@ -33,7 +33,7 @@
 
 #include "spdk/stdinc.h"
 
-#include "blockdev_rbd.h"
+#include "bdev_rbd.h"
 
 #include <rbd/librbd.h>
 #include <rados/librados.h>
@@ -48,34 +48,34 @@
 
 #include "spdk_internal/bdev.h"
 
-static TAILQ_HEAD(, blockdev_rbd) g_rbds = TAILQ_HEAD_INITIALIZER(g_rbds);
-static int blockdev_rbd_count = 0;
+static TAILQ_HEAD(, bdev_rbd) g_rbds = TAILQ_HEAD_INITIALIZER(g_rbds);
+static int bdev_rbd_count = 0;
 
-struct blockdev_rbd_io {
+struct bdev_rbd_io {
 	rbd_completion_t completion;
 };
 
-struct blockdev_rbd {
+struct bdev_rbd {
 	struct spdk_bdev disk;
 	char *rbd_name;
 	char *pool_name;
 	rbd_image_info_t info;
-	TAILQ_ENTRY(blockdev_rbd) tailq;
+	TAILQ_ENTRY(bdev_rbd) tailq;
 };
 
-struct blockdev_rbd_io_channel {
+struct bdev_rbd_io_channel {
 	rados_ioctx_t io_ctx;
 	rados_t cluster;
 	struct pollfd pfd;
 	rbd_image_t image;
 	rbd_completion_t *comps;
 	uint32_t queue_depth;
-	struct blockdev_rbd *disk;
+	struct bdev_rbd *disk;
 	struct spdk_bdev_poller *poller;
 };
 
 static void
-blockdev_rbd_free(struct blockdev_rbd *rbd)
+bdev_rbd_free(struct bdev_rbd *rbd)
 {
 	if (!rbd) {
 		return;
@@ -88,8 +88,8 @@ blockdev_rbd_free(struct blockdev_rbd *rbd)
 }
 
 static int
-blockdev_rados_context_init(const char *rbd_pool_name, rados_t *cluster,
-			    rados_ioctx_t *io_ctx)
+bdev_rados_context_init(const char *rbd_pool_name, rados_t *cluster,
+			rados_ioctx_t *io_ctx)
 {
 	int ret;
 
@@ -124,14 +124,14 @@ blockdev_rados_context_init(const char *rbd_pool_name, rados_t *cluster,
 }
 
 static int
-blockdev_rbd_init(const char *rbd_pool_name, const char *rbd_name, rbd_image_info_t *info)
+bdev_rbd_init(const char *rbd_pool_name, const char *rbd_name, rbd_image_info_t *info)
 {
 	int ret;
 	rados_t cluster = NULL;
 	rados_ioctx_t io_ctx = NULL;
 	rbd_image_t image = NULL;
 
-	ret = blockdev_rados_context_init(rbd_pool_name, &cluster, &io_ctx);
+	ret = bdev_rados_context_init(rbd_pool_name, &cluster, &io_ctx);
 	if (ret < 0) {
 		SPDK_ERRLOG("Failed to create rados context for rbd_pool=%s\n",
 			    rbd_name);
@@ -158,26 +158,26 @@ err:
 }
 
 static void
-blockdev_rbd_exit(rbd_image_t image)
+bdev_rbd_exit(rbd_image_t image)
 {
 	rbd_flush(image);
 	rbd_close(image);
 }
 
 static void
-blockdev_rbd_finish_aiocb(rbd_completion_t cb, void *arg)
+bdev_rbd_finish_aiocb(rbd_completion_t cb, void *arg)
 {
 	/* Doing nothing here */
 }
 
 static int
-blockdev_rbd_start_aio(rbd_image_t image, struct blockdev_rbd_io *cmd,
-		       void *buf, uint64_t offset, size_t len)
+bdev_rbd_start_aio(rbd_image_t image, struct bdev_rbd_io *cmd,
+		   void *buf, uint64_t offset, size_t len)
 {
 	int ret;
 	struct spdk_bdev_io *bdev_io = spdk_bdev_io_from_ctx(cmd);
 
-	ret = rbd_aio_create_completion((void *)cmd, blockdev_rbd_finish_aiocb,
+	ret = rbd_aio_create_completion((void *)cmd, bdev_rbd_finish_aiocb,
 					&cmd->completion);
 	if (ret < 0) {
 		return -1;
@@ -201,112 +201,112 @@ blockdev_rbd_start_aio(rbd_image_t image, struct blockdev_rbd_io *cmd,
 	return 0;
 }
 
-static void blockdev_rbd_library_init(void);
-static void blockdev_rbd_library_fini(void);
+static void bdev_rbd_library_init(void);
+static void bdev_rbd_library_fini(void);
 
 static int
-blockdev_rbd_get_ctx_size(void)
+bdev_rbd_get_ctx_size(void)
 {
-	return sizeof(struct blockdev_rbd_io);
+	return sizeof(struct bdev_rbd_io);
 }
 
-SPDK_BDEV_MODULE_REGISTER(rbd, blockdev_rbd_library_init, blockdev_rbd_library_fini, NULL,
-			  blockdev_rbd_get_ctx_size)
+SPDK_BDEV_MODULE_REGISTER(rbd, bdev_rbd_library_init, bdev_rbd_library_fini, NULL,
+			  bdev_rbd_get_ctx_size)
 
 static int64_t
-blockdev_rbd_readv(struct blockdev_rbd *disk, struct spdk_io_channel *ch,
-		   struct blockdev_rbd_io *cmd, struct iovec *iov,
-		   int iovcnt, size_t len, uint64_t offset)
+bdev_rbd_readv(struct bdev_rbd *disk, struct spdk_io_channel *ch,
+	       struct bdev_rbd_io *cmd, struct iovec *iov,
+	       int iovcnt, size_t len, uint64_t offset)
 {
-	struct blockdev_rbd_io_channel *rbdio_ch = spdk_io_channel_get_ctx(ch);
+	struct bdev_rbd_io_channel *rbdio_ch = spdk_io_channel_get_ctx(ch);
 
 	if (iovcnt != 1 || iov->iov_len != len)
 		return -1;
 
-	return blockdev_rbd_start_aio(rbdio_ch->image, cmd, iov->iov_base, offset, len);
+	return bdev_rbd_start_aio(rbdio_ch->image, cmd, iov->iov_base, offset, len);
 }
 
 static int64_t
-blockdev_rbd_writev(struct blockdev_rbd *disk, struct spdk_io_channel *ch,
-		    struct blockdev_rbd_io *cmd, struct iovec *iov,
-		    int iovcnt, size_t len, uint64_t offset)
+bdev_rbd_writev(struct bdev_rbd *disk, struct spdk_io_channel *ch,
+		struct bdev_rbd_io *cmd, struct iovec *iov,
+		int iovcnt, size_t len, uint64_t offset)
 {
-	struct blockdev_rbd_io_channel *rbdio_ch = spdk_io_channel_get_ctx(ch);
+	struct bdev_rbd_io_channel *rbdio_ch = spdk_io_channel_get_ctx(ch);
 
 	if ((iovcnt != 1) || (iov->iov_len != len))
 		return -1;
 
-	return blockdev_rbd_start_aio(rbdio_ch->image, cmd, (void *)iov->iov_base, offset, len);
+	return bdev_rbd_start_aio(rbdio_ch->image, cmd, (void *)iov->iov_base, offset, len);
 }
 
 static int64_t
-blockdev_rbd_flush(struct blockdev_rbd *disk, struct spdk_io_channel *ch,
-		   struct blockdev_rbd_io *cmd, uint64_t offset, uint64_t nbytes)
+bdev_rbd_flush(struct bdev_rbd *disk, struct spdk_io_channel *ch,
+	       struct bdev_rbd_io *cmd, uint64_t offset, uint64_t nbytes)
 {
-	struct blockdev_rbd_io_channel *rbdio_ch = spdk_io_channel_get_ctx(ch);
+	struct bdev_rbd_io_channel *rbdio_ch = spdk_io_channel_get_ctx(ch);
 
-	return blockdev_rbd_start_aio(rbdio_ch->image, cmd, NULL, offset, nbytes);
+	return bdev_rbd_start_aio(rbdio_ch->image, cmd, NULL, offset, nbytes);
 }
 
 static int
-blockdev_rbd_destruct(void *ctx)
+bdev_rbd_destruct(void *ctx)
 {
 	return 0;
 }
 
-static void blockdev_rbd_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static void bdev_rbd_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
 	int ret;
 
-	ret = blockdev_rbd_readv(bdev_io->bdev->ctxt,
-				 ch,
-				 (struct blockdev_rbd_io *)bdev_io->driver_ctx,
-				 bdev_io->u.read.iovs,
-				 bdev_io->u.read.iovcnt,
-				 bdev_io->u.read.len,
-				 bdev_io->u.read.offset);
+	ret = bdev_rbd_readv(bdev_io->bdev->ctxt,
+			     ch,
+			     (struct bdev_rbd_io *)bdev_io->driver_ctx,
+			     bdev_io->u.read.iovs,
+			     bdev_io->u.read.iovcnt,
+			     bdev_io->u.read.len,
+			     bdev_io->u.read.offset);
 
 	if (ret != 0) {
 		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
 	}
 }
 
-static int _blockdev_rbd_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static int _bdev_rbd_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
 	switch (bdev_io->type) {
 	case SPDK_BDEV_IO_TYPE_READ:
-		spdk_bdev_io_get_buf(bdev_io, blockdev_rbd_get_buf_cb);
+		spdk_bdev_io_get_buf(bdev_io, bdev_rbd_get_buf_cb);
 		return 0;
 
 	case SPDK_BDEV_IO_TYPE_WRITE:
-		return blockdev_rbd_writev((struct blockdev_rbd *)bdev_io->bdev->ctxt,
-					   ch,
-					   (struct blockdev_rbd_io *)bdev_io->driver_ctx,
-					   bdev_io->u.write.iovs,
-					   bdev_io->u.write.iovcnt,
-					   bdev_io->u.write.len,
-					   bdev_io->u.write.offset);
+		return bdev_rbd_writev((struct bdev_rbd *)bdev_io->bdev->ctxt,
+				       ch,
+				       (struct bdev_rbd_io *)bdev_io->driver_ctx,
+				       bdev_io->u.write.iovs,
+				       bdev_io->u.write.iovcnt,
+				       bdev_io->u.write.len,
+				       bdev_io->u.write.offset);
 	case SPDK_BDEV_IO_TYPE_FLUSH:
-		return blockdev_rbd_flush((struct blockdev_rbd *)bdev_io->bdev->ctxt,
-					  ch,
-					  (struct blockdev_rbd_io *)bdev_io->driver_ctx,
-					  bdev_io->u.flush.offset,
-					  bdev_io->u.flush.length);
+		return bdev_rbd_flush((struct bdev_rbd *)bdev_io->bdev->ctxt,
+				      ch,
+				      (struct bdev_rbd_io *)bdev_io->driver_ctx,
+				      bdev_io->u.flush.offset,
+				      bdev_io->u.flush.length);
 	default:
 		return -1;
 	}
 	return 0;
 }
 
-static void blockdev_rbd_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+static void bdev_rbd_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
-	if (_blockdev_rbd_submit_request(ch, bdev_io) < 0) {
+	if (_bdev_rbd_submit_request(ch, bdev_io) < 0) {
 		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
 	}
 }
 
 static bool
-blockdev_rbd_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
+bdev_rbd_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 {
 	switch (io_type) {
 	case SPDK_BDEV_IO_TYPE_READ:
@@ -320,10 +320,10 @@ blockdev_rbd_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
 }
 
 static void
-blockdev_rbd_io_poll(void *arg)
+bdev_rbd_io_poll(void *arg)
 {
-	struct blockdev_rbd_io_channel *ch = arg;
-	struct blockdev_rbd_io *req;
+	struct bdev_rbd_io_channel *ch = arg;
+	struct bdev_rbd_io *req;
 	struct spdk_bdev_io *bdev_io;
 	int i, io_status, status, rc;
 
@@ -336,7 +336,7 @@ blockdev_rbd_io_poll(void *arg)
 
 	rc = rbd_poll_io_events(ch->image, ch->comps, ch->queue_depth);
 	for (i = 0; i < rc; i++) {
-		req = (struct blockdev_rbd_io *)rbd_aio_get_arg(ch->comps[i]);
+		req = (struct bdev_rbd_io *)rbd_aio_get_arg(ch->comps[i]);
 		bdev_io = spdk_bdev_io_from_ctx(req);
 		io_status = rbd_aio_get_return_value(ch->comps[i]);
 		if (bdev_io->type == SPDK_BDEV_IO_TYPE_READ) {
@@ -359,14 +359,14 @@ blockdev_rbd_io_poll(void *arg)
 }
 
 static void
-blockdev_rbd_free_channel(struct blockdev_rbd_io_channel *ch)
+bdev_rbd_free_channel(struct bdev_rbd_io_channel *ch)
 {
 	if (!ch) {
 		return;
 	}
 
 	if (ch->image) {
-		blockdev_rbd_exit(ch->image);
+		bdev_rbd_exit(ch->image);
 	}
 
 	if (ch->io_ctx) {
@@ -387,9 +387,9 @@ blockdev_rbd_free_channel(struct blockdev_rbd_io_channel *ch)
 }
 
 static void *
-blockdev_rbd_handle(void *arg)
+bdev_rbd_handle(void *arg)
 {
-	struct blockdev_rbd_io_channel *ch = arg;
+	struct bdev_rbd_io_channel *ch = arg;
 	void *ret = arg;
 
 	if (rbd_open(ch->io_ctx, ch->disk->rbd_name, &ch->image, NULL) < 0) {
@@ -401,24 +401,24 @@ blockdev_rbd_handle(void *arg)
 }
 
 static int
-blockdev_rbd_create_cb(void *io_device, void *ctx_buf)
+bdev_rbd_create_cb(void *io_device, void *ctx_buf)
 {
-	struct blockdev_rbd_io_channel *ch = ctx_buf;
+	struct bdev_rbd_io_channel *ch = ctx_buf;
 	int ret;
 
-	ch->disk = (struct blockdev_rbd *)((uintptr_t)io_device - offsetof(struct blockdev_rbd, info));
+	ch->disk = (struct bdev_rbd *)((uintptr_t)io_device - offsetof(struct bdev_rbd, info));
 	ch->image = NULL;
 	ch->io_ctx = NULL;
 	ch->pfd.fd = -1;
 
-	ret = blockdev_rados_context_init(ch->disk->pool_name, &ch->cluster, &ch->io_ctx);
+	ret = bdev_rados_context_init(ch->disk->pool_name, &ch->cluster, &ch->io_ctx);
 	if (ret < 0) {
 		SPDK_ERRLOG("Failed to create rados context for rbd_pool=%s\n",
 			    ch->disk->pool_name);
 		goto err;
 	}
 
-	if (spdk_call_unaffinitized(blockdev_rbd_handle, ch) == NULL) {
+	if (spdk_call_unaffinitized(bdev_rbd_handle, ch) == NULL) {
 		goto err;
 	}
 
@@ -442,95 +442,95 @@ blockdev_rbd_create_cb(void *io_device, void *ctx_buf)
 		goto err;
 	}
 
-	spdk_bdev_poller_start(&ch->poller, blockdev_rbd_io_poll, ch,
+	spdk_bdev_poller_start(&ch->poller, bdev_rbd_io_poll, ch,
 			       spdk_env_get_current_core(), 0);
 
 	return 0;
 
 err:
-	blockdev_rbd_free_channel(ch);
+	bdev_rbd_free_channel(ch);
 	return -1;
 }
 
 static void
-blockdev_rbd_destroy_cb(void *io_device, void *ctx_buf)
+bdev_rbd_destroy_cb(void *io_device, void *ctx_buf)
 {
-	struct blockdev_rbd_io_channel *io_channel = ctx_buf;
+	struct bdev_rbd_io_channel *io_channel = ctx_buf;
 
-	blockdev_rbd_free_channel(io_channel);
+	bdev_rbd_free_channel(io_channel);
 
 	spdk_bdev_poller_stop(&io_channel->poller);
 }
 
 static struct spdk_io_channel *
-blockdev_rbd_get_io_channel(void *ctx)
+bdev_rbd_get_io_channel(void *ctx)
 {
-	struct blockdev_rbd *rbd_bdev = ctx;
+	struct bdev_rbd *rbd_bdev = ctx;
 
 	return spdk_get_io_channel(&rbd_bdev->info);
 }
 
 static const struct spdk_bdev_fn_table rbd_fn_table = {
-	.destruct		= blockdev_rbd_destruct,
-	.submit_request		= blockdev_rbd_submit_request,
-	.io_type_supported	= blockdev_rbd_io_type_supported,
-	.get_io_channel		= blockdev_rbd_get_io_channel,
+	.destruct		= bdev_rbd_destruct,
+	.submit_request		= bdev_rbd_submit_request,
+	.io_type_supported	= bdev_rbd_io_type_supported,
+	.get_io_channel		= bdev_rbd_get_io_channel,
 };
 
 static void
-blockdev_rbd_library_fini(void)
+bdev_rbd_library_fini(void)
 {
-	struct blockdev_rbd *rbd;
+	struct bdev_rbd *rbd;
 
 	while (!TAILQ_EMPTY(&g_rbds)) {
 		rbd = TAILQ_FIRST(&g_rbds);
 		TAILQ_REMOVE(&g_rbds, rbd, tailq);
-		blockdev_rbd_free(rbd);
+		bdev_rbd_free(rbd);
 	}
 }
 
 struct spdk_bdev *
 spdk_bdev_rbd_create(const char *pool_name, const char *rbd_name, uint32_t block_size)
 {
-	struct blockdev_rbd *rbd;
+	struct bdev_rbd *rbd;
 	int ret;
 
 	if ((pool_name == NULL) || (rbd_name == NULL)) {
 		return NULL;
 	}
 
-	rbd = calloc(1, sizeof(struct blockdev_rbd));
+	rbd = calloc(1, sizeof(struct bdev_rbd));
 	if (rbd == NULL) {
-		SPDK_ERRLOG("Failed to allocate blockdev_rbd struct\n");
+		SPDK_ERRLOG("Failed to allocate bdev_rbd struct\n");
 		return NULL;
 	}
 
 	rbd->rbd_name = strdup(rbd_name);
 	if (!rbd->rbd_name) {
-		blockdev_rbd_free(rbd);
+		bdev_rbd_free(rbd);
 		return NULL;
 	}
 
 	rbd->pool_name = strdup(pool_name);
 	if (!rbd->pool_name) {
-		blockdev_rbd_free(rbd);
+		bdev_rbd_free(rbd);
 		return NULL;
 	}
 
-	ret = blockdev_rbd_init(rbd->pool_name, rbd_name, &rbd->info);
+	ret = bdev_rbd_init(rbd->pool_name, rbd_name, &rbd->info);
 	if (ret < 0) {
-		blockdev_rbd_free(rbd);
+		bdev_rbd_free(rbd);
 		SPDK_ERRLOG("Failed to init rbd device\n");
 		return NULL;
 	}
 
-	rbd->disk.name = spdk_sprintf_alloc("Ceph%d", blockdev_rbd_count);
+	rbd->disk.name = spdk_sprintf_alloc("Ceph%d", bdev_rbd_count);
 	if (!rbd->disk.name) {
-		blockdev_rbd_free(rbd);
+		bdev_rbd_free(rbd);
 		return NULL;
 	}
 	rbd->disk.product_name = "Ceph Rbd Disk";
-	blockdev_rbd_count++;
+	bdev_rbd_count++;
 
 	rbd->disk.write_cache = 0;
 	rbd->disk.blocklen = block_size;
@@ -542,15 +542,15 @@ spdk_bdev_rbd_create(const char *pool_name, const char *rbd_name, uint32_t block
 	SPDK_NOTICELOG("Add %s rbd disk to lun\n", rbd->disk.name);
 	TAILQ_INSERT_TAIL(&g_rbds, rbd, tailq);
 
-	spdk_io_device_register(&rbd->info, blockdev_rbd_create_cb,
-				blockdev_rbd_destroy_cb,
-				sizeof(struct blockdev_rbd_io_channel));
+	spdk_io_device_register(&rbd->info, bdev_rbd_create_cb,
+				bdev_rbd_destroy_cb,
+				sizeof(struct bdev_rbd_io_channel));
 	spdk_bdev_register(&rbd->disk);
 	return &rbd->disk;
 }
 
 static void
-blockdev_rbd_library_init(void)
+bdev_rbd_library_init(void)
 {
 	int i, rc = 0;
 	const char *val;
diff --git a/lib/bdev/rbd/blockdev_rbd.h b/lib/bdev/rbd/bdev_rbd.h
similarity index 95%
rename from lib/bdev/rbd/blockdev_rbd.h
rename to lib/bdev/rbd/bdev_rbd.h
index bbc2ca563..397d710f9 100644
--- a/lib/bdev/rbd/blockdev_rbd.h
+++ b/lib/bdev/rbd/bdev_rbd.h
@@ -31,8 +31,8 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SPDK_BLOCKDEV_RBD_H
-#define SPDK_BLOCKDEV_RBD_H
+#ifndef SPDK_BDEV_RBD_H
+#define SPDK_BDEV_RBD_H
 
 #include "spdk/stdinc.h"
 
@@ -41,4 +41,4 @@
 struct spdk_bdev *spdk_bdev_rbd_create(const char *pool_name, const char *rbd_name,
 				       uint32_t block_size);
 
-#endif // SPDK_BLOCKDEV_RBD_H
+#endif // SPDK_BDEV_RBD_H
diff --git a/lib/bdev/rbd/blockdev_rbd_rpc.c b/lib/bdev/rbd/bdev_rbd_rpc.c
similarity index 99%
rename from lib/bdev/rbd/blockdev_rbd_rpc.c
rename to lib/bdev/rbd/bdev_rbd_rpc.c
index a20b8bbe9..f939b7cf4 100644
--- a/lib/bdev/rbd/blockdev_rbd_rpc.c
+++ b/lib/bdev/rbd/bdev_rbd_rpc.c
@@ -31,7 +31,7 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "blockdev_rbd.h"
+#include "bdev_rbd.h"
 #include "spdk/rpc.h"
 #include "spdk/util.h"
 
diff --git a/lib/bdev/split/vbdev_split.c b/lib/bdev/split/vbdev_split.c
index 33a8abd5f..23e6c0dc9 100644
--- a/lib/bdev/split/vbdev_split.c
+++ b/lib/bdev/split/vbdev_split.c
@@ -369,7 +369,7 @@ vbdev_split_examine(struct spdk_bdev *bdev)
 
 		base_bdev_name = spdk_conf_section_get_nmval(sp, "Split", i, 0);
 		if (!base_bdev_name) {
-			SPDK_ERRLOG("Split configuration missing blockdev name\n");
+			SPDK_ERRLOG("Split configuration missing bdev name\n");
 			break;
 		}
 
diff --git a/lib/scsi/lun.c b/lib/scsi/lun.c
index 36ca08b5b..88a243261 100644
--- a/lib/scsi/lun.c
+++ b/lib/scsi/lun.c
@@ -249,9 +249,9 @@ spdk_scsi_lun_hot_remove(void *remove_ctx)
  * \brief Constructs a new spdk_scsi_lun object based on the provided parameters.
  *
  * \param name Name for the SCSI LUN.
- * \param blockdev  Blockdev associated with this LUN
+ * \param bdev  bdev associated with this LUN
  *
- * \return NULL if blockdev == NULL
+ * \return NULL if bdev == NULL
  * \return pointer to the new spdk_scsi_lun object otherwise
  */
 _spdk_scsi_lun *
@@ -262,7 +262,7 @@ spdk_scsi_lun_construct(const char *name, struct spdk_bdev *bdev,
 	int rc;
 
 	if (bdev == NULL) {
-		SPDK_ERRLOG("blockdev must be non-NULL\n");
+		SPDK_ERRLOG("bdev must be non-NULL\n");
 		return NULL;
 	}
 
diff --git a/lib/scsi/scsi_bdev.c b/lib/scsi/scsi_bdev.c
index 483685c14..f29ed2406 100644
--- a/lib/scsi/scsi_bdev.c
+++ b/lib/scsi/scsi_bdev.c
@@ -1249,7 +1249,7 @@ spdk_bdev_scsi_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success,
 	struct spdk_scsi_task *task = cb_arg;
 	int sc, sk, asc, ascq;
 
-	task->blockdev_io = bdev_io;
+	task->bdev_io = bdev_io;
 
 	spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq);
 	spdk_scsi_task_set_status(task, sc, sk, asc, ascq);
@@ -1262,7 +1262,7 @@ spdk_bdev_scsi_task_complete_mgmt(struct spdk_bdev_io *bdev_io, bool success,
 {
 	struct spdk_scsi_task *task = cb_arg;
 
-	task->blockdev_io = bdev_io;
+	task->bdev_io = bdev_io;
 
 	if (success) {
 		task->response = SPDK_SCSI_TASK_MGMT_RESP_SUCCESS;
diff --git a/lib/scsi/scsi_internal.h b/lib/scsi/scsi_internal.h
index bcaf9fdac..1d1049d56 100644
--- a/lib/scsi/scsi_internal.h
+++ b/lib/scsi/scsi_internal.h
@@ -78,13 +78,13 @@ struct spdk_scsi_lun {
 	/** Pointer to the SCSI device containing this LUN. */
 	struct spdk_scsi_dev *dev;
 
-	/** The blockdev associated with this LUN. */
+	/** The bdev associated with this LUN. */
 	struct spdk_bdev *bdev;
 
 	/** Descriptor for opened block device. */
 	struct spdk_bdev_desc *bdev_desc;
 
-	/** I/O channel for the blockdev associated with this LUN. */
+	/** I/O channel for the bdev associated with this LUN. */
 	struct spdk_io_channel *io_channel;
 
 	/** Thread ID for the thread that allocated the I/O channel for this
diff --git a/lib/scsi/task.c b/lib/scsi/task.c
index bde28a974..9279a6154 100644
--- a/lib/scsi/task.c
+++ b/lib/scsi/task.c
@@ -47,7 +47,7 @@ spdk_scsi_task_put(struct spdk_scsi_task *task)
 	task->ref--;
 
 	if (task->ref == 0) {
-		struct spdk_bdev_io *bdev_io = task->blockdev_io;
+		struct spdk_bdev_io *bdev_io = task->bdev_io;
 
 		if (task->parent) {
 			spdk_scsi_task_put(task->parent);