diff --git a/configure.d/1_alloc_disk.conf b/configure.d/1_alloc_disk.conf
index ba76ae9..6ec8d95 100644
--- a/configure.d/1_alloc_disk.conf
+++ b/configure.d/1_alloc_disk.conf
@@ -34,7 +34,7 @@ apply() {
 		return 0;
         }"
 	add_function "
-	static inline void cas_cleanup_mq_disk(struct casdsk_exp_obj *exp_obj)
+	static inline void cas_cleanup_mq_disk(struct cas_exp_obj *exp_obj)
 	{
 		blk_cleanup_disk(exp_obj->gd);
 	}"
@@ -61,7 +61,7 @@ apply() {
         }"
 
 	add_function "
-	static inline void cas_cleanup_mq_disk(struct casdsk_exp_obj *exp_obj){
+	static inline void cas_cleanup_mq_disk(struct cas_exp_obj *exp_obj){
 		blk_cleanup_queue(exp_obj->queue);
 		put_disk(exp_obj->gd);
 	}"
diff --git a/modules/cas_cache/cas_cache.h b/modules/cas_cache/cas_cache.h
index 6d295a1..23b3eb4 100644
--- a/modules/cas_cache/cas_cache.h
+++ b/modules/cas_cache/cas_cache.h
@@ -50,7 +50,7 @@ enum {
 /** \endcond */
 };
 
-struct casdsk_module {
+struct cas_module {
 	struct list_head disk_list;
 	uint32_t next_disk_id;
 	int disk_major;
@@ -62,7 +62,7 @@ struct casdsk_module {
 	struct kobject kobj;
 };
 
-extern struct casdsk_module *casdsk_module;
+extern struct cas_module cas_module;
 
 struct cas_classifier;
 
diff --git a/modules/cas_cache/debug.h b/modules/cas_cache/debug.h
index 61825f9..cc7d2b1 100644
--- a/modules/cas_cache/debug.h
+++ b/modules/cas_cache/debug.h
@@ -5,41 +5,41 @@
 #ifndef __CASDISK_DEBUG_H__
 #define __CASDISK_DEBUG_H__
 
-#undef CASDSK_DEBUG
+#undef CAS_DEBUG
 
-#ifdef CASDSK_DEBUG
-#define CASDSK_DEBUG_TRACE()						\
+#ifdef CAS_DEBUG
+#define CAS_DEBUG_TRACE()						\
 	printk(KERN_INFO "%s\n", __func__)
 
-#define CASDSK_DEBUG_DISK_TRACE(dsk)					\
+#define CAS_DEBUG_DISK_TRACE(dsk)					\
 	printk(KERN_INFO "[%u] %s\n", dsk->id,  __func__)
 
-#define CASDSK_DEBUG_MSG(msg)						\
+#define CAS_DEBUG_MSG(msg)						\
 	printk(KERN_INFO "%s - %s\n", __func__, msg)
 
-#define CASDSK_DEBUG_PARAM(format, ...)					\
+#define CAS_DEBUG_PARAM(format, ...)					\
 	printk(KERN_INFO "%s - "format"\n",			\
 	       __func__, ##__VA_ARGS__)
 
-#define CASDSK_DEBUG_DISK(dsk, format, ...)				\
+#define CAS_DEBUG_DISK(dsk, format, ...)				\
 	printk(KERN_INFO "[%u] %s - "format"\n",			\
 	       dsk->id,							\
 	       __func__, ##__VA_ARGS__)
 
-#define CASDSK_DEBUG_ERROR(error, ...)					\
-	CASDSK_DEBUG_PARAM("ERROR(%d) "error, __LINE__, ##__VA_ARGS__)
+#define CAS_DEBUG_ERROR(error, ...)					\
+	CAS_DEBUG_PARAM("ERROR(%d) "error, __LINE__, ##__VA_ARGS__)
 
-#define CASDSK_DEBUG_DISK_ERROR(dsk, error, ...)				\
-	CASDSK_DEBUG_DISK(dsk, "ERROR(%d) "error, __LINE__, ##__VA_ARGS__)
+#define CAS_DEBUG_DISK_ERROR(dsk, error, ...)				\
+	CAS_DEBUG_DISK(dsk, "ERROR(%d) "error, __LINE__, ##__VA_ARGS__)
 
 #else
-#define CASDSK_DEBUG_TRACE()
-#define CASDSK_DEBUG_DISK_TRACE(dsk)
-#define CASDSK_DEBUG_MSG(msg)
-#define CASDSK_DEBUG_PARAM(format, ...)
-#define CASDSK_DEBUG_DISK(dsk, format, ...)
-#define CASDSK_DEBUG_ERROR(error, ...)
-#define CASDSK_DEBUG_DISK_ERROR(dsk, error, ...)
+#define CAS_DEBUG_TRACE()
+#define CAS_DEBUG_DISK_TRACE(dsk)
+#define CAS_DEBUG_MSG(msg)
+#define CAS_DEBUG_PARAM(format, ...)
+#define CAS_DEBUG_DISK(dsk, format, ...)
+#define CAS_DEBUG_ERROR(error, ...)
+#define CAS_DEBUG_DISK_ERROR(dsk, error, ...)
 #endif
 
 #endif
diff --git a/modules/cas_cache/disk.c b/modules/cas_cache/disk.c
index 4069579..37d38db 100644
--- a/modules/cas_cache/disk.c
+++ b/modules/cas_cache/disk.c
@@ -11,11 +11,11 @@
 #include "exp_obj.h"
 #include "debug.h"
 
-#define CASDSK_DISK_OPEN_FMODE (FMODE_READ | FMODE_WRITE)
+#define CAS_DISK_OPEN_FMODE (FMODE_READ | FMODE_WRITE)
 
-static inline struct casdsk_disk *casdsk_kobj_to_disk(struct kobject *kobj)
+static inline struct cas_disk *cas_kobj_to_disk(struct kobject *kobj)
 {
-	return container_of(kobj, struct casdsk_disk, kobj);
+	return container_of(kobj, struct cas_disk, kobj);
 }
 
 static inline struct block_device *open_bdev_exclusive(const char *path,
@@ -30,85 +30,85 @@ static inline void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)
 	blkdev_put(bdev, mode | FMODE_EXCL);
 }
 
-static void _casdsk_disk_release(struct kobject *kobj)
+static void _cas_disk_release(struct kobject *kobj)
 {
-	struct casdsk_disk *dsk;
+	struct cas_disk *dsk;
 
 	BUG_ON(!kobj);
 
-	dsk = casdsk_kobj_to_disk(kobj);
+	dsk = cas_kobj_to_disk(kobj);
 	BUG_ON(!dsk);
 
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
 	kfree(dsk->path);
 
-	kmem_cache_free(casdsk_module->disk_cache, dsk);
+	kmem_cache_free(cas_module.disk_cache, dsk);
 }
 
-static struct kobj_type casdsk_disk_ktype = {
-	.release = _casdsk_disk_release,
+static struct kobj_type cas_disk_ktype = {
+	.release = _cas_disk_release,
 };
 
-int __init casdsk_init_disks(void)
+int __init cas_init_disks(void)
 {
-	CASDSK_DEBUG_TRACE();
+	CAS_DEBUG_TRACE();
 
-	casdsk_module->next_disk_id = 1;
-	INIT_LIST_HEAD(&casdsk_module->disk_list);
+	cas_module.next_disk_id = 1;
+	INIT_LIST_HEAD(&cas_module.disk_list);
 
-	casdsk_module->disk_major = register_blkdev(casdsk_module->disk_major,
+	cas_module.disk_major = register_blkdev(cas_module.disk_major,
 						  "cas");
-	if (casdsk_module->disk_major <= 0) {
-		CASDSK_DEBUG_ERROR("Cannot allocate major number");
+	if (cas_module.disk_major <= 0) {
+		CAS_DEBUG_ERROR("Cannot allocate major number");
 		return -EINVAL;
 	}
-	CASDSK_DEBUG_PARAM("Allocated major number: %d", casdsk_module->disk_major);
+	CAS_DEBUG_PARAM("Allocated major number: %d", cas_module.disk_major);
 
-	casdsk_module->disk_cache =
-		kmem_cache_create("casdsk_disk", sizeof(struct casdsk_disk),
+	cas_module.disk_cache =
+		kmem_cache_create("cas_disk", sizeof(struct cas_disk),
 				  0, 0, NULL);
-	if (!casdsk_module->disk_cache) {
-		unregister_blkdev(casdsk_module->disk_major, "cas");
+	if (!cas_module.disk_cache) {
+		unregister_blkdev(cas_module.disk_major, "cas");
 		return -ENOMEM;
 	}
 
 	return 0;
 }
 
-void casdsk_deinit_disks(void)
+void cas_deinit_disks(void)
 {
-	CASDSK_DEBUG_TRACE();
+	CAS_DEBUG_TRACE();
 
-	kmem_cache_destroy(casdsk_module->disk_cache);
-	unregister_blkdev(casdsk_module->disk_major, "cas");
+	kmem_cache_destroy(cas_module.disk_cache);
+	unregister_blkdev(cas_module.disk_major, "cas");
 }
 
-static int _casdsk_disk_init_kobject(struct casdsk_disk *dsk)
+static int _cas_disk_init_kobject(struct cas_disk *dsk)
 {
 	int result = 0;
 
-	kobject_init(&dsk->kobj, &casdsk_disk_ktype);
+	kobject_init(&dsk->kobj, &cas_disk_ktype);
 	result = kobject_add(&dsk->kobj, &disk_to_dev(dsk->bd->bd_disk)->kobj,
 			     "cas%d", dsk->id);
 	if (result)
-		CASDSK_DEBUG_DISK_ERROR(dsk, "Cannot register kobject");
+		CAS_DEBUG_DISK_ERROR(dsk, "Cannot register kobject");
 
 	return result;
 }
 
-struct casdsk_disk *casdsk_disk_open(const char *path, void *private)
+struct cas_disk *cas_disk_open(const char *path, void *private)
 {
-	struct casdsk_disk *dsk;
+	struct cas_disk *dsk;
 	int result = 0;
 
 	BUG_ON(!path);
 
-	CASDSK_DEBUG_TRACE();
+	CAS_DEBUG_TRACE();
 
-	dsk = kmem_cache_zalloc(casdsk_module->disk_cache, GFP_KERNEL);
+	dsk = kmem_cache_zalloc(cas_module.disk_cache, GFP_KERNEL);
 	if (!dsk) {
-		CASDSK_DEBUG_ERROR("Cannot allocate memory");
+		CAS_DEBUG_ERROR("Cannot allocate memory");
 		result = -ENOMEM;
 		goto error_kmem;
 	}
@@ -121,106 +121,106 @@ struct casdsk_disk *casdsk_disk_open(const char *path, void *private)
 		goto error_kstrdup;
 	}
 
-	dsk->bd = open_bdev_exclusive(path, CASDSK_DISK_OPEN_FMODE, dsk);
+	dsk->bd = open_bdev_exclusive(path, CAS_DISK_OPEN_FMODE, dsk);
 	if (IS_ERR(dsk->bd)) {
-		CASDSK_DEBUG_ERROR("Cannot open exclusive");
+		CAS_DEBUG_ERROR("Cannot open exclusive");
 		result = PTR_ERR(dsk->bd);
 		goto error_open_bdev;
 	}
 
 	dsk->private = private;
 
-	dsk->id = casdsk_module->next_disk_id++;
-	list_add(&dsk->list, &casdsk_module->disk_list);
+	dsk->id = cas_module.next_disk_id++;
+	list_add(&dsk->list, &cas_module.disk_list);
 
-	result = _casdsk_disk_init_kobject(dsk);
+	result = _cas_disk_init_kobject(dsk);
 	if (result)
 		goto error_kobject;
 
-	CASDSK_DEBUG_DISK(dsk, "Created (%p)", dsk);
+	CAS_DEBUG_DISK(dsk, "Created (%p)", dsk);
 
 	return dsk;
 
 error_kobject:
 	list_del(&dsk->list);
-	close_bdev_exclusive(dsk->bd, CASDSK_DISK_OPEN_FMODE);
+	close_bdev_exclusive(dsk->bd, CAS_DISK_OPEN_FMODE);
 error_open_bdev:
 	kfree(dsk->path);
 error_kstrdup:
-	kmem_cache_free(casdsk_module->disk_cache, dsk);
+	kmem_cache_free(cas_module.disk_cache, dsk);
 error_kmem:
 	return ERR_PTR(result);
 }
 
-static void _casdsk_disk_claim(struct casdsk_disk *dsk, void *private)
+static void _cas_disk_claim(struct cas_disk *dsk, void *private)
 {
 	dsk->private = private;
 }
 
-struct casdsk_disk *casdsk_disk_claim(const char *path, void *private)
+struct cas_disk *cas_disk_claim(const char *path, void *private)
 {
 	struct list_head *item;
-	struct casdsk_disk *dsk = NULL;
+	struct cas_disk *dsk = NULL;
 
 	BUG_ON(!path);
 
-	list_for_each(item, &casdsk_module->disk_list) {
-		dsk = list_entry(item, struct casdsk_disk, list);
+	list_for_each(item, &cas_module.disk_list) {
+		dsk = list_entry(item, struct cas_disk, list);
 		if (strncmp(path, dsk->path, PATH_MAX) == 0) {
-			_casdsk_disk_claim(dsk, private);
+			_cas_disk_claim(dsk, private);
 			return dsk;
 		}
 	}
 	return NULL;
 }
 
-static void __casdsk_disk_close(struct casdsk_disk *dsk)
+static void __cas_disk_close(struct cas_disk *dsk)
 {
-	close_bdev_exclusive(dsk->bd, CASDSK_DISK_OPEN_FMODE);
+	close_bdev_exclusive(dsk->bd, CAS_DISK_OPEN_FMODE);
 
-	casdsk_exp_obj_free(dsk);
+	cas_exp_obj_free(dsk);
 	kobject_put(&dsk->kobj);
 }
 
-void casdsk_disk_close(struct casdsk_disk *dsk)
+void cas_disk_close(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
 	BUG_ON(!dsk->bd);
 
-	CASDSK_DEBUG_DISK(dsk, "Destroying (%p)", dsk);
+	CAS_DEBUG_DISK(dsk, "Destroying (%p)", dsk);
 
 	list_del(&dsk->list);
 
-	__casdsk_disk_close(dsk);
+	__cas_disk_close(dsk);
 }
 
-struct block_device *casdsk_disk_get_blkdev(struct casdsk_disk *dsk)
+struct block_device *cas_disk_get_blkdev(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
 	return dsk->bd;
 }
 
-struct gendisk *casdsk_disk_get_gendisk(struct casdsk_disk *dsk)
+struct gendisk *cas_disk_get_gendisk(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
 	BUG_ON(!dsk->bd);
 	return dsk->bd->bd_disk;
 }
 
-struct request_queue *casdsk_disk_get_queue(struct casdsk_disk *dsk)
+struct request_queue *cas_disk_get_queue(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
 	BUG_ON(!dsk->bd);
 	return cas_bdev_whole(dsk->bd)->bd_disk->queue;
 }
 
-int casdsk_disk_allocate_minors(int count)
+int cas_disk_allocate_minors(int count)
 {
 	int minor = -1;
 
-	if (casdsk_module->next_minor + count <= (1 << MINORBITS)) {
-		minor = casdsk_module->next_minor;
-		casdsk_module->next_minor += count;
+	if (cas_module.next_minor + count <= (1 << MINORBITS)) {
+		minor = cas_module.next_minor;
+		cas_module.next_minor += count;
 	}
 
 	return minor;
diff --git a/modules/cas_cache/disk.h b/modules/cas_cache/disk.h
index b499bc8..a2bab73 100644
--- a/modules/cas_cache/disk.h
+++ b/modules/cas_cache/disk.h
@@ -12,9 +12,9 @@
 #include <linux/blk-mq.h>
 #include "cas_cache.h"
 
-struct casdsk_exp_obj;
+struct cas_exp_obj;
 
-struct casdsk_disk {
+struct cas_disk {
 	uint32_t id;
 	char *path;
 
@@ -28,7 +28,7 @@ struct casdsk_disk {
 	int gd_minors;
 
 	struct blk_mq_tag_set tag_set;
-	struct casdsk_exp_obj *exp_obj;
+	struct cas_exp_obj *exp_obj;
 
 	struct kobject kobj;
 	struct list_head list;
@@ -36,54 +36,54 @@ struct casdsk_disk {
 	void *private;
 };
 
-int __init casdsk_init_disks(void);
-void casdsk_deinit_disks(void);
+int __init cas_init_disks(void);
+void cas_deinit_disks(void);
 
-int casdsk_disk_allocate_minors(int count);
+int cas_disk_allocate_minors(int count);
 
 /**
  * @brief Open block device
  * @param path Path to block device
  * @param private Private data
- * @return Pointer to casdsk_disk related to opened block device
+ * @return Pointer to cas_disk related to opened block device
  */
-struct casdsk_disk *casdsk_disk_open(const char *path, void *private);
+struct cas_disk *cas_disk_open(const char *path, void *private);
 
 /**
- * @brief Claim previously opened block device (holded by cas_disk)
+ * @brief Claim previously opened block device
  * @param path Path to block device
  * @param private Private data
- * @return Pointer to casdsk_disk structure related to block device, or NULL
- *	if device is not opened by cas_disk.
+ * @return Pointer to cas_disk structure related to block device, or NULL
+ *	if device is not opened.
  */
-struct casdsk_disk *casdsk_disk_claim(const char *path, void *private);
+struct cas_disk *cas_disk_claim(const char *path, void *private);
 
 /**
- * @brief Close block device and remove from cas_disk
- * @param dsk Pointer to casdsk_disk structure related to block device
+ * @brief Close block device and remove from cas
+ * @param dsk Pointer to cas_disk structure related to block device
  *	which should be closed.
  */
-void casdsk_disk_close(struct casdsk_disk *dsk);
+void cas_disk_close(struct cas_disk *dsk);
 
 /**
  * @brief Get block_device structure of bottom block device
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return Pointer to block_device structure of bottom block device
  */
-struct block_device *casdsk_disk_get_blkdev(struct casdsk_disk *dsk);
+struct block_device *cas_disk_get_blkdev(struct cas_disk *dsk);
 
 /**
  * @brief Get request queue of bottom block device
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return Pointer to reqest_queue structure of bottom block device
  */
-struct request_queue *casdsk_disk_get_queue(struct casdsk_disk *dsk);
+struct request_queue *cas_disk_get_queue(struct cas_disk *dsk);
 
 /**
  * @brief Get gendisk structure of bottom block device
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return Pointer to gendisk structure of bottom block device
  */
-struct gendisk *casdsk_disk_get_gendisk(struct casdsk_disk *dsk);
+struct gendisk *cas_disk_get_gendisk(struct cas_disk *dsk);
 
 #endif
diff --git a/modules/cas_cache/exp_obj.c b/modules/cas_cache/exp_obj.c
index 5deede1..4d2895f 100644
--- a/modules/cas_cache/exp_obj.c
+++ b/modules/cas_cache/exp_obj.c
@@ -16,12 +16,12 @@
 #include "cas_cache.h"
 #include "debug.h"
 
-#define CASDSK_DEV_MINORS 16
+#define CAS_DEV_MINORS 16
 #define KMEM_CACHE_MIN_SIZE sizeof(void *)
 
-static inline struct casdsk_exp_obj *casdsk_kobj_to_exp_obj(struct kobject *kobj)
+static inline struct cas_exp_obj *cas_kobj_to_exp_obj(struct kobject *kobj)
 {
-	return container_of(kobj, struct casdsk_exp_obj, kobj);
+	return container_of(kobj, struct cas_exp_obj, kobj);
 }
 
 static inline int bd_claim_by_disk(struct block_device *bdev, void *holder,
@@ -47,54 +47,54 @@ static inline void bd_release_from_disk(struct block_device *bdev,
 	#define MAKE_RQ_RET_TYPE int
 #endif
 
-int __init casdsk_init_exp_objs(void)
+int __init cas_init_exp_objs(void)
 {
-	CASDSK_DEBUG_TRACE();
+	CAS_DEBUG_TRACE();
 
-	casdsk_module->exp_obj_cache = kmem_cache_create("casdsk_exp_obj",
-			sizeof(struct casdsk_exp_obj), 0, 0, NULL);
-	if (!casdsk_module->exp_obj_cache)
+	cas_module.exp_obj_cache = kmem_cache_create("cas_exp_obj",
+			sizeof(struct cas_exp_obj), 0, 0, NULL);
+	if (!cas_module.exp_obj_cache)
 		return -ENOMEM;
 
 	return 0;
 }
 
-void casdsk_deinit_exp_objs(void)
+void cas_deinit_exp_objs(void)
 {
-	CASDSK_DEBUG_TRACE();
+	CAS_DEBUG_TRACE();
 
-	kmem_cache_destroy(casdsk_module->exp_obj_cache);
+	kmem_cache_destroy(cas_module.exp_obj_cache);
 }
 
-static inline void _casdsk_exp_obj_handle_bio(struct casdsk_disk *dsk,
+static inline void _cas_exp_obj_handle_bio(struct cas_disk *dsk,
 					    struct bio *bio)
 {
 	dsk->exp_obj->ops->submit_bio(dsk, bio, dsk->private);
 }
 
-static MAKE_RQ_RET_TYPE _casdsk_exp_obj_submit_bio(struct bio *bio)
+static MAKE_RQ_RET_TYPE _cas_exp_obj_submit_bio(struct bio *bio)
 {
-	struct casdsk_disk *dsk;
+	struct cas_disk *dsk;
 
 	BUG_ON(!bio);
 	dsk = CAS_BIO_GET_GENDISK(bio)->private_data;
 
-	_casdsk_exp_obj_handle_bio(dsk, bio);
+	_cas_exp_obj_handle_bio(dsk, bio);
 
 	KRETURN(0);
 }
 
-static MAKE_RQ_RET_TYPE _casdsk_exp_obj_make_rq_fn(struct request_queue *q,
+static MAKE_RQ_RET_TYPE _cas_exp_obj_make_rq_fn(struct request_queue *q,
 						 struct bio *bio)
 {
-	_casdsk_exp_obj_submit_bio(bio);
+	_cas_exp_obj_submit_bio(bio);
 	cas_blk_queue_exit(q);
 	KRETURN(0);
 }
 
-static int _casdsk_del_partitions(struct casdsk_disk *dsk)
+static int _cas_del_partitions(struct cas_disk *dsk)
 {
-	struct block_device *bd = casdsk_disk_get_blkdev(dsk);
+	struct block_device *bd = cas_disk_get_blkdev(dsk);
 	struct file *bd_file;
 	unsigned long __user usr_bpart;
 	unsigned long __user usr_barg;
@@ -160,22 +160,22 @@ out_map_bpart:
 }
 
 #ifdef GENHD_FL_NO_PART_SCAN
-static int _casdsk_flags = GENHD_FL_NO_PART_SCAN | GENHD_FL_EXT_DEVT;
+static int _cas_flags = GENHD_FL_NO_PART_SCAN | GENHD_FL_EXT_DEVT;
 #else
-static int _casdsk_flags = GENHD_FL_EXT_DEVT;
+static int _cas_flags = GENHD_FL_EXT_DEVT;
 #endif
 
-static int _casdsk_exp_obj_hide_parts(struct casdsk_disk *dsk)
+static int _cas_exp_obj_hide_parts(struct cas_disk *dsk)
 {
-	struct block_device *bd = casdsk_disk_get_blkdev(dsk);
-	struct gendisk *gdsk = casdsk_disk_get_gendisk(dsk);
+	struct block_device *bd = cas_disk_get_blkdev(dsk);
+	struct gendisk *gdsk = cas_disk_get_gendisk(dsk);
 
 	if (bd != cas_bdev_whole(bd))
 		/* It is partition, no more job required */
 		return 0;
 
 	if (disk_max_parts(dsk->bd->bd_disk) > 1) {
-		if (_casdsk_del_partitions(dsk)) {
+		if (_cas_del_partitions(dsk)) {
 			printk(KERN_ERR "Error deleting a partition on thedevice %s\n",
 				gdsk->disk_name);
 
@@ -186,11 +186,11 @@ static int _casdsk_exp_obj_hide_parts(struct casdsk_disk *dsk)
 	}
 
 	/* Save original flags and minors */
-	dsk->gd_flags = gdsk->flags & _casdsk_flags;
+	dsk->gd_flags = gdsk->flags & _cas_flags;
 	dsk->gd_minors = gdsk->minors;
 
 	/* Setup disk of bottom device as not partitioned device */
-	gdsk->flags &= ~_casdsk_flags;
+	gdsk->flags &= ~_cas_flags;
 	gdsk->minors = 1;
 	/* Rescan partitions */
 	cas_reread_partitions(bd);
@@ -198,41 +198,41 @@ static int _casdsk_exp_obj_hide_parts(struct casdsk_disk *dsk)
 	return 0;
 }
 
-static int _casdsk_exp_obj_set_dev_t(struct casdsk_disk *dsk, struct gendisk *gd)
+static int _cas_exp_obj_set_dev_t(struct cas_disk *dsk, struct gendisk *gd)
 {
 	int flags;
-	int minors = disk_max_parts(casdsk_disk_get_gendisk(dsk));
+	int minors = disk_max_parts(cas_disk_get_gendisk(dsk));
 	struct block_device *bdev;
 
-	bdev = casdsk_disk_get_blkdev(dsk);
+	bdev = cas_disk_get_blkdev(dsk);
 	BUG_ON(!bdev);
 
 	if (cas_bdev_whole(bdev) != bdev) {
 		minors = 1;
 		flags = 0;
 	} else {
-		if (_casdsk_exp_obj_hide_parts(dsk))
+		if (_cas_exp_obj_hide_parts(dsk))
 			return -EINVAL;
 		flags = dsk->gd_flags;
 	}
 
-	gd->first_minor = casdsk_disk_allocate_minors(minors);
+	gd->first_minor = cas_disk_allocate_minors(minors);
 	if (gd->first_minor < 0) {
-		CASDSK_DEBUG_DISK_ERROR(dsk, "Cannot allocate %d minors", minors);
+		CAS_DEBUG_DISK_ERROR(dsk, "Cannot allocate %d minors", minors);
 		return -EINVAL;
 	}
 	gd->minors = minors;
 
-	gd->major = casdsk_module->disk_major;
+	gd->major = cas_module.disk_major;
 	gd->flags |= flags;
 
 	return 0;
 }
 
-static void _casdsk_exp_obj_clear_dev_t(struct casdsk_disk *dsk)
+static void _cas_exp_obj_clear_dev_t(struct cas_disk *dsk)
 {
-	struct block_device *bdev = casdsk_disk_get_blkdev(dsk);
-	struct gendisk *gdsk = casdsk_disk_get_gendisk(dsk);
+	struct block_device *bdev = cas_disk_get_blkdev(dsk);
+	struct gendisk *gdsk = cas_disk_get_gendisk(dsk);
 
 	if (cas_bdev_whole(bdev) == bdev) {
 		/* Restore previous configuration of bottom disk */
@@ -242,9 +242,9 @@ static void _casdsk_exp_obj_clear_dev_t(struct casdsk_disk *dsk)
 	}
 }
 
-static int _casdsk_exp_obj_open(struct block_device *bdev, fmode_t mode)
+static int _cas_exp_obj_open(struct block_device *bdev, fmode_t mode)
 {
-	struct casdsk_disk *dsk = bdev->bd_disk->private_data;
+	struct cas_disk *dsk = bdev->bd_disk->private_data;
 	int result = -ENAVAIL;
 
 	mutex_lock(&dsk->openers_lock);
@@ -262,9 +262,9 @@ static int _casdsk_exp_obj_open(struct block_device *bdev, fmode_t mode)
 	return result;
 }
 
-static void _casdsk_exp_obj_close(struct gendisk *gd, fmode_t mode)
+static void _cas_exp_obj_close(struct gendisk *gd, fmode_t mode)
 {
-	struct casdsk_disk *dsk = gd->private_data;
+	struct cas_disk *dsk = gd->private_data;
 
 	BUG_ON(dsk->openers == 0);
 
@@ -274,25 +274,25 @@ static void _casdsk_exp_obj_close(struct gendisk *gd, fmode_t mode)
 
 }
 
-static const struct block_device_operations _casdsk_exp_obj_ops = {
+static const struct block_device_operations _cas_exp_obj_ops = {
 	.owner = THIS_MODULE,
-	.open = _casdsk_exp_obj_open,
-	.release = _casdsk_exp_obj_close,
-	CAS_SET_SUBMIT_BIO(_casdsk_exp_obj_submit_bio)
+	.open = _cas_exp_obj_open,
+	.release = _cas_exp_obj_close,
+	CAS_SET_SUBMIT_BIO(_cas_exp_obj_submit_bio)
 };
 
-static int casdsk_exp_obj_alloc(struct casdsk_disk *dsk)
+static int cas_exp_obj_alloc(struct cas_disk *dsk)
 {
-	struct casdsk_exp_obj *exp_obj;
+	struct cas_exp_obj *exp_obj;
 
 	BUG_ON(!dsk);
 	BUG_ON(dsk->exp_obj);
 
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
-	exp_obj = kmem_cache_zalloc(casdsk_module->exp_obj_cache, GFP_KERNEL);
+	exp_obj = kmem_cache_zalloc(cas_module.exp_obj_cache, GFP_KERNEL);
 	if (!exp_obj) {
-		CASDSK_DEBUG_ERROR("Cannot allocate memory");
+		CAS_DEBUG_ERROR("Cannot allocate memory");
 		return -ENOMEM;
 	}
 
@@ -301,11 +301,11 @@ static int casdsk_exp_obj_alloc(struct casdsk_disk *dsk)
 	return 0;
 }
 
-void casdsk_exp_obj_free(struct casdsk_disk *dsk)
+void cas_exp_obj_free(struct cas_disk *dsk)
 {
-	struct casdsk_exp_obj *exp_obj;
+	struct cas_exp_obj *exp_obj;
 
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
 	exp_obj = dsk->exp_obj;
 
@@ -316,64 +316,64 @@ void casdsk_exp_obj_free(struct casdsk_disk *dsk)
 	dsk->exp_obj = NULL;
 }
 
-static void __casdsk_exp_obj_release(struct casdsk_exp_obj *exp_obj)
+static void __cas_exp_obj_release(struct cas_exp_obj *exp_obj)
 {
-	kmem_cache_free(casdsk_module->exp_obj_cache, exp_obj);
+	kmem_cache_free(cas_module.exp_obj_cache, exp_obj);
 }
 
-static void _casdsk_exp_obj_release(struct kobject *kobj)
+static void _cas_exp_obj_release(struct kobject *kobj)
 {
-	struct casdsk_exp_obj *exp_obj;
+	struct cas_exp_obj *exp_obj;
 	struct module *owner;
 
 	BUG_ON(!kobj);
 
-	exp_obj = casdsk_kobj_to_exp_obj(kobj);
+	exp_obj = cas_kobj_to_exp_obj(kobj);
 	BUG_ON(!exp_obj);
 
-	CASDSK_DEBUG_TRACE();
+	CAS_DEBUG_TRACE();
 
 	owner = exp_obj->owner;
 
 	kfree(exp_obj->dev_name);
-	__casdsk_exp_obj_release(exp_obj);
+	__cas_exp_obj_release(exp_obj);
 
 	if (owner)
 		module_put(owner);
 }
 
-static struct kobj_type casdsk_exp_obj_ktype = {
-	.release = _casdsk_exp_obj_release
+static struct kobj_type cas_exp_obj_ktype = {
+	.release = _cas_exp_obj_release
 };
 
-static int _casdsk_exp_obj_init_kobject(struct casdsk_disk *dsk)
+static int _cas_exp_obj_init_kobject(struct cas_disk *dsk)
 {
 	int result = 0;
-	struct casdsk_exp_obj *exp_obj = dsk->exp_obj;
+	struct cas_exp_obj *exp_obj = dsk->exp_obj;
 
-	kobject_init(&exp_obj->kobj, &casdsk_exp_obj_ktype);
+	kobject_init(&exp_obj->kobj, &cas_exp_obj_ktype);
 	result = kobject_add(&exp_obj->kobj, &dsk->kobj,
 			     "%s", exp_obj->dev_name);
 	if (result)
-		CASDSK_DEBUG_DISK_ERROR(dsk, "Cannot register kobject");
+		CAS_DEBUG_DISK_ERROR(dsk, "Cannot register kobject");
 
 	return result;
 }
 
-static CAS_BLK_STATUS_T _casdsk_exp_obj_queue_rq(struct blk_mq_hw_ctx *hctx,
+static CAS_BLK_STATUS_T _cas_exp_obj_queue_rq(struct blk_mq_hw_ctx *hctx,
 		const struct blk_mq_queue_data *bd)
 {
 	return CAS_BLK_STS_NOTSUPP;
 }
 
-static struct blk_mq_ops casdsk_mq_ops = {
-	.queue_rq       = _casdsk_exp_obj_queue_rq,
+static struct blk_mq_ops cas_mq_ops = {
+	.queue_rq       = _cas_exp_obj_queue_rq,
 #ifdef CAS_BLK_MQ_OPS_MAP_QUEUE
 	.map_queue	= blk_mq_map_queue,
 #endif
 };
 
-static void _casdsk_init_queues(struct casdsk_disk *dsk)
+static void _cas_init_queues(struct cas_disk *dsk)
 {
 	struct request_queue *q = dsk->exp_obj->queue;
 	struct blk_mq_hw_ctx *hctx;
@@ -387,12 +387,12 @@ static void _casdsk_init_queues(struct casdsk_disk *dsk)
 	}
 }
 
-static int _casdsk_init_tag_set(struct casdsk_disk *dsk, struct blk_mq_tag_set *set)
+static int _cas_init_tag_set(struct cas_disk *dsk, struct blk_mq_tag_set *set)
 {
 	BUG_ON(!dsk);
 	BUG_ON(!set);
 
-	set->ops = &casdsk_mq_ops;
+	set->ops = &cas_mq_ops;
 	set->nr_hw_queues = num_online_cpus();
 	set->numa_node = NUMA_NO_NODE;
 	/*TODO: Should we inherit qd from core device? */
@@ -406,10 +406,10 @@ static int _casdsk_init_tag_set(struct casdsk_disk *dsk, struct blk_mq_tag_set *
 	return blk_mq_alloc_tag_set(set);
 }
 
-int casdsk_exp_obj_create(struct casdsk_disk *dsk, const char *dev_name,
-			struct module *owner, struct casdsk_exp_obj_ops *ops)
+int cas_exp_obj_create(struct cas_disk *dsk, const char *dev_name,
+			struct module *owner, struct cas_exp_obj_ops *ops)
 {
-	struct casdsk_exp_obj *exp_obj;
+	struct cas_exp_obj *exp_obj;
 	struct request_queue *queue;
 	struct gendisk *gd;
 	int result = 0;
@@ -419,12 +419,12 @@ int casdsk_exp_obj_create(struct casdsk_disk *dsk, const char *dev_name,
 	BUG_ON(!ops);
 	BUG_ON(dsk->exp_obj);
 
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
 	if (strlen(dev_name) >= DISK_NAME_LEN)
 		return -EINVAL;
 
-	result = casdsk_exp_obj_alloc(dsk);
+	result = cas_exp_obj_alloc(dsk);
 	if (result)
 		goto error_exp_obj_alloc;
 
@@ -437,19 +437,19 @@ int casdsk_exp_obj_create(struct casdsk_disk *dsk, const char *dev_name,
 	}
 
 	if (!try_module_get(owner)) {
-		CASDSK_DEBUG_DISK_ERROR(dsk, "Cannot get reference to module");
+		CAS_DEBUG_DISK_ERROR(dsk, "Cannot get reference to module");
 		result = -ENAVAIL;
 		goto error_module_get;
 	}
 	exp_obj->owner = owner;
 	exp_obj->ops = ops;
 
-	result = _casdsk_exp_obj_init_kobject(dsk);
+	result = _cas_exp_obj_init_kobject(dsk);
 	if (result) {
 		goto error_init_kobject;
 	}
 
-	result = _casdsk_init_tag_set(dsk, &dsk->tag_set);
+	result = _cas_init_tag_set(dsk, &dsk->tag_set);
 	if (result) {
 		goto error_init_tag_set;
 	}
@@ -461,7 +461,7 @@ int casdsk_exp_obj_create(struct casdsk_disk *dsk, const char *dev_name,
 
 	exp_obj->gd = gd;
 
-	result = _casdsk_exp_obj_set_dev_t(dsk, gd);
+	result = _cas_exp_obj_set_dev_t(dsk, gd);
 	if (result)
 		goto error_exp_obj_set_dev_t;
 
@@ -469,13 +469,13 @@ int casdsk_exp_obj_create(struct casdsk_disk *dsk, const char *dev_name,
 	queue->queuedata = dsk;
 	exp_obj->queue = queue;
 
-	_casdsk_init_queues(dsk);
+	_cas_init_queues(dsk);
 
-	gd->fops = &_casdsk_exp_obj_ops;
+	gd->fops = &_cas_exp_obj_ops;
 	gd->private_data = dsk;
 	strlcpy(gd->disk_name, exp_obj->dev_name, sizeof(gd->disk_name));
 
-	cas_blk_queue_make_request(queue, _casdsk_exp_obj_make_rq_fn);
+	cas_blk_queue_make_request(queue, _cas_exp_obj_make_rq_fn);
 
 	if (exp_obj->ops->set_geometry) {
 		result = exp_obj->ops->set_geometry(dsk, dsk->private);
@@ -486,7 +486,7 @@ int casdsk_exp_obj_create(struct casdsk_disk *dsk, const char *dev_name,
 	return 0;
 
 error_set_geometry:
-	_casdsk_exp_obj_clear_dev_t(dsk);
+	_cas_exp_obj_clear_dev_t(dsk);
 error_exp_obj_set_dev_t:
 	cas_cleanup_mq_disk(exp_obj);
 	dsk->exp_obj->gd = NULL;
@@ -502,28 +502,28 @@ error_init_kobject:
 error_module_get:
 	kfree(exp_obj->dev_name);
 error_kstrdup:
-	__casdsk_exp_obj_release(exp_obj);
+	__cas_exp_obj_release(exp_obj);
 	dsk->exp_obj = NULL;
 error_exp_obj_alloc:
 	return result;
 
 }
 
-struct request_queue *casdsk_exp_obj_get_queue(struct casdsk_disk *dsk)
+struct request_queue *cas_exp_obj_get_queue(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
 	BUG_ON(!dsk->exp_obj);
 	return dsk->exp_obj->queue;
 }
 
-struct gendisk *casdsk_exp_obj_get_gendisk(struct casdsk_disk *dsk)
+struct gendisk *cas_exp_obj_get_gendisk(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
 	BUG_ON(!dsk->exp_obj);
 	return dsk->exp_obj->gd;
 }
 
-static bool _casdsk_exp_obj_exists(const char *path)
+static bool _cas_exp_obj_exists(const char *path)
 {
 	struct file *exported;
 
@@ -540,7 +540,7 @@ static bool _casdsk_exp_obj_exists(const char *path)
 	return true;
 }
 
-int casdsk_exp_obj_activate(struct casdsk_disk *dsk)
+int cas_exp_obj_activate(struct cas_disk *dsk)
 {
 	char *path;
 	int result;
@@ -550,14 +550,14 @@ int casdsk_exp_obj_activate(struct casdsk_disk *dsk)
 	BUG_ON(!dsk->exp_obj->gd);
 	BUG_ON(dsk->exp_obj->activated);
 
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
 	path = kmalloc(PATH_MAX, GFP_KERNEL);
 	if (!path)
 		return -ENOMEM;
 
 	snprintf(path, PATH_MAX, "/dev/%s", dsk->exp_obj->dev_name);
-	if (_casdsk_exp_obj_exists(path)) {
+	if (_cas_exp_obj_exists(path)) {
 		printk(KERN_ERR "Could not activate exported object, "
 				"because file %s exists.\n", path);
 		kfree(path);
@@ -578,7 +578,7 @@ int casdsk_exp_obj_activate(struct casdsk_disk *dsk)
 	if (result)
 		goto error_sysfs_link;
 
-	CASDSK_DEBUG_DISK(dsk, "Activated exp object %s", dsk->exp_obj->dev_name);
+	CAS_DEBUG_DISK(dsk, "Activated exp object %s", dsk->exp_obj->dev_name);
 
 	return 0;
 
@@ -590,21 +590,21 @@ error_bd_claim:
 	return result;
 }
 
-bool casdsk_exp_obj_activated(struct casdsk_disk *dsk)
+bool cas_exp_obj_activated(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
 	return dsk->exp_obj->activated;
 }
 
-int casdsk_exp_obj_lock(struct casdsk_disk *dsk)
+int cas_exp_obj_lock(struct cas_disk *dsk)
 {
-	struct casdsk_exp_obj *exp_obj;
+	struct cas_exp_obj *exp_obj;
 	int result = -EBUSY;
 
 	BUG_ON(!dsk);
 	BUG_ON(!dsk->exp_obj);
 
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
 	exp_obj = dsk->exp_obj;
 
@@ -619,10 +619,10 @@ int casdsk_exp_obj_lock(struct casdsk_disk *dsk)
 	return result;
 }
 
-int casdsk_exp_obj_unlock(struct casdsk_disk *dsk)
+int cas_exp_obj_unlock(struct cas_disk *dsk)
 {
 	BUG_ON(!dsk);
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
 	mutex_lock(&dsk->openers_lock);
 	dsk->claimed = false;
@@ -631,23 +631,23 @@ int casdsk_exp_obj_unlock(struct casdsk_disk *dsk)
 	return 0;
 }
 
-int casdsk_exp_obj_destroy(struct casdsk_disk *dsk)
+int cas_exp_obj_destroy(struct cas_disk *dsk)
 {
-	struct casdsk_exp_obj *exp_obj;
+	struct cas_exp_obj *exp_obj;
 
 	BUG_ON(!dsk);
 
 	if (!dsk->exp_obj)
 		return -ENODEV;
 
-	CASDSK_DEBUG_DISK_TRACE(dsk);
+	CAS_DEBUG_DISK_TRACE(dsk);
 
 	exp_obj = dsk->exp_obj;
 
-	if (casdsk_exp_obj_activated(dsk)) {
+	if (cas_exp_obj_activated(dsk)) {
 		sysfs_remove_link(&exp_obj->kobj, "blockdev");
 		bd_release_from_disk(dsk->bd, exp_obj->gd);
-		_casdsk_exp_obj_clear_dev_t(dsk);
+		_cas_exp_obj_clear_dev_t(dsk);
 		del_gendisk(exp_obj->gd);
 	}
 
diff --git a/modules/cas_cache/exp_obj.h b/modules/cas_cache/exp_obj.h
index 49319aa..dfe4ecc 100644
--- a/modules/cas_cache/exp_obj.h
+++ b/modules/cas_cache/exp_obj.h
@@ -8,25 +8,24 @@
 #include <linux/kobject.h>
 #include <linux/fs.h>
 
-struct casdsk_disk;
+struct cas_disk;
 
-struct casdsk_exp_obj_ops {
+struct cas_exp_obj_ops {
 	/**
 	 * @brief Set geometry of exported object (top) block device.
 	 *	Could be NULL.
 	 */
-	int (*set_geometry)(struct casdsk_disk *dsk, void *private);
+	int (*set_geometry)(struct cas_disk *dsk, void *private);
 
 	/**
 	 * @brief submit_bio of exported object (top) block device.
-	 * Called by cas_disk when cas_disk device is in attached mode.
 	 *
 	 */
-	void (*submit_bio)(struct casdsk_disk *dsk,
+	void (*submit_bio)(struct cas_disk *dsk,
 			       struct bio *bio, void *private);
 };
 
-struct casdsk_exp_obj {
+struct cas_exp_obj {
 
 	struct gendisk *gd;
 	struct request_queue *queue;
@@ -37,7 +36,7 @@ struct casdsk_exp_obj {
 
 	bool activated;
 
-	struct casdsk_exp_obj_ops *ops;
+	struct cas_exp_obj_ops *ops;
 
 	const char *dev_name;
 	struct kobject kobj;
@@ -46,63 +45,63 @@ struct casdsk_exp_obj {
 	atomic_t *pending_rqs;
 };
 
-int __init casdsk_init_exp_objs(void);
-void casdsk_deinit_exp_objs(void);
+int __init cas_init_exp_objs(void);
+void cas_deinit_exp_objs(void);
 
-void casdsk_exp_obj_free(struct casdsk_disk *dsk);
+void cas_exp_obj_free(struct cas_disk *dsk);
 
 /**
  * @brief Create exported object (top device)
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @param dev_name Name of exported object (top device)
  * @param owner Pointer to cas module
  * @param ops Pointer to structure with callback functions
  * @return 0 if success, errno if failure
  */
-int casdsk_exp_obj_create(struct casdsk_disk *dsk, const char *dev_name,
-			struct module *owner, struct casdsk_exp_obj_ops *ops);
+int cas_exp_obj_create(struct cas_disk *dsk, const char *dev_name,
+			struct module *owner, struct cas_exp_obj_ops *ops);
 
 /**
  * @brief Get request queue of exported object (top) block device
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return Pointer to reqest_queue structure of top block device
  */
-struct request_queue *casdsk_exp_obj_get_queue(struct casdsk_disk *dsk);
+struct request_queue *cas_exp_obj_get_queue(struct cas_disk *dsk);
 
 /**
  * @brief Get gendisk structure of exported object (top) block device
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return Pointer to gendisk structure of top block device
  */
-struct gendisk *casdsk_exp_obj_get_gendisk(struct casdsk_disk *dsk);
+struct gendisk *cas_exp_obj_get_gendisk(struct cas_disk *dsk);
 
 /**
  * @brief Activate exported object (make it visible to OS
  *	and allow I/O handling)
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return 0 if success, errno if failure
  */
-int casdsk_exp_obj_activate(struct casdsk_disk *dsk);
+int cas_exp_obj_activate(struct cas_disk *dsk);
 
 /**
  * @brief Lock exported object
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return 0 if success, errno if failure
  */
-int casdsk_exp_obj_lock(struct casdsk_disk *dsk);
+int cas_exp_obj_lock(struct cas_disk *dsk);
 
 /**
  * @brief Unlock exported object
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return 0 if success, errno if failure
  */
-int casdsk_exp_obj_unlock(struct casdsk_disk *dsk);
+int cas_exp_obj_unlock(struct cas_disk *dsk);
 
 /**
  * @brief Destroy exported object
- * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @param dsk Pointer to cas_disk structure representing a block device
  * @return 0 if success, errno if failure
  */
-int casdsk_exp_obj_destroy(struct casdsk_disk *dsk);
+int cas_exp_obj_destroy(struct cas_disk *dsk);
 
 #endif
diff --git a/modules/cas_cache/layer_cache_management.c b/modules/cas_cache/layer_cache_management.c
index 5c07b81..c635d9b 100644
--- a/modules/cas_cache/layer_cache_management.c
+++ b/modules/cas_cache/layer_cache_management.c
@@ -2047,7 +2047,7 @@ static void init_instance_complete(struct _cache_mngt_attach_context *ctx,
 
 	/* Set other back information */
 	name = block_dev_get_elevator_name(
-			casdsk_disk_get_queue(bd_cache_obj->dsk));
+			cas_disk_get_queue(bd_cache_obj->dsk));
 	if (name)
 		strlcpy(ctx->cache_elevator, name, MAX_ELEVATOR_NAME);
 }
diff --git a/modules/cas_cache/main.c b/modules/cas_cache/main.c
index a84f757..5453a51 100644
--- a/modules/cas_cache/main.c
+++ b/modules/cas_cache/main.c
@@ -40,8 +40,7 @@ MODULE_PARM_DESC(seq_cut_off_mb,
 
 /* globals */
 ocf_ctx_t cas_ctx;
-struct casdsk_module cas_module;
-struct casdsk_module *casdsk_module;
+struct cas_module cas_module;
 
 static int __init cas_init_module(void)
 {
@@ -72,13 +71,11 @@ static int __init cas_init_module(void)
 		return -EINVAL;
 	}
 
-	casdsk_module = &cas_module;
-
-	result = casdsk_init_exp_objs();
+	result = cas_init_exp_objs();
 	if (result)
 		return result;
 
-	result = casdsk_init_disks();
+	result = cas_init_disks();
 	if (result)
 		goto error_init_disks;
 
@@ -104,9 +101,9 @@ static int __init cas_init_module(void)
 error_init_device:
 	cas_cleanup_context();
 error_init_context:
-	casdsk_deinit_disks();
+	cas_deinit_disks();
 error_init_disks:
-	casdsk_deinit_exp_objs();
+	cas_deinit_exp_objs();
 
 	return result;
 }
@@ -117,8 +114,8 @@ static void __exit cas_exit_module(void)
 {
 	cas_ctrl_device_deinit();
 	cas_cleanup_context();
-	casdsk_deinit_disks();
-	casdsk_deinit_exp_objs();
+	cas_deinit_disks();
+	cas_deinit_exp_objs();
 }
 
 module_exit(cas_exit_module);
diff --git a/modules/cas_cache/service_ui_ioctl.h b/modules/cas_cache/service_ui_ioctl.h
index 4969c60..09f35c1 100644
--- a/modules/cas_cache/service_ui_ioctl.h
+++ b/modules/cas_cache/service_ui_ioctl.h
@@ -1,5 +1,5 @@
 /*
-* Copyright(c) 2012-2021 Intel Corporation
+* Copyright(c) 2012-2022 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
@@ -7,7 +7,7 @@
 
 #define __SERVICE_UI_IOCTL_H__
 
-struct casdsk_disk;
+struct cas_disk;
 
 long cas_service_ioctl_ctrl(struct file *filp, unsigned int cmd,
 		unsigned long arg);
diff --git a/modules/cas_cache/volume/obj_blk.h b/modules/cas_cache/volume/obj_blk.h
index 3213b6d..281446e 100644
--- a/modules/cas_cache/volume/obj_blk.h
+++ b/modules/cas_cache/volume/obj_blk.h
@@ -1,5 +1,5 @@
 /*
-* Copyright(c) 2012-2021 Intel Corporation
+* Copyright(c) 2012-2022 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
@@ -9,10 +9,10 @@
 #include "vol_block_dev_bottom.h"
 #include "vol_block_dev_top.h"
 
-struct casdsk_disk;
+struct cas_disk;
 
 struct bd_object {
-	struct casdsk_disk *dsk;
+	struct cas_disk *dsk;
 
 	struct block_device *btm_bd;
 
diff --git a/modules/cas_cache/volume/vol_block_dev_bottom.c b/modules/cas_cache/volume/vol_block_dev_bottom.c
index ead32dc..528dd79 100644
--- a/modules/cas_cache/volume/vol_block_dev_bottom.c
+++ b/modules/cas_cache/volume/vol_block_dev_bottom.c
@@ -28,14 +28,14 @@ int block_dev_open_object(ocf_volume_t vol, void *volume_params)
 {
 	struct bd_object *bdobj = bd_object(vol);
 	const struct ocf_volume_uuid *uuid = ocf_volume_get_uuid(vol);
-	struct casdsk_disk *dsk;
+	struct cas_disk *dsk;
 
 	if (bdobj->opened_by_bdev) {
 		/* Bdev has been set manually, so there is nothing to do. */
 		return 0;
 	}
 
-	dsk = casdsk_disk_open(uuid->data, NULL);
+	dsk = cas_disk_open(uuid->data, NULL);
 	if (IS_ERR_OR_NULL(dsk)) {
 		int error = PTR_ERR(dsk) ?: -EINVAL;
 
@@ -46,7 +46,7 @@ int block_dev_open_object(ocf_volume_t vol, void *volume_params)
 	}
 
 	bdobj->dsk = dsk;
-	bdobj->btm_bd = casdsk_disk_get_blkdev(dsk);
+	bdobj->btm_bd = cas_disk_get_blkdev(dsk);
 
 	return 0;
 }
@@ -58,7 +58,7 @@ void block_dev_close_object(ocf_volume_t vol)
 	if (bdobj->opened_by_bdev)
 		return;
 
-	casdsk_disk_close(bdobj->dsk);
+	cas_disk_close(bdobj->dsk);
 }
 
 unsigned int block_dev_get_max_io_size(ocf_volume_t vol)
diff --git a/modules/cas_cache/volume/vol_block_dev_top.c b/modules/cas_cache/volume/vol_block_dev_top.c
index 8534652..c265742 100644
--- a/modules/cas_cache/volume/vol_block_dev_top.c
+++ b/modules/cas_cache/volume/vol_block_dev_top.c
@@ -55,9 +55,9 @@ void blkdev_set_exported_object_flush_fua(ocf_core_t core)
 	bd_core_vol = bd_object(core_vol);
 	bd_cache_vol = bd_object(cache_vol);
 
-	core_q = casdsk_disk_get_queue(bd_core_vol->dsk);
-	exp_q = casdsk_exp_obj_get_queue(bd_core_vol->dsk);
-	cache_q = casdsk_disk_get_queue(bd_cache_vol->dsk);
+	core_q = cas_disk_get_queue(bd_core_vol->dsk);
+	exp_q = cas_exp_obj_get_queue(bd_core_vol->dsk);
+	cache_q = cas_disk_get_queue(bd_cache_vol->dsk);
 
 	flush = (CAS_CHECK_QUEUE_FLUSH(core_q) || CAS_CHECK_QUEUE_FLUSH(cache_q));
 	fua = (CAS_CHECK_QUEUE_FUA(core_q) || CAS_CHECK_QUEUE_FUA(cache_q));
@@ -96,7 +96,7 @@ static void blkdev_set_discard_properties(ocf_cache_t cache,
  * Map geometry of underlying (core) object geometry (sectors etc.)
  * to geometry of exported object.
  */
-static int blkdev_core_set_geometry(struct casdsk_disk *dsk, void *private)
+static int blkdev_core_set_geometry(struct cas_disk *dsk, void *private)
 {
 	ocf_core_t core;
 	ocf_cache_t cache;
@@ -118,19 +118,19 @@ static int blkdev_core_set_geometry(struct casdsk_disk *dsk, void *private)
 	bd_cache_vol = bd_object(cache_vol);
 	path = ocf_volume_get_uuid(core_vol)->data;
 
-	core_bd = casdsk_disk_get_blkdev(dsk);
+	core_bd = cas_disk_get_blkdev(dsk);
 	BUG_ON(!core_bd);
 
-	cache_bd = casdsk_disk_get_blkdev(bd_cache_vol->dsk);
+	cache_bd = cas_disk_get_blkdev(bd_cache_vol->dsk);
 	BUG_ON(!cache_bd);
 
 	core_q = cas_bdev_whole(core_bd)->bd_disk->queue;
 	cache_q = cache_bd->bd_disk->queue;
-	exp_q = casdsk_exp_obj_get_queue(dsk);
+	exp_q = cas_exp_obj_get_queue(dsk);
 
 	sectors = ocf_volume_get_length(core_vol) >> SECTOR_SHIFT;
 
-	set_capacity(casdsk_exp_obj_get_gendisk(dsk), sectors);
+	set_capacity(cas_exp_obj_get_gendisk(dsk), sectors);
 
 	cas_copy_queue_limits(exp_q, cache_q, core_q);
 
@@ -440,7 +440,7 @@ static void blkdev_submit_bio(struct bd_object *bvol, struct bio *bio)
 		blkdev_handle_bio(bvol, bio);
 }
 
-static void blkdev_core_submit_bio(struct casdsk_disk *dsk,
+static void blkdev_core_submit_bio(struct cas_disk *dsk,
 		struct bio *bio, void *private)
 {
 	ocf_core_t core = private;
@@ -453,12 +453,12 @@ static void blkdev_core_submit_bio(struct casdsk_disk *dsk,
 	blkdev_submit_bio(bvol, bio);
 }
 
-static struct casdsk_exp_obj_ops kcas_core_exp_obj_ops = {
+static struct cas_exp_obj_ops kcas_core_exp_obj_ops = {
 	.set_geometry = blkdev_core_set_geometry,
 	.submit_bio = blkdev_core_submit_bio,
 };
 
-static int blkdev_cache_set_geometry(struct casdsk_disk *dsk, void *private)
+static int blkdev_cache_set_geometry(struct cas_disk *dsk, void *private)
 {
 	ocf_cache_t cache;
 	ocf_volume_t volume;
@@ -473,15 +473,15 @@ static int blkdev_cache_set_geometry(struct casdsk_disk *dsk, void *private)
 
 	bvol = bd_object(volume);
 
-	bd = casdsk_disk_get_blkdev(bvol->dsk);
+	bd = cas_disk_get_blkdev(bvol->dsk);
 	BUG_ON(!bd);
 
 	cache_q = bd->bd_disk->queue;
-	exp_q = casdsk_exp_obj_get_queue(dsk);
+	exp_q = cas_exp_obj_get_queue(dsk);
 
 	sectors = ocf_volume_get_length(volume) >> SECTOR_SHIFT;
 
-	set_capacity(casdsk_exp_obj_get_gendisk(dsk), sectors);
+	set_capacity(cas_exp_obj_get_gendisk(dsk), sectors);
 
 	cas_copy_queue_limits(exp_q, cache_q, cache_q);
 
@@ -496,7 +496,7 @@ static int blkdev_cache_set_geometry(struct casdsk_disk *dsk, void *private)
 	return 0;
 }
 
-static void blkdev_cache_submit_bio(struct casdsk_disk *dsk,
+static void blkdev_cache_submit_bio(struct cas_disk *dsk,
 		struct bio *bio, void *private)
 {
 	ocf_cache_t cache = private;
@@ -509,7 +509,7 @@ static void blkdev_cache_submit_bio(struct casdsk_disk *dsk,
 	blkdev_submit_bio(bvol, bio);
 }
 
-static struct casdsk_exp_obj_ops kcas_cache_exp_obj_ops = {
+static struct cas_exp_obj_ops kcas_cache_exp_obj_ops = {
 	.set_geometry = blkdev_cache_set_geometry,
 	.submit_bio = blkdev_cache_submit_bio,
 };
@@ -530,15 +530,15 @@ static const char *get_core_id_string(ocf_core_t core)
 }
 
 static int kcas_volume_create_exported_object(ocf_volume_t volume,
-		const char *name, void *priv, struct casdsk_exp_obj_ops *ops)
+		const char *name, void *priv, struct cas_exp_obj_ops *ops)
 {
 	struct bd_object *bvol = bd_object(volume);
 	const struct ocf_volume_uuid *uuid = ocf_volume_get_uuid(volume);
 	char dev_name[DISK_NAME_LEN];
-	struct casdsk_disk *dsk;
+	struct cas_disk *dsk;
 	int result;
 
-	dsk = casdsk_disk_claim(uuid->data, priv);
+	dsk = cas_disk_claim(uuid->data, priv);
 	if (dsk != bvol->dsk) {
 		result = -KCAS_ERR_SYSTEM;
 		goto end;
@@ -552,7 +552,7 @@ static int kcas_volume_create_exported_object(ocf_volume_t volume,
 		goto end;
 	}
 
-	result = casdsk_exp_obj_create(dsk, name,
+	result = cas_exp_obj_create(dsk, name,
 			THIS_MODULE, ops);
 	if (result) {
 		destroy_workqueue(bvol->expobj_wq);
@@ -582,13 +582,13 @@ static int kcas_volume_destroy_exported_object(ocf_volume_t volume)
 	if (!bvol->expobj_valid)
 		return 0;
 
-	result = casdsk_exp_obj_lock(bvol->dsk);
+	result = cas_exp_obj_lock(bvol->dsk);
 	if (result == -EBUSY)
 		return -KCAS_ERR_DEV_PENDING;
 	else if (result)
 		return result;
 
-	result = casdsk_exp_obj_destroy(bvol->dsk);
+	result = cas_exp_obj_destroy(bvol->dsk);
 	if (result)
 		goto out;
 
@@ -596,7 +596,7 @@ static int kcas_volume_destroy_exported_object(ocf_volume_t volume)
 	destroy_workqueue(bvol->expobj_wq);
 
 out:
-	casdsk_exp_obj_unlock(bvol->dsk);
+	cas_exp_obj_unlock(bvol->dsk);
 
 	return result;
 }
@@ -605,12 +605,12 @@ out:
  * @brief this routine actually adds /dev/casM-N inode
  */
 static int kcas_volume_activate_exported_object(ocf_volume_t volume,
-		struct casdsk_exp_obj_ops *ops)
+		struct cas_exp_obj_ops *ops)
 {
 	struct bd_object *bvol = bd_object(volume);
 	int result;
 
-	result = casdsk_exp_obj_activate(bvol->dsk);
+	result = cas_exp_obj_activate(bvol->dsk);
 	if (result == -EEXIST)
 		result = -KCAS_ERR_FILE_EXISTS;
 
@@ -705,15 +705,15 @@ static int kcas_core_lock_exported_object(ocf_core_t core, void *cntx)
 	if (!bvol->expobj_valid)
 		return 0;
 
-	result = casdsk_exp_obj_lock(bvol->dsk);
+	result = cas_exp_obj_lock(bvol->dsk);
 
 	if (-EBUSY == result) {
 		printk(KERN_WARNING "Stopping %s failed - device in use\n",
-			casdsk_exp_obj_get_gendisk(bvol->dsk)->disk_name);
+			cas_exp_obj_get_gendisk(bvol->dsk)->disk_name);
 		return -KCAS_ERR_DEV_PENDING;
 	} else if (result) {
 		printk(KERN_WARNING "Stopping %s failed - device unavailable\n",
-			casdsk_exp_obj_get_gendisk(bvol->dsk)->disk_name);
+			cas_exp_obj_get_gendisk(bvol->dsk)->disk_name);
 		return -OCF_ERR_CORE_NOT_AVAIL;
 	}
 
@@ -728,7 +728,7 @@ static int kcas_core_unlock_exported_object(ocf_core_t core, void *cntx)
 	struct bd_object *bvol = bd_object(ocf_core_get_volume(core));
 
 	if (bvol->expobj_locked) {
-		casdsk_exp_obj_unlock(bvol->dsk);
+		cas_exp_obj_unlock(bvol->dsk);
 		bvol->expobj_locked = false;
 	}
 
@@ -745,9 +745,9 @@ static int kcas_core_stop_exported_object(ocf_core_t core, void *cntx)
 		BUG_ON(!bvol->expobj_locked);
 
 		printk(KERN_INFO "Stopping device %s\n",
-			casdsk_exp_obj_get_gendisk(bvol->dsk)->disk_name);
+			cas_exp_obj_get_gendisk(bvol->dsk)->disk_name);
 
-		ret = casdsk_exp_obj_destroy(bvol->dsk);
+		ret = cas_exp_obj_destroy(bvol->dsk);
 		if (!ret) {
 			bvol->expobj_valid = false;
 			destroy_workqueue(bvol->expobj_wq);
@@ -755,7 +755,7 @@ static int kcas_core_stop_exported_object(ocf_core_t core, void *cntx)
 	}
 
 	if (bvol->expobj_locked) {
-		casdsk_exp_obj_unlock(bvol->dsk);
+		cas_exp_obj_unlock(bvol->dsk);
 		bvol->expobj_locked = false;
 	}
 
@@ -766,7 +766,7 @@ static int kcas_core_free_exported_object(ocf_core_t core, void *cntx)
 {
 	struct bd_object *bvol = bd_object(ocf_core_get_volume(core));
 
-	casdsk_exp_obj_free(bvol->dsk);
+	cas_exp_obj_free(bvol->dsk);
 
 	return 0;
 }