github/open-cas-linux
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #1319 from robertbaldyga/casdsk-remove-dead-code

Browse Source 
Clean cas_disk out of dead code
This commit is contained in:
Robert Baldyga 2022-09-09 09:54:34 +02:00 committed by GitHub
commit a03c577f59
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 93 additions and 836 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
modules/cas_cache/cas_cache.h
View File

@ -1,5 +1,5 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* Copyright(c) 2012-2022 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
@ -64,34 +64,6 @@ struct cache_priv {
extern ocf_ctx_t cas_ctx;
extern struct casdsk_functions_mapper casdisk_functions;
struct casdsk_functions_mapper {
int (*casdsk_disk_detach)(struct casdsk_disk *dsk);
int (*casdsk_exp_obj_destroy)(struct casdsk_disk *dsk);
int (*casdsk_exp_obj_create)(struct casdsk_disk *dsk, const char *dev_name,
struct module *owner, struct casdsk_exp_obj_ops *ops);
void(*casdsk_exp_obj_free)(struct casdsk_disk *dsk);
struct request_queue *(*casdsk_disk_get_queue)(struct casdsk_disk *dsk);
struct block_device *(*casdsk_disk_get_blkdev)(struct casdsk_disk *dsk);
struct request_queue *(*casdsk_exp_obj_get_queue)(struct casdsk_disk *dsk);
uint32_t (*casdsk_get_version)(void);
void (*casdsk_disk_close)(struct casdsk_disk *dsk);
struct casdsk_disk *(*casdsk_disk_claim)(const char *path, void *private);
int (*casdsk_exp_obj_unlock)(struct casdsk_disk *dsk);
int (*casdsk_disk_set_pt)(struct casdsk_disk *dsk);
struct gendisk *(*casdsk_disk_get_gendisk)(struct casdsk_disk *dsk);
int (*casdsk_disk_attach) (struct casdsk_disk *dsk, struct module *owner,
struct casdsk_exp_obj_ops *ops);
int (*casdsk_disk_set_attached)(struct casdsk_disk *dsk);
int (*casdsk_exp_obj_activate)(struct casdsk_disk *dsk);
bool (*casdsk_exp_obj_activated)(struct casdsk_disk *ds);
int (*casdsk_exp_obj_lock)(struct casdsk_disk *dsk);
struct casdsk_disk *(*casdsk_disk_open)(const char *path, void *private);
int (*casdsk_disk_clear_pt)(struct casdsk_disk *dsk);
struct gendisk *(*casdsk_exp_obj_get_gendisk)(struct casdsk_disk *dsk);
};
static inline void cache_name_from_id(char *name, uint16_t id)
{
int result;

76
modules/cas_cache/main.c
View File

@ -40,86 +40,12 @@ MODULE_PARM_DESC(seq_cut_off_mb,
/* globals */
ocf_ctx_t cas_ctx;
struct casdsk_functions_mapper casdisk_functions;
#if defined(SYMBOL_LOOKUP_SUPPORTED) && defined(MODULE_MUTEX_SUPPORTED)
struct exported_symbol {
char *name;
unsigned long addr;
};
int static cas_find_symbol(void *data, const char *namebuf,
struct module *module, unsigned long kallsyms_addresses)
{
struct exported_symbol *sym = data;
if (strcmp(namebuf, sym->name) == 0)
sym->addr = kallsyms_addresses;
return 0;
}
#define cas_lookup_symbol(f) ({ \
struct exported_symbol sym = {#f, 0}; \
kallsyms_on_each_symbol(&cas_find_symbol, &sym); \
casdisk_functions.f = (void *)sym.addr; \
if (!casdisk_functions.f) \
return -EINVAL; \
})
#else
#include "../cas_disk/cas_disk.h"
#include "../cas_disk/exp_obj.h"
#define cas_lookup_symbol(f) ({ \
casdisk_functions.f = (void *)f; \
})
#endif
int static cas_casdisk_lookup_funtions(void)
{
#ifdef MODULE_MUTEX_SUPPORTED
mutex_lock(&module_mutex);
#endif
cas_lookup_symbol(casdsk_disk_detach);
cas_lookup_symbol(casdsk_exp_obj_destroy);
cas_lookup_symbol(casdsk_exp_obj_create);
cas_lookup_symbol(casdsk_exp_obj_free);
cas_lookup_symbol(casdsk_disk_get_queue);
cas_lookup_symbol(casdsk_disk_get_blkdev);
cas_lookup_symbol(casdsk_exp_obj_get_queue);
cas_lookup_symbol(casdsk_get_version);
cas_lookup_symbol(casdsk_disk_close);
cas_lookup_symbol(casdsk_disk_claim);
cas_lookup_symbol(casdsk_exp_obj_unlock);
cas_lookup_symbol(casdsk_disk_set_pt);
cas_lookup_symbol(casdsk_disk_get_gendisk);
cas_lookup_symbol(casdsk_disk_attach);
cas_lookup_symbol(casdsk_disk_set_attached);
cas_lookup_symbol(casdsk_exp_obj_activate);
cas_lookup_symbol(casdsk_exp_obj_activated);
cas_lookup_symbol(casdsk_exp_obj_lock);
cas_lookup_symbol(casdsk_disk_open);
cas_lookup_symbol(casdsk_disk_clear_pt);
cas_lookup_symbol(casdsk_exp_obj_get_gendisk);
#ifdef MODULE_MUTEX_SUPPORTED
mutex_unlock(&module_mutex);
#endif
return 0;
}
static int __init cas_init_module(void)
{
int result = 0;
result = cas_casdisk_lookup_funtions();
if (result) {
printk(KERN_ERR OCF_PREFIX_SHORT
"Could not find cas_disk functions.\n");
return result;
}
if (casdisk_functions.casdsk_get_version() != CASDSK_IFACE_VERSION) {
if (casdsk_get_version() != CASDSK_IFACE_VERSION) {
printk(KERN_ERR OCF_PREFIX_SHORT
"Incompatible cas_disk module\n");
return -EINVAL;

8
modules/cas_cache/volume/vol_block_dev_bottom.c
View File

@ -1,5 +1,5 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* Copyright(c) 2012-2022 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
@ -35,7 +35,7 @@ int block_dev_open_object(ocf_volume_t vol, void *volume_params)
return 0;
}
dsk = casdisk_functions.casdsk_disk_open(uuid->data, NULL);
dsk = casdsk_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 = casdisk_functions.casdsk_disk_get_blkdev(dsk);
bdobj->btm_bd = casdsk_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;
casdisk_functions.casdsk_disk_close(bdobj->dsk);
casdsk_disk_close(bdobj->dsk);
}
unsigned int block_dev_get_max_io_size(ocf_volume_t vol)

48
modules/cas_cache/volume/vol_block_dev_top.c
View File

@ -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 = casdisk_functions.casdsk_disk_get_queue(bd_core_vol->dsk);
exp_q = casdisk_functions.casdsk_exp_obj_get_queue(bd_core_vol->dsk);
cache_q = casdisk_functions.casdsk_disk_get_queue(bd_cache_vol->dsk);
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);
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));
@ -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 = casdisk_functions.casdsk_disk_get_blkdev(dsk);
core_bd = casdsk_disk_get_blkdev(dsk);
BUG_ON(!core_bd);
cache_bd = casdisk_functions.casdsk_disk_get_blkdev(bd_cache_vol->dsk);
cache_bd = casdsk_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 = casdisk_functions.casdsk_exp_obj_get_queue(dsk);
exp_q = casdsk_exp_obj_get_queue(dsk);
sectors = ocf_volume_get_length(core_vol) >> SECTOR_SHIFT;
set_capacity(casdisk_functions.casdsk_exp_obj_get_gendisk(dsk), sectors);
set_capacity(casdsk_exp_obj_get_gendisk(dsk), sectors);
cas_copy_queue_limits(exp_q, cache_q, core_q);
@ -473,15 +473,15 @@ static int blkdev_cache_set_geometry(struct casdsk_disk *dsk, void *private)
bvol = bd_object(volume);
bd = casdisk_functions.casdsk_disk_get_blkdev(bvol->dsk);
bd = casdsk_disk_get_blkdev(bvol->dsk);
BUG_ON(!bd);
cache_q = bd->bd_disk->queue;
exp_q = casdisk_functions.casdsk_exp_obj_get_queue(dsk);
exp_q = casdsk_exp_obj_get_queue(dsk);
sectors = ocf_volume_get_length(volume) >> SECTOR_SHIFT;
set_capacity(casdisk_functions.casdsk_exp_obj_get_gendisk(dsk), sectors);
set_capacity(casdsk_exp_obj_get_gendisk(dsk), sectors);
cas_copy_queue_limits(exp_q, cache_q, cache_q);
@ -538,7 +538,7 @@ static int kcas_volume_create_exported_object(ocf_volume_t volume,
struct casdsk_disk *dsk;
int result;
dsk = casdisk_functions.casdsk_disk_claim(uuid->data, priv);
dsk = casdsk_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 = casdisk_functions.casdsk_exp_obj_create(dsk, name,
result = casdsk_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 = casdisk_functions.casdsk_exp_obj_lock(bvol->dsk);
result = casdsk_exp_obj_lock(bvol->dsk);
if (result == -EBUSY)
return -KCAS_ERR_DEV_PENDING;
else if (result)
return result;
result = casdisk_functions.casdsk_exp_obj_destroy(bvol->dsk);
result = casdsk_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:
casdisk_functions.casdsk_exp_obj_unlock(bvol->dsk);
casdsk_exp_obj_unlock(bvol->dsk);
return result;
}
@ -610,7 +610,7 @@ static int kcas_volume_activate_exported_object(ocf_volume_t volume,
struct bd_object *bvol = bd_object(volume);
int result;
result = casdisk_functions.casdsk_exp_obj_activate(bvol->dsk);
result = casdsk_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 = casdisk_functions.casdsk_exp_obj_lock(bvol->dsk);
result = casdsk_exp_obj_lock(bvol->dsk);
if (-EBUSY == result) {
printk(KERN_WARNING "Stopping %s failed - device in use\n",
casdisk_functions.casdsk_exp_obj_get_gendisk(bvol->dsk)->disk_name);
casdsk_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",
casdisk_functions.casdsk_exp_obj_get_gendisk(bvol->dsk)->disk_name);
casdsk_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) {
casdisk_functions.casdsk_exp_obj_unlock(bvol->dsk);
casdsk_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",
casdisk_functions.casdsk_exp_obj_get_gendisk(bvol->dsk)->disk_name);
casdsk_exp_obj_get_gendisk(bvol->dsk)->disk_name);
ret = casdisk_functions.casdsk_exp_obj_destroy(bvol->dsk);
ret = casdsk_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) {
casdisk_functions.casdsk_exp_obj_unlock(bvol->dsk);
casdsk_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));
casdisk_functions.casdsk_exp_obj_free(bvol->dsk);
casdsk_exp_obj_free(bvol->dsk);
return 0;
}

