Merge pull request #67 from mmichal10/execute-configure-in-parallel

Execute configure in parallel
This commit is contained in:
Michal Rakowski 2019-07-16 14:14:37 +02:00 committed by GitHub
commit a493b9d3fc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
36 changed files with 1384 additions and 677 deletions

82
configure vendored
View File

@ -3,23 +3,83 @@
# Copyright(c) 2012-2019 Intel Corporation # Copyright(c) 2012-2019 Intel Corporation
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
which dirname 2>&1 > /dev/null || { echo >&2 "Eror: missing 'dirname' utility"; exit 1; }
which realpath 2>&1 > /dev/null || { echo >&2 "Eror: missing 'realpath' utility"; exit 1; } check_util() {
which $1 2>&1 > /dev/null || { echo >&2 "Error: missing '$1' utility"; exit 1; }
}
check_util dirname
check_util realpath
check_util basename
check_util awk
SCRIPTPATH=`dirname $0` SCRIPTPATH=`dirname $0`
SCRIPTPATH=`realpath $SCRIPTPATH` SCRIPTPATH=`realpath $SCRIPTPATH`
CONFIG_FILES=`ls $SCRIPTPATH/configure.d/*.conf | sort` CONFIG_FILES=`ls $SCRIPTPATH/configure.d/*.conf | sort`
FILES_COUNT=`echo $CONFIG_FILES | wc -w`
rm -f $SCRIPTPATH/modules/generated_defines.h CONFIG_FILE=$SCRIPTPATH/"config.out"
files_count=`echo $CONFIG_FILES | wc -w` generate_config() {
progress=0 rm -f ${CONFIG_FILE}
touch ${CONFIG_FILE}
declare -a pid_list
progress=0
for file in $CONFIG_FILES; do # Compile each test module in background
progress=$((progress+1)) echo "Preparing configuration"
echo -ne "Configuring OpenCAS: $progress/$files_count\033[0K\r" for file in $CONFIG_FILES; do
/bin/bash $file progress=$((progress+1))
done # $1 - Action to be performed
echo -ne " \033[0K\r" # $2 - File with stored configuration
# $3 - Name of called script (since script is running as subprocess
# it has to be passed explicitly)
source $file "check" "$CONFIG_FILE" "$file" &
pid_list+=($!)
done
# Wait for all compilation processes to finish
wait
grep "X" ${CONFIG_FILE} &> /dev/null
if [ $? -eq 0 ] ; then
echo "ERROR! Following steps failed while preparing config:"
grep "X" ${CONFIG_FILE} | cut -f1 -d ' '
exit 1
fi
}
generate_header() {
rm -f $SCRIPTPATH/modules/generated_defines.h
# Configs starting with '1_' have to be put as first in header
FIRST=$(echo $CONFIG_FILES | tr ' ' '\n' | grep '1_')
SECOND=$(echo $CONFIG_FILES | tr ' ' '\n' | grep '2_')
echo "Configuring OpenCAS"
for file in $FIRST; do
CONF=$(cat ${CONFIG_FILE} | grep $(basename $file) | cut -d' ' -f2)
source $file "apply" "$CONF" "$file" &
done
wait
for file in $SECOND; do
CONF=$(cat ${CONFIG_FILE} | grep $(basename $file) | cut -d' ' -f2)
source $file "apply" "$CONF" "$file" &
done
wait
}
if [ -z "$1" ]; then
generate_config
else
CONFIG_FILE=$(realpath $1)
if [ $? -ne 0 ] ; then
echo "Invaild path to config file!"
exit 1
fi
fi
generate_header

View File

@ -4,13 +4,31 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct bio *b;blk_rq_append_bio(NULL, &b)" "linux/blkdev.h"
then check() {
add_define "cas_blk_rq_append_bio(rq, bounce_bio) \\ cur_name=$(basename $2)
blk_rq_append_bio(rq, &bounce_bio)" config_file_path=$1
else if compile_module $cur_name "struct bio *b;blk_rq_append_bio(NULL, &b)" "linux/blkdev.h"
add_define "cas_blk_rq_append_bio(rq, bounce_bio) \\ then
blk_rq_append_bio(rq, bounce_bio)" echo $cur_name 1 >> $config_file_path
fi else
echo $cur_name 2 >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "cas_blk_rq_append_bio(rq, bounce_bio) \\
blk_rq_append_bio(rq, &bounce_bio)" ;;
"2")
add_define "cas_blk_rq_append_bio(rq, bounce_bio) \\
blk_rq_append_bio(rq, bounce_bio)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,14 +4,33 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "lookup_bdev(\"some_path\")" "linux/fs.h" check() {
then cur_name=$(basename $2)
add_define "CAS_LOOKUP_BDEV(PATH) \\ config_file_path=$1
lookup_bdev(PATH)" if compile_module $cur_name "lookup_bdev(\"some_path\")" "linux/fs.h"
elif compile_module "lookup_bdev(\"some_path\", 0)" "linux/fs.h" then
then echo $cur_name "1" >> $config_file_path
add_define "CAS_LOOKUP_BDEV(PATH) \\ elif compile_module $cur_name "lookup_bdev(\"some_path\", 0)" "linux/fs.h"
lookup_bdev(PATH, 0)" then
fi echo $cur_name "2" >> $config_file_path
else
echo $cur_name "X" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_LOOKUP_BDEV(PATH) \\
lookup_bdev(PATH)" ;;
"2")
add_define "CAS_LOOKUP_BDEV(PATH) \\
lookup_bdev(PATH, 0)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,24 +4,45 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "bio_clone(NULL, 0)" "linux/bio.h" check() {
then cur_name=$(basename $2)
add_function "static inline struct bio *cas_bio_clone(struct bio *bio, gfp_t gfp_mask) config_file_path=$1
{ if compile_module $cur_name "bio_clone(NULL, 0)" "linux/bio.h"
return bio_clone(bio, gfp_mask); then
}" echo $cur_name "1" >> $config_file_path
elif compile_module "bio_clone_kmalloc(NULL, 0)" "linux/bio.h" elif compile_module $cur_name "bio_clone_kmalloc(NULL, 0)" "linux/bio.h"
then then
add_function "static inline struct bio *cas_bio_clone(struct bio *bio, gfp_t gfp_mask) echo $cur_name "2" >> $config_file_path
{ elif compile_module $cur_name "bio_clone_fast(NULL, 0, NULL)" "linux/bio.h"
return bio_clone_kmalloc(bio, gfp_mask); then
}" echo $cur_name "3" >> $config_file_path
elif compile_module "bio_clone_fast(NULL, 0, NULL)" "linux/bio.h" else
then echo $cur_name "X" >> $config_file_path
add_function "static inline struct bio *cas_bio_clone(struct bio *bio, gfp_t gfp_mask) fi
{ }
return bio_clone_fast(bio, gfp_mask, NULL);
}" apply() {
fi case "$1" in
"1")
add_function "static inline struct bio *cas_bio_clone(struct bio *bio, gfp_t gfp_mask)
{
return bio_clone(bio, gfp_mask);
}" ;;
"2")
add_function "static inline struct bio *cas_bio_clone(struct bio *bio, gfp_t gfp_mask)
{
return bio_clone_kmalloc(bio, gfp_mask);
}" ;;
"3")
add_function "static inline struct bio *cas_bio_clone(struct bio *bio, gfp_t gfp_mask)
{
return bio_clone_fast(bio, gfp_mask, NULL);
}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,28 +4,46 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct bio b;b.bi_end_io(NULL, 0)" "linux/bio.h" check() {
then cur_name=$(basename $2)
add_define "CAS_BIO_ENDIO(BIO, BYTES_DONE, ERROR) \\ config_file_path=$1
bio_endio(BIO, ERROR)" if compile_module $cur_name "struct bio b;b.bi_end_io(NULL, 0)" "linux/bio.h"
add_define "CAS_DECLARE_BLOCK_CALLBACK(name, BIO, BYTES_DONE, ERROR) \\ then
void name##_callback(BIO, ERROR)" echo $cur_name "1" >> $config_file_path
add_define "CAS_BLOCK_CALLBACK_ERROR(BIO, ERROR) \\ elif compile_module $cur_name "struct bio b;b.bi_end_io(NULL)" "linux/bio.h"
ERROR" then
elif compile_module "struct bio b;b.bi_end_io(NULL)" "linux/bio.h" echo $cur_name "2" >> $config_file_path
then else
add_define "CAS_BIO_ENDIO(BIO, BYTES_DONE, ERROR) \\ echo $cur_name "X" >> $config_file_path
({ CAS_BIO_OP_STATUS(BIO) = ERROR; bio_endio(BIO); })" fi
add_define "CAS_DECLARE_BLOCK_CALLBACK(name, BIO, BYTES_DONE, ERROR) \\ }
void name##_callback(BIO)"
add_define "CAS_BLOCK_CALLBACK_ERROR(BIO, ERROR) \\ apply() {
CAS_BIO_OP_STATUS(BIO)" add_define "CAS_REFER_BLOCK_CALLBACK(name) \\
fi name##_callback"
add_define "CAS_REFER_BLOCK_CALLBACK(name) \\ add_define "CAS_BLOCK_CALLBACK_INIT(BIO) \\
name##_callback" {; }"
add_define "CAS_BLOCK_CALLBACK_INIT(BIO) \\ add_define "CAS_BLOCK_CALLBACK_RETURN(BIO) \\
{; }" { return; }"
add_define "CAS_BLOCK_CALLBACK_RETURN(BIO) \\
{ return; }" case "$1" in
"1")
add_define "CAS_BIO_ENDIO(BIO, BYTES_DONE, ERROR) \\
bio_endio(BIO, ERROR)"
add_define "CAS_DECLARE_BLOCK_CALLBACK(name, BIO, BYTES_DONE, ERROR) \\
void name##_callback(BIO, ERROR)"
add_define "CAS_BLOCK_CALLBACK_ERROR(BIO, ERROR) \\
ERROR" ;;
"2")
add_define "CAS_BIO_ENDIO(BIO, BYTES_DONE, ERROR) \\
({ CAS_BIO_OP_STATUS(BIO) = ERROR; bio_endio(BIO); })"
add_define "CAS_DECLARE_BLOCK_CALLBACK(name, BIO, BYTES_DONE, ERROR) \\
void name##_callback(BIO)"
add_define "CAS_BLOCK_CALLBACK_ERROR(BIO, ERROR) \\
CAS_BIO_OP_STATUS(BIO)" ;;
esac
}
conf_run $@

