Consolidate modules

Signed-off-by: Robert Baldyga <robert.baldyga@intel.com>

modules/cas_cache/cas_cache.h

@@ -19,7 +19,7 @@
 #include "classifier.h"
 #include "context.h"
 #include <linux/kallsyms.h>
-#include "../cas_disk/cas_disk.h"
+#include "cas_disk.h"
 
 #define CAS_KERN_EMERG KERN_EMERG OCF_PREFIX_SHORT
 #define CAS_KERN_ALERT KERN_ALERT OCF_PREFIX_SHORT
@@ -49,6 +49,20 @@ enum {
 /** \endcond */
 };
 
+struct casdsk_module {
+	struct list_head disk_list;
+	uint32_t next_disk_id;
+	int disk_major;
+	int next_minor;
+
+	struct kmem_cache *disk_cache;
+	struct kmem_cache *exp_obj_cache;
+
+	struct kobject kobj;
+};
+
+extern struct casdsk_module *casdsk_module;
+
 struct cas_classifier;
 
 struct cache_priv {

modules/cas_cache/cas_disk.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright(c) 2012-2022 Intel Corporation
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef __CASDISK_H__
+#define __CASDISK_H__
+
+#include <linux/blkdev.h>
+#include "linux_kernel_version.h"
+#include "disk.h"
+#include "exp_obj.h"
+
+struct casdsk_disk;
+
+struct casdsk_exp_obj_ops {
+	/**
+	 * @brief Set geometry of exported object (top) block device.
+	 *	Could be NULL.
+	 */
+	int (*set_geometry)(struct casdsk_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,
+			       struct bio *bio, void *private);
+};
+
+/**
+ * @brief Open block device
+ * @param path Path to block device
+ * @param private Private data
+ * @return Pointer to casdsk_disk related to opened block device
+ */
+struct casdsk_disk *casdsk_disk_open(const char *path, void *private);
+
+/**
+ * @brief Claim previously opened block device (holded by cas_disk)
+ * @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.
+ */
+struct casdsk_disk *casdsk_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
+ *	which should be closed.
+ */
+void casdsk_disk_close(struct casdsk_disk *dsk);
+
+/**
+ * @brief Get block_device structure of bottom block device
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return Pointer to block_device structure of bottom block device
+ */
+struct block_device *casdsk_disk_get_blkdev(struct casdsk_disk *dsk);
+
+/**
+ * @brief Get request queue of bottom block device
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return Pointer to reqest_queue structure of bottom block device
+ */
+struct request_queue *casdsk_disk_get_queue(struct casdsk_disk *dsk);
+
+/**
+ * @brief Get gendisk structure of bottom block device
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return Pointer to gendisk structure of bottom block device
+ */
+struct gendisk *casdsk_disk_get_gendisk(struct casdsk_disk *dsk);
+
+/**
+ * @brief Create exported object (top device)
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk 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);
+
+/**
+ * @brief Get request queue of exported object (top) block device
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return Pointer to reqest_queue structure of top block device
+ */
+struct request_queue *casdsk_exp_obj_get_queue(struct casdsk_disk *dsk);
+
+/**
+ * @brief Get gendisk structure of exported object (top) block device
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return Pointer to gendisk structure of top block device
+ */
+struct gendisk *casdsk_exp_obj_get_gendisk(struct casdsk_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
+ * @return 0 if success, errno if failure
+ */
+int casdsk_exp_obj_activate(struct casdsk_disk *dsk);
+
+/**
+ * @brief Lock exported object
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return 0 if success, errno if failure
+ */
+int casdsk_exp_obj_lock(struct casdsk_disk *dsk);
+
+/**
+ * @brief Unlock exported object
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return 0 if success, errno if failure
+ */
+int casdsk_exp_obj_unlock(struct casdsk_disk *dsk);
+
+/**
+ * @brief Destroy exported object
+ * @param dsk Pointer to casdsk_disk structure related to cas_disk device
+ * @return 0 if success, errno if failure
+ */
+int casdsk_exp_obj_destroy(struct casdsk_disk *dsk);
+
+#endif

modules/cas_cache/debug.h

@@ -0,0 +1,45 @@
+/*
+* Copyright(c) 2012-2022 Intel Corporation
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+#ifndef __CASDISK_DEBUG_H__
+#define __CASDISK_DEBUG_H__
+
+#undef CASDSK_DEBUG
+
+#ifdef CASDSK_DEBUG
+#define CASDSK_DEBUG_TRACE()						\
+	printk(KERN_INFO "%s\n", __func__)
+
+#define CASDSK_DEBUG_DISK_TRACE(dsk)					\
+	printk(KERN_INFO "[%u] %s\n", dsk->id,  __func__)
+
+#define CASDSK_DEBUG_MSG(msg)						\
+	printk(KERN_INFO "%s - %s\n", __func__, msg)
+
+#define CASDSK_DEBUG_PARAM(format, ...)					\
+	printk(KERN_INFO "%s - "format"\n",			\
+	       __func__, ##__VA_ARGS__)
+
+#define CASDSK_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 CASDSK_DEBUG_DISK_ERROR(dsk, error, ...)				\
+	CASDSK_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, ...)
+#endif
+
+#endif

modules/cas_cache/disk.c

@@ -0,0 +1,222 @@
+/*
+* Copyright(c) 2012-2022 Intel Corporation
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/delay.h>
+#include "cas_cache.h"
+#include "disk.h"
+#include "exp_obj.h"
+#include "debug.h"
+
+#define CASDSK_DISK_OPEN_FMODE (FMODE_READ | FMODE_WRITE)
+
+static inline struct block_device *open_bdev_exclusive(const char *path,
+						       fmode_t mode,
+						       void *holder)
+{
+	return blkdev_get_by_path(path, mode | FMODE_EXCL, holder);
+}
+
+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)
+{
+	struct casdsk_disk *dsk;
+
+	BUG_ON(!kobj);
+
+	dsk = casdsk_kobj_to_disk(kobj);
+	BUG_ON(!dsk);
+
+	CASDSK_DEBUG_DISK_TRACE(dsk);
+
+	kfree(dsk->path);
+
+	kmem_cache_free(casdsk_module->disk_cache, dsk);
+}
+
+static struct kobj_type casdsk_disk_ktype = {
+	.release = _casdsk_disk_release,
+};
+
+int __init casdsk_init_disks(void)
+{
+	CASDSK_DEBUG_TRACE();
+
+	casdsk_module->next_disk_id = 1;
+	INIT_LIST_HEAD(&casdsk_module->disk_list);
+
+	casdsk_module->disk_major = register_blkdev(casdsk_module->disk_major,
+						  "cas");
+	if (casdsk_module->disk_major <= 0) {
+		CASDSK_DEBUG_ERROR("Cannot allocate major number");
+		return -EINVAL;
+	}
+	CASDSK_DEBUG_PARAM("Allocated major number: %d", casdsk_module->disk_major);
+
+	casdsk_module->disk_cache =
+		kmem_cache_create("casdsk_disk", sizeof(struct casdsk_disk),
+				  0, 0, NULL);
+	if (!casdsk_module->disk_cache) {
+		unregister_blkdev(casdsk_module->disk_major, "cas");
+		return -ENOMEM;
+	}
+
+	return 0;
+}
+
+void casdsk_deinit_disks(void)
+{
+	CASDSK_DEBUG_TRACE();
+
+	kmem_cache_destroy(casdsk_module->disk_cache);
+	unregister_blkdev(casdsk_module->disk_major, "cas");
+}
+
+static int _casdsk_disk_init_kobject(struct casdsk_disk *dsk)
+{
+	int result = 0;
+
+	kobject_init(&dsk->kobj, &casdsk_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");
+
+	return result;
+}
+
+struct casdsk_disk *casdsk_disk_open(const char *path, void *private)
+{
+	struct casdsk_disk *dsk;
+	int result = 0;
+
+	BUG_ON(!path);
+
+	CASDSK_DEBUG_TRACE();
+
+	dsk = kmem_cache_zalloc(casdsk_module->disk_cache, GFP_KERNEL);
+	if (!dsk) {
+		CASDSK_DEBUG_ERROR("Cannot allocate memory");
+		result = -ENOMEM;
+		goto error_kmem;
+	}
+
+	mutex_init(&dsk->openers_lock);
+
+	dsk->path = kstrdup(path, GFP_KERNEL);
+	if (!dsk->path) {
+		result = -ENOMEM;
+		goto error_kstrdup;
+	}
+
+	dsk->bd = open_bdev_exclusive(path, CASDSK_DISK_OPEN_FMODE, dsk);
+	if (IS_ERR(dsk->bd)) {
+		CASDSK_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);
+
+	result = _casdsk_disk_init_kobject(dsk);
+	if (result)
+		goto error_kobject;
+
+	CASDSK_DEBUG_DISK(dsk, "Created (%p)", dsk);
+
+	return dsk;
+
+error_kobject:
+	list_del(&dsk->list);
+	close_bdev_exclusive(dsk->bd, CASDSK_DISK_OPEN_FMODE);
+error_open_bdev:
+	kfree(dsk->path);
+error_kstrdup:
+	kmem_cache_free(casdsk_module->disk_cache, dsk);
+error_kmem:
+	return ERR_PTR(result);
+}
+
+static void _casdsk_disk_claim(struct casdsk_disk *dsk, void *private)
+{
+	dsk->private = private;
+}
+
+struct casdsk_disk *casdsk_disk_claim(const char *path, void *private)
+{
+	struct list_head *item;
+	struct casdsk_disk *dsk = NULL;
+
+	BUG_ON(!path);
+
+	list_for_each(item, &casdsk_module->disk_list) {
+		dsk = list_entry(item, struct casdsk_disk, list);
+		if (strncmp(path, dsk->path, PATH_MAX) == 0) {
+			_casdsk_disk_claim(dsk, private);
+			return dsk;
+		}
+	}
+	return NULL;
+}
+
+static void __casdsk_disk_close(struct casdsk_disk *dsk)
+{
+	close_bdev_exclusive(dsk->bd, CASDSK_DISK_OPEN_FMODE);
+
+	casdsk_exp_obj_free(dsk);
+	kobject_put(&dsk->kobj);
+}
+
+void casdsk_disk_close(struct casdsk_disk *dsk)
+{
+	BUG_ON(!dsk);
+	BUG_ON(!dsk->bd);
+
+	CASDSK_DEBUG_DISK(dsk, "Destroying (%p)", dsk);
+
+	list_del(&dsk->list);
+
+	__casdsk_disk_close(dsk);
+}
+
+struct block_device *casdsk_disk_get_blkdev(struct casdsk_disk *dsk)
+{
+	BUG_ON(!dsk);
+	return dsk->bd;
+}
+
+struct gendisk *casdsk_disk_get_gendisk(struct casdsk_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)
+{
+	BUG_ON(!dsk);
+	BUG_ON(!dsk->bd);
+	return cas_bdev_whole(dsk->bd)->bd_disk->queue;
+}
+
+int casdsk_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;
+	}
+
+	return minor;
+}

modules/cas_cache/disk.h

@@ -0,0 +1,59 @@
+/*
+* Copyright(c) 2012-2022 Intel Corporation
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+#ifndef __CASDISK_DISK_H__
+#define __CASDISK_DISK_H__
+
+#include <linux/kobject.h>
+#include <linux/fs.h>
+#include <linux/blkdev.h>
+#include <linux/mutex.h>
+#include <linux/blk-mq.h>
+#include "cas_cache.h"
+
+struct casdsk_exp_obj;
+
+struct casdsk_disk {
+	uint32_t id;
+	char *path;
+
+	struct mutex openers_lock;
+	unsigned int openers;
+	bool claimed;
+
+	struct block_device *bd;
+
+	int gd_flags;
+	int gd_minors;
+
+	struct blk_mq_tag_set tag_set;
+	struct casdsk_exp_obj *exp_obj;
+
+	struct kobject kobj;
+	struct list_head list;
+
+	void *private;
+};
+
+int __init casdsk_init_disks(void);
+void casdsk_deinit_disks(void);
+
+int casdsk_disk_allocate_minors(int count);
+
+static inline void casdsk_disk_lock(struct casdsk_disk *dsk)
+{
+	mutex_lock(&dsk->lock);
+}
+
+static inline void casdsk_disk_unlock(struct casdsk_disk *dsk)
+{
+	mutex_unlock(&dsk->lock);
+}
+
+static inline struct casdsk_disk *casdsk_kobj_to_disk(struct kobject *kobj)
+{
+	return container_of(kobj, struct casdsk_disk, kobj);
+}
+
+#endif

modules/cas_cache/exp_obj.c

@@ -0,0 +1,659 @@
+/*
+* Copyright(c) 2012-2022 Intel Corporation
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+#include <linux/module.h>
+#include <linux/blkdev.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/blkpg.h>
+#include <linux/elevator.h>
+#include <linux/blk-mq.h>
+
+#include "cas_disk.h"
+#include "disk.h"
+#include "exp_obj.h"
+#include "linux_kernel_version.h"
+#include "cas_cache.h"
+#include "debug.h"
+
+#define CASDSK_DEV_MINORS 16
+#define KMEM_CACHE_MIN_SIZE sizeof(void *)
+
+static inline int bd_claim_by_disk(struct block_device *bdev, void *holder,
+				   struct gendisk *disk)
+{
+	return bd_link_disk_holder(bdev, disk);
+}
+
+static inline void bd_release_from_disk(struct block_device *bdev,
+					struct gendisk *disk)
+{
+	return bd_unlink_disk_holder(bdev, disk);
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 3, 0)
+	#define KRETURN(x)	({ return (x); })
+	#define MAKE_RQ_RET_TYPE blk_qc_t
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
+	#define KRETURN(x)	return
+	#define MAKE_RQ_RET_TYPE void
+#else
+	#define KRETURN(x)	({ return (x); })
+	#define MAKE_RQ_RET_TYPE int
+#endif
+
+int __init casdsk_init_exp_objs(void)
+{
+	CASDSK_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)
+		return -ENOMEM;
+
+	return 0;
+}
+
+void casdsk_deinit_exp_objs(void)
+{
+	CASDSK_DEBUG_TRACE();
+
+	kmem_cache_destroy(casdsk_module->exp_obj_cache);
+}
+
+static inline void _casdsk_exp_obj_handle_bio(struct casdsk_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)
+{
+	struct casdsk_disk *dsk;
+
+	BUG_ON(!bio);
+	dsk = CAS_BIO_GET_GENDISK(bio)->private_data;
+
+	_casdsk_exp_obj_handle_bio(dsk, bio);
+
+	KRETURN(0);
+}
+
+static MAKE_RQ_RET_TYPE _casdsk_exp_obj_make_rq_fn(struct request_queue *q,
+						 struct bio *bio)
+{
+	_casdsk_exp_obj_submit_bio(bio);
+	cas_blk_queue_exit(q);
+	KRETURN(0);
+}
+
+static int _casdsk_del_partitions(struct casdsk_disk *dsk)
+{
+	struct block_device *bd = casdsk_disk_get_blkdev(dsk);
+	struct file *bd_file;
+	unsigned long __user usr_bpart;
+	unsigned long __user usr_barg;
+	struct blkpg_partition bpart;
+	struct blkpg_ioctl_arg barg;
+	int result = 0;
+	int part_no;
+
+	bd_file = filp_open(dsk->path, 0, 0);
+	if (IS_ERR(bd_file))
+		return PTR_ERR(bd_file);
+
+	usr_bpart = cas_vm_mmap(NULL, 0, sizeof(bpart));
+	if (IS_ERR((void *)usr_bpart)) {
+		result = PTR_ERR((void *)usr_bpart);
+		goto out_map_bpart;
+	}
+
+	usr_barg = cas_vm_mmap(NULL, 0, sizeof(barg));
+	if (IS_ERR((void *)usr_barg)) {
+		result = PTR_ERR((void *)usr_barg);
+		goto out_map_barg;
+	}
+
+
+	memset(&bpart, 0, sizeof(bpart));
+	memset(&barg, 0, sizeof(barg));
+	barg.data = (void __user *)usr_bpart;
+	barg.op = BLKPG_DEL_PARTITION;
+
+	result = copy_to_user((void __user *)usr_barg, &barg, sizeof(barg));
+	if (result) {
+		result = -EINVAL;
+		goto out_copy;
+	}
+
+	while ((part_no = cas_bd_get_next_part(bd))) {
+		bpart.pno = part_no;
+		result = copy_to_user((void __user *)usr_bpart, &bpart,
+				sizeof(bpart));
+		if (result) {
+			result = -EINVAL;
+			break;
+		}
+		result = cas_vfs_ioctl(bd_file, BLKPG, usr_barg);
+		if (result == 0) {
+			printk(KERN_INFO "Partition %d on %s hidden\n",
+				part_no, bd->bd_disk->disk_name);
+		} else {
+			printk(KERN_ERR "Error(%d) hiding the partition %d on %s\n",
+				result, part_no, bd->bd_disk->disk_name);
+			break;
+		}
+	}
+
+out_copy:
+	cas_vm_munmap(usr_barg, sizeof(barg));
+out_map_barg:
+	cas_vm_munmap(usr_bpart, sizeof(bpart));
+out_map_bpart:
+	filp_close(bd_file, NULL);
+	return result;
+}
+
+#ifdef GENHD_FL_NO_PART_SCAN
+static int _casdsk_flags = GENHD_FL_NO_PART_SCAN | GENHD_FL_EXT_DEVT;
+#else
+static int _casdsk_flags = GENHD_FL_EXT_DEVT;
+#endif
+
+static int _casdsk_exp_obj_hide_parts(struct casdsk_disk *dsk)
+{
+	struct block_device *bd = casdsk_disk_get_blkdev(dsk);
+	struct gendisk *gdsk = casdsk_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)) {
+			printk(KERN_ERR "Error deleting a partition on thedevice %s\n",
+				gdsk->disk_name);
+
+			/* Try restore previous partitions by rescaning */
+			cas_reread_partitions(bd);
+			return -EINVAL;
+		}
+	}
+
+	/* Save original flags and minors */
+	dsk->gd_flags = gdsk->flags & _casdsk_flags;
+	dsk->gd_minors = gdsk->minors;
+
+	/* Setup disk of bottom device as not partitioned device */
+	gdsk->flags &= ~_casdsk_flags;
+	gdsk->minors = 1;
+	/* Rescan partitions */
+	cas_reread_partitions(bd);
+
+	return 0;
+}
+
+static int _casdsk_exp_obj_set_dev_t(struct casdsk_disk *dsk, struct gendisk *gd)
+{
+	int flags;
+	int minors = disk_max_parts(casdsk_disk_get_gendisk(dsk));
+	struct block_device *bdev;
+
+	bdev = casdsk_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))
+			return -EINVAL;
+		flags = dsk->gd_flags;
+	}
+
+	gd->first_minor = casdsk_disk_allocate_minors(minors);
+	if (gd->first_minor < 0) {
+		CASDSK_DEBUG_DISK_ERROR(dsk, "Cannot allocate %d minors", minors);
+		return -EINVAL;
+	}
+	gd->minors = minors;
+
+	gd->major = casdsk_module->disk_major;
+	gd->flags |= flags;
+
+	return 0;
+}
+
+static void _casdsk_exp_obj_clear_dev_t(struct casdsk_disk *dsk)
+{
+	struct block_device *bdev = casdsk_disk_get_blkdev(dsk);
+	struct gendisk *gdsk = casdsk_disk_get_gendisk(dsk);
+
+	if (cas_bdev_whole(bdev) == bdev) {
+		/* Restore previous configuration of bottom disk */
+		gdsk->minors = dsk->gd_minors;
+		gdsk->flags |= dsk->gd_flags;
+		cas_reread_partitions(bdev);
+	}
+}
+
+static int _casdsk_exp_obj_open(struct block_device *bdev, fmode_t mode)
+{
+	struct casdsk_disk *dsk = bdev->bd_disk->private_data;
+	int result = -ENAVAIL;
+
+	mutex_lock(&dsk->openers_lock);
+
+	if (!dsk->claimed) {
+		if (unlikely(dsk->openers == UINT_MAX)) {
+			result = -EBUSY;
+		} else {
+			dsk->openers++;
+			result = 0;
+		}
+	}
+
+	mutex_unlock(&dsk->openers_lock);
+	return result;
+}
+
+static void _casdsk_exp_obj_close(struct gendisk *gd, fmode_t mode)
+{
+	struct casdsk_disk *dsk = gd->private_data;
+
+	BUG_ON(dsk->openers == 0);
+
+	mutex_lock(&dsk->openers_lock);
+	dsk->openers--;
+	mutex_unlock(&dsk->openers_lock);
+
+}
+
+static const struct block_device_operations _casdsk_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)
+};
+
+static int casdsk_exp_obj_alloc(struct casdsk_disk *dsk)
+{
+	struct casdsk_exp_obj *exp_obj;
+
+	BUG_ON(!dsk);
+	BUG_ON(dsk->exp_obj);
+
+	CASDSK_DEBUG_DISK_TRACE(dsk);
+
+	exp_obj = kmem_cache_zalloc(casdsk_module->exp_obj_cache, GFP_KERNEL);
+	if (!exp_obj) {
+		CASDSK_DEBUG_ERROR("Cannot allocate memory");
+		return -ENOMEM;
+	}
+
+	dsk->exp_obj = exp_obj;
+
+	return 0;
+}
+
+void casdsk_exp_obj_free(struct casdsk_disk *dsk)
+{
+	struct casdsk_exp_obj *exp_obj;
+
+	CASDSK_DEBUG_DISK_TRACE(dsk);
+
+	exp_obj = dsk->exp_obj;
+
+	if (!exp_obj)
+		return;
+
+	kobject_put(&exp_obj->kobj);
+	dsk->exp_obj = NULL;
+}
+
+static void __casdsk_exp_obj_release(struct casdsk_exp_obj *exp_obj)
+{
+	kmem_cache_free(casdsk_module->exp_obj_cache, exp_obj);
+}
+
+static void _casdsk_exp_obj_release(struct kobject *kobj)
+{
+	struct casdsk_exp_obj *exp_obj;
+	struct module *owner;
+
+	BUG_ON(!kobj);
+
+	exp_obj = casdsk_kobj_to_exp_obj(kobj);
+	BUG_ON(!exp_obj);
+
+	CASDSK_DEBUG_TRACE();
+
+	owner = exp_obj->owner;
+
+	kfree(exp_obj->dev_name);
+	__casdsk_exp_obj_release(exp_obj);
+
+	if (owner)
+		module_put(owner);
+}
+
+static struct kobj_type casdsk_exp_obj_ktype = {
+	.release = _casdsk_exp_obj_release
+};
+
+static int _casdsk_exp_obj_init_kobject(struct casdsk_disk *dsk)
+{
+	int result = 0;
+	struct casdsk_exp_obj *exp_obj = dsk->exp_obj;
+
+	kobject_init(&exp_obj->kobj, &casdsk_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");
+
+	return result;
+}
+
+static CAS_BLK_STATUS_T _casdsk_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,
+#ifdef CAS_BLK_MQ_OPS_MAP_QUEUE
+	.map_queue	= blk_mq_map_queue,
+#endif
+};
+
+static void _casdsk_init_queues(struct casdsk_disk *dsk)
+{
+	struct request_queue *q = dsk->exp_obj->queue;
+	struct blk_mq_hw_ctx *hctx;
+	int i;
+
+	queue_for_each_hw_ctx(q, hctx, i) {
+		if (!hctx->nr_ctx || !hctx->tags)
+			continue;
+
+		hctx->driver_data = dsk;
+	}
+}
+
+static int _casdsk_init_tag_set(struct casdsk_disk *dsk, struct blk_mq_tag_set *set)
+{
+	BUG_ON(!dsk);
+	BUG_ON(!set);
+
+	set->ops = &casdsk_mq_ops;
+	set->nr_hw_queues = num_online_cpus();
+	set->numa_node = NUMA_NO_NODE;
+	/*TODO: Should we inherit qd from core device? */
+	set->queue_depth = BLKDEV_MAX_RQ;
+
+	set->cmd_size = 0;
+	set->flags = BLK_MQ_F_SHOULD_MERGE | CAS_BLK_MQ_F_STACKING | CAS_BLK_MQ_F_BLOCKING;
+
+	set->driver_data = dsk;
+
+	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)
+{
+	struct casdsk_exp_obj *exp_obj;
+	struct request_queue *queue;
+	struct gendisk *gd;
+	int result = 0;
+
+	BUG_ON(!owner);
+	BUG_ON(!dsk);
+	BUG_ON(!ops);
+	BUG_ON(dsk->exp_obj);
+
+	CASDSK_DEBUG_DISK_TRACE(dsk);
+
+	if (strlen(dev_name) >= DISK_NAME_LEN)
+		return -EINVAL;
+
+	result = casdsk_exp_obj_alloc(dsk);
+	if (result)
+		goto error_exp_obj_alloc;
+
+	exp_obj = dsk->exp_obj;
+
+	exp_obj->dev_name = kstrdup(dev_name, GFP_KERNEL);
+	if (!exp_obj->dev_name) {
+		result = -ENOMEM;
+		goto error_kstrdup;
+	}
+
+	if (!try_module_get(owner)) {
+		CASDSK_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);
+	if (result) {
+		goto error_init_kobject;
+	}
+
+	result = _casdsk_init_tag_set(dsk, &dsk->tag_set);
+	if (result) {
+		goto error_init_tag_set;
+	}
+
+	result = cas_alloc_mq_disk(&gd, &queue, &dsk->tag_set);
+	if (result) {
+		goto error_alloc_mq_disk;
+	}
+
+	exp_obj->gd = gd;
+
+	result = _casdsk_exp_obj_set_dev_t(dsk, gd);
+	if (result)
+		goto error_exp_obj_set_dev_t;
+
+	BUG_ON(queue->queuedata);
+	queue->queuedata = dsk;
+	exp_obj->queue = queue;
+
+	_casdsk_init_queues(dsk);
+
+	gd->fops = &_casdsk_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);
+
+	if (exp_obj->ops->set_geometry) {
+		result = exp_obj->ops->set_geometry(dsk, dsk->private);
+		if (result)
+			goto error_set_geometry;
+	}
+
+	return 0;
+
+error_set_geometry:
+	_casdsk_exp_obj_clear_dev_t(dsk);
+error_exp_obj_set_dev_t:
+	cas_cleanup_mq_disk(exp_obj);
+	dsk->exp_obj->gd = NULL;
+error_alloc_mq_disk:
+	blk_mq_free_tag_set(&dsk->tag_set);
+error_init_tag_set:
+	kobject_put(&exp_obj->kobj);
+	/* kobject put does all the cleanup below internally */
+	return result;
+error_init_kobject:
+	module_put(owner);
+	dsk->exp_obj->owner = NULL;
+error_module_get:
+	kfree(exp_obj->dev_name);
+error_kstrdup:
+	__casdsk_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)
+{
+	BUG_ON(!dsk);
+	BUG_ON(!dsk->exp_obj);
+	return dsk->exp_obj->queue;
+}
+
+struct gendisk *casdsk_exp_obj_get_gendisk(struct casdsk_disk *dsk)
+{
+	BUG_ON(!dsk);
+	BUG_ON(!dsk->exp_obj);
+	return dsk->exp_obj->gd;
+}
+
+static bool _casdsk_exp_obj_exists(const char *path)
+{
+	struct file *exported;
+
+	exported = filp_open(path, O_RDONLY, 0);
+
+	if (!exported || IS_ERR(exported)) {
+		/*failed to open file - it is safe to assume,
+		 * it does not exist
+		 */
+		return false;
+	}
+
+	filp_close(exported, NULL);
+	return true;
+}
+
+int casdsk_exp_obj_activate(struct casdsk_disk *dsk)
+{
+	char *path;
+	int result;
+
+	BUG_ON(!dsk);
+	BUG_ON(!dsk->exp_obj);
+	BUG_ON(!dsk->exp_obj->gd);
+	BUG_ON(dsk->exp_obj->activated);
+
+	CASDSK_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)) {
+		printk(KERN_ERR "Could not activate exported object, "
+				"because file %s exists.\n", path);
+		kfree(path);
+		return -EEXIST;
+	}
+	kfree(path);
+
+	dsk->exp_obj->activated = true;
+	add_disk(dsk->exp_obj->gd);
+
+	result = bd_claim_by_disk(dsk->bd, dsk, dsk->exp_obj->gd);
+	if (result)
+		goto error_bd_claim;
+
+	result = sysfs_create_link(&dsk->exp_obj->kobj,
+				   &disk_to_dev(dsk->exp_obj->gd)->kobj,
+				   "blockdev");
+	if (result)
+		goto error_sysfs_link;
+
+	CASDSK_DEBUG_DISK(dsk, "Activated exp object %s", dsk->exp_obj->dev_name);
+
+	return 0;
+
+error_sysfs_link:
+	bd_release_from_disk(dsk->bd, dsk->exp_obj->gd);
+error_bd_claim:
+	del_gendisk(dsk->exp_obj->gd);
+	dsk->exp_obj->activated = false;
+	return result;
+}
+
+bool casdsk_exp_obj_activated(struct casdsk_disk *dsk)
+{
+	BUG_ON(!dsk);
+	return dsk->exp_obj->activated;
+}
+
+int casdsk_exp_obj_lock(struct casdsk_disk *dsk)
+{
+	struct casdsk_exp_obj *exp_obj;
+	int result = -EBUSY;
+
+	BUG_ON(!dsk);
+	BUG_ON(!dsk->exp_obj);
+
+	CASDSK_DEBUG_DISK_TRACE(dsk);
+
+	exp_obj = dsk->exp_obj;
+
+	mutex_lock(&dsk->openers_lock);
+
+	if (dsk->openers == 0) {
+		dsk->claimed = true;
+		result = 0;
+	}
+
+	mutex_unlock(&dsk->openers_lock);
+	return result;
+}
+
+int casdsk_exp_obj_unlock(struct casdsk_disk *dsk)
+{
+	BUG_ON(!dsk);
+	CASDSK_DEBUG_DISK_TRACE(dsk);
+
+	mutex_lock(&dsk->openers_lock);
+	dsk->claimed = false;
+	mutex_unlock(&dsk->openers_lock);
+
+	return 0;
+}
+
+int casdsk_exp_obj_destroy(struct casdsk_disk *dsk)
+{
+	struct casdsk_exp_obj *exp_obj;
+
+	BUG_ON(!dsk);
+
+	if (!dsk->exp_obj)
+		return -ENODEV;
+
+	CASDSK_DEBUG_DISK_TRACE(dsk);
+
+	exp_obj = dsk->exp_obj;
+
+	if (casdsk_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);
+		del_gendisk(exp_obj->gd);
+	}
+
+	if (exp_obj->queue)
+		blk_cleanup_queue(exp_obj->queue);
+
+	blk_mq_free_tag_set(&dsk->tag_set);
+
+	put_disk(exp_obj->gd);
+
+	return 0;
+
+}