3
modules/cas_disk/Makefile
View File

@ -1,5 +1,5 @@
#
# Copyright(c) 2012-2021 Intel Corporation
# Copyright(c) 2012-2022 Intel Corporation
# SPDX-License-Identifier: BSD-3-Clause
#
include $(M)/config.mk
@ -9,4 +9,3 @@ obj-m := cas_disk.o
cas_disk-objs = main.o
cas_disk-objs += disk.o
cas_disk-objs += exp_obj.o
cas_disk-objs += sysfs.o

47
modules/cas_disk/cas_disk.h
View File

@ -1,5 +1,5 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* Copyright(c) 2012-2022 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef __CASDISK_H__
@ -82,44 +82,6 @@ struct request_queue *casdsk_disk_get_queue(struct casdsk_disk *dsk);
*/
struct gendisk *casdsk_disk_get_gendisk(struct casdsk_disk *dsk);
/**
* @brief Prepare cas_disk device to switch to pass-through mode
* @param dsk Pointer to casdsk_disk structure related to cas_disk device
* @return 0 if success, errno if failure
*/
int casdsk_disk_set_pt(struct casdsk_disk *dsk);
/**
* @brief Prepare cas_disk device to switch to attached mode
* @param dsk Pointer to casdsk_disk structure related to cas_disk device
* @return 0 if success, errno if failure
*/
int casdsk_disk_set_attached(struct casdsk_disk *dsk);
/**
* @brief Revert cas_disk device back to attached mode
* @param dsk Pointer to casdsk_disk structure related to cas_disk device
* @return 0 if success, errno if failure
*/
int casdsk_disk_clear_pt(struct casdsk_disk *dsk);
/**
* @brief Detach cas from cas_disk device
* @param dsk Pointer to casdsk_disk structure related to cas_disk device
* @return 0 if success, errno if failure
*/
int casdsk_disk_detach(struct casdsk_disk *dsk);
/**
* @brief Attach cas to cas_disk device
* @param dsk Pointer to casdsk_disk structure related to cas_disk device
* @param owner Pointer to cas module
* @param ops Pointer to structure with callback functions
* @return 0 if success, errno if failure
*/
int casdsk_disk_attach(struct casdsk_disk *dsk, struct module *owner,
struct casdsk_exp_obj_ops *ops);
/**
* @brief Create exported object (top device)
* @param dsk Pointer to casdsk_disk structure related to cas_disk device
@ -153,13 +115,6 @@ struct gendisk *casdsk_exp_obj_get_gendisk(struct casdsk_disk *dsk);
*/
int casdsk_exp_obj_activate(struct casdsk_disk *dsk);
/**
* @brief Check if exported object is active
* @param dsk Pointer to casdsk_disk structure related to cas_disk device
* @return true if exported object is active
*/
bool casdsk_exp_obj_activated(struct casdsk_disk *dsk);
/**
* @brief Lock exported object
* @param dsk Pointer to casdsk_disk structure related to cas_disk device

53
modules/cas_disk/cas_disk_defs.h
View File

@ -1,5 +1,5 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* Copyright(c) 2012-2022 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef __CASDISK_DEFS_H__
@ -22,63 +22,12 @@ struct casdsk_module {
struct kmem_cache *disk_cache;
struct kmem_cache *exp_obj_cache;
struct kmem_cache *pt_io_ctx_cache;
struct kmem_cache *pending_rqs_cache;
struct kobject kobj;
};
extern struct casdsk_module *casdsk_module;
/* prefixes for messages */
#define CASDSK_LOGO "CAS Disk"
#define CASDSK_PREFIX_SHORT "[" CASDSK_LOGO "] "
#define CASDSK_PREFIX_LONG "Cache Acceleration Software Linux"
#define CASDSK_KERN_EMERG KERN_EMERG""CASDSK_PREFIX_SHORT
#define CASDSK_KERN_ALERT KERN_ALERT""CASDSK_PREFIX_SHORT
#define CASDSK_KERN_CRIT KERN_CRIT""CASDSK_PREFIX_SHORT
#define CASDSK_KERN_ERR KERN_ERR""CASDSK_PREFIX_SHORT
#define CASDSK_KERN_WARNING KERN_WARNING""CASDSK_PREFIX_SHORT
#define CASDSK_KERN_NOTICE KERN_NOTICE""CASDSK_PREFIX_SHORT
#define CASDSK_KERN_INFO KERN_INFO""CASDSK_PREFIX_SHORT
#define CASDSK_KERN_DEBUG KERN_DEBUG""CASDSK_PREFIX_SHORT
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 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
#include "debug.h"
#endif