View File

@ -4,30 +4,53 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "bio_op(NULL)" "linux/bio.h" check() {
then cur_name=$(basename $2)
add_define "CAS_IS_DISCARD(bio) \\ config_file_path=$1
(bio_op(bio) == REQ_OP_DISCARD)" if compile_module $cur_name "bio_op(NULL)" "linux/bio.h"
add_define "CAS_BIO_DISCARD \\ then
(REQ_OP_DISCARD)" echo $cur_name "1" >> $config_file_path
elif compile_module "REQ_OP_MASK" "linux/blk_types.h" elif compile_module $cur_name "REQ_OP_MASK" "linux/blk_types.h"
then then
add_define "CAS_IS_DISCARD(bio) \\ echo $cur_name "2" >> $config_file_path
(((CAS_BIO_OP_FLAGS(bio)) & REQ_OP_MASK) == REQ_OP_DISCARD)" elif compile_module $cur_name "REQ_OP_DISCARD" "linux/blk_types.h"
add_define "CAS_BIO_DISCARD \\ then
((REQ_OP_WRITE | REQ_OP_DISCARD))" echo $cur_name "3" >> $config_file_path
elif compile_module "REQ_OP_DISCARD" "linux/blk_types.h" elif compile_module $cur_name "REQ_DISCARD" "linux/blk_types.h"
then then
add_define "CAS_IS_DISCARD(bio) \\ echo $cur_name "4" >> $config_file_path
((CAS_BIO_OP_FLAGS(bio)) & REQ_OP_DISCARD)" else
add_define "CAS_BIO_DISCARD \\ echo $cur_name "X" >> $config_file_path
((REQ_OP_WRITE | REQ_OP_DISCARD))" fi
elif compile_module "REQ_DISCARD" "linux/blk_types.h" }
then
add_define "CAS_IS_DISCARD(bio) \\ apply() {
((CAS_BIO_OP_FLAGS(bio)) & REQ_DISCARD)" case "$1" in
add_define "CAS_BIO_DISCARD \\ "1")
(REQ_WRITE | REQ_DISCARD)" add_define "CAS_IS_DISCARD(bio) \\
fi (bio_op(bio) == REQ_OP_DISCARD)"
add_define "CAS_BIO_DISCARD \\
(REQ_OP_DISCARD)" ;;
"2")
add_define "CAS_IS_DISCARD(bio) \\
(((CAS_BIO_OP_FLAGS(bio)) & REQ_OP_MASK) == REQ_OP_DISCARD)"
add_define "CAS_BIO_DISCARD \\
((REQ_OP_WRITE | REQ_OP_DISCARD))" ;;
"3")
add_define "CAS_IS_DISCARD(bio) \\
((CAS_BIO_OP_FLAGS(bio)) & REQ_OP_DISCARD)"
add_define "CAS_BIO_DISCARD \\
((REQ_OP_WRITE | REQ_OP_DISCARD))" ;;
"4")
add_define "CAS_IS_DISCARD(bio) \\
((CAS_BIO_OP_FLAGS(bio)) & REQ_DISCARD)"
add_define "CAS_BIO_DISCARD \\
(REQ_WRITE | REQ_DISCARD)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,14 +4,32 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
check() {
cur_name=$(basename $2)
config_file_path=$1
if compile_module $cur_name "struct bio b;b.bi_status" "linux/bio.h"
then
echo $cur_name "1" >> $config_file_path
elif compile_module $cur_name "struct bio b;b.bi_error" "linux/bio.h"
then
echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_BIO_OP_STATUS(bio) \\
bio->bi_status" ;;
"2")
add_define "CAS_BIO_OP_STATUS(bio) \\
bio->bi_error" ;;
*)
exit 1
esac
}
conf_run $@
if compile_module "struct bio b;b.bi_status" "linux/bio.h"
then
add_define "CAS_BIO_OP_STATUS(bio) \\
bio->bi_status"
elif compile_module "struct bio b;b.bi_error" "linux/bio.h"
then
add_define "CAS_BIO_OP_STATUS(bio) \\
bio->bi_error"
fi

View File

