125 lines
3.0 KiB
C
125 lines
3.0 KiB
C
/*
|
|
* Copyright(c) 2012-2022 Intel Corporation
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#include "cas_cache.h"
|
|
|
|
/* Layer information. */
|
|
MODULE_AUTHOR("Intel(R) Corporation");
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
MODULE_VERSION(CAS_VERSION);
|
|
|
|
u32 max_writeback_queue_size = 65536;
|
|
module_param(max_writeback_queue_size, uint, (S_IRUSR | S_IRGRP));
|
|
MODULE_PARM_DESC(max_writeback_queue_size,
|
|
"Max cache writeback queue size (65536)");
|
|
|
|
u32 writeback_queue_unblock_size = 60000;
|
|
module_param(writeback_queue_unblock_size, uint, (S_IRUSR | S_IRGRP));
|
|
MODULE_PARM_DESC(writeback_queue_unblock_size,
|
|
"Cache writeback queue size (60000) at which queue "
|
|
"is unblocked when blocked");
|
|
|
|
u32 use_io_scheduler = 1;
|
|
module_param(use_io_scheduler, uint, (S_IRUSR | S_IRGRP));
|
|
MODULE_PARM_DESC(use_io_scheduler,
|
|
"Configure how IO shall be handled. "
|
|
"0 - in make request function, 1 - in request function");
|
|
|
|
u32 unaligned_io = 1;
|
|
module_param(unaligned_io, uint, (S_IRUSR | S_IRGRP));
|
|
MODULE_PARM_DESC(unaligned_io,
|
|
"Define how to handle I/O requests unaligned to 4 kiB, "
|
|
"0 - apply PT, 1 - handle by cache");
|
|
|
|
u32 seq_cut_off_mb = 1;
|
|
module_param(seq_cut_off_mb, uint, (S_IRUSR | S_IRGRP));
|
|
MODULE_PARM_DESC(seq_cut_off_mb,
|
|
"Sequential cut off threshold in MiB. 0 - disable");
|
|
|
|
/* 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 (!writeback_queue_unblock_size || !max_writeback_queue_size) {
|
|
printk(KERN_ERR OCF_PREFIX_SHORT
|
|
"Invalid module parameter.\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (writeback_queue_unblock_size >= max_writeback_queue_size) {
|
|
printk(KERN_ERR OCF_PREFIX_SHORT
|
|
"parameter writeback_queue_unblock_size"
|
|
" must be less than max_writeback_queue_size\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (unaligned_io != 0 && unaligned_io != 1) {
|
|
printk(KERN_ERR OCF_PREFIX_SHORT
|
|
"Invalid value for unaligned_io parameter\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (use_io_scheduler != 0 && use_io_scheduler != 1) {
|
|
printk(KERN_ERR OCF_PREFIX_SHORT
|
|
"Invalid value for use_io_scheduler parameter\n");
|
|
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");
|
|
goto error_init_context;
|
|
}
|
|
|
|
result = cas_ctrl_device_init();
|
|
if (result) {
|
|
printk(KERN_ERR OCF_PREFIX_SHORT
|
|
"Cannot initialize control device\n");
|
|
goto error_init_device;
|
|
}
|
|
|
|
printk(KERN_INFO "%s Version %s (%s)::Module loaded successfully\n",
|
|
OCF_PREFIX_LONG, CAS_VERSION, CAS_KERNEL);
|
|
|
|
return 0;
|
|
|
|
error_init_device:
|
|
cas_cleanup_context();
|
|
error_init_context:
|
|
casdsk_deinit_disks();
|
|
error_init_disks:
|
|
casdsk_deinit_exp_objs();
|
|
|
|
return result;
|
|
}
|
|
|
|
module_init(cas_init_module);
|
|
|
|
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);
|