12
modules/cas_disk/debug.h
View File

@ -1,5 +1,5 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* Copyright(c) 2012-2022 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef __CASDISK_DEBUG_H__
@ -9,20 +9,20 @@
#ifdef CASDSK_DEBUG
#define CASDSK_DEBUG_TRACE() \
printk(CASDSK_KERN_INFO "%s\n", __func__)
printk(KERN_INFO "%s\n", __func__)
#define CASDSK_DEBUG_DISK_TRACE(dsk) \
printk(CASDSK_KERN_INFO "[%u] %s\n", dsk->id, __func__)
printk(KERN_INFO "[%u] %s\n", dsk->id, __func__)
#define CASDSK_DEBUG_MSG(msg) \
printk(CASDSK_KERN_INFO "%s - %s\n", __func__, msg)
printk(KERN_INFO "%s - %s\n", __func__, msg)
#define CASDSK_DEBUG_PARAM(format, ...) \
printk(CASDSK_KERN_INFO "%s - "format"\n", \
printk(KERN_INFO "%s - "format"\n", \
__func__, ##__VA_ARGS__)
#define CASDSK_DEBUG_DISK(dsk, format, ...) \
printk(CASDSK_KERN_INFO "[%u] %s - "format"\n", \
printk(KERN_INFO "[%u] %s - "format"\n", \
dsk->id, \
__func__, ##__VA_ARGS__)

231
modules/cas_disk/disk.c
View File

@ -10,17 +10,20 @@
#include "cas_cache.h"
#include "disk.h"
#include "exp_obj.h"
#include "sysfs.h"
#define CASDSK_DISK_OPEN_FMODE (FMODE_READ | FMODE_WRITE)
static const char * const _casdsk_disk_modes[] = {
[CASDSK_MODE_UNKNOWN] = "unknown",
[CASDSK_MODE_PT] = "pass-through",
[CASDSK_MODE_ATTACHED] = "attached",
[CASDSK_MODE_TRANS_TO_PT] = "attached -> pass-through",
[CASDSK_MODE_TRANS_TO_ATTACHED] = "pass-through -> attached"
};
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)
{
@ -38,28 +41,8 @@ static void _casdsk_disk_release(struct kobject *kobj)
kmem_cache_free(casdsk_module->disk_cache, dsk);
}
static ssize_t _casdsk_disk_mode_show(struct kobject *kobj, char *page)
{
struct casdsk_disk *dsk = casdsk_kobj_to_disk(kobj);
CASDSK_DEBUG_DISK_TRACE(dsk);
return scnprintf(page, PAGE_SIZE, "%s",
_casdsk_disk_modes[atomic_read(&dsk->mode)]);
}
static struct casdsk_attribute _casdsk_disk_mode_attr =
__ATTR(mode, S_IRUGO, _casdsk_disk_mode_show, NULL);
static struct attribute *_casdsk_disk_attrs[] = {
&_casdsk_disk_mode_attr.attr,
NULL
};
static struct kobj_type casdsk_disk_ktype = {
.release = _casdsk_disk_release,
.sysfs_ops = &casdsk_sysfs_ops,
.default_attrs = _casdsk_disk_attrs
};
int __init casdsk_init_disks(void)
@ -134,8 +117,6 @@ struct casdsk_disk *casdsk_disk_open(const char *path, void *private)
goto error_kstrdup;
}
atomic_set(&dsk->mode, CASDSK_MODE_UNKNOWN);
dsk->bd = open_bdev_exclusive(path, CASDSK_DISK_OPEN_FMODE, dsk);
if (IS_ERR(dsk->bd)) {
CASDSK_DEBUG_ERROR("Cannot open exclusive");
@ -225,45 +206,6 @@ void casdsk_disk_close(struct casdsk_disk *dsk)
}
EXPORT_SYMBOL(casdsk_disk_close);
void __exit casdsk_disk_shutdown_all(void)
{
struct list_head *item, *n;
struct casdsk_disk *dsk;
CASDSK_DEBUG_TRACE();
mutex_lock(&casdsk_module->lock);
list_for_each_safe(item, n, &casdsk_module->disk_list) {
dsk = list_entry(item, struct casdsk_disk, list);
list_del(item);
casdsk_disk_lock(dsk);
BUG_ON(!casdsk_disk_is_pt(dsk) && !casdsk_disk_is_unknown(dsk));
if (casdsk_disk_is_pt(dsk)) {
atomic_set(&dsk->mode, CASDSK_MODE_TRANS_TO_SHUTDOWN);
casdsk_exp_obj_prepare_shutdown(dsk);
}
atomic_set(&dsk->mode, CASDSK_MODE_SHUTDOWN);
if (dsk->exp_obj) {
casdsk_exp_obj_lock(dsk);
casdsk_exp_obj_destroy(dsk);
casdsk_exp_obj_unlock(dsk);
}
casdsk_disk_unlock(dsk);
__casdsk_disk_close(dsk);
}
mutex_unlock(&casdsk_module->lock);
}
struct block_device *casdsk_disk_get_blkdev(struct casdsk_disk *dsk)
{
BUG_ON(!dsk);
@ -277,7 +219,6 @@ struct gendisk *casdsk_disk_get_gendisk(struct casdsk_disk *dsk)
BUG_ON(!dsk->bd);
return dsk->bd->bd_disk;
}
EXPORT_SYMBOL(casdsk_disk_get_gendisk);
struct request_queue *casdsk_disk_get_queue(struct casdsk_disk *dsk)
{
@ -300,153 +241,3 @@ int casdsk_disk_allocate_minors(int count)
return minor;
}
static inline int __casdsk_disk_set_pt(struct casdsk_disk *dsk)
{
BUG_ON(!dsk);
atomic_set(&dsk->mode, CASDSK_MODE_TRANS_TO_PT);
casdsk_exp_obj_prepare_pt(dsk);
return 0;
}
int casdsk_disk_set_pt(struct casdsk_disk *dsk)
{
int result;
CASDSK_DEBUG_DISK_TRACE(dsk);
if (!dsk->exp_obj)
return 0;
casdsk_disk_lock(dsk);
result = __casdsk_disk_set_pt(dsk);
casdsk_disk_unlock(dsk);
return result;
}
EXPORT_SYMBOL(casdsk_disk_set_pt);
static inline int __casdsk_disk_set_attached(struct casdsk_disk *dsk)
{
atomic_set(&dsk->mode, CASDSK_MODE_TRANS_TO_ATTACHED);
casdsk_exp_obj_prepare_attached(dsk);
return 0;
}
int casdsk_disk_set_attached(struct casdsk_disk *dsk)
{
int result;
BUG_ON(!dsk);
CASDSK_DEBUG_DISK_TRACE(dsk);
if (!dsk->exp_obj)
return 0;
casdsk_disk_lock(dsk);
result = __casdsk_disk_set_attached(dsk);
casdsk_disk_unlock(dsk);
return result;
}
EXPORT_SYMBOL(casdsk_disk_set_attached);
static inline int __casdsk_disk_clear_pt(struct casdsk_disk *dsk)
{
BUG_ON(atomic_read(&dsk->mode) != CASDSK_MODE_TRANS_TO_PT);
atomic_set(&dsk->mode, CASDSK_MODE_ATTACHED);
return 0;
}
int casdsk_disk_clear_pt(struct casdsk_disk *dsk)
{
int result;
BUG_ON(!dsk);
CASDSK_DEBUG_DISK_TRACE(dsk);
if (!dsk->exp_obj)
return 0;
casdsk_disk_lock(dsk);
result = __casdsk_disk_clear_pt(dsk);
casdsk_disk_unlock(dsk);
return result;
}
EXPORT_SYMBOL(casdsk_disk_clear_pt);
static inline int __casdsk_disk_detach(struct casdsk_disk *dsk)
{
int result;
BUG_ON(atomic_read(&dsk->mode) != CASDSK_MODE_TRANS_TO_PT);
atomic_set(&dsk->mode, CASDSK_MODE_PT);
result = casdsk_exp_obj_detach(dsk);
if (result) {
atomic_set(&dsk->mode, CASDSK_MODE_ATTACHED);
return result;
}
return 0;
}
int casdsk_disk_detach(struct casdsk_disk *dsk)
{
int result;
BUG_ON(!dsk);
CASDSK_DEBUG_DISK_TRACE(dsk);
if (!dsk->exp_obj)
return 0;
casdsk_disk_lock(dsk);
result = __casdsk_disk_detach(dsk);
casdsk_disk_unlock(dsk);
return result;
}
EXPORT_SYMBOL(casdsk_disk_detach);
static inline int __casdsk_disk_attach(struct casdsk_disk *dsk,
struct module *owner, struct casdsk_exp_obj_ops *ops)
{
int result;
BUG_ON(!ops);
BUG_ON(atomic_read(&dsk->mode) != CASDSK_MODE_TRANS_TO_ATTACHED);
result = casdsk_exp_obj_attach(dsk, owner, ops);
if (result) {
atomic_set(&dsk->mode, CASDSK_MODE_PT);
return result;
}
atomic_set(&dsk->mode, CASDSK_MODE_ATTACHED);
return 0;
}
int casdsk_disk_attach(struct casdsk_disk *dsk, struct module *owner,
struct casdsk_exp_obj_ops *ops)
{
int result;
CASDSK_DEBUG_DISK_TRACE(dsk);
if (!dsk->exp_obj)
return 0;
casdsk_disk_lock(dsk);
result = __casdsk_disk_attach(dsk, owner, ops);
casdsk_disk_unlock(dsk);
return result;
}
EXPORT_SYMBOL(casdsk_disk_attach);

42
modules/cas_disk/disk.h
View File

@ -13,20 +13,8 @@
struct casdsk_exp_obj;
#define CASDSK_MODE_UNKNOWN 0
#define CASDSK_MODE_PT (1 << 0)
#define CASDSK_MODE_ATTACHED (1 << 1)
#define CASDSK_MODE_SHUTDOWN (1 << 2)
#define CASDSK_MODE_TRANSITION (1 << 3)
#define CASDSK_MODE_TRANS_TO_ATTACHED (CASDSK_MODE_PT | CASDSK_MODE_TRANSITION)
#define CASDSK_MODE_TRANS_TO_PT (CASDSK_MODE_ATTACHED | \
CASDSK_MODE_TRANSITION)
#define CASDSK_MODE_TRANS_TO_SHUTDOWN (CASDSK_MODE_SHUTDOWN | \
CASDSK_MODE_TRANSITION)
struct casdsk_disk {
uint32_t id;
atomic_t mode;
char *path;
struct mutex lock;
@ -52,8 +40,6 @@ struct casdsk_disk {
int __init casdsk_init_disks(void);
void casdsk_deinit_disks(void);
void __exit casdsk_disk_shutdown_all(void);
int casdsk_disk_allocate_minors(int count);
static inline void casdsk_disk_lock(struct casdsk_disk *dsk)
@ -71,32 +57,4 @@ static inline struct casdsk_disk *casdsk_kobj_to_disk(struct kobject *kobj)
return container_of(kobj, struct casdsk_disk, kobj);
}
static inline bool casdsk_disk_in_transition(struct casdsk_disk *dsk)
{
return (atomic_read(&dsk->mode) & CASDSK_MODE_TRANSITION) ==
CASDSK_MODE_TRANSITION;
}
static inline bool casdsk_disk_is_attached(struct casdsk_disk *dsk)
{
return (atomic_read(&dsk->mode) & CASDSK_MODE_ATTACHED) ==
CASDSK_MODE_ATTACHED;
}
static inline bool casdsk_disk_is_pt(struct casdsk_disk *dsk)
{
return (atomic_read(&dsk->mode) & CASDSK_MODE_PT) == CASDSK_MODE_PT;
}
static inline bool casdsk_disk_is_shutdown(struct casdsk_disk *dsk)
{
return (atomic_read(&dsk->mode) & CASDSK_MODE_SHUTDOWN) ==
CASDSK_MODE_SHUTDOWN;
}
static inline bool casdsk_disk_is_unknown(struct casdsk_disk *dsk)
{
return atomic_read(&dsk->mode) == CASDSK_MODE_UNKNOWN;
}
#endif

246
modules/cas_disk/exp_obj.c
View File

@ -19,167 +19,63 @@
#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)
{
int ncpus;
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)
goto error_exp_obj_cache;
ncpus = num_online_cpus();
casdsk_module->pending_rqs_cache =
kmem_cache_create("casdsk_exp_obj_pending_rqs",
((sizeof(atomic_t) * ncpus) < KMEM_CACHE_MIN_SIZE) ?
KMEM_CACHE_MIN_SIZE : (sizeof(atomic_t) * ncpus),
0, 0, NULL);
if (!casdsk_module->pending_rqs_cache)
goto error_pending_rqs_cache;
casdsk_module->pt_io_ctx_cache =
kmem_cache_create("casdsk_exp_obj_pt_io_ctx",
sizeof(struct casdsk_exp_obj_pt_io_ctx),
0, 0, NULL);
if (!casdsk_module->pt_io_ctx_cache)
goto error_pt_io_ctx_cache;
return -ENOMEM;
return 0;
error_pt_io_ctx_cache:
kmem_cache_destroy(casdsk_module->pending_rqs_cache);
error_pending_rqs_cache:
kmem_cache_destroy(casdsk_module->exp_obj_cache);
error_exp_obj_cache:
return -ENOMEM;
}
void casdsk_deinit_exp_objs(void)
{
CASDSK_DEBUG_TRACE();
kmem_cache_destroy(casdsk_module->pt_io_ctx_cache);
kmem_cache_destroy(casdsk_module->pending_rqs_cache);
kmem_cache_destroy(casdsk_module->exp_obj_cache);
}
static inline void _casdsk_exp_obj_handle_bio_att(struct casdsk_disk *dsk,
struct bio *bio)
{
dsk->exp_obj->ops->submit_bio(dsk, bio, dsk->private);
}
CAS_DECLARE_BLOCK_CALLBACK(_casdsk_exp_obj_bio_pt_io, struct bio *bio,
unsigned int bytes_done, int error)
{
struct casdsk_exp_obj_pt_io_ctx *io;
BUG_ON(!bio);
CAS_BLOCK_CALLBACK_INIT(bio);
io = bio->bi_private;
BUG_ON(!io);
CAS_BIO_ENDIO(io->bio, CAS_BIO_BISIZE(io->bio),
CAS_BLOCK_CALLBACK_ERROR(bio, CAS_ERRNO_TO_BLK_STS(error)));
if (atomic_dec_return(&io->dsk->exp_obj->pt_ios) < 0)
BUG();
bio_put(bio);
kmem_cache_free(casdsk_module->pt_io_ctx_cache, io);
CAS_BLOCK_CALLBACK_RETURN();
}
static inline void _casdsk_exp_obj_handle_bio_pt(struct casdsk_disk *dsk,
struct bio *bio)
{
struct bio *cloned_bio;
struct casdsk_exp_obj_pt_io_ctx *io;
io = kmem_cache_zalloc(casdsk_module->pt_io_ctx_cache, GFP_NOIO);
if (!io) {
CAS_BIO_ENDIO(bio, CAS_BIO_BISIZE(bio), CAS_ERRNO_TO_BLK_STS(-ENOMEM));
return;
}
cloned_bio = cas_bio_clone(bio, GFP_NOIO);
if (!cloned_bio) {
kmem_cache_free(casdsk_module->pt_io_ctx_cache, io);
CAS_BIO_ENDIO(bio, CAS_BIO_BISIZE(bio), CAS_ERRNO_TO_BLK_STS(-ENOMEM));
return;
}
io->bio = bio;
io->dsk = dsk;
atomic_inc(&dsk->exp_obj->pt_ios);
CAS_BIO_SET_DEV(cloned_bio, casdsk_disk_get_blkdev(dsk));
cloned_bio->bi_private = io;
cloned_bio->bi_end_io = CAS_REFER_BLOCK_CALLBACK(_casdsk_exp_obj_bio_pt_io);
cas_submit_bio(CAS_BIO_OP_FLAGS(cloned_bio), cloned_bio);
}
static inline void _casdsk_exp_obj_handle_bio(struct casdsk_disk *dsk,
struct bio *bio)
{
if (likely(casdsk_disk_is_attached(dsk)))
_casdsk_exp_obj_handle_bio_att(dsk, bio);
else if (casdsk_disk_is_pt(dsk))
_casdsk_exp_obj_handle_bio_pt(dsk, bio);
else if (casdsk_disk_is_shutdown(dsk))
CAS_BIO_ENDIO(bio, CAS_BIO_BISIZE(bio), CAS_ERRNO_TO_BLK_STS(-EIO));
else
BUG();
}
static inline void _casdsk_exp_obj_end_rq(struct casdsk_disk *dsk, unsigned int cpu)
{
return atomic_dec(&dsk->exp_obj->pending_rqs[cpu]);
}
static inline unsigned int _casdsk_exp_obj_begin_rq(struct casdsk_disk *dsk)
{
unsigned int cpu;
BUG_ON(!dsk);
retry:
while (unlikely(casdsk_disk_in_transition(dsk)))
io_schedule();
cpu = smp_processor_id();
atomic_inc(&dsk->exp_obj->pending_rqs[cpu]);
if (unlikely(casdsk_disk_in_transition(dsk))) {
/*
* If we are in transition state, decrement pending rqs counter
* and retry bio processing
*/
_casdsk_exp_obj_end_rq(dsk, cpu);
goto retry;
}
return cpu;
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;
unsigned int cpu;
BUG_ON(!bio);
dsk = CAS_BIO_GET_GENDISK(bio)->private_data;
cpu = _casdsk_exp_obj_begin_rq(dsk);
_casdsk_exp_obj_handle_bio(dsk, bio);
_casdsk_exp_obj_end_rq(dsk, cpu);
KRETURN(0);
}
@ -240,10 +136,10 @@ static int _casdsk_del_partitions(struct casdsk_disk *dsk)
}
result = cas_vfs_ioctl(bd_file, BLKPG, usr_barg);
if (result == 0) {
printk(CASDSK_KERN_INFO "Partition %d on %s hidden\n",
printk(KERN_INFO "Partition %d on %s hidden\n",
part_no, bd->bd_disk->disk_name);
} else {
printk(CASDSK_KERN_ERR "Error(%d) hiding the partition %d on %s\n",
printk(KERN_ERR "Error(%d) hiding the partition %d on %s\n",
result, part_no, bd->bd_disk->disk_name);
break;
}
@ -275,7 +171,7 @@ static int _casdsk_exp_obj_hide_parts(struct casdsk_disk *dsk)
if (disk_max_parts(dsk->bd->bd_disk) > 1) {
if (_casdsk_del_partitions(dsk)) {
printk(CASDSK_KERN_ERR "Error deleting a partition on thedevice %s\n",
printk(KERN_ERR "Error deleting a partition on thedevice %s\n",
gdsk->disk_name);
/* Try restore previous partitions by rescaning */
@ -383,7 +279,6 @@ static const struct block_device_operations _casdsk_exp_obj_ops = {
static int casdsk_exp_obj_alloc(struct casdsk_disk *dsk)
{
struct casdsk_exp_obj *exp_obj;
int result;
BUG_ON(!dsk);
BUG_ON(dsk->exp_obj);
@ -393,24 +288,12 @@ static int casdsk_exp_obj_alloc(struct casdsk_disk *dsk)
exp_obj = kmem_cache_zalloc(casdsk_module->exp_obj_cache, GFP_KERNEL);
if (!exp_obj) {
CASDSK_DEBUG_ERROR("Cannot allocate memory");
result = -ENOMEM;
goto error_exp_obj_alloc;
}
exp_obj->pending_rqs = kmem_cache_zalloc(casdsk_module->pending_rqs_cache,
GFP_KERNEL);
if (!exp_obj->pending_rqs) {
result = -ENOMEM;
goto error_pending_rqs_alloc;
return -ENOMEM;
}
dsk->exp_obj = exp_obj;
return 0;
error_pending_rqs_alloc:
kmem_cache_free(casdsk_module->exp_obj_cache, exp_obj);
error_exp_obj_alloc:
return result;
}
void casdsk_exp_obj_free(struct casdsk_disk *dsk)
@ -431,7 +314,6 @@ EXPORT_SYMBOL(casdsk_exp_obj_free);
static void __casdsk_exp_obj_release(struct casdsk_exp_obj *exp_obj)
{
kmem_cache_free(casdsk_module->pending_rqs_cache, exp_obj->pending_rqs);
kmem_cache_free(casdsk_module->exp_obj_cache, exp_obj);
}
@ -675,7 +557,7 @@ int casdsk_exp_obj_activate(struct casdsk_disk *dsk)
snprintf(path, PATH_MAX, "/dev/%s", dsk->exp_obj->dev_name);
if (_casdsk_exp_obj_exists(path)) {
printk(CASDSK_KERN_ERR "Could not activate exported object, "
printk(KERN_ERR "Could not activate exported object, "
"because file %s exists.\n", path);
kfree(path);
return -EEXIST;
@ -683,7 +565,6 @@ int casdsk_exp_obj_activate(struct casdsk_disk *dsk)
kfree(path);
dsk->exp_obj->activated = true;
atomic_set(&dsk->mode, CASDSK_MODE_ATTACHED);
add_disk(dsk->exp_obj->gd);
result = bd_claim_by_disk(dsk->bd, dsk, dsk->exp_obj->gd);
@ -714,7 +595,6 @@ bool casdsk_exp_obj_activated(struct casdsk_disk *dsk)
BUG_ON(!dsk);
return dsk->exp_obj->activated;
}
EXPORT_SYMBOL(casdsk_exp_obj_activated);
int casdsk_exp_obj_lock(struct casdsk_disk *dsk)
{
@ -778,75 +658,9 @@ int casdsk_exp_obj_destroy(struct casdsk_disk *dsk)
blk_mq_free_tag_set(&dsk->tag_set);
atomic_set(&dsk->mode, CASDSK_MODE_UNKNOWN);
put_disk(exp_obj->gd);
return 0;
}
EXPORT_SYMBOL(casdsk_exp_obj_destroy);
int casdsk_exp_obj_detach(struct casdsk_disk *dsk)
{
module_put(dsk->exp_obj->owner);
dsk->exp_obj->owner = NULL;
dsk->exp_obj->ops = NULL;
return 0;
}
int casdsk_exp_obj_attach(struct casdsk_disk *dsk, struct module *owner,
struct casdsk_exp_obj_ops *ops)
{
if (!try_module_get(owner)) {
CASDSK_DEBUG_DISK_ERROR(dsk, "Cannot get reference to module");
return -ENAVAIL;
}
dsk->exp_obj->owner = owner;
dsk->exp_obj->ops = ops;
return 0;
}
static void _casdsk_exp_obj_wait_for_pending_rqs(struct casdsk_disk *dsk)
{
int i, ncpus;
struct casdsk_exp_obj *exp_obj = dsk->exp_obj;
ncpus = num_online_cpus();
for (i = 0; i < ncpus; i++)
while (atomic_read(&exp_obj->pending_rqs[i]))
schedule();
}
static void _casdsk_exp_obj_flush_queue(struct casdsk_disk *dsk)
{
struct casdsk_exp_obj *exp_obj = dsk->exp_obj;
struct request_queue *q = exp_obj->queue;
blk_mq_run_hw_queues(q, false);
blk_sync_queue(q);
}
void casdsk_exp_obj_prepare_pt(struct casdsk_disk *dsk)
{
_casdsk_exp_obj_wait_for_pending_rqs(dsk);
_casdsk_exp_obj_flush_queue(dsk);
}
void casdsk_exp_obj_prepare_attached(struct casdsk_disk *dsk)
{
_casdsk_exp_obj_wait_for_pending_rqs(dsk);
while (atomic_read(&dsk->exp_obj->pt_ios))
schedule_timeout(msecs_to_jiffies(200));
}
void casdsk_exp_obj_prepare_shutdown(struct casdsk_disk *dsk)
{
_casdsk_exp_obj_wait_for_pending_rqs(dsk);
while (atomic_read(&dsk->exp_obj->pt_ios))
schedule_timeout(msecs_to_jiffies(200));
}

8
modules/cas_disk/exp_obj.h
View File

@ -40,14 +40,6 @@ void casdsk_deinit_exp_objs(void);
void casdsk_exp_obj_free(struct casdsk_disk *dsk);
int casdsk_exp_obj_detach(struct casdsk_disk *dsk);
int casdsk_exp_obj_attach(struct casdsk_disk *dsk, struct module *owner,
struct casdsk_exp_obj_ops *ops);
void casdsk_exp_obj_prepare_pt(struct casdsk_disk *dsk);
void casdsk_exp_obj_prepare_attached(struct casdsk_disk *dsk);
void casdsk_exp_obj_prepare_shutdown(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);

53
modules/cas_disk/main.c
View File

@ -1,5 +1,5 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* Copyright(c) 2012-2022 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
@ -10,7 +10,8 @@
#include "cas_disk.h"
#include "disk.h"
#include "exp_obj.h"
#include "sysfs.h"
#define CASDSK_LOGO "CAS Disk"
/* Layer information. */
MODULE_AUTHOR("Intel(R) Corporation");
@ -28,38 +29,6 @@ uint32_t casdsk_get_version(void)
}
EXPORT_SYMBOL(casdsk_get_version);
static void _casdsk_module_release(struct kobject *kobj)
{
struct casdsk_module *mod;
CASDSK_DEBUG_TRACE();
BUG_ON(!kobj);
mod = container_of(kobj, struct casdsk_module, kobj);
BUG_ON(!mod);
kfree(mod);
}
static struct kobj_type _casdsk_module_ktype = {
.release = _casdsk_module_release,
};
static int __init casdsk_init_kobjects(void)
{
int result = 0;
CASDSK_DEBUG_TRACE();
kobject_init(&casdsk_module->kobj, &_casdsk_module_ktype);
result = kobject_add(&casdsk_module->kobj, kernel_kobj, "cas_disk");
if (result)
CASDSK_DEBUG_ERROR("Cannot register kobject");
return result;
}
static int __init casdsk_init_module(void)
{
int result = 0;
@ -82,19 +51,13 @@ static int __init casdsk_init_module(void)
if (result)
goto error_init_disks;
result = casdsk_init_kobjects();
if (result)
goto error_kobjects;
mutex_unlock(&casdsk_module->lock);
printk(CASDSK_KERN_INFO "%s Version %s (%s)::Module loaded successfully\n",
printk(KERN_INFO "%s Version %s (%s)::Module loaded successfully\n",
CASDSK_LOGO, CAS_VERSION, CAS_KERNEL);
return result;
error_kobjects:
casdsk_deinit_disks();
error_init_disks:
casdsk_deinit_exp_objs();
error_init_exp_objs:
@ -105,16 +68,10 @@ error_kmalloc:
}
module_init(casdsk_init_module);
static void __exit casdsk_deinit_kobjects(void)
{
kobject_put(&casdsk_module->kobj);
}
static void __exit casdsk_exit_module(void)
{
casdsk_disk_shutdown_all();
casdsk_deinit_disks();
casdsk_deinit_exp_objs();
casdsk_deinit_kobjects();
kfree(casdsk_module);
}
module_exit(casdsk_exit_module);

35
modules/cas_disk/sysfs.c
View File

@ -1,35 +0,0 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "cas_disk_defs.h"
#include "sysfs.h"
static ssize_t _casdsk_sysfs_show(struct kobject *kobj, struct attribute *attr,
char *page)
{
struct casdsk_attribute *casdsk_attr =
container_of(attr, struct casdsk_attribute, attr);
if (!casdsk_attr->show)
return -EIO;
return casdsk_attr->show(kobj, page);
}
static ssize_t _casdsk_sysfs_store(struct kobject *kobj, struct attribute *attr,
const char *buf, size_t len)
{
struct casdsk_attribute *casdsk_attr =
container_of(attr, struct casdsk_attribute, attr);
if (!casdsk_attr->store)
return -EIO;
return casdsk_attr->store(kobj, buf, len);
}
const struct sysfs_ops casdsk_sysfs_ops = {
.show = _casdsk_sysfs_show,
.store = _casdsk_sysfs_store
};

21
modules/cas_disk/sysfs.h
View File

@ -1,21 +0,0 @@
/*
* Copyright(c) 2012-2021 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef __CASDISK_SYSFS_H__
#define __CASDISK_SYSFS_H__
#include <linux/kobject.h>
#include <linux/sysfs.h>
struct casdsk_disk;
struct casdsk_attribute {
struct attribute attr;
ssize_t (*show)(struct kobject *kobj, char *page);
ssize_t (*store)(struct kobject *kobj, const char *buf, size_t len);
};
extern const struct sysfs_ops casdsk_sysfs_ops;
#endif