@ -4,16 +4,35 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct bio b;b.bi_opf" "linux/bio.h" check() {
then cur_name=$(basename $2)
add_define "CAS_BIO_OP_FLAGS_FORMAT \"0x%016X\"" config_file_path=$1
add_define "CAS_BIO_OP_FLAGS(bio) \\ if compile_module $cur_name "struct bio b;b.bi_opf" "linux/bio.h"
(bio)->bi_opf" then
elif compile_module "struct bio b;b.bi_rw" "linux/bio.h" echo $cur_name "1" >> $config_file_path
then elif compile_module $cur_name "struct bio b;b.bi_rw" "linux/bio.h"
add_define "CAS_BIO_OP_FLAGS_FORMAT \"0x%016lX\"" then
add_define "CAS_BIO_OP_FLAGS(bio) \\ echo $cur_name "2" >> $config_file_path
(bio)->bi_rw" else
fi echo $cur_name "X" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_BIO_OP_FLAGS_FORMAT \"0x%016X\""
add_define "CAS_BIO_OP_FLAGS(bio) \\
(bio)->bi_opf" ;;
"2")
add_define "CAS_BIO_OP_FLAGS_FORMAT \"0x%016lX\""
add_define "CAS_BIO_OP_FLAGS(bio) \\
(bio)->bi_rw" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,22 +4,41 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct bio b;b.bi_iter.bi_size" "linux/bio.h" check() {
then cur_name=$(basename $2)
add_define "CAS_BIO_BISIZE(bio) \\ config_file_path=$1
bio->bi_iter.bi_size" if compile_module $cur_name "struct bio b;b.bi_iter.bi_size" "linux/bio.h"
add_define "CAS_BIO_BIIDX(bio) \\ then
bio->bi_iter.bi_idx" echo $cur_name "1" >> $config_file_path
add_define "CAS_BIO_BISECTOR(bio) \\ elif compile_module $cur_name "struct bio b;b.bi_size" "linux/bio.h"
bio->bi_iter.bi_sector" then
elif compile_module "struct bio b;b.bi_size" "linux/bio.h" echo $cur_name "2" >> $config_file_path
then else
add_define "CAS_BIO_BISIZE(bio) \\ echo $cur_name "X" >> $config_file_path
bio->bi_size" fi
add_define "CAS_BIO_BIIDX(bio) \\ }
bio->bi_idx"
add_define "CAS_BIO_BISECTOR(bio) \\ apply() {
bio->bi_sector" case "$1" in
fi "1")
add_define "CAS_BIO_BISIZE(bio) \\
bio->bi_iter.bi_size"
add_define "CAS_BIO_BIIDX(bio) \\
bio->bi_iter.bi_idx"
add_define "CAS_BIO_BISECTOR(bio) \\
bio->bi_iter.bi_sector" ;;
"2")
add_define "CAS_BIO_BISIZE(bio) \\
bio->bi_size"
add_define "CAS_BIO_BIIDX(bio) \\
bio->bi_idx"
add_define "CAS_BIO_BISECTOR(bio) \\
bio->bi_sector" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,13 +4,30 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct bio b;&bio_iovec(&b)" "linux/bio.h" check() {
then cur_name=$(basename $2)
add_define "CAS_SEGMENT_BVEC(vec) \\ config_file_path=$1
(&(vec))" if compile_module $cur_name "struct bio b;&bio_iovec(&b)" "linux/bio.h"
else then
add_define "CAS_SEGMENT_BVEC(vec) \\ echo $cur_name "1" >> $config_file_path
(vec)" else
fi echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_SEGMENT_BVEC(vec) \\
(&(vec))" ;;
"2")
add_define "CAS_SEGMENT_BVEC(vec) \\
(vec)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,13 +4,30 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "blk_rq_set_block_pc(NULL)" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_define "cas_blk_rq_set_block_pc(rq) \\ config_file_path=$1
blk_rq_set_block_pc(rq)" if compile_module $cur_name "blk_rq_set_block_pc(NULL)" "linux/blkdev.h"
else then
add_define "cas_blk_rq_set_block_pc(rq) \\ echo $cur_name "1" >> $config_file_path
{}" else
fi echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "cas_blk_rq_set_block_pc(rq) \\
blk_rq_set_block_pc(rq)" ;;
"2")
add_define "cas_blk_rq_set_block_pc(rq) \\
{}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,13 +4,30 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "deamonize(\"some_name\", NULL)" "linux/sched.h" check() {
then cur_name=$(basename $2)
add_define "CAS_DAEMONIZE(name, arg...) \\ config_file_path=$1
daemonize(name, ##arg)" if compile_module $cur_name "deamonize(\"some_name\", NULL)" "linux/sched.h"
else then
add_define "CAS_DAEMONIZE(name, arg...) \\ echo $cur_name "1" >> $config_file_path
do { } while (0)" else
fi echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_DAEMONIZE(name, arg...) \\
daemonize(name, ##arg)" ;;
"2")
add_define "CAS_DAEMONIZE(name, arg...) \\
do { } while (0)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,14 +4,33 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct dentry dentry;dentry.d_u.d_alias" "linux/dcache.h" check() {
then cur_name=$(basename $2)
add_define "CAS_ALIAS_NODE_TO_DENTRY(alias) \\ config_file_path=$1
container_of(alias, struct dentry, d_u.d_alias)" if compile_module $cur_name "struct dentry dentry;dentry.d_u.d_alias" "linux/dcache.h"
elif compile_module "struct dentry dentry;dentry.d_alias" "linux/dcache.h" then
then echo $cur_name "1" >> $config_file_path
add_define "CAS_ALIAS_NODE_TO_DENTRY(alias) \\ elif compile_module $cur_name "struct dentry dentry;dentry.d_alias" "linux/dcache.h"
container_of(alias, struct dentry, d_alias)" then
fi echo $cur_name "2" >> $config_file_path
else
echo $cur_name "X" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_ALIAS_NODE_TO_DENTRY(alias) \\
container_of(alias, struct dentry, d_u.d_alias)" ;;
"2")
add_define "CAS_ALIAS_NODE_TO_DENTRY(alias) \\
container_of(alias, struct dentry, d_alias)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,13 +4,30 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct queue_limits q;q.discard_zeroes_data" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_define "CAS_SET_DISCARD_ZEROES_DATA(queue_limits, val) \\ config_file_path=$1
queue_limits.discard_zeroes_data = val" if compile_module $cur_name "struct queue_limits q;q.discard_zeroes_data" "linux/blkdev.h"
else then
add_define "CAS_SET_DISCARD_ZEROES_DATA(queue_limits, val) \\ echo $cur_name "1" >> $config_file_path
({})" else
fi echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_SET_DISCARD_ZEROES_DATA(queue_limits, val) \\
queue_limits.discard_zeroes_data = val" ;;
"2")
add_define "CAS_SET_DISCARD_ZEROES_DATA(queue_limits, val) \\
({})" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,18 +4,37 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "REQ_PREFLUSH" "linux/blk_types.h" check() {
then cur_name=$(basename $2)
add_define "CAS_REQ_FLUSH \\ config_file_path=$1
REQ_PREFLUSH" if compile_module $cur_name "REQ_PREFLUSH" "linux/blk_types.h"
add_define "CAS_FLUSH_SUPPORTED \\ then
1" echo $cur_name "1" >> $config_file_path
elif compile_module "REQ_FLUSH" "linux/blk_types.h" elif compile_module $cur_name "REQ_FLUSH" "linux/blk_types.h"
then then
add_define "CAS_REQ_FLUSH \\ echo $cur_name "2" >> $config_file_path
REQ_FLUSH" else
add_define "CAS_FLUSH_SUPPORTED \\ echo $cur_name "X" >> $config_file_path
1" fi
fi }
apply() {
case "$1" in
"1")
add_define "CAS_REQ_FLUSH \\
REQ_PREFLUSH"
add_define "CAS_FLUSH_SUPPORTED \\
1" ;;
"2")
add_define "CAS_REQ_FLUSH \\
REQ_FLUSH"
add_define "CAS_FLUSH_SUPPORTED \\
1" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,82 +4,104 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if check() {
compile_module "generic_start_io_acct(NULL, 0, 0, NULL)" "linux/bio.h" cur_name=$(basename $2)
then config_file_path=$1
add_function " if compile_module $cur_name "generic_start_io_acct(NULL, 0, 0, NULL)" "linux/bio.h"
static inline void cas_generic_start_io_acct(struct request_queue *q, then
int rw, unsigned long sectors, struct hd_struct *part) { echo $cur_name "1" >> $config_file_path
generic_start_io_acct(q, rw, sectors, part); elif compile_module $cur_name "generic_start_io_acct(0, 0, NULL)" "linux/bio.h"
}" then
add_function " echo $cur_name "2" >> $config_file_path
static inline void cas_generic_end_io_acct(struct request_queue *q, elif compile_module $cur_name "part_round_stats(1, 1)" "linux/genhd.h"
int rw, struct hd_struct *part, unsigned long start_time) then
{ echo $cur_name "3" >> $config_file_path
generic_end_io_acct(q, rw, part, start_time); elif compile_module $cur_name "part_round_stats(NULL, 1, 1)" "linux/genhd.h"
}" then
elif compile_module "generic_start_io_acct(0, 0, NULL)" "linux/bio.h" echo $cur_name "4" >> $config_file_path
then else
add_function " echo $cur_name "X" >> $config_file_path
static inline void cas_generic_start_io_acct(struct request_queue *q, fi
int rw, unsigned long sectors, struct hd_struct *part) }
{
generic_start_io_acct(rw, sectors, part); apply() {
}" case "$1" in
add_function " "1")
static inline void cas_generic_end_io_acct(struct request_queue *q, add_function "
int rw, struct hd_struct *part, unsigned long start_time) static inline void cas_generic_start_io_acct(struct request_queue *q,
{ int rw, unsigned long sectors, struct hd_struct *part) {
generic_end_io_acct(rw, part, start_time); generic_start_io_acct(q, rw, sectors, part);
}" }"
elif compile_module "part_round_stats(1, 1)" "linux/genhd.h" add_function "
then static inline void cas_generic_end_io_acct(struct request_queue *q,
add_function " int rw, struct hd_struct *part, unsigned long start_time)
static inline void cas_generic_start_io_acct(struct request_queue *q, {
int rw, unsigned long sectors, struct hd_struct *part) generic_end_io_acct(q, rw, part, start_time);
{ }" ;;
int cpu = part_stat_lock(); "2")
part_round_stats(cpu, part); add_function "
part_stat_inc(cpu, part, ios[rw]); static inline void cas_generic_start_io_acct(struct request_queue *q,
part_stat_add(cpu, part, sectors[rw], sectors); int rw, unsigned long sectors, struct hd_struct *part)
part_inc_in_flight(part, rw); {
part_stat_unlock(); generic_start_io_acct(rw, sectors, part);
}" }"
add_function " add_function "
static inline void cas_generic_end_io_acct(struct request_queue *q, static inline void cas_generic_end_io_acct(struct request_queue *q,
int rw, struct hd_struct *part, unsigned long start_time) int rw, struct hd_struct *part, unsigned long start_time)
{ {
unsigned long duration = jiffies - start_time; generic_end_io_acct(rw, part, start_time);
int cpu = part_stat_lock(); }" ;;
part_stat_add(cpu, part, ticks[rw], duration); "3")
part_round_stats(cpu, part); add_function "
part_dec_in_flight(part, rw); static inline void cas_generic_start_io_acct(struct request_queue *q,
part_stat_unlock(); int rw, unsigned long sectors, struct hd_struct *part)
}" {
elif compile_module "part_round_stats(NULL, 1, 1)" "linux/genhd.h" int cpu = part_stat_lock();
then part_round_stats(cpu, part);
add_function " part_stat_inc(cpu, part, ios[rw]);
static inline void cas_generic_start_io_acct(struct request_queue *q, part_stat_add(cpu, part, sectors[rw], sectors);
int rw, unsigned long sectors, struct hd_struct *part) part_inc_in_flight(part, rw);
{ part_stat_unlock();
int cpu = part_stat_lock(); }"
part_round_stats(NULL, cpu, part); add_function "
part_stat_inc(cpu, part, ios[rw]); static inline void cas_generic_end_io_acct(struct request_queue *q,
part_stat_add(cpu, part, sectors[rw], sectors); int rw, struct hd_struct *part, unsigned long start_time)
part_inc_in_flight(NULL, part, rw); {
part_stat_unlock(); unsigned long duration = jiffies - start_time;
}" int cpu = part_stat_lock();
add_function " part_stat_add(cpu, part, ticks[rw], duration);
static inline void cas_generic_end_io_acct(struct request_queue *q, part_round_stats(cpu, part);
int rw, struct hd_struct *part, unsigned long start_time) part_dec_in_flight(part, rw);
{ part_stat_unlock();
unsigned long duration = jiffies - start_time; }" ;;
int cpu = part_stat_lock(); "4")
part_stat_add(cpu, part, ticks[rw], duration); add_function "
part_round_stats(NULL, cpu, part); static inline void cas_generic_start_io_acct(struct request_queue *q,
part_dec_in_flight(NULL, part, rw); int rw, unsigned long sectors, struct hd_struct *part)
part_stat_unlock(); {
}" int cpu = part_stat_lock();
fi part_round_stats(NULL, cpu, part);
part_stat_inc(cpu, part, ios[rw]);
part_stat_add(cpu, part, sectors[rw], sectors);
part_inc_in_flight(NULL, part, rw);
part_stat_unlock();
}"
add_function "
static inline void cas_generic_end_io_acct(struct request_queue *q,
int rw, struct hd_struct *part, unsigned long start_time)
{
unsigned long duration = jiffies - start_time;
int cpu = part_stat_lock();
part_stat_add(cpu, part, ticks[rw], duration);
part_round_stats(NULL, cpu, part);
part_dec_in_flight(NULL, part, rw);
part_stat_unlock();
}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,29 +4,47 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
check() {
cur_name=$(basename $2)
config_file_path=$1
if compile_module $cur_name "global_zone_page_state(1)" "linux/mm.h"
then
echo $cur_name "1" >> $config_file_path
elif compile_module $cur_name "global_page_state(1)" "linux/mm.h"
then
echo $cur_name "2" >> $config_file_path
else
echo $cur_name "X" >> $config_file_path
fi
}
if compile_module "global_zone_page_state(1)" "linux/mm.h" apply() {
then case "$1" in
add_function " "1")
static inline unsigned long cas_global_zone_page_state(enum zone_stat_item item) add_function "
{ static inline unsigned long cas_global_zone_page_state(enum zone_stat_item item)
return global_zone_page_state(item); {
}" return global_zone_page_state(item);
add_define "CAS_BIO_SET_DEV(bio, bdev) \\ }"
bio_set_dev(bio, bdev)" add_define "CAS_BIO_SET_DEV(bio, bdev) \\
add_define "CAS_BIO_GET_DEV(bio) \\ bio_set_dev(bio, bdev)"
bio->bi_disk" add_define "CAS_BIO_GET_DEV(bio) \\
elif compile_module "global_page_state(1)" "linux/mm.h" bio->bi_disk" ;;
then "2")
add_function " add_function "
static inline unsigned long cas_global_zone_page_state(enum zone_stat_item item) static inline unsigned long cas_global_zone_page_state(enum zone_stat_item item)
{ {
return global_page_state(item); return global_page_state(item);
}" }"
add_define "CAS_BIO_SET_DEV(bio, bdev) \\ add_define "CAS_BIO_SET_DEV(bio, bdev) \\
bio->bi_bdev = bdev" bio->bi_bdev = bdev"
add_define "CAS_BIO_GET_DEV(bio) \\ add_define "CAS_BIO_GET_DEV(bio) \\
bio->bi_bdev->bd_disk" bio->bi_bdev->bd_disk" ;;
fi *)
exit 1
esac
}
conf_run $@