modules/cas_cache/exp_obj.h

@@ -0,0 +1,48 @@
+/*
+* Copyright(c) 2012-2022 Intel Corporation
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+#ifndef __CASDISK_EXP_OBJ_H__
+#define __CASDISK_EXP_OBJ_H__
+
+#include <linux/kobject.h>
+#include <linux/fs.h>
+
+struct casdsk_disk;
+
+struct casdsk_exp_obj_pt_io_ctx {
+	struct casdsk_disk *dsk;
+	struct bio *bio;
+};
+
+struct casdsk_exp_obj {
+
+	struct gendisk *gd;
+	struct request_queue *queue;
+
+	struct block_device *locked_bd;
+
+	struct module *owner;
+
+	bool activated;
+
+	struct casdsk_exp_obj_ops *ops;
+
+	const char *dev_name;
+	struct kobject kobj;
+
+	atomic_t pt_ios;
+	atomic_t *pending_rqs;
+};
+
+int __init casdsk_init_exp_objs(void);
+void casdsk_deinit_exp_objs(void);
+
+void casdsk_exp_obj_free(struct casdsk_disk *dsk);
+
+static inline struct casdsk_exp_obj *casdsk_kobj_to_exp_obj(struct kobject *kobj)
+{
+	return container_of(kobj, struct casdsk_exp_obj, kobj);
+}
+
+#endif

modules/cas_cache/linux_kernel_version.h

@@ -40,7 +40,7 @@
 #include <linux/mm.h>
 #include <linux/blk-mq.h>
 #include <linux/ktime.h>
-#include "../cas_disk/exp_obj.h"
+#include "exp_obj.h"
 
 #include "generated_defines.h"
 

modules/cas_cache/main.c

@@ -40,17 +40,13 @@ MODULE_PARM_DESC(seq_cut_off_mb,
 
 /* globals */
 ocf_ctx_t cas_ctx;