View File

@ -4,22 +4,41 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct hlist_node list" "linux/types.h" check() {
then cur_name=$(basename $2)
add_define "CAS_ALIAS_NODE_TYPE \\ config_file_path=$1
struct hlist_node" if compile_module $cur_name "struct hlist_node list" "linux/types.h"
add_define "CAS_DENTRY_LIST_EMPTY(head) \\ then
hlist_empty(head)" echo $cur_name "1" >> $config_file_path
add_define "CAS_INODE_FOR_EACH_DENTRY(pos, head) \\ elif compile_module $cur_name "struct list_head list" "linux/list.h"
hlist_for_each(pos, head)" then
elif compile_module "struct list_head list" "linux/list.h" echo $cur_name "2" >> $config_file_path
then else
add_define "CAS_ALIAS_NODE_TYPE \\ echo $cur_name "X" >> $config_file_path
struct list_head" fi
add_define "CAS_DENTRY_LIST_EMPTY(head) \\ }
list_empty(head)"
add_define "CAS_INODE_FOR_EACH_DENTRY(pos, head) \\ apply() {
list_for_each(pos, head)" case "$1" in
fi "1")
add_define "CAS_ALIAS_NODE_TYPE \\
struct hlist_node"
add_define "CAS_DENTRY_LIST_EMPTY(head) \\
hlist_empty(head)"
add_define "CAS_INODE_FOR_EACH_DENTRY(pos, head) \\
hlist_for_each(pos, head)" ;;
"2")
add_define "CAS_ALIAS_NODE_TYPE \\
struct list_head"
add_define "CAS_DENTRY_LIST_EMPTY(head) \\
list_empty(head)"
add_define "CAS_INODE_FOR_EACH_DENTRY(pos, head) \\
list_for_each(pos, head)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,14 +4,33 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct file file;file.f_inode" "linux/fs.h" check() {
then cur_name=$(basename $2)
add_define "CAS_FILE_INODE(file) \\ config_file_path=$1
file->f_inode" if compile_module $cur_name "struct file file;file.f_inode" "linux/fs.h"
elif compile_module "struct file file;file->f_dentry->d_inode" "linux/fs.h" then
then echo $cur_name "1" >> $config_file_path
add_define "CAS_FILE_INODE(file) \\ elif compile_module $cur_name "struct file file;file->f_dentry->d_inode" "linux/fs.h"
file->f_dentry->d_inode" then
fi echo $cur_name "2" >> $config_file_path
else
echo $cur_name "X" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_FILE_INODE(file) \\
file->f_inode" ;;
"2")
add_define "CAS_FILE_INODE(file) \\
file->f_dentry->d_inode" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,36 +4,55 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "vm_munmap(0, 0)" "linux/mm.h" check() {
then cur_name=$(basename $2)
add_function " config_file_path=$1
if compile_module $cur_name "vm_munmap(0, 0)" "linux/mm.h"
then
echo $cur_name "1" >> $config_file_path
elif compile_module $cur_name "do_munmap(NULL, 0)" "linux/mm.h"
then
echo $cur_name "2" >> $config_file_path
else
echo $cur_name "X" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_function "
#include <uapi/asm-generic/mman-common.h> #include <uapi/asm-generic/mman-common.h>
static inline unsigned long cas_vm_mmap(struct file *file, static inline unsigned long cas_vm_mmap(struct file *file,
unsigned long addr, unsigned long len) unsigned long addr, unsigned long len)
{ {
return vm_mmap(file, addr, len, PROT_READ | PROT_WRITE, return vm_mmap(file, addr, len, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, 0); MAP_ANONYMOUS | MAP_PRIVATE, 0);
}" }"
add_function " add_function "
static inline int cas_vm_munmap(unsigned long start, size_t len) static inline int cas_vm_munmap(unsigned long start, size_t len)
{ {
return vm_munmap(start, len); return vm_munmap(start, len);
}" }" ;;
elif compile_module "do_munmap(NULL, 0)" "linux/mm.h" "2")
then add_function "
add_function "
#include <asm-generic/mman-common.h> #include <asm-generic/mman-common.h>
static inline unsigned long cas_vm_mmap(struct file *file, static inline unsigned long cas_vm_mmap(struct file *file,
unsigned long addr, unsigned long len) unsigned long addr, unsigned long len)
{ {
return do_mmap_pgoff(file, addr, len, PROT_READ | PROT_WRITE, return do_mmap_pgoff(file, addr, len, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, 0); MAP_ANONYMOUS | MAP_PRIVATE, 0);
}" }"
add_function " add_function "
static inline int cas_vm_munmap(unsigned long start, size_t len) static inline int cas_vm_munmap(unsigned long start, size_t len)
{ {
return do_munmap(current->mm, start, len); return do_munmap(current->mm, start, len);
}" }" ;;
fi *)
exit 1
esac
}
conf_run $@

View File

@ -4,13 +4,30 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "blk_queue_bounce(NULL, NULL);" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_define "cas_blk_queue_bounce(q, bounce_bio) \\ config_file_path=$1
blk_queue_bounce(q, bounce_bio)" if compile_module $cur_name "blk_queue_bounce(NULL, NULL);" "linux/blkdev.h"
else then
add_define "cas_blk_queue_bounce(q, bounce_bio) \\ echo $cur_name "1" >> $config_file_path
({})" else
fi echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "cas_blk_queue_bounce(q, bounce_bio) \\
blk_queue_bounce(q, bounce_bio)" ;;
"2")
add_define "cas_blk_queue_bounce(q, bounce_bio) \\
({})" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,13 +4,30 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "struct request_queue q;q.limits.chunk_sectors" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_define "CAS_SET_QUEUE_CHUNK_SECTORS(queue, chunk_size) \\ config_file_path=$1
queue->limits.chunk_sectors = chunk_size" if compile_module $cur_name "struct request_queue q;q.limits.chunk_sectors" "linux/blkdev.h"
else then
add_define "CAS_SET_QUEUE_CHUNK_SECTORS(queue, chunk_size) \\ echo $cur_name "1" >> $config_file_path
{;}" else
fi echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_SET_QUEUE_CHUNK_SECTORS(queue, chunk_size) \\
queue->limits.chunk_sectors = chunk_size" ;;
"2")
add_define "CAS_SET_QUEUE_CHUNK_SECTORS(queue, chunk_size) \\
{;}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,13 +4,30 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "blk_queue_flag_set(0, NULL)" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_define "cas_queue_flag_set_unlocked(flag, request_queue) \\ config_file_path=$1
blk_queue_flag_set(flag, request_queue)" if compile_module $cur_name "blk_queue_flag_set(0, NULL)" "linux/blkdev.h"
else then
add_define "cas_queue_flag_set_unlocked(flag, request_queue) \\ echo $cur_name "1" >> $config_file_path
queue_flag_set_unlocked(flag, request_queue)" else
fi echo $cur_name "2" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "cas_queue_flag_set_unlocked(flag, request_queue) \\
blk_queue_flag_set(flag, request_queue)" ;;
"2")
add_define "cas_queue_flag_set_unlocked(flag, request_queue) \\
queue_flag_set_unlocked(flag, request_queue)" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,50 +4,71 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
# RHEL 7.3 # RHEL 7.3
if compile_module "struct queue_limits q;q.limits_aux" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_function " config_file_path=$1
static inline void cas_copy_queue_limits(struct request_queue *exp_q, if compile_module $cur_name "struct queue_limits q;q.limits_aux" "linux/blkdev.h"
struct request_queue *cache_q, struct request_queue *core_q) then
{ echo $cur_name "1" >> $config_file_path
struct queue_limits_aux *l_aux = exp_q->limits.limits_aux; elif compile_module $cur_name "struct queue_limits q;q.max_write_zeroes_sectors" "linux/blkdev.h"
exp_q->limits = cache_q->limits; then
exp_q->limits.limits_aux = l_aux; echo $cur_name "2" >> $config_file_path
if (exp_q->limits.limits_aux && cache_q->limits.limits_aux) elif compile_module $cur_name "struct queue_limits q;q.max_write_same_sectors" "linux/blkdev.h"
*exp_q->limits.limits_aux = *cache_q->limits.limits_aux; then
exp_q->limits.max_sectors = core_q->limits.max_sectors; echo $cur_name "3" >> $config_file_path
exp_q->limits.max_hw_sectors = core_q->limits.max_hw_sectors; else
exp_q->limits.max_segments = core_q->limits.max_segments; echo $cur_name "X" >> $config_file_path
exp_q->limits.max_write_same_sectors = 0; fi
if (queue_virt_boundary(cache_q)) }
queue_flag_set(QUEUE_FLAG_NOMERGES, cache_q);
}" apply() {
elif compile_module "struct queue_limits q;q.max_write_zeroes_sectors" "linux/blkdev.h" case "$1" in
then "1")
add_function " add_function "
static inline void cas_copy_queue_limits(struct request_queue *exp_q, static inline void cas_copy_queue_limits(struct request_queue *exp_q,
struct request_queue *cache_q, struct request_queue *core_q) struct request_queue *cache_q, struct request_queue *core_q)
{ {
exp_q->limits = cache_q->limits; struct queue_limits_aux *l_aux = exp_q->limits.limits_aux;
exp_q->limits.max_sectors = core_q->limits.max_sectors; exp_q->limits = cache_q->limits;
exp_q->limits.max_hw_sectors = core_q->limits.max_hw_sectors; exp_q->limits.limits_aux = l_aux;
exp_q->limits.max_segments = core_q->limits.max_segments; if (exp_q->limits.limits_aux && cache_q->limits.limits_aux)
exp_q->limits.max_write_same_sectors = 0; *exp_q->limits.limits_aux = *cache_q->limits.limits_aux;
exp_q->limits.max_write_zeroes_sectors = 0; exp_q->limits.max_sectors = core_q->limits.max_sectors;
}" exp_q->limits.max_hw_sectors = core_q->limits.max_hw_sectors;
elif compile_module "struct queue_limits q;q.max_write_same_sectors" "linux/blkdev.h" exp_q->limits.max_segments = core_q->limits.max_segments;
then exp_q->limits.max_write_same_sectors = 0;
add_function " if (queue_virt_boundary(cache_q))
static inline void cas_copy_queue_limits(struct request_queue *exp_q, queue_flag_set(QUEUE_FLAG_NOMERGES, cache_q);
struct request_queue *cache_q, struct request_queue *core_q) }" ;;
{ "2")
exp_q->limits = cache_q->limits; add_function "
exp_q->limits.max_sectors = core_q->limits.max_sectors; static inline void cas_copy_queue_limits(struct request_queue *exp_q,
exp_q->limits.max_hw_sectors = core_q->limits.max_hw_sectors; struct request_queue *cache_q, struct request_queue *core_q)
exp_q->limits.max_segments = core_q->limits.max_segments; {
exp_q->limits.max_write_same_sectors = 0; exp_q->limits = cache_q->limits;
}" exp_q->limits.max_sectors = core_q->limits.max_sectors;
fi exp_q->limits.max_hw_sectors = core_q->limits.max_hw_sectors;
exp_q->limits.max_segments = core_q->limits.max_segments;
exp_q->limits.max_write_same_sectors = 0;
exp_q->limits.max_write_zeroes_sectors = 0;
}" ;;
"3")
add_function "
static inline void cas_copy_queue_limits(struct request_queue *exp_q,
struct request_queue *cache_q, struct request_queue *core_q)
{
exp_q->limits = cache_q->limits;
exp_q->limits.max_sectors = core_q->limits.max_sectors;
exp_q->limits.max_hw_sectors = core_q->limits.max_hw_sectors;
exp_q->limits.max_segments = core_q->limits.max_segments;
exp_q->limits.max_write_same_sectors = 0;
}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,27 +4,44 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "REQ_TYPE_FS" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_function " config_file_path=$1
static inline int cas_is_rq_type_fs(struct request *rq) if compile_module $cur_name "REQ_TYPE_FS" "linux/blkdev.h"
{ then
return rq->cmd_type == REQ_TYPE_FS; echo $cur_name "1" >> $config_file_path
}" else
else echo $cur_name "2" >> $config_file_path
add_function " fi
static inline int cas_is_rq_type_fs(struct request *rq) }
{
switch (req_op(rq)){ apply() {
case REQ_OP_READ: case "$1" in
case REQ_OP_WRITE: "1")
case REQ_OP_FLUSH: add_function "
case REQ_OP_DISCARD: static inline int cas_is_rq_type_fs(struct request *rq)
return true; {
default: return rq->cmd_type == REQ_TYPE_FS;
return false; }" ;;
} "2")
}" add_function "
fi static inline int cas_is_rq_type_fs(struct request *rq)
{
switch (req_op(rq)){
case REQ_OP_READ:
case REQ_OP_WRITE:
case REQ_OP_FLUSH:
case REQ_OP_DISCARD:
return true;
default:
return false;
}
}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,41 +4,64 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
# submit_bio() can be defined in "bio.h" or in "fs.h" # submit_bio() can be defined in "bio.h" or in "fs.h"
# If it is defind in fs.h, three possibilities are available: # If it is defind in fs.h, three possibilities are available:
# * it takes one argument and retuns non-void # * it takes one argument and retuns non-void
# * it takes two arguments and returns non-void # * it takes two arguments and returns non-void
# * it takse two arguments and is void-type # * it takse two arguments and is void-type
if compile_module "submit_bio(NULL)" "linux/bio.h" check() {
then cur_name=$(basename $2)
add_function " config_file_path=$1
static inline blk_qc_t cas_submit_bio(int rw, struct bio *bio) if compile_module $cur_name "submit_bio(NULL)" "linux/bio.h"
{ then
CAS_BIO_OP_FLAGS(bio) |= rw; echo $cur_name "1" >> $config_file_path
return submit_bio(bio); elif compile_module $cur_name "submit_bio(NULL)" "linux/fs.h"
}" then
elif compile_module "submit_bio(NULL)" "linux/fs.h" echo $cur_name "2" >> $config_file_path
then elif compile_module $cur_name "void *t=submit_bio(0, NULL)" "linux/fs.h"
add_function " then
static inline blk_qc_t cas_submit_bio(int rw, struct bio *bio) echo $cur_name "4" >> $config_file_path
{ elif compile_module $cur_name "submit_bio(0, NULL)" "linux/fs.h"
CAS_BIO_OP_FLAGS(bio) |= rw; then
return submit_bio(bio); echo $cur_name "4" >> $config_file_path
}" else
elif compile_module "void *t=submit_bio(0, NULL)" "linux/fs.h" echo $cur_name "X" >> $config_file_path
then fi
add_function " }
static inline blk_qc_t cas_submit_bio(int rw, struct bio *bio)
{ apply() {
return submit_bio(rw, bio); case "$1" in
}" "1")
elif compile_module "submit_bio(0, NULL)" "linux/fs.h" add_function "
then static inline blk_qc_t cas_submit_bio(int rw, struct bio *bio)
add_function " {
static inline void cas_submit_bio(int rw, struct bio *bio) CAS_BIO_OP_FLAGS(bio) |= rw;
{ return submit_bio(bio);
submit_bio(rw, bio); }" ;;
}" "2")
fi add_function "
static inline blk_qc_t cas_submit_bio(int rw, struct bio *bio)
{
CAS_BIO_OP_FLAGS(bio) |= rw;
return submit_bio(bio);
}" ;;
"3")
add_function "
static inline blk_qc_t cas_submit_bio(int rw, struct bio *bio)
{
return submit_bio(rw, bio);
}" ;;
"4")
add_function "
static inline void cas_submit_bio(int rw, struct bio *bio)
{
submit_bio(rw, bio);
}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -1,13 +0,0 @@
#!/bin/bash
#
# Copyright(c) 2012-2019 Intel Corporation
# SPDX-License-Identifier: BSD-3-Clause-Clear
#
. `dirname $0`/conf_framework
if compile_module "struct bio b;b.bi_write_hint" "linux/bio.h"
then
add_define "CAS_WLTH_SUPPORT \\
1"
fi