+struct casdsk_module cas_module;
+struct casdsk_module *casdsk_module;
 
 static int __init cas_init_module(void)
 {
 	int result = 0;
 
-	if (casdsk_get_version() != CASDSK_IFACE_VERSION) {
-		printk(KERN_ERR OCF_PREFIX_SHORT
-				"Incompatible cas_disk module\n");
-		return -EINVAL;
-	}
-
 	if (!writeback_queue_unblock_size || !max_writeback_queue_size) {
 		printk(KERN_ERR OCF_PREFIX_SHORT
 				"Invalid module parameter.\n");
@@ -76,18 +72,28 @@ static int __init cas_init_module(void)
 		return -EINVAL;
 	}
 
+	casdsk_module = &cas_module;
+
+	result = casdsk_init_exp_objs();
+	if (result)
+		return result;
+
+	result = casdsk_init_disks();
+	if (result)
+		goto error_init_disks;
+
 	result = cas_initialize_context();
 	if (result) {
 		printk(KERN_ERR OCF_PREFIX_SHORT
 				"Cannot initialize cache library\n");
-		return result;
+		goto error_init_context;
 	}
 
 	result = cas_ctrl_device_init();
 	if (result) {
 		printk(KERN_ERR OCF_PREFIX_SHORT
 				"Cannot initialize control device\n");
-		goto error_cas_ctx_init;
+		goto error_init_device;
 	}
 
 	printk(KERN_INFO "%s Version %s (%s)::Module loaded successfully\n",
@@ -95,8 +101,12 @@ static int __init cas_init_module(void)
 
 	return 0;
 
-error_cas_ctx_init:
+error_init_device:
 	cas_cleanup_context();
+error_init_context:
+	casdsk_deinit_disks();
+error_init_disks:
+	casdsk_deinit_exp_objs();
 
 	return result;
 }
@@ -107,6 +117,8 @@ static void __exit cas_exit_module(void)
 {
 	cas_ctrl_device_deinit();
 	cas_cleanup_context();
+	casdsk_deinit_disks();
+	casdsk_deinit_exp_objs();
 }
 
 module_exit(cas_exit_module);