View File

@ -4,14 +4,33 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "WRITE" "linux/blk_types.h" check() {
then cur_name=$(basename $2)
add_define "CAS_RQ_DATA_DIR_WR \\ config_file_path=$1
WRITE" if compile_module $cur_name "WRITE" "linux/blk_types.h"
elif compile_module "REQ_WRITE" "linux/blk_types.h" then
then echo $cur_name "1" >> $config_file_path
add_define "CAS_RQ_DATA_DIR_WR \\ elif compile_module $cur_name "REQ_WRITE" "linux/blk_types.h"
REQ_WRITE" then
fi echo $cur_name "2" >> $config_file_path
else
echo $cur_name "X" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_RQ_DATA_DIR_WR \\
WRITE" ;;
"2")
add_define "CAS_RQ_DATA_DIR_WR \\
REQ_WRITE" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,29 +4,52 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "WRITE_FUA" "linux/fs.h" check() {
then cur_name=$(basename $2)
add_define "CAS_WRITE_FUA \\ config_file_path=$1
WRITE_FUA" if compile_module $cur_name "WRITE_FUA" "linux/fs.h"
if compile_module "BIO_FUA" "linux/bio.h" then
then if compile_module $cur_name "BIO_FUA" "linux/bio.h"
add_define "CAS_IS_WRITE_FUA(flags) \\ then
((flags) & BIO_FUA)" echo $cur_name "1" >> $config_file_path
else else
add_define "CAS_IS_WRITE_FUA(flags) \\ echo $cur_name "2" >> $config_file_path
((flags) & REQ_FUA)" fi
elif compile_module $cur_name "REQ_FUA" "linux/blk_types.h"
then
echo $cur_name "3" >> $config_file_path
else
echo $cur_name "4" >> $config_file_path
fi fi
elif compile_module "REQ_FUA" "linux/blk_types.h" }
then
add_define "CAS_IS_WRITE_FUA(flags) \\ apply() {
((flags) & REQ_FUA)" case "$1" in
add_define "CAS_WRITE_FUA \\ "1")
REQ_FUA" add_define "CAS_WRITE_FUA \\
else WRITE_FUA"
add_define "CAS_IS_WRITE_FUA(flags) \\ add_define "CAS_IS_WRITE_FUA(flags) \\
0" ((flags) & BIO_FUA)" ;;
add_define "CAS_WRITE_FUA \\ "2")
WRITE_BARRIER" add_define "CAS_WRITE_FUA \\
fi WRITE_FUA"
add_define "CAS_IS_WRITE_FUA(flags) \\
((flags) & REQ_FUA)" ;;
"3")
add_define "CAS_IS_WRITE_FUA(flags) \\
((flags) & REQ_FUA)"
add_define "CAS_WRITE_FUA \\
REQ_FUA" ;;
"4")
add_define "CAS_IS_WRITE_FUA(flags) \\
0"
add_define "CAS_WRITE_FUA \\
WRITE_BARRIER" ;;
*)
exit 1
esac
}
conf_run $@

28
configure.d/1_wtlh.conf Normal file
View File

@ -0,0 +1,28 @@
#!/bin/bash
#
# Copyright(c) 2012-2019 Intel Corporation
# SPDX-License-Identifier: BSD-3-Clause-Clear
#
. $(dirname $3)/conf_framework
check() {
cur_name=$(basename $2)
config_file_path=$1
if compile_module $cur_name "struct bio b;b.bi_write_hint" "linux/bio.h"
then
echo $cur_name "1" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_WLTH_SUPPORT \\
1" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,18 +4,39 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "RQF_SOFTBARRIER" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_define "CAS_CHECK_BARRIER(bio) \\ config_file_path=$1
((CAS_BIO_OP_FLAGS(bio) & RQF_SOFTBARRIER) != 0)" if compile_module $cur_name "RQF_SOFTBARRIER" "linux/blkdev.h"
elif compile_module "REQ_SOFTBARRIER" "linux/blk_types.h" then
then echo $cur_name "1" >> $config_file_path
add_define "CAS_CHECK_BARRIER(bio) \\ elif compile_module $cur_name "REQ_SOFTBARRIER" "linux/blk_types.h"
((CAS_BIO_OP_FLAGS(bio) & REQ_SOFTBARRIER) != 0)" then
elif compile_module "BIO_RW_BARRIER" "linux/fs.h" echo $cur_name "2" >> $config_file_path
then elif compile_module $cur_name "BIO_RW_BARRIER" "linux/fs.h"
add_define "CAS_CHECK_BARRIER(bio) \\ then
(bio_rw_flagged((bio), BIO_RW_BARRIER))" echo $cur_name "3" >> $config_file_path
fi else
echo $cur_name "X" >> $config_file_path
fi
}
apply() {
case "$1" in
"1")
add_define "CAS_CHECK_BARRIER(bio) \\
((CAS_BIO_OP_FLAGS(bio) & RQF_SOFTBARRIER) != 0)" ;;
"2")
add_define "CAS_CHECK_BARRIER(bio) \\
((CAS_BIO_OP_FLAGS(bio) & REQ_SOFTBARRIER) != 0)" ;;
"3")
add_define "CAS_CHECK_BARRIER(bio) \\
(bio_rw_flagged((bio), BIO_RW_BARRIER))" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,29 +4,52 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "WRITE_FLUSH_FUA" "linux/fs.h" check() {
then cur_name=$(basename $2)
add_define "CAS_WRITE_FLUSH_FUA \\ config_file_path=$1
WRITE_FLUSH_FUA" if compile_module $cur_name "WRITE_FLUSH_FUA" "linux/fs.h"
if compile_module "BIO_FUA" "linux/bio.h" then
then if compile_module $cur_name "BIO_FUA" "linux/bio.h"
add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\ then
((BIO_FUA | BIO_FLUSH) == ((flags) & (BIO_FUA | BIO_FLUSH)))" echo $cur_name "1" >> $config_file_path
else else
add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\ echo $cur_name "2" >> $config_file_path
((REQ_FUA | CAS_REQ_FLUSH) == ((flags) & (REQ_FUA | CAS_REQ_FLUSH)))" fi
elif compile_module $cur_name "REQ_PREFLUSH" "linux/blk_types.h"
then
echo $cur_name "3" >> $config_file_path
else
echo $cur_name "4" >> $config_file_path
fi fi
elif compile_module "REQ_PREFLUSH" "linux/blk_types.h" }
then
add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\ apply() {
((REQ_PREFLUSH | REQ_FUA) == ((flags) & (REQ_PREFLUSH |REQ_FUA)))" case "$1" in
add_define "CAS_WRITE_FLUSH_FUA \\ "1")
(REQ_PREFLUSH | REQ_FUA)" add_define "CAS_WRITE_FLUSH_FUA \\
else WRITE_FLUSH_FUA"
add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\ add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\
0" ((BIO_FUA | BIO_FLUSH) == ((flags) & (BIO_FUA | BIO_FLUSH)))" ;;
add_define "CAS_WRITE_FLUSH_FUA \\ "2")
WRITE_BARRIER" add_define "CAS_WRITE_FLUSH_FUA \\
fi WRITE_FLUSH_FUA"
add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\
((REQ_FUA | CAS_REQ_FLUSH) == ((flags) & (REQ_FUA | CAS_REQ_FLUSH)))" ;;
"3")
add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\
((REQ_PREFLUSH | REQ_FUA) == ((flags) & (REQ_PREFLUSH |REQ_FUA)))"
add_define "CAS_WRITE_FLUSH_FUA \\
(REQ_PREFLUSH | REQ_FUA)" ;;
"4")
add_define "CAS_IS_WRITE_FLUSH_FUA(flags) \\
0"
add_define "CAS_WRITE_FLUSH_FUA \\
WRITE_BARRIER" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,36 +4,53 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "blk_make_request(NULL, NULL, 0)" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_function " config_file_path=$1
static inline struct request *cas_blk_make_request(struct request_queue *q, if compile_module $cur_name "blk_make_request(NULL, NULL, 0)" "linux/blkdev.h"
struct bio *bio, gfp_t gfp_mask) then
{ echo $cur_name "1" >> $config_file_path
return blk_make_request(q, bio, gfp_mask); else
}" echo $cur_name "2" >> $config_file_path
else fi
add_function " }
static inline struct request *cas_blk_make_request(struct request_queue *q,
struct bio *bio, gfp_t gfp_mask) apply() {
{ case "$1" in
struct request *rq = blk_get_request(q, bio_data_dir(bio), gfp_mask); "1")
if (IS_ERR(rq)) add_function "
return rq; static inline struct request *cas_blk_make_request(struct request_queue *q,
cas_blk_rq_set_block_pc(rq); struct bio *bio, gfp_t gfp_mask)
rq->q = q; {
for_each_bio(bio) { return blk_make_request(q, bio, gfp_mask);
struct bio *bounce_bio = bio; }" ;;
int ret; "2")
cas_blk_queue_bounce(q, &bounce_bio); add_function "
ret = cas_blk_rq_append_bio(rq, bounce_bio); static inline struct request *cas_blk_make_request(struct request_queue *q,
if (unlikely(ret)) { struct bio *bio, gfp_t gfp_mask)
blk_put_request(rq); {
return ERR_PTR(ret); struct request *rq = blk_get_request(q, bio_data_dir(bio), gfp_mask);
if (IS_ERR(rq))
return rq;
cas_blk_rq_set_block_pc(rq);
rq->q = q;
for_each_bio(bio) {
struct bio *bounce_bio = bio;
int ret;
cas_blk_queue_bounce(q, &bounce_bio);
ret = cas_blk_rq_append_bio(rq, bounce_bio);
if (unlikely(ret)) {
blk_put_request(rq);
return ERR_PTR(ret);
}
} }
} return rq;
return rq; }" ;;
}" *)
fi exit 1
esac
}
conf_run $@

View File

@ -4,35 +4,54 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "blk_queue_write_cache(NULL, 0, 0)" "linux/blkdev.h" check() {
then cur_name=$(basename $2)
add_define "CAS_CHECK_QUEUE_FLUSH(q) \\ config_file_path=$1
test_bit(QUEUE_FLAG_WC, &(q)->queue_flags)" if compile_module $cur_name "blk_queue_write_cache(NULL, 0, 0)" "linux/blkdev.h"
add_define "CAS_CHECK_QUEUE_FUA(q) \\ then
test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags)" echo $cur_name "1" >> $config_file_path
add_function " elif compile_module $cur_name "struct request_queue rq;rq.flush_flags" "linux/blkdev.h"
static inline void cas_set_queue_flush_fua(struct request_queue *q, then
bool flush, bool fua) echo $cur_name "2" >> $config_file_path
{ else
blk_queue_write_cache(q, flush, fua); echo $cur_name "X" >> $config_file_path
}" fi
elif compile_module "struct request_queue rq;rq.flush_flags" "linux/blkdev.h" }
then
add_define "CAS_CHECK_QUEUE_FLUSH(q) \\ apply() {
((q)->flush_flags & CAS_REQ_FLUSH)" case "$1" in
add_define "CAS_CHECK_QUEUE_FUA(q) \\ "1")
((q)->flush_flags & REQ_FUA)" add_define "CAS_CHECK_QUEUE_FLUSH(q) \\
add_function "static inline void cas_set_queue_flush_fua(struct request_queue *q, test_bit(QUEUE_FLAG_WC, &(q)->queue_flags)"
add_define "CAS_CHECK_QUEUE_FUA(q) \\
test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags)"
add_function "
static inline void cas_set_queue_flush_fua(struct request_queue *q,
bool flush, bool fua) bool flush, bool fua)
{ {
unsigned int flags = 0; blk_queue_write_cache(q, flush, fua);
if (flush) }" ;;
flags |= CAS_REQ_FLUSH; "2")
if (fua) add_define "CAS_CHECK_QUEUE_FLUSH(q) \\
flags |= REQ_FUA; ((q)->flush_flags & CAS_REQ_FLUSH)"
if (flags) add_define "CAS_CHECK_QUEUE_FUA(q) \\
blk_queue_flush(q, flags); ((q)->flush_flags & REQ_FUA)"
}" add_function "static inline void cas_set_queue_flush_fua(struct request_queue *q,
fi bool flush, bool fua)
{
unsigned int flags = 0;
if (flush)
flags |= CAS_REQ_FLUSH;
if (fua)
flags |= REQ_FUA;
if (flags)
blk_queue_flush(q, flags);
}" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -4,35 +4,60 @@
# SPDX-License-Identifier: BSD-3-Clause-Clear # SPDX-License-Identifier: BSD-3-Clause-Clear
# #
. `dirname $0`/conf_framework . $(dirname $3)/conf_framework
if compile_module "WRITE_FLUSH" "linux/fs.h" check() {
then cur_name=$(basename $2)
add_define "CAS_RQ_IS_FLUSH(rq) \\ config_file_path=$1
((rq)->cmd_flags & CAS_REQ_FLUSH)" if compile_module $cur_name "WRITE_FLUSH" "linux/fs.h"
add_define "CAS_WRITE_FLUSH \\ then
WRITE_FLUSH" if compile_module $cur_name "BIO_FLUSH" "linux/bio.h"
if compile_module "BIO_FLUSH" "linux/bio.h" then
then echo $cur_name "1" >> $config_file_path
add_define "CAS_IS_WRITE_FLUSH(flags) \\ else
((flags) & BIO_FLUSH)" echo $cur_name "2" >> $config_file_path
else fi
add_define "CAS_IS_WRITE_FLUSH(flags) \\ elif compile_module $cur_name "REQ_PREFLUSH" "linux/blk_types.h"
((flags) & CAS_REQ_FLUSH)" then
echo $cur_name "3" >> $config_file_path
else
echo $cur_name "4" >> $config_file_path
fi fi
elif compile_module "REQ_PREFLUSH" "linux/blk_types.h" }
then
add_define "CAS_RQ_IS_FLUSH(rq) \\ apply() {
((rq)->cmd_flags & REQ_PREFLUSH)" case "$1" in
add_define "CAS_WRITE_FLUSH \\ "1")
(REQ_OP_WRITE | REQ_PREFLUSH)" add_define "CAS_RQ_IS_FLUSH(rq) \\
add_define "CAS_IS_WRITE_FLUSH(flags) \\ ((rq)->cmd_flags & CAS_REQ_FLUSH)"
(CAS_WRITE_FLUSH == ((flags) & CAS_WRITE_FLUSH))" add_define "CAS_WRITE_FLUSH \\
else WRITE_FLUSH"
add_define "CAS_RQ_IS_FLUSH(rq) \\ add_define "CAS_IS_WRITE_FLUSH(flags) \\
0" ((flags) & BIO_FLUSH)" ;;
add_define "CAS_IS_WRITE_FLUSH(flags) \\ "2")
(WRITE_BARRIER == ((flags) & WRITE_BARRIER))" add_define "CAS_RQ_IS_FLUSH(rq) \\
add_define "CAS_WRITE_FLUSH \\ ((rq)->cmd_flags & CAS_REQ_FLUSH)"
WRITE_BARRIER" add_define "CAS_WRITE_FLUSH \\
fi WRITE_FLUSH"
add_define "CAS_IS_WRITE_FLUSH(flags) \\
((flags) & CAS_REQ_FLUSH)" ;;
"3")
add_define "CAS_RQ_IS_FLUSH(rq) \\
((rq)->cmd_flags & REQ_PREFLUSH)"
add_define "CAS_WRITE_FLUSH \\
(REQ_OP_WRITE | REQ_PREFLUSH)"
add_define "CAS_IS_WRITE_FLUSH(flags) \\
(CAS_WRITE_FLUSH == ((flags) & CAS_WRITE_FLUSH))" ;;
"4")
add_define "CAS_RQ_IS_FLUSH(rq) \\
0"
add_define "CAS_IS_WRITE_FLUSH(flags) \\
(WRITE_BARRIER == ((flags) & WRITE_BARRIER))"
add_define "CAS_WRITE_FLUSH \\
WRITE_BARRIER" ;;
*)
exit 1
esac
}
conf_run $@

View File

@ -6,12 +6,10 @@
SCRIPTPATH=`dirname $0` SCRIPTPATH=`dirname $0`
SCRIPTPATH=`realpath $SCRIPTPATH` SCRIPTPATH=`realpath $SCRIPTPATH`
MODULE_FILE=$SCRIPTPATH/test_mod.c
OBJ_MOD=$SCRIPTPATH/test_mod.o
KERNEL_DIR="${KERNEL_DIR:-/lib/modules/$(uname -r)/build/}" KERNEL_DIR="${KERNEL_DIR:-/lib/modules/$(uname -r)/build/}"
KERNEL_VER="$(cd $KERNEL_DIR; make kernelversion)" KERNEL_VER="$(cd $KERNEL_DIR; make kernelversion)"
NPROC=`nproc` NPROC=`nproc`
DEFINE_FILE=$SCRIPTPATH/../modules/generated_defines.h DEFINE_FILE=$SCRIPTPATH/modules/generated_defines.h
add_define() { add_define() {
@ -23,41 +21,58 @@ add_function() {
} }
compile_module(){ compile_module(){
if [ $# -gt 1 ] if [ $# -gt 2 ]
then then
INCLUDE="#include <$2>" INCLUDE="#include <$3>"
else else
INCLUDE="" INCLUDE=""
fi fi
config_file=$1
test_module_dir=$SCRIPTPATH/configure.d/${config_file}_dir
test_module_file=$test_module_dir/test_mod.c
test_module_obj=$test_module_dir/test_mod.o
mkdir -p $test_module_dir
cp -f $SCRIPTPATH/configure.d/Makefile $test_module_dir
############# TEST MODULE ############# ############# TEST MODULE #############
cat > $MODULE_FILE <<- EOF cat > $test_module_file <<- EOF
#include <linux/module.h> #include <linux/module.h>
#include <linux/kernel.h> #include <linux/kernel.h>
$INCLUDE $INCLUDE
int init_module(void) { int init_module(void) {
$1; $2;
return 0; return 0;
} }
void cleanup_module(void) {}; void cleanup_module(void) {};
EOF EOF
####################################### #######################################
make -C $SCRIPTPATH KERNEL_DIR=${KERNEL_DIR} &> /dev/null make -C $test_module_dir KERNEL_DIR=${KERNEL_DIR} &> /dev/null
local ret=$? local ret=$?
if [ $ret -eq 0 ]; then
make -C $SCRIPTPATH clean &> /dev/null rm -Rf $test_module_dir
fi
return $ret return $ret
} }
kernel_not_supp_fail() { kernel_not_supp_fail() {
echo "Current kernel is not supported!" echo "Current kernel is not supported!"
rm $DEFINE_FILE rm $DEFINE_FILE
exit 1 exit 1
}
# $1 - name of function to be called
# $2 - path to file with valid configs
# $3 - name of processed template file
conf_run() {
case "$1" in
"check") check $2 $3;;
"apply") apply $2 ;;
esac
} }
IFS='?' IFS='?'