diff --git a/cmake_targets/tools/Kbuild.cmake b/cmake_targets/tools/Kbuild.cmake deleted file mode 100755 index 7403cd04df..0000000000 --- a/cmake_targets/tools/Kbuild.cmake +++ /dev/null @@ -1,4 +0,0 @@ -src=${dir} -obj-m += ${name}.o -${name}-y += ${objs} -ccflags-y += ${module_cc_opt} diff --git a/cmake_targets/tools/MODULES/CMakeParseArguments.cmake b/cmake_targets/tools/MODULES/CMakeParseArguments.cmake deleted file mode 100755 index ab53b112fa..0000000000 --- a/cmake_targets/tools/MODULES/CMakeParseArguments.cmake +++ /dev/null @@ -1,66 +0,0 @@ -# Analogue for standard CMake module with same name, appeared in CMake 2.8.3. -# -# Used for compatibility with older versions of cmake. - -function(cmake_parse_arguments prefix options one_value_keywords multi_value_keywords) - set(all_keywords ${options} ${one_value_keywords} ${multi_value_keywords}) - # Clear variables before parsing. - foreach(arg ${one_value_keywords} ${multie_value_keywords}) - set(cpa_${arg}) - endforeach() - - foreach(arg ${options}) - set(cpa_${arg} FALSE) - endforeach() - - set(cpa_UNPARSED_ARGUMENTS) - - set(current_keyword) - # Classification for current_keyword: - # 'ONE' or 'MULTY'. - set(current_keyword_type) - - # now iterate over all arguments and fill the result variables - foreach(arg ${ARGN}) - list(FIND all_keywords ${arg} keyword_index) - - if(keyword_index EQUAL -1) - if(current_keyword) - if(current_keyword_type STREQUAL "ONE") - set(cpa_${current_keyword} ${arg}) - set(current_keyword) - else(current_keyword_type STREQUAL "ONE") - list(APPEND cpa_${current_keyword} ${arg}) - endif(current_keyword_type STREQUAL "ONE") - else(current_keyword) - list(APPEND cpa_UNPARSED_ARGUMENTS ${arg}) - endif(current_keyword) - else(keyword_index EQUAL -1) - if(current_keyword AND current_keyword_type STREQUAL "ONE") - message(SEND_ERROR "Value is expected for one-value-keyword ${current_keyword}") - endif(current_keyword AND current_keyword_type STREQUAL "ONE") - list(FIND options ${arg} option_index) - if(option_index EQUAL -1) - set(current_keyword ${arg}) - list(FIND one_value_keywords ${arg} one_value_index) - if(one_value_index EQUAL -1) - set(current_keyword_type "MULTI") - else(one_value_index EQUAL -1) - set(current_keyword_type "ONE") - endif(one_value_index EQUAL -1) - else(option_index EQUAL -1) - set(current_keyword) - set(cpa_${arg} TRUE) - endif(option_index EQUAL -1) - endif(keyword_index EQUAL -1) - endforeach(arg ${ARGN}) - - if(current_keyword AND current_keyword_type STREQUAL "ONE") - message(SEND_ERROR "Value is expected for one-value-keyword ${current_keyword}") - endif(current_keyword AND current_keyword_type STREQUAL "ONE") - - # propagate the result variables to the caller: - foreach(keyword ${all_keywords} UNPARSED_ARGUMENTS) - set(${prefix}_${keyword} ${cpa_${keyword}} PARENT_SCOPE) - endforeach(keyword ${all_keywords}) -endfunction(cmake_parse_arguments prefix options one_value_keywords multi_value_keywords) diff --git a/cmake_targets/tools/MODULES/CMakeUserFindMySQL.cmake b/cmake_targets/tools/MODULES/CMakeUserFindMySQL.cmake deleted file mode 100755 index 1b5de7e3ac..0000000000 --- a/cmake_targets/tools/MODULES/CMakeUserFindMySQL.cmake +++ /dev/null @@ -1,48 +0,0 @@ -# - Find mysqlclient -# Find the native MySQL includes and library -# -# MYSQL_INCLUDE_DIR - where to find mysql.h, etc. -# MYSQL_LIBRARIES - List of libraries when using MySQL. -# MYSQL_FOUND - True if MySQL found. - -IF (MYSQL_INCLUDE_DIR) - # Already in cache, be silent - SET(MYSQL_FIND_QUIETLY TRUE) -ENDIF (MYSQL_INCLUDE_DIR) - -FIND_PATH(MYSQL_INCLUDE_DIR mysql.h - /usr/local/include/mysql - /usr/include/mysql -) - -SET(MYSQL_NAMES mysqlclient mysqlclient_r) -FIND_LIBRARY(MYSQL_LIBRARY - NAMES ${MYSQL_NAMES} - PATHS /usr/lib /usr/local/lib - PATH_SUFFIXES mysql -) - -IF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) - SET(MYSQL_FOUND TRUE) - SET( MYSQL_LIBRARIES ${MYSQL_LIBRARY} ) -ELSE (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) - SET(MYSQL_FOUND FALSE) - SET( MYSQL_LIBRARIES ) -ENDIF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) - -IF (MYSQL_FOUND) - IF (NOT MYSQL_FIND_QUIETLY) - MESSAGE(STATUS "Found MySQL: ${MYSQL_LIBRARY}") - ENDIF (NOT MYSQL_FIND_QUIETLY) -ELSE (MYSQL_FOUND) - IF (MYSQL_FIND_REQUIRED) - MESSAGE(STATUS "Looked for MySQL libraries named ${MYSQL_NAMES}.") - MESSAGE(FATAL_ERROR "Could NOT find MySQL library") - ENDIF (MYSQL_FIND_REQUIRED) -ENDIF (MYSQL_FOUND) - -MARK_AS_ADVANCED( - MYSQL_LIBRARY - MYSQL_INCLUDE_DIR - ) - diff --git a/cmake_targets/tools/MODULES/CMakeUserUseBison.cmake b/cmake_targets/tools/MODULES/CMakeUserUseBison.cmake deleted file mode 100755 index 5295a1ba39..0000000000 --- a/cmake_targets/tools/MODULES/CMakeUserUseBison.cmake +++ /dev/null @@ -1,71 +0,0 @@ -# - Look for GNU Bison, the parser generator -# Based off a news post from Andy Cedilnik at Kitware -# Defines the following: -# BISON_EXECUTABLE - path to the bison executable -# BISON_FILE - parse a file with bison -# BISON_PREFIX_OUTPUTS - Set to true to make BISON_FILE produce prefixed -# symbols in the generated output based on filename. -# So for ${filename}.y, you'll get ${filename}parse(), etc. -# instead of yyparse(). -# BISON_GENERATE_DEFINES - Set to true to make BISON_FILE output the matching -# .h file for a .c file. You want this if you're using -# flex. - -IF(NOT DEFINED BISON_PREFIX_OUTPUTS) - SET(BISON_PREFIX_OUTPUTS FALSE) -ENDIF(NOT DEFINED BISON_PREFIX_OUTPUTS) - -IF(NOT DEFINED BISON_GENERATE_DEFINES) - SET(BISON_GENERATE_DEFINES FALSE) -ENDIF(NOT DEFINED BISON_GENERATE_DEFINES) - -IF(NOT BISON_EXECUTABLE) - MESSAGE(STATUS "Looking for bison") - FIND_PROGRAM(BISON_EXECUTABLE bison) - IF(BISON_EXECUTABLE) - MESSAGE(STATUS "Looking for bison -- ${BISON_EXECUTABLE}") - ENDIF(BISON_EXECUTABLE) -ENDIF(NOT BISON_EXECUTABLE) - -IF(BISON_EXECUTABLE) - MACRO(BISON_FILE FILENAME) - GET_FILENAME_COMPONENT(PATH "${FILENAME}" PATH) - IF("${PATH}" STREQUAL "") - SET(PATH_OPT "") - ELSE("${PATH}" STREQUAL "") - SET(PATH_OPT "/${PATH}") - ENDIF("${PATH}" STREQUAL "") - GET_FILENAME_COMPONENT(HEAD "${FILENAME}" NAME_WE) - IF(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}") - FILE(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}") - ENDIF(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}") - IF(BISON_PREFIX_OUTPUTS) - SET(PREFIX "${HEAD}") - ELSE(BISON_PREFIX_OUTPUTS) - SET(PREFIX "yy") - ENDIF(BISON_PREFIX_OUTPUTS) - SET(OUTFILE "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}/${HEAD}.tab.c") - IF(BISON_GENERATE_DEFINES) - SET(HEADER "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}/${HEAD}.tab.h") - ADD_CUSTOM_COMMAND( - OUTPUT "${OUTFILE}" "${HEADER}" - COMMAND "${BISON_EXECUTABLE}" - ARGS "--name-prefix=${PREFIX}" - "--defines" - "--output-file=${OUTFILE}" - "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}" - DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}") - SET_SOURCE_FILES_PROPERTIES("${OUTFILE}" "${HEADER}" PROPERTIES GENERATED TRUE) - SET_SOURCE_FILES_PROPERTIES("${HEADER}" PROPERTIES HEADER_FILE_ONLY TRUE) - ELSE(BISON_GENERATE_DEFINES) - ADD_CUSTOM_COMMAND( - OUTPUT "${OUTFILE}" - COMMAND "${BISON_EXECUTABLE}" - ARGS "--name-prefix=${PREFIX}" - "--output-file=${OUTFILE}" - "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}" - DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}") - SET_SOURCE_FILES_PROPERTIES("${OUTFILE}" PROPERTIES GENERATED TRUE) - ENDIF(BISON_GENERATE_DEFINES) - ENDMACRO(BISON_FILE) -ENDIF(BISON_EXECUTABLE) diff --git a/cmake_targets/tools/MODULES/CMakeUserUseFlex.cmake b/cmake_targets/tools/MODULES/CMakeUserUseFlex.cmake deleted file mode 100755 index 09a3e71e6d..0000000000 --- a/cmake_targets/tools/MODULES/CMakeUserUseFlex.cmake +++ /dev/null @@ -1,46 +0,0 @@ -# - Look for GNU flex, the lexer generator. -# Defines the following: -# FLEX_EXECUTABLE - path to the flex executable -# FLEX_FILE - parse a file with flex -# FLEX_PREFIX_OUTPUTS - Set to true to make FLEX_FILE produce outputs of -# lex.${filename}.c, not lex.yy.c . Passes -P to flex. - -IF(NOT DEFINED FLEX_PREFIX_OUTPUTS) - SET(FLEX_PREFIX_OUTPUTS FALSE) -ENDIF(NOT DEFINED FLEX_PREFIX_OUTPUTS) - -IF(NOT FLEX_EXECUTABLE) - MESSAGE(STATUS "Looking for flex") - FIND_PROGRAM(FLEX_EXECUTABLE flex) - IF(FLEX_EXECUTABLE) - MESSAGE(STATUS "Looking for flex -- ${FLEX_EXECUTABLE}") - ENDIF(FLEX_EXECUTABLE) -ENDIF(NOT FLEX_EXECUTABLE) - -IF(FLEX_EXECUTABLE) - MACRO(FLEX_FILE FILENAME) - GET_FILENAME_COMPONENT(PATH "${FILENAME}" PATH) - IF("${PATH}" STREQUAL "") - SET(PATH_OPT "") - ELSE("${PATH}" STREQUAL "") - SET(PATH_OPT "/${PATH}") - ENDIF("${PATH}" STREQUAL "") - IF(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}") - FILE(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}") - ENDIF(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}") - IF(FLEX_PREFIX_OUTPUTS) - GET_FILENAME_COMPONENT(PREFIX "${FILENAME}" NAME_WE) - ELSE(FLEX_PREFIX_OUTPUTS) - SET(PREFIX "yy") - ENDIF(FLEX_PREFIX_OUTPUTS) - SET(OUTFILE "${CMAKE_CURRENT_BINARY_DIR}${PATH_OPT}/lex.${PREFIX}.c") - ADD_CUSTOM_COMMAND( - OUTPUT "${OUTFILE}" - COMMAND "${FLEX_EXECUTABLE}" - ARGS "--prefix=${PREFIX}" - "--outfile=${OUTFILE}" - "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}" - DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}") - SET_SOURCE_FILES_PROPERTIES("${OUTFILE}" PROPERTIES GENERATED TRUE) - ENDMACRO(FLEX_FILE) -ENDIF(FLEX_EXECUTABLE) diff --git a/cmake_targets/tools/MODULES/FindGCCXML.cmake b/cmake_targets/tools/MODULES/FindGCCXML.cmake deleted file mode 100755 index 6a4daa084d..0000000000 --- a/cmake_targets/tools/MODULES/FindGCCXML.cmake +++ /dev/null @@ -1,8 +0,0 @@ -# FindGCCXML -# ---------- -find_program(GCCXML -NAMES gccxml -PATHS "/usr/bin" -"usr/local/bin" -) -mark_as_advanced(GCCXML) diff --git a/cmake_targets/tools/MODULES/FindKbuild.cmake b/cmake_targets/tools/MODULES/FindKbuild.cmake deleted file mode 100755 index 08accb8551..0000000000 --- a/cmake_targets/tools/MODULES/FindKbuild.cmake +++ /dev/null @@ -1,105 +0,0 @@ -# - Support for building kernel modules - -# This module defines several variables which may be used when build -# kernel modules. -# -# The following variables are set here: -# Kbuild_VERSION_STRING - kernel version. -# Kbuild_ARCH - architecture. -# Kbuild_BUILD_DIR - directory for build kernel and/or its components. -# Kbuild_VERSION_{MAJOR|MINOR|TWEAK} - kernel version components -# Kbuild_VERSION_STRING_CLASSIC - classic representation of version, -# where parts are delimited by dots. -# -# Cache variables which affect on this package: -# CMAKE_SYSTEM_VERSION - change Kbuild_VERSION_STRING -# Also, setting CMAKE_SYSTEM_VERSION will be interpreted by cmake as crosscompile. -# -# Cache variables(ADVANCED) which affect on this package: -# ARCH - if not empty, change Kbuild_ARCH -# KBUILD_DIR - change Kbuild_BUILD_DIR - -set(Kbuild_VERSION_STRING ${CMAKE_SYSTEM_VERSION}) - -# Form classic version view. -string(REGEX MATCH "([0-9]+)\\.([0-9]+)[.-]([0-9]+)" - _kernel_version_match - "${Kbuild_VERSION_STRING}" -) - -if(NOT _kernel_version_match) - message(FATAL_ERROR "Kernel version has unexpected format: ${Kbuild_VERSION_STRING}") -endif(NOT _kernel_version_match) - -set(Kbuild_VERSION_MAJOR ${CMAKE_MATCH_1}) -set(Kbuild_VERSION_MINOR ${CMAKE_MATCH_2}) -set(Kbuild_VERSION_TWEAK ${CMAKE_MATCH_3}) -# Version string for compare -set(Kbuild_VERSION_STRING_CLASSIC "${Kbuild_VERSION_MAJOR}.${Kbuild_VERSION_MINOR}.${Kbuild_VERSION_TWEAK}") - -set(KBUILD_DIR "/lib/modules/${Kbuild_VERSION_STRING}/build" CACHE PATH - "Directory for build linux kernel and/or its components." -) -mark_as_advanced(KBUILD_DIR) - -set(Kbuild_BUILD_DIR "${KBUILD_DIR}") - -set(ARCH "" CACHE STRING - "Architecture for build linux kernel components for, empty string means autodetect." -) -mark_as_advanced(ARCH) - -if(NOT ARCH) - # Autodetect arch. - execute_process(COMMAND uname -m - RESULT_VARIABLE uname_m_result - OUTPUT_VARIABLE ARCH_DEFAULT - ) - if(NOT uname_m_result EQUAL 0) - message("'uname -m' failed:") - message("${ARCH_DEFAULT}") - message(FATAL_ERROR "Failed to determine system architecture.") - endif(NOT uname_m_result EQUAL 0) - - string(REGEX REPLACE "\n$" "" ARCH_DEFAULT "${ARCH_DEFAULT}") - - # Pairs of pattern-replace for postprocess architecture string from - # 'uname -m'. - # Taken from ./Makefile of the kernel build. - set(_kbuild_arch_replacers - "i.86" "x86" - "x86_64" "x86" - "sun4u" "sparc64" - "arm.*" "arm" - "sa110" "arm" - "s390x" "s390" - "parisc64" "parisc" - "ppc.*" "powerpc" - "mips.*" "mips" - "sh[234].*" "sh" - "aarch64.*" "arm64" - ) - - set(_current_pattern) - foreach(p ${_kbuild_arch_replacers}) - if(_current_pattern) - string(REGEX REPLACE "${_current_pattern}" "${p}" ARCH_DEFAULT "${ARCH_DEFAULT}") - set(_current_pattern) - else(_current_pattern) - set(_current_pattern "${p}") - endif(_current_pattern) - endforeach(p ${_kbuild_arch_replacers}) - - set(Kbuild_ARCH "${ARCH_DEFAULT}") -else(NOT ARCH) - # User-provided value is used. - set(Kbuild_ARCH "${ARCH}") -endif(NOT ARCH) - - - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(Kbuild - REQUIRED_VARS Kbuild_BUILD_DIR - VERSION_VAR KBuild_VERSION_STRING_CLASSIC -) diff --git a/cmake_targets/tools/MODULES/Kbuild.cmake b/cmake_targets/tools/MODULES/Kbuild.cmake deleted file mode 100755 index 7403cd04df..0000000000 --- a/cmake_targets/tools/MODULES/Kbuild.cmake +++ /dev/null @@ -1,4 +0,0 @@ -src=${dir} -obj-m += ${name}.o -${name}-y += ${objs} -ccflags-y += ${module_cc_opt} diff --git a/cmake_targets/tools/MODULES/cmake_useful.cmake b/cmake_targets/tools/MODULES/cmake_useful.cmake deleted file mode 100755 index af6bbb56c7..0000000000 --- a/cmake_targets/tools/MODULES/cmake_useful.cmake +++ /dev/null @@ -1,229 +0,0 @@ -# Create rule for obtain one file by copying another one -function(rule_copy_file target_file source_file) - add_custom_command(OUTPUT ${target_file} - COMMAND cp -p ${source_file} ${target_file} - DEPENDS ${source_file} - ) -endfunction(rule_copy_file target_file source_file) - -# rule_copy_source([source_dir] file ...) -# -# Create rule for obtain file(s) in binary tree by copiing it from source tree. -# -# Files are given relative to ${source_dir}, if it is set, or -# relative to ${CMAKE_CURRENT_SOURCE_DIR}. -# -# Files will be copied into ${CMAKE_CURRENT_BINARY_DIR} with same -# relative paths. -# -# ${source_dir} should be absolute path(that is, starts from '/'). -# Otherwise first argument is treated as first file to copy. -function(rule_copy_source file) - string(REGEX MATCH "^/" is_abs_path ${file}) - if(is_abs_path) - set(source_dir ${file}) - set(files ${ARGN}) - else(is_abs_path) - set(source_dir ${CMAKE_CURRENT_SOURCE_DIR}) - set(files ${file} ${ARGN}) - endif(is_abs_path) - - foreach(file_real ${files}) - rule_copy_file("${CMAKE_CURRENT_BINARY_DIR}/${file_real}" - ${source_dir}/${file_real}) - endforeach(file_real ${files}) -endfunction(rule_copy_source file) - -# to_abs_path(output_var path [...]) -# -# Convert relative path of file to absolute path: -# use path in source tree, if file already exist there. -# otherwise use path in binary tree. -# If initial path already absolute, return it. -function(to_abs_path output_var) - set(result) - foreach(path ${ARGN}) - string(REGEX MATCH "^/" _is_abs_path ${path}) - if(_is_abs_path) - list(APPEND result ${path}) - else(_is_abs_path) - file(GLOB to_abs_path_file - "${CMAKE_CURRENT_SOURCE_DIR}/${path}" - ) - if(NOT to_abs_path_file) - set (to_abs_path_file "${CMAKE_CURRENT_BINARY_DIR}/${path}") - endif(NOT to_abs_path_file) - list(APPEND result ${to_abs_path_file}) - endif(_is_abs_path) - endforeach(path ${ARGN}) - set("${output_var}" ${result} PARENT_SCOPE) -endfunction(to_abs_path output_var path) - -# is_path_inside_dir(output_var dir path) -# -# Set output_var to true if path is absolute path inside given directory. -# NOTE: Path should be absolute. -macro(is_path_inside_dir output_var dir path) - file(RELATIVE_PATH _rel_path ${dir} ${path}) - string(REGEX MATCH "^\\.\\." _is_not_inside_dir ${_rel_path}) - if(_is_not_inside_dir) - set(${output_var} "FALSE") - else(_is_not_inside_dir) - set(${output_var} "TRUE") - endif(_is_not_inside_dir) -endmacro(is_path_inside_dir output_var dir path) - - -# Write given content to the file. -# -# If file is already exists and its content is same as written one, file -# is not rewritten, so its write timestamp remains unchanged. -function(file_update filename content) - if(EXISTS "${filename}") - file(READ "${filename}" old_content) - if(old_content STREQUAL "${content}") - return() - endif(old_content STREQUAL "${content}") - endif(EXISTS "${filename}") - # File doesn't exists or its content differ. - file(WRITE "${filename}" "${content}") -endfunction(file_update filename content) - - -# Write given content to the file in APPEND mode. -# -# For append we use position variable which should be initialized -# to 0 for every new build process and which is updated every time when -# this function is called. -# If file is already exists and its content at given is same as -# written one, file is not rewritten, so its write timestamp remains unchanged. -# -# Note, that file will not be rewritten if new build process issues less -# APPEND actions than one which create file. -# But similar problem exists for file_update() and even for built-in -# configure_file() command: file will not be removed if new build process -# do not call configure_file() for it. -function(file_update_append filename content POS) - set(pos "${${POS}}") - string(LENGTH "${content}" len) - # Update output variable first. - # This allows to use return() when need not to do anything - math(EXPR pos_new "${pos}+${len}") - set(${POS} "${pos_new}" PARENT_SCOPE) - if(EXISTS "${filename}") - file(READ "${filename}" old_content LIMIT "${len}" OFFSET "${pos}") - if(old_content STREQUAL "${content}") - return() - elseif(old_content STREQUAL "") - file(APPEND "${filename}" "${content}") - return() - endif(old_content STREQUAL "${content}") - else(EXISTS "${filename}") - if(NOT pos EQUAL 0) - message(FATAL_ERROR "Appending to non-zero position to non-existent file.") - endif(NOT pos EQUAL 0) - endif(EXISTS "${filename}") - # File doesn't exists or its content differ. - if(NOT pos EQUAL 0) - file(READ "${filename}" prefix LIMIT "${pos}") - else(NOT pos EQUAL 0) - set(prefix) - endif(NOT pos EQUAL 0) - file(WRITE "${filename}" "${prefix}${content}") -endfunction(file_update_append filename content POS) - - -# Common mechanism for output status message -# when checking different aspects. -# -# Normal using: -# -# check_begin("Checking <...>") -# if(NOT ) -# check_try() # Here message is printed -# # Perform check(try_compile(), etc.) -# endif(NOT ) -# check_end("") # Here message is printed with result. - -# Should be called (unconditionally) when new cheking is issued. -# Note, that given @status_msg is not printed at that step. -function(check_begin status_msg) - set(_check_status_msg ${status_msg} PARENT_SCOPE) - set(_check_has_tries PARENT_SCOPE) -endfunction(check_begin status_msg) - -# Should be called before every real checking, that is which is not come -# from cache variables comparision. -# -# First call of that function is trigger printing of @status_msg, -# passed to check_begin(). -function(check_try) - if(NOT _check_has_tries) - message(STATUS "${_check_status_msg}") - set(_check_has_tries "1" PARENT_SCOPE) - endif(NOT _check_has_tries) -endfunction(check_try) - -# Should be called when cheking is end, and @result_msg should be short -# description of check result. -# If any check_try() has been issued before, -# "@status_msg - @result_msg" -# will be printed. -# Otherwise, -# "@status_msg - [cached] @result_msg" -# will be printed, at it will be the only message for that check. -function(check_end result_msg) - if(NOT _check_has_tries) - message(STATUS "${_check_status_msg} [cached] - ${result_msg}") - else(NOT _check_has_tries) - message(STATUS "${_check_status_msg} - ${result_msg}") - endif(NOT _check_has_tries) - set(_check_status_msg PARENT_SCOPE) - set(_check_has_tries PARENT_SCOPE) -endfunction(check_end result_msg) - -# set_bool_string(var true_string false_string value [CACHE ... | PARENT_SCOPE]) -# -# Set variable to one of two string according to true property of some value. -# -# If 'value' is true-evaluated, 'var' will be set to 'true_string', -# otherwise to 'var' will be set to 'false_string'. -# Like standard set(), macro accept CACHE and PARENT_SCOPE modifiers. -# -# Useful for form meaningful value for cache variables, contained result -# of some operation. -# Also may be used for form message for check_end(). -macro(set_bool_string var true_string false_string value) - # Macro parameters are not a variables, so them cannot be tested - # using 'if(value)'. - # Usage 'if(${value})' leads to warnings since 2.6.4 when ${val} - # is boolean constant - # (because until 2.6.4 'if(value)' always dereference val). - # So copy 'value' to local variable for test it. - set(_set_bool_string_value ${value}) - if(_set_bool_string_value) - set(${var} "${true_string}" ${ARGN}) - else() - set(${var} "${false_string}" ${ARGN}) - endif() -endmacro(set_bool_string) - -# set_zero_string(var true_string false_string value [CACHE ... | PARENT_SCOPE]) -# -# Set variable to one of two string according to zero property of some value. -# -# If 'value' is '0' (presizely), 'var' will be set to 'zero_string', -# otherwise to 'var' will be set to 'nonzero_string'. -# Like standard set(), macro accept CACHE and PARENT_SCOPE modifiers. -# -# Useful for form meaningful value for cache variables, contained result -# of execute_process(). -# Also may be used for form message for check_end(). -macro(set_zero_string var zero_string nonzero_string value) - set(_set_zero_string_value ${value}) - if(_set_zero_string_value EQUAL "0") - set(${var} ${zero_string} ${ARGN}) - else() - set(${var} ${nonzero_string} ${ARGN}) - endif() -endmacro(set_zero_string) \ No newline at end of file diff --git a/cmake_targets/tools/MODULES/kbuild_system.cmake b/cmake_targets/tools/MODULES/kbuild_system.cmake deleted file mode 100755 index 42a1a2d42b..0000000000 --- a/cmake_targets/tools/MODULES/kbuild_system.cmake +++ /dev/null @@ -1,1131 +0,0 @@ -# Provide way for create kernel modules, and perform other actions on them -# in a way similar to standard cmake executables and libraries processing. -# -# NB: At the end of the whole configuration stage -# kbuild_finalize_linking() -# should be executed. -# -# Should be included after: -# find_package(Kbuild) -# -# Cached variables(ADVANCED), which affects on definitions below: -# CROSS_COMPILE - corresponded parameter for 'make' to build kernel objects. -# KBUILD_C_FLAGS - Additional kbuild flags for all builds -# KBUILD_C_FLAGS{DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL} - per-configuration flags. - -include(cmake_useful) - -# Compute path to the auxiliary files. -get_filename_component(kbuild_this_module_dir ${CMAKE_CURRENT_LIST_FILE} PATH) -set(kbuild_aux_dir "${kbuild_this_module_dir}/kbuild_system_files") - -# _declare_per_build_vars( ) -# -# [INTERNAL] Per-build type definitions for given . -# -# Create CACHE STRING variables _{DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL} -# with documentation string where %build% is replaced -# with corresponded build type description. -# -# Default value for variable _ is taken from __INIT. -macro(_declare_per_build_vars variable doc_pattern) - set(_build_type) - foreach(t - RELEASE "release" - DEBUG "debug" - RELWITHDEBINFO "Release With Debug Info" - MINSIZEREL "release minsize" - ) - if(_build_type) - string(REPLACE "%build%" "${t}" _docstring ${doc_pattern}) - set("${variable}_${_build_type}" "${${variable}_${_build_type}_INIT}" - CACHE STRING "${_docstring}") - set(_build_type) - else(_build_type) - set(_build_type "${t}") - endif(_build_type) - endforeach(t) -endmacro(_declare_per_build_vars variable doc_pattern) - - -# Default compiler flags. -# -# These flags are used directly when configuring 'Kbuild', so them should be -# expressed as single-string, where different flags are joinged using ' '. -set(KBUILD_C_FLAGS "" CACHE STRING - "Compiler flags used by Kbuild system during all builds." -) - -# Additional default compiler flags per build type. -set(KBUILD_C_FLAGS_DEBUG_INIT "-g") -set(KBUILD_C_FLAGS_RELWITHDEBINFO_INIT "-g") - -_declare_per_build_vars(KBUILD_C_FLAGS - "Compiler flags used by Kbuild system during %build% builds." -) -mark_as_advanced( - KBUILD_C_FLAGS - KBUILD_C_FLAGS_DEBUG - KBUILD_C_FLAGS_RELEASE - KBUILD_C_FLAGS_RELWITHDEBINFO - KBUILD_C_FLAGS_MINSIZEREL -) - - -# Additional definitions which are passed directly to 'make' for -# kbuild process. -# -# Unlike to compiler flags, these ones are expressed using cmake list. -set(KBUILD_MAKE_FLAGS "" CACHE STRING - "Make flags used by Kbuild system during all builds." -) - -_declare_per_build_vars(KBUILD_MAKE_FLAGS - "Make flags used by Kbuild system during %build% builds." -) - -mark_as_advanced( - KBUILD_MAKE_FLAGS - KBUILD_MAKE_FLAGS_DEBUG - KBUILD_MAKE_FLAGS_RELEASE - KBUILD_MAKE_FLAGS_RELWITHDEBINFO - KBUILD_MAKE_FLAGS_MINSIZEREL -) - -set(CROSS_COMPILE "" CACHE STRING "Cross compilation prefix for build linux kernel objects.") -mark_as_advanced(CROSS_COMPILE) - -# Property prefixed with 'KMODULE_' is readonly for outer use, -# unless explicitely noted in its description. - -# Property is set for every target described kernel module. -# Concrete property's value currently has no special meaning. -define_property(TARGET PROPERTY KMODULE_TYPE - BRIEF_DOCS "Whether given target describes kernel module." - FULL_DOCS "Whether given target describes kernel module." -) - -# Absolute filename of .ko file which is built. -# NOTE: Imported targets use -# KMODULE_IMPORTED_MODULE_LOCATION -# property instead. -define_property(TARGET PROPERTY KMODULE_MODULE_LOCATION - BRIEF_DOCS "Location of the built kernel module." - FULL_DOCS "Location of the built kernel module." -) - -# Name of the given module, like "ext4" or "kedr". -define_property(TARGET PROPERTY KMODULE_MODULE_NAME - BRIEF_DOCS "Name of the kernel module." - FULL_DOCS "Name of the kernel module." -) - - -# Absolute filename of Module.symvers file which is built. -# NOTE: Imported targets use -# KMODULE_IMPORTED_SYMVERS_LOCATION -# property instead. -define_property(TARGET PROPERTY KMODULE_SYMVERS_LOCATION - BRIEF_DOCS "Location of the symvers file of the kernel module." - FULL_DOCS "Location of the symvers file of the kernel module." -) - -# Property is "TRUE" for every target described imported kernel module, -# "FALSE" for other targets described kernel module. -define_property(TARGET PROPERTY KMODULE_IMPORTED - BRIEF_DOCS "Whether given target describes imported kernel module." - FULL_DOCS "Whether given target describes imported kernel module." -) - -# Absolute filename of .ko file which is imported. -# Property may be set after -# kbuild_add_module(... IMPORTED) -# for allow loading of given module or perform other actions required -# kernel module itself. -# -# Analogue for KMODULE_MODULE_LOCATION property of normal(non-exported) -# kernel module target. -define_property(TARGET PROPERTY KMODULE_IMPORTED_MODULE_LOCATION - BRIEF_DOCS "Location of the imported kernel module." - FULL_DOCS "Location of the imported kernel module." -) - -# Absolute filename of Module.symvers file for imported kernel module. -# Property may be set after -# kbuild_add_module(... IMPORTED) -# for allow linking with given module or perform other actions required -# its symbols. -# -# Analogue for KMODULE_MODULE_SYMVERS_LOCATION property of normal(non-exported) -# kernel module target. -define_property(TARGET PROPERTY KMODULE_IMPORTED_SYMVERS_LOCATION - BRIEF_DOCS "Location of the symvers file for imported kernel module." - FULL_DOCS "Location of the symvers file for imported kernel module." -) - -# Helpers for simple extract some kernel module properties. - -# kbuild_get_module_location(RESULT_VAR name) -# -# Return location of the module, determined by the property -# KMODULE_MODULE_LOCATION or KMODULE_IMPORTED_MODULE_LOCATION for -# imported target. In the last case the property is checked for being set. -function(kbuild_get_module_location RESULT_VAR name) - if(NOT TARGET ${name}) - message(FATAL_ERROR "\"${name}\" is not really a target.") - endif(NOT TARGET ${name}) - get_property(kmodule_type TARGET ${name} PROPERTY KMODULE_TYPE) - if(NOT kmodule_type) - message(FATAL_ERROR "\"${name}\" is not really a target for kernel module.") - endif(NOT kmodule_type) - get_property(kmodule_imported TARGET ${name} PROPERTY KMODULE_IMPORTED) - if(kmodule_imported) - get_property(module_location TARGET ${name} PROPERTY KMODULE_IMPORTED_MODULE_LOCATION) - if(NOT module_location) - message(FATAL_ERROR "target \"${name}\" for imported module has no property KMODULE_IMPORTED_MODULE_LOCATION set.") - endif(NOT module_location) - else(kmodule_imported) - get_property(module_location TARGET ${name} PROPERTY KMODULE_MODULE_LOCATION) - endif(kmodule_imported) - set(${RESULT_VAR} ${module_location} PARENT_SCOPE) -endfunction(kbuild_get_module_location RESULT_VAR module) - -# kbuild_get_symvers_location(RESULT_VAR name) -# -# Return location of the symvers file for the module, determined by the -# property KMODULE_SYMVERS_LOCATION or KMODULE_IMPORTED_SYMVERS_LOCATION -# for imported target. In the last case the property is checked for being set. -function(kbuild_get_symvers_location RESULT_VAR name) - if(NOT TARGET ${name}) - message(FATAL_ERROR "\"${name}\" is not really a target.") - endif(NOT TARGET ${name}) - get_property(kmodule_type TARGET ${name} PROPERTY KMODULE_TYPE) - if(NOT kmodule_type) - message(FATAL_ERROR "\"${name}\" is not really a target for kernel module.") - endif(NOT kmodule_type) - get_property(kmodule_imported TARGET ${name} PROPERTY KMODULE_IMPORTED) - if(kmodule_imported) - get_property(symvers_location TARGET ${name} PROPERTY KMODULE_IMPORTED_SYMVERS_LOCATION) - if(NOT symvers_location) - message(FATAL_ERROR "target \"${name}\" for imported module has no property KMODULE_IMPORTED_SYMVERS_LOCATION set.") - endif(NOT symvers_location) - else(kmodule_imported) - get_property(symvers_location TARGET ${name} PROPERTY KMODULE_SYMVERS_LOCATION) - endif(kmodule_imported) - set(${RESULT_VAR} ${symvers_location} PARENT_SCOPE) -endfunction(kbuild_get_symvers_location RESULT_VAR module) - -# kbuild_add_module( [EXCLUDE_FROM_ALL] [MODULE_NAME ] [ ...]) -# -# Build kernel module from , analogue of add_library(). -# -# Source files are divided into two categories: -# -Object sources -# -Other sourses -# -# Object sources are those sources, which may be used in building kernel -# module externally. -# Follow types of object sources are supported now: -# .c: a file with the code in C language; -# .S: a file with the code in assembly language; -# .o_shipped: shipped file in binary format, -# does not require additional preprocessing. -# -# Other sources are treated as only prerequisite of building process. -# -# -# kbuild_add_module( [MODULE_NAME ] IMPORTED) -# -# Create target, corresponded to the imported kernel module. -# In that case KMODULE_IMPORTED_* properties should be set manually if needed. -# -# In either case, if MODULE_NAME option is given, it determine name -# of the kernel module. Otherwise itself is used. -function(kbuild_add_module name) - cmake_parse_arguments(kbuild_add_module "IMPORTED;EXCLUDE_FROM_ALL" "MODULE_NAME" "" ${ARGN}) - if(kbuild_add_module_MODULE_NAME) - set(module_name "${kbuild_add_module_MODULE_NAME}") - else(kbuild_add_module_MODULE_NAME) - set(module_name "${name}") - endif(kbuild_add_module_MODULE_NAME) - - string(LENGTH ${module_name} module_name_len) - if(module_name_len GREATER 55) - # Name of the kernel module should fit into array of size (64-sizeof(unsigned long)). - # On 64-bit systems(most restricted) this is 56. - # Even 56 length is not good, as it is not include null character. - # Without it, old versions of rmmod failed to unload module. - message(SEND_ERROR "Kernel module name exceeds 55 characters: '${module_name}'") - endif(module_name_len GREATER 55) - - if(kbuild_add_module_IMPORTED) - # Creation of IMPORTED target is simple. - add_custom_target(${name}) - set_property(TARGET ${name} PROPERTY KMODULE_TYPE "kmodule") - set_property(TARGET ${name} PROPERTY KMODULE_IMPORTED "TRUE") - set_property(TARGET ${name} PROPERTY KMODULE_MODULE_NAME "${module_name}") - return() - endif(kbuild_add_module_IMPORTED) - - if(kbuild_add_module_EXCLUDE_FROM_ALL) - set(all_arg) - else(kbuild_add_module_EXCLUDE_FROM_ALL) - set(all_arg "ALL") - endif(kbuild_add_module_EXCLUDE_FROM_ALL) - - # List of all source files, which are given. - set(sources ${kbuild_add_module_UNPARSED_ARGUMENTS}) - - # Sources with absolute paths - to_abs_path(sources_abs ${sources}) - # list of files from which module building is depended - set(depend_files) - # Sources of "c" type, but without extension. - # Used for clean files, and for out-of-source builds do not create - # files in source tree. - set(c_sources_noext_abs) - # The sources with the code in assembly - set(asm_sources_noext_abs) - # Sources of "o_shipped" type, but without extension - set(shipped_sources_noext_abs) - # Categorize sources - foreach(source_abs ${sources_abs}) - get_filename_component(ext ${source_abs} EXT) - if(ext STREQUAL ".c" OR ext STREQUAL ".S" OR ext STREQUAL ".o_shipped") - # Real sources - # Move source into binary tree, if needed - copy_source_to_binary_dir("${source_abs}" source_abs) - - get_filename_component(source_noext "${source_abs}" NAME_WE) - get_filename_component(source_dir "${source_abs}" PATH) - set(source_noext_abs "${source_dir}/${source_noext}") - if(ext STREQUAL ".c") - # c-source - list(APPEND c_sources_noext_abs ${source_noext_abs}) - elseif(ext STREQUAL ".S") - # asm source - list(APPEND asm_sources_noext_abs ${source_noext_abs}) - elseif(ext STREQUAL ".o_shipped") - # shipped-source - list(APPEND shipped_sources_noext_abs ${source_noext_abs}) - endif(ext STREQUAL ".c") - endif(ext STREQUAL ".c" OR ext STREQUAL ".S" OR ext STREQUAL ".o_shipped") - # In any case, add file to depend list - list(APPEND depend_files ${source_abs}) - endforeach(source_abs ${sources_abs}) - - # Object sources relative to current binary dir - # (for $(module)-y :=) - set(obj_sources_noext_rel) - foreach(obj_sources_noext_abs - ${c_sources_noext_abs} ${asm_sources_noext_abs} ${shipped_sources_noext_abs}) - file(RELATIVE_PATH obj_source_noext_rel - ${CMAKE_CURRENT_BINARY_DIR} ${obj_sources_noext_abs}) - list(APPEND obj_sources_noext_rel ${obj_source_noext_rel}) - endforeach(obj_sources_noext_abs) - - if(NOT obj_sources_noext_rel) - message(FATAL_ERROR "List of object files for building kernel module ${name} is empty.") - endif(NOT obj_sources_noext_rel) - - set(obj_sources_rel) - # Detect, if build simple - source object name coincide with module name - - if(NOT obj_sources_noext_rel STREQUAL ${name}) - # Check, whether only one of source object names coincide with module name. - # This situation is incorrect for kbuild system. - list(FIND obj_sources_noext_rel ${name} is_objects_contain_name) - if(is_objects_contain_name GREATER -1) - message(FATAL_ERROR "Module should be built " - "either from only one object with same name, " - "or from objects with names different from the name of the module") - endif(is_objects_contain_name GREATER -1) - - foreach(obj_source_noext_rel ${obj_sources_noext_rel}) - list(APPEND obj_sources_rel "${obj_source_noext_rel}.o") - endforeach(obj_source_noext_rel ${obj_sources_noext_rel}) - endif(NOT obj_sources_noext_rel STREQUAL ${name}) - - _get_directory_property_chained(ccflags KBUILD_COMPILE_DEFINITIONS " ") - _get_directory_property_chained(include_dirs KBUILD_INCLUDE_DIRECTORIES) - - # Target for create module. - add_custom_target(${name} ALL - DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${module_name}.ko" - "${CMAKE_CURRENT_BINARY_DIR}/${_kbuild_symvers}" - ) - - # Create .cmd files for 'shipped' sources. - # Gcc does not create them automatically for some reason. - set(cmd_create_command) - if(shipped_sources_noext_abs) - foreach(shipped_source_noext_abs ${shipped_source_noext_abs}) - get_filename_component(shipped_dir ${shipped_source_noext_abs} PATH) - get_filename_component(shipped_name ${shipped_source_noext_abs} NAME) - list(APPEND cmd_create_command - COMMAND printf "cmd_%s.o := cp -p %s.o_shipped %s.o\\n" - "${shipped_source_noext_abs}" - "${shipped_source_noext_abs}" - "${shipped_source_noext_abs}" - > "${shipped_dir}/.${shipped_name}.o.cmd") - endforeach(shipped_source_noext_abs ${shipped_source_noext_abs}) - endif(shipped_sources_noext_abs) - - # User-defined parameters for 'make' - set(make_flags ${KBUILD_MAKE_FLAGS}) - _get_per_build_var(make_flags_per_build KBUILD_MAKE_FLAGS) - list(APPEND make_flags ${make_flags_per_build}) - - # Rule for create module(and symvers file). - add_custom_command( - OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${module_name}.ko" - "${CMAKE_CURRENT_BINARY_DIR}/${_kbuild_symvers}" - ${cmd_create_command} - COMMAND $(MAKE) ${make_flags} ${kbuild_additional_make_flags} - -C ${Kbuild_BUILD_DIR} M=${CMAKE_CURRENT_BINARY_DIR} modules -# Update timestamps for targets. -# In some cases Kbuild system may decide do not update resulted files -# even in case when depencies newer. -# Updating timestamps prevent command to be executed every make call. - COMMAND touch "${CMAKE_CURRENT_BINARY_DIR}/${module_name}.ko" - "${CMAKE_CURRENT_BINARY_DIR}/${_kbuild_symvers}" - DEPENDS ${depend_files} - "${CMAKE_CURRENT_BINARY_DIR}/Kbuild" - COMMENT "Building kernel module ${name}" - ) - - # Fill properties for the target. - set_property(TARGET ${name} PROPERTY KMODULE_TYPE "kmodule") - set_property(TARGET ${name} PROPERTY KMODULE_IMPORTED "FALSE") - set_property(TARGET ${name} PROPERTY KMODULE_MODULE_NAME "${module_name}") - - set_property(TARGET ${name} PROPERTY KMODULE_MODULE_LOCATION - "${CMAKE_CURRENT_BINARY_DIR}/${module_name}.ko" - ) - set_property(TARGET ${name} PROPERTY KMODULE_SYMVERS_LOCATION - "${CMAKE_CURRENT_BINARY_DIR}/${_kbuild_symvers}" - ) - - # Internal properties - set_property(TARGET ${name} PROPERTY KMODULE_BINARY_DIR - "${CMAKE_CURRENT_BINARY_DIR}" - ) - set_property(TARGET ${name} PROPERTY KMODULE_OBJ_SOURCES ${obj_sources_rel}) - set_property(TARGET ${name} PROPERTY KMODULE_COMPILE_FLAGS ${ccflags}) - set_property(TARGET ${name} PROPERTY KMODULE_INCLUDE_DIRECTORIES ${include_dirs}) - - - # Add target to the list of modules for built. - set_property(GLOBAL APPEND PROPERTY KMODULE_TARGETS "${name}") - - # The rule to clean files - _kbuild_module_clean_files(${name} - C_SOURCE ${c_sources_noext_abs} - ASM_SOURCE ${asm_sources_noext_abs} - SHIPPED_SOURCE ${shipped_sources_noext_abs}) -endfunction(kbuild_add_module name) - -# kbuild_include_directories(dirs ...) -# -# Add include directories for Kbuild process. -macro(kbuild_include_directories) - set_property(DIRECTORY APPEND PROPERTY KBUILD_INCLUDE_DIRECTORIES ${ARGN}) -endmacro(kbuild_include_directories) - -# kbuild_add_definitions (flags) -# -# Specify additional flags for compile kernel module. -# -# Note that multiple flags should be specified as single string, -# delimited with ' '. -function(kbuild_add_definitions flags) - get_property(current_flags DIRECTORY PROPERTY KBUILD_COMPILE_DEFINITIONS) - _string_join(" " current_flags "${current_flags}" "${flags}") - set_property(DIRECTORY PROPERTY KBUILD_COMPILE_DEFINITIONS "${current_flags}") -endfunction(kbuild_add_definitions flags) - -# There is no control for kbuild make flags except default values. -# Support for kbuild_add_make_definitions may be added if needed. - - -# kbuild_link_module( [ ...]) -# -# Link kernel module with other modules, that allows to use symbols from -# other modules. -# -# may be: -# 1) target name for other kernel module intended for build -# 2) target name for imported kernel module with -# KMODULE_IMPORTED_SYMVERS_LOCATION property set -# 3) absolute path to symvers file of other kernel module. -# -# In any case, file-level dependency will be created for symvers file to link with. -# In the first case, also target-level dependency will be added -# -# Analogue for target_link_library(). -# -# May be used only from the same directory, where module target is created. -function(kbuild_link_module name) - # Check that @name corresponds to kernel module target for build. - get_property(is_module TARGET ${name} PROPERTY KMODULE_TYPE SET) - if(NOT is_module) - message(FATAL_ERROR "kbuild_module_link: passed \n\t\"${name}\"\n which is not kernel module target.") - endif(NOT is_module) - get_property(module_imported TARGET ${name} PROPERTY KMODULE_IMPORTED) - if(kmodule_imported) - message(FATAL_ERROR "Imported kernel module target \"${name}\" may not be linked.") - endif(kmodule_imported) - - get_property(module_name TARGET ${name} PROPERTY KMODULE_MODULE_NAME) - - foreach(l ${ARGN}) - string(REGEX MATCH "/" link_is_file ${l}) - if(link_is_file) - string(REGEX MATCH "^/" file_is_absolute ${l}) - if(NOT file_is_absolute) - message(FATAL_ERROR "kbuild_module_link: passed filename\n\t\"${link}\"\nwhich is not absolute as .") - endif(NOT file_is_absolute) - set(symvers_location "${l}") - # Do not require symvers file to be already existed. - else(link_is_file) - if(NOT TARGET ${l}) - message(FATAL_ERROR "kbuild_module_link: passed link\n\t\"${l}\"\n which is neither an absolute path to symvers file nor a target.") - endif(NOT TARGET ${l}) - get_property(kmodule_type TARGET ${l} PROPERTY KMODULE_TYPE) - if(NOT kmodule_type) - message(FATAL_ERROR "kbuild_module_link: passed target\n\t\"${l}\"\n which is not a target for kernel module as link.") - endif(NOT kmodule_type) - get_property(kmodule_imported TARGET ${l} PROPERTY KMODULE_IMPORTED) - if(kmodule_imported) - get_property(symvers_location TARGET ${l} PROPERTY KMODULE_IMPORTED_SYMVERS_LOCATION) - if(NOT symvers_location) - message(FATAL_ERROR "kbuild_module_link: passed imported target\n\t\"${l}\"\n without \"KMODULE_IMPORTED_SYMVERS_LOCATION\" property set as link.") - endif(NOT symvers_location) - else(kmodule_imported) - get_property(symvers_location TARGET ${l} PROPERTY KMODULE_SYMVERS_LOCATION) - # Target dependency is added only for non-imported target. - add_dependencies(${name} ${l}) - endif(kmodule_imported) - endif(link_is_file) - add_custom_command(OUTPUT - "${CMAKE_CURRENT_BINARY_DIR}/${module_name}.ko" - "${CMAKE_CURRENT_BINARY_DIR}/${_kbuild_symvers}" - DEPENDS ${symvers_location} - APPEND - ) - set_property(TARGET ${name} APPEND PROPERTY KMODULE_DEPEND_SYMVERS ${symvers_location}) - endforeach(l ${ARGN}) -endfunction(kbuild_link_module name) - -# kbuild_finalize_linking() -# -# Should be called after all kernel modules and their links defined. -# Usually this is the end of main CMakeLists.txt file. -function(kbuild_finalize_linking) - _get_per_build_var(ccflags_per_build KBUILD_C_FLAGS) - - get_property(kmodule_targets GLOBAL PROPERTY KMODULE_TARGETS) - foreach(m ${kmodule_targets}) - get_property(module_binary_dir TARGET ${m} PROPERTY KMODULE_BINARY_DIR) - get_property(module_name TARGET ${m} PROPERTY KMODULE_MODULE_NAME) - get_property(module_symvers_cmake TARGET ${m} PROPERTY KMODULE_DEPEND_SYMVERS) - - get_property(obj_sources TARGET ${m} PROPERTY KMODULE_OBJ_SOURCES) - get_property(ccflags_local TARGET ${m} PROPERTY KMODULE_COMPILE_FLAGS) - get_property(include_dirs TARGET ${m} PROPERTY KMODULE_INCLUDE_DIRECTORIES) - - # Combine all compiler flags together - _string_join(" " ccflags "${KBUILD_C_FLAGS}" "${ccflags_local}") - foreach(dir ${include_dirs}) - _string_join(" " ccflags "${ccflags}" "-I${dir}") - endforeach(dir ${include_dirs}) - _string_join(" " ccflags "${ccflags}" "${ccflags_per_build}") - - string(REPLACE ";" " " module_symvers "${module_symvers_cmake}") - - if(obj_sources) - set(obj_src_string "${module_name}-y := ") - foreach(obj ${obj_sources}) - set(obj_src_string "${obj_src_string} ${obj}") - endforeach(obj ${obj_sources}) - else(obj_sources) - # Simple building process - module name is same as the name - # of the only source. - set(obj_src_string "") - endif(obj_sources) - # Configure kbuild file - configure_file(${kbuild_this_module_dir}/kbuild_system_files/Kbuild.in - ${module_binary_dir}/Kbuild - ) - endforeach(m ${kmodule_targets}) -endfunction(kbuild_finalize_linking) - -# kbuild_install(TARGETS ... -# [[MODULE|SYMVERS] -# DESTINATION -# [CONFIGURATIONS [...]] -# [COMPONENT ] -# ]+) -# -# Install kernel module(s) and/or symvers file(s) into given directory. -# -# Almost all options means same as for install() cmake command. -# 'MODULE' refers to kernel module itself, SYMVERS refers symvers file. -# -# Unlike to standard install() command, there is no default destination -# directory neither for modules nor for symvers files. -# So, at least one rule should be defined, and 'DESTINATION' option -# should be set for every rule. -# -# TODO: support for 'EXPORT' mode. -function(kbuild_install type) - if(NOT type STREQUAL "TARGETS") - message(FATAL_ERROR "Only 'TARGETS' mode is currently supported") - endif(NOT type STREQUAL "TARGETS") - - parse_install_arguments(kbuild_install - "MODULE;SYMVERS" # Section types - "" "DESTINATION;COMPONENT" "CONFIGURATIONS" # Section keywords classification. - ${ARGN} - ) - - set(kbuild_install_TARGETS ${kbuild_install_GLOBAL_ARGUMENTS}) - if(NOT kbuild_install_TARGETS) - message(FATAL_ERROR "No targets given for kbuild_install() command") - endif(NOT kbuild_install_TARGETS) - - if(NOT kbuild_install_sections) - message(FATAL_ERROR "There is no default destination for install kernel module components, but no section described it is given.") - endif(NOT kbuild_install_sections) - - foreach(section_type ${kbuild_install_sections}) - if(NOT kbuild_install_${section_type}_DESTINATION) - message(FATAL_ERROR "DESTINATION is not defined for section ${section_type}") - endif(NOT kbuild_install_${section_type}_DESTINATION) - # All additional arguments for given section. - set(install_args_${section_type} - DESTINATION "${kbuild_install_${section_type}_DESTINATION}") - if(kbuild_install_${section_type}_CONFIGURATION) - list(APPEND install_args_${section_type} - CONFIGURATION "${kbuild_install_${section_type}_CONFIGURATION}" - ) - endif(kbuild_install_${section_type}_CONFIGURATION) - if(kbuild_install_${section_type}_COMPONENT) - list(APPEND install_args_${section_type} - COMPONENT "${kbuild_install_${section_type}_COMPONENT}" - ) - endif(kbuild_install_${section_type}_COMPONENT) - # Module installation. - if(section_type STREQUAL "MODULE" OR section_type STREQUAL "ALL") - # Combine locations for all modules in one list. - set(module_locations) - foreach(t ${kbuild_install_TARGETS}) - kbuild_get_module_location(module_location ${t}) - list(APPEND module_locations ${module_location}) - endforeach(t ${kbuild_install_TARGETS}) - # .. and install them at once. - install(FILES ${module_locations} ${install_args_${section_type}}) - endif(section_type STREQUAL "MODULE" OR section_type STREQUAL "ALL") - # Symvers installation. - if(section_type STREQUAL "SYMVERS" OR section_type STREQUAL "ALL") - # Because of renaming, symvers files should be installed separately. - foreach(t ${kbuild_install_TARGETS}) - kbuild_get_symvers_location(symvers_location ${t}) - get_property(module_name TARGET ${t} PROPERTY KMODULE_MODULE_NAME) - install(FILES ${symvers_location} - RENAME "${module_name}.symvers" - ${install_args_${section_type}} - ) - endforeach(t ${kbuild_install_TARGETS}) - endif(section_type STREQUAL "SYMVERS" OR section_type STREQUAL "ALL") - endforeach(section_type ${kbuild_install_sections}) -endfunction(kbuild_install type) - - -# kbuild_try_compile(RESULT_VAR bindir srcfile|SOURCES src ... -# [CMAKE_FLAGS ] -# [KBUILD_COMPILE_DEFINITIONS flags ...] -# [OUTPUT_VARIABLE var]) -# -# Similar to try_module in simplified form, but compile srcfile as -# kernel module, instead of user space program. -# -# KBUILD_COMPILE_DEFINITIONS contains compiler definition flags for -# build kernel module. -# -# Possible CMAKE_FLAGS which has special semantic: -# KBUILD_INCLUDE_DIRECTORIES - include directories for build kernel module -# KBUILD_LINK_MODULE - symvers file(s) for link module with other modules. -function(kbuild_try_compile RESULT_VAR bindir srcfile) - cmake_parse_arguments(kbuild_try_compile "" "OUTPUT_VARIABLE" "CMAKE_FLAGS;KBUILD_COMPILE_DEFINITIONS" ${ARGN}) - if(srcfile STREQUAL "SOURCES") - set(srcfiles ${kbuild_try_compile_UNPARSED_ARGUMENTS}) - else(srcfile STREQUAL "SOURCES") - set(srcfiles ${srcfile}) - endif(srcfile STREQUAL "SOURCES") - - # Inside try_compile project values of variables - # CMAKE_CURRENT_BINARY_DIR and CMAKE_CURRENT_SOURCE_DIR - # differs from ones in current project. - # - # So make all paths absolute before pass them into try_compile project. - # Note, that copiing files into binary dir is nevertheless performed - # in the try_compile project, because it bases on real current binary dir. - to_abs_path(srcfiles_abs ${srcfiles}) - - # Collect parameters to try_compile() function - set(cmake_flags - "-DSOURCES:STRING=${srcfiles_abs}" # Source file(s) - "-DCMAKE_MODULE_PATH:PATH=${CMAKE_MODULE_PATH}" # Path for search include files. - ${kbuild_try_compile_CMAKE_FLAGS} - ) - - # Parameters for compiler - if(kbuild_try_compile_KBUILD_COMPILE_DEFINITIONS) - list(APPEND cmake_flags - "-DKBUILD_COMPILE_DEFINITIONS:STRING=${kbuild_try_compile_KBUILD_COMPILE_DEFINITIONS}" - ) - endif(kbuild_try_compile_KBUILD_COMPILE_DEFINITIONS) - - # Other user-defined cmake flags - if(kbuild_try_compile_CMAKE_FLAGS) - - endif(kbuild_try_compile_CMAKE_FLAGS) - - # Possible definition of output variable. - if(kbuild_try_compile_OUTPUT_VARIABLE) - set(output_variable_def "OUTPUT_VARIABLE" "output_tmp") - else(build_try_compile_OUTPUT_VARIABLE) - set(output_variable_def) - endif(kbuild_try_compile_OUTPUT_VARIABLE) - - - try_compile(result_tmp # Result variable(temporary) - "${bindir}" # Binary directory - "${kbuild_aux_dir}/try_compile_project" # Source directory - "kmodule" # Project name - CMAKE_FLAGS # Flags to CMake: - ${cmake_flags} - ${kbuild_try_compile_flags} - ${output_variable_def} - ) - - if(kbuild_try_compile_OUTPUT_VARIABLE) - # Set output variable for the caller - set("${kbuild_try_compile_OUTPUT_VARIABLE}" "${output_tmp}" PARENT_SCOPE) - endif(kbuild_try_compile_OUTPUT_VARIABLE) - # Set result variable for the caller - set("${RESULT_VAR}" "${result_tmp}" PARENT_SCOPE) -endfunction(kbuild_try_compile RESULT_VAR bindir srcfile) - -########### Auxiliary functions for internal use ####################### -# Per-directory tracking for kbuild compiler flags. -# -# Unlike to standard COMPILE_FLAGS, these flags do not include values -# set for parent directories. -# (There is no generic "fill-with-parent's values" mechanism exists -# in cmake). -# -# So, this property has a little sence for the user. -# It exists only for make effect of kbuild_add_definitions() to -# cross "function" scope. -define_property(DIRECTORY PROPERTY KBUILD_COMPILE_FLAGS - BRIEF_DOCS "Compiler flags used by Kbuild system added in this directory." - FULL_DOCS "Compiler flags used by Kbuild system added in this directory." -) - -# Per-directory tracking for kbuild include directories. -# -# Unlike to standard INCLUDE_DIRECTORIES, these ones do not include values -# set for parent directories. -# (There is no generic "fill-with-parent's values" mechanism exists -# in cmake). -# -# So, this property has a little sence for the user. -# It exists only for make effect of kbuild_include_directories() to -# cross "function" scope. -define_property(DIRECTORY PROPERTY KBUILD_INCLUDE_DIRECTORIES - BRIEF_DOCS "Include directories used by Kbuild system; added in this directory." - FULL_DOCS "Include directories used by Kbuild system; added in this directory." -) - - -# Parameters below are set externally only in try_compile() for subproject, -# which include this file. -# No need to cache them as try_compile() project is not configured by the user. - -# Real top-level source directory. -if(NOT KBUILD_REAL_SOURCE_DIR) - set(KBUILD_REAL_SOURCE_DIR ${CMAKE_SOURCE_DIR}) -endif(NOT KBUILD_REAL_SOURCE_DIR) -# Real top-level binary directory. -if(NOT KBUILD_REAL_BINARY_DIR) - set(KBUILD_REAL_BINARY_DIR ${CMAKE_BINARY_DIR}) -endif(NOT KBUILD_REAL_BINARY_DIR) - -# These flags are passed to the 'make' when compile kernel module. -set(kbuild_additional_make_flags) -# These CMake flags will be passed to try_compile() subproject. -set(kbuild_try_compile_flags - "-DKBUILD_REAL_SOURCE_DIR=${KBUILD_REAL_SOURCE_DIR}" - "-DKBUILD_REAL_BINARY_DIR=${KBUILD_REAL_BINARY_DIR}" -) - -# ARCH and CROSS_COMPILE are passed to submake only when non-empty. -if(ARCH) - list(APPEND kbuild_additional_make_flags "ARCH=${ARCH}") - list(APPEND kbuild_try_compile_flags "-DARCH=${ARCH}") -endif(ARCH) -if(CROSS_COMPILE) - list(APPEND kbuild_additional_make_flags "CROSS_COMPILE=${CROSS_COMPILE}") - list(APPEND kbuild_try_compile_flags "-DCROSS_COMPILE=${CROSS_COMPILE}") -endif(CROSS_COMPILE) - -# List of targets created with kmodule_add_module() without -# 'IMPORTED' option. -# -# This list is traversed in kmodule_finalize_linking() for -# create 'Kbuild' files. -# -# Note, that this list does not contain all defined kernel modules, -# so property normally shouldn't be used by outer code. -define_property(GLOBAL PROPERTY KMODULE_TARGETS - BRIEF_DOCS "List of kernel module targets configured for build" - FULL_DOCS "List of kernel module targets configured for build" -) - -# CMAKE_CURRENT_BINARY_DIR at the moment, when kbuild_add_module() is issued. -define_property(TARGET PROPERTY KMODULE_BINARY_DIR - BRIEF_DOCS "CMAKE_CURRENT_BINARY_DIR where module is built." - FULL_DOCS "CMAKE_CURRENT_BINARY_DIR where module is built." -) - -# List of object files, used for build kernel module. -# -# List may be empty in case of simple build, when target module has same -# name as its only source. -# -# This is internal property for configure 'Kbuild' file. -define_property(TARGET PROPERTY KMODULE_OBJ_SOURCES - BRIEF_DOCS "Object source files for build kernel module." - FULL_DOCS "Object source files for build kernel module." -) - -# Compiler flags, added with kbuild_add_definitions() -# -# Note, that KBUILD_C_FLAGS* are not included here. -# -# This is internal property for configure 'Kbuild' file. -define_property(TARGET PROPERTY KMODULE_COMPILE_FLAGS - BRIEF_DOCS "Additional compile flags for build kernel module." - FULL_DOCS "Additional compile flags for build kernel module." -) - -# Include directories, added with kbuild_include_directories(). -# -# This is internal property for configure 'Kbuild' file. -define_property(TARGET PROPERTY KMODULE_COMPILE_FLAGS - BRIEF_DOCS "Additional compile flags for build kernel module." - FULL_DOCS "Additional compile flags for build kernel module." -) - - -# List of symvers files, added by kbuild_link_module(). -# -# This is internal property for configure 'Kbuild' file. -define_property(TARGET PROPERTY KMODULE_DEPEND_SYMVERS - BRIEF_DOCS "Symvers files this module depends on." - FULL_DOCS "Symvers files this module depends on." -) - -# Constants for internal filenames. -set(_kbuild_symvers "Module.symvers") - -# copy_source_to_binary_dir( ) -# -# Helper for the building kernel module. -# -# Make sure that given source file is inside current binary dir. -# That place is writable and has some "uniqeness" garantee for generate -# auxiliary files during build process. -# -# If already inside current binary dir, do nothing and -# set variable to itself. -# -# Otherwise create rule for copy source into "nice" place inside -# current binary dir and set pointed to that place. -function(copy_source_to_binary_dir source new_source_var) - is_path_inside_dir(is_in_current_binary ${CMAKE_CURRENT_BINARY_DIR} "${source}") - if(is_in_current_binary) - # Source is already placed where we want. - set(${new_source_var} "${source}" PARENT_SCOPE) - else(is_in_current_binary) - # Base directory from which count relative source path. - # By default, it is root directory. - set(base_dir "/") - # Try "nicer" base directories. - foreach(d - ${KBUILD_REAL_BINARY_DIR} - ${CMAKE_CURRENT_SOURCE_DIR} - ${KBUILD_REAL_SOURCE_DIR} - ) - is_path_inside_dir(is_in_d ${d} "${source}") - if(is_in_d) - set(base_dir ${d}) - break() - endif(is_in_d) - endforeach(d) - # Copy source into same relativ dir, but inside current binary one. - file(RELATIVE_PATH source_rel "${base_dir}" "${source}") - set(new_source "${CMAKE_CURRENT_BINARY_DIR}/${source_rel}") - get_filename_component(new_source_dir ${new_source} PATH) - file(MAKE_DIRECTORY "${new_source_dir}") - rule_copy_file("${new_source}" "${source}") - # Return path to the new source. - set(${new_source_var} "${new_source}" PARENT_SCOPE) - endif(is_in_current_binary) -endfunction(copy_source_to_binary_dir source new_source_var) - -# _get_per_build_var(RESULT_VAR variable) -# -# Return value of per-build variable. -macro(_get_per_build_var RESULT_VAR variable) - if(CMAKE_BUILD_TYPE) - string(TOUPPER "${CMAKE_BUILD_TYPE}" _build_type_uppercase) - set(${RESULT_VAR} "${${variable}_${_build_type_uppercase}}") - else(CMAKE_BUILD_TYPE) - set(${RESULT_VAR}) - endif(CMAKE_BUILD_TYPE) -endmacro(_get_per_build_var RESULT_VAR variable) - -# _string_join(sep RESULT_VAR str1 str2) -# -# Join strings and using as glue. -# -# Note, that precisely 2 string are joined, not a list of strings. -# This prevents automatic replacing of ';' inside strings while parsing arguments. -macro(_string_join sep RESULT_VAR str1 str2) - if("${str1}" STREQUAL "") - set("${RESULT_VAR}" "${str2}") - elseif("${str2}" STREQUAL "") - set("${RESULT_VAR}" "${str1}") - else("${str1}" STREQUAL "") - set("${RESULT_VAR}" "${str1}${sep}${str2}") - endif("${str1}" STREQUAL "") -endmacro(_string_join sep RESULT_VAR str1 str2) -# _build_get_directory_property_chained(RESULT_VAR []) -# -# Return list of all values for given property in the current directory -# and all parent directories. -# -# If is given, it is used as glue for join values. -# By default, cmake list separator (';') is used. -function(_get_directory_property_chained RESULT_VAR property_name) - set(sep ";") - foreach(arg ${ARGN}) - set(sep "${arg}") - endforeach(arg ${ARGN}) - set(result "") - set(d "${CMAKE_CURRENT_SOURCE_DIR}") - while(NOT "${d}" STREQUAL "") - get_property(p DIRECTORY "${d}" PROPERTY "${property_name}") - # debug - # message("Property ${property_name} for directory ${d}: '${p}'") - _string_join("${sep}" result "${p}" "${result}") - # message("Intermediate result: '${result}'") - get_property(d DIRECTORY "${d}" PROPERTY PARENT_DIRECTORY) - endwhile(NOT "${d}" STREQUAL "") - set("${RESULT_VAR}" "${result}" PARENT_SCOPE) -endfunction(_get_directory_property_chained RESULT_VAR property_name) - -# _kbuild_module_clean_files(module_name -# [C_SOURCE c_source_noext_abs ...] -# [ASM_SOURCE asm_source_noext_abs ...] -# [SHIPPED_SOURCE shipped_source_noext_abs ...]) -# -# Tell CMake that intermediate files, created by kbuild system, -# should be cleaned with 'make clean'. -function(_kbuild_module_clean_files module_name) - cmake_parse_arguments(kbuild_module_clean "" "" "C_SOURCE;ASM_SOURCE;SHIPPED_SOURCE" ${ARGN}) - if(kbuild_module_clean_UNPARSED_ARGUMENTS) - message(FATAL_ERROR "Unparsed arguments") - endif(kbuild_module_clean_UNPARSED_ARGUMENTS) - - # List common files (names only) for cleaning - set(common_files_names - ".tmp_versions" # Directory - "modules.order" - "Module.markers" - ) - # List module name-depending files (extensions only) for cleaning - set(name_files_ext - ".o" - ".mod.c" - ".mod.o" - ) - # Same but for the files with names starting with a dot ('.'). - set(name_files_dot_ext - ".ko.cmd" - ".mod.o.cmd" - ".o.cmd" - ) - # List source name-depending files (extensions only) for cleaning - set(source_name_files_ext - ".o" - ) - # Same but for the files with names starting with a dot ('.') - set(source_name_files_dot_ext - ".o.cmd" - ".o.d" # This file is created in case of unsuccessfull build - ) - - # Now collect all sort of files into list - set(files_list) - - foreach(name ${common_files_names}) - list(APPEND files_list "${CMAKE_CURRENT_BINARY_DIR}/${name}") - endforeach(name ${common_files_names}) - - foreach(ext ${name_files_ext}) - list(APPEND files_list - "${CMAKE_CURRENT_BINARY_DIR}/${module_name}${ext}") - endforeach(ext ${name_files_ext}) - - foreach(ext ${name_files_dot_ext}) - list(APPEND files_list - "${CMAKE_CURRENT_BINARY_DIR}/.${module_name}${ext}") - endforeach(ext ${name_files_ext}) - - # All the types of sources are processed in a similar way - foreach(obj_source_noext_abs ${kbuild_module_clean_C_SOURCE} - ${kbuild_module_clean_ASM_SOURCE} ${kbuild_module_clean_SHIPPED_SOURCE}) - - get_filename_component(dir ${obj_source_noext_abs} PATH) - get_filename_component(name ${obj_source_noext_abs} NAME) - foreach(ext ${source_name_files_ext}) - list(APPEND files_list "${dir}/${name}${ext}") - endforeach(ext ${source_name_files_ext}) - foreach(ext ${source_name_files_dot_ext}) - list(APPEND files_list "${dir}/.${name}${ext}") - endforeach(ext ${source_name_files_ext}) - endforeach(obj_source_noext_abs) - # Tell CMake that given files should be cleaned. - set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${files_list}") -endfunction(_kbuild_module_clean_files module_name) - -# parse_install_arguments(prefix args..) -# -# Helper for parse arguments for install-like command. -# -# All arguments before the first keyword are classified as GLOBAL_ARGUMENTS -# and stored into list ${prefix}_GLOBAL_ARGUMENTS. -# -# describe possible keywords denoting section type. -# At most one section may exist for every type. -# Special type ALL means generic section. -# -# , and describe -# all keywords inside section. -# Values corresponded to these keywords are stored under -# __*. -# Note, that unlike to cmake_parse_arguments(), all arguments inside -# section definition should be either keyword or its value(s). -# Additionally, _ is set to TRUE for every -# encountered section and _sections contains list of such sections. -# -# If non section is currently active, the first section keyword starts -# special generic section. Definitions for this section are stored as -# for section of type ALL. -# If such section exists, it should be the only section. -# -# Function is generic, but currently is used only there. -function(parse_install_arguments prefix section_types options one_value_keywords multiple_value_keywords) - set(all_keywords ${section_types} ${options} ${one_value_keywords} ${multiple_value_keywords}) - # Type of the currently parsed section('ALL' for ALL section). - set(current_section_type) - # Active section-related keyword for current section. - set(current_section_keyword) - # Classification for @_current_section_keyword: - # 'OPTION', 'ONE' or 'MULTY'. - set(current_section_keyword_type) - - # Clean all previous keyword values. - set("pia_GLOBAL_ARGUMENTS") - foreach(section_type "ALL" ${section_types}) - set(pia_${section_type} "FALSE") - foreach(opt ${options}) - set("pia_${section_type}_${opt}" "FALSE") - endforeach(opt ${options}) - foreach(keyword ${one_value_keywords} ${multiple_value_keywords}) - set("pia_${section_type}_${keyword}") - endforeach(keyword ${one_value_keywords} ${multiple_value_keywords}) - endforeach(section_type "ALL" ${section_types}) - set("pia_sections") - - foreach(arg ${ARGN}) - list(FIND all_keywords ${arg} keyword_index) - if(keyword_index EQUAL "-1") - if(current_section_type) - if(NOT current_section_keyword) - message(FATAL_ERROR "In section ${current_section_type} argument ${arg} does not belong to any keyword.") - endif(NOT current_section_keyword) - if(current_section_keyword_type STREQUAL "ONE") - set("pia_${current_section_type}_${current_section_keyword}" "${arg}") - set(current_section_keyword "") - else(current_section_keyword_type STREQUAL "ONE") - list(APPEND "pia_${current_section_type}_${current_section_keyword}" "${arg}") - endif(current_section_keyword_type STREQUAL "ONE") - else(current_section_type) - list(APPEND "pia_GLOBAL_ARGUMENTS" "${arg}") - endif(current_section_type) - else(keyword_index EQUAL "-1") - if(current_section_type AND current_section_keyword AND current_section_keyword_type STREQUAL "ONE") - message(FATAL_ERROR "Keyword ${arg} found while value for one-value-option ${current_section_keyword} expected.") - endif(current_section_type AND current_section_keyword AND current_section_keyword_type STREQUAL "ONE") - list(FIND section_types "${arg}" section_type_index) - if(section_type_index EQUAL "-1") - if(NOT current_section_type) - set(current_section_type "ALL") - set("pia_${current_section_type}" "TRUE") - list(APPEND "pia_sections" "${current_section_type}") - endif(NOT current_section_type) - list(FIND options ${arg} option_index) - if(option_index EQUAL "-1") - set(current_section_keyword ${arg}) - list(FIND one_value_keywords ${current_section_keyword} one_index) - if(one_index EQUAL "-1") - set(current_section_keyword_type "MULTY") - else(one_index EQUAL "-1") - set(current_section_keyword_type "ONE") - endif(one_index EQUAL "-1") - set("pia_${current_section_type}_${current_section_keyword}") - else(option_index EQUAL "-1") - set("${prefix}_${current_section_type}_${current_section_keyword}" "TRUE") - set(current_section_keyword_type) - endif(option_index EQUAL "-1") - else(section_type_index EQUAL "-1") - if("pia_ALL") - message(FATAL_ERROR "Generic section should be the only section defined") - endif("pia_ALL") - set(current_section_type "${arg}") - if("pia_${current_section_type}") - message(FATAL_ERROR "Section ${current_section_type} is defined twice.") - endif("pia_${current_section_type}") - set("pia_${current_section_type}" "TRUE") - list(APPEND "pia_sections" "${current_section_type}") - # Current keyword is initially undefined for such section. - set(current_section_keyword) - endif(section_type_index EQUAL "-1") - endif(keyword_index EQUAL "-1") - endforeach(arg ${ARGN}) - - # propagate the result variables to the caller - set("${prefix}_GLOBAL_ARGUMENTS" ${pia_GLOBAL_ARGUMENTS} PARENT_SCOPE) - foreach(section_type "ALL" ${section_types}) - set(${prefix}_${section_type} ${pia_${section_type}} PARENT_SCOPE) - foreach(keyword ${options} ${one_value_keywords} ${multiple_value_keywords}) - set("${prefix}_${section_type}_${keyword}" ${pia_${section_type}_${keyword}} PARENT_SCOPE) - endforeach(keyword ${options} ${one_value_keywords} ${multiple_value_keywords}) - endforeach(section_type "ALL" ${section_types}) - set("${prefix}_sections" ${pia_sections} PARENT_SCOPE) -endfunction(parse_install_arguments prefix section_types options one_value_keywords multiple_value_keywords) diff --git a/cmake_targets/tools/MODULES/kmodule.cmake b/cmake_targets/tools/MODULES/kmodule.cmake deleted file mode 100755 index 2912ac115a..0000000000 --- a/cmake_targets/tools/MODULES/kmodule.cmake +++ /dev/null @@ -1,539 +0,0 @@ -set(kmodule_this_module_dir "${CMAKE_SOURCE_DIR}/cmake/modules/") -set(kmodule_test_sources_dir "${CMAKE_SOURCE_DIR}/cmake/kmodule_sources") - -set(kmodule_function_map_file "") -if (CMAKE_CROSSCOMPILING) - if (KEDR_SYSTEM_MAP_FILE) - set (kmodule_function_map_file "${KEDR_SYSTEM_MAP_FILE}") - else (KEDR_SYSTEM_MAP_FILE) -# KEDR_SYSTEM_MAP_FILE is not specified, construct the default path -# to the symbol map file. - set (kmodule_function_map_file - "${KEDR_ROOT_DIR}/boot/System.map-${KBUILD_VERSION_STRING}" - ) - endif (KEDR_SYSTEM_MAP_FILE) -endif (CMAKE_CROSSCOMPILING) - -# List of unreliable functions, that is, the functions that may be -# be exported and mentioned in System.map but still cannot be used -# because no header provides their declarations. -set(unreliable_functions_list - "__kmalloc_node" - "kmem_cache_alloc_node" - "kmem_cache_alloc_node_notrace" - "kmem_cache_alloc_node_trace" -) - -# kmodule_is_function_exist(function_name RESULT_VAR) -# Verify, whether given function exist in the kernel space on the current system. -# RESULT_VAR is TRUE, if function_name exist in the kernel space, FALSE otherwise. -# RESULT_VAR is cached. - -function(kmodule_is_function_exist function_name RESULT_VAR) - check_begin("Looking for ${function_name} in the kernel") - if(NOT DEFINED ${RESULT_VAR}) - check_try() - execute_process( - COMMAND sh "${kmodule_this_module_dir}/kmodule_files/scripts/lookup_kernel_function.sh" - ${function_name} ${kmodule_function_map_file} - WORKING_DIRECTORY ${CMAKE_BINARY_DIR} - RESULT_VARIABLE kmodule_is_function_exist_result - OUTPUT_QUIET) - - if (kmodule_is_function_exist_result EQUAL 0) - list(FIND unreliable_functions_list ${function_name} unreliable_function_index) - if(unreliable_function_index GREATER -1) - # Additional verification for unreliable function - kbuild_try_compile(kmodule_function_is_exist_reliable - "${CMAKE_BINARY_DIR}/check_unreliable_functions/${function_name}" - "${kmodule_test_sources_dir}/check_unreliable_functions/${function_name}.c" - ) - if(NOT kmodule_function_is_exist_reliable) - set(kmodule_is_function_exist_result 1) - endif(NOT kmodule_function_is_exist_reliable) - endif(unreliable_function_index GREATER -1) - endif(kmodule_is_function_exist_result EQUAL 0) - - if (kmodule_is_function_exist_result EQUAL 0) - set(${RESULT_VAR} "TRUE" CACHE INTERNAL "Does ${function_name} exist in the kernel?") - elseif(kmodule_is_function_exist_result EQUAL 1) - set(${RESULT_VAR} "FALSE" CACHE INTERNAL "Does ${function_name} exist in the kernel?") - else(kmodule_is_function_exist_result EQUAL 0) - message(FATAL_ERROR -"Cannot determine whether function '${function_name}' exists in the kernel" - ) - endif(kmodule_is_function_exist_result EQUAL 0) - endif(NOT DEFINED ${RESULT_VAR}) - set_bool_string(check_result "found" "not found" ${${RESULT_VAR}}) - check_end(${check_result}) -endfunction(kmodule_is_function_exist function_name RESULT_VAR) - -# Creates the list of functions that actually exist on the -# current system. -# -# kmodule_configure_kernel_functions(output_list -# {[REQUIRED | OPTIONAL] {func | ONE_OF_LIST}} ...) -# -# ONE_OF_LIST := ONE_OF_BEGIN {func ...} ONE_OF_END -# -# There are 2 modes of function lookup: -# OPTIONAL - if the function doesn't exist, it is silently ignored. -# REQUIRED - if the function doesn't exist, FATAL_ERROR message is printed. -# -# Initial mode is REQUIRED, and it can be changed at any time by REQUIRED -# and OPTIONAL keywords. -# -# ONE_OF_BEGIN/ONE_OF_END determine a section for which no more than one -# function among all listed there should exist. FATAL_ERROR message is -# printed otherwise. When mode is REQUIRED, precisely one function must -# exist. -# Inside this section other keywords must not be used (even another -# ONE_OF_BEGIN). - -function(kmodule_configure_kernel_functions output_list) - set(kmodule_configure_kernel_functions_mode "REQUIRED") - set(kmodule_configure_kernel_functions_one_of_section "FALSE") - set(output_list_tmp) - set(${output_list}) - foreach(arg ${ARGN}) - if(arg STREQUAL "REQUIRED" OR arg STREQUAL "OPTIONAL") - if(kmodule_configure_kernel_functions_one_of_section) - message(FATAL_ERROR -"Inside ONE_OF_BEGIN/ONE_OF_END section, other keywords are not allowed." - ) - endif(kmodule_configure_kernel_functions_one_of_section) - set(kmodule_configure_kernel_functions_mode ${arg}) - elseif(arg STREQUAL "ONE_OF_BEGIN") - if(kmodule_configure_kernel_functions_one_of_section) - message(FATAL_ERROR "Nested ONE_OF_BEGIN/ONE_OF_END sections are not allowed.") - endif(kmodule_configure_kernel_functions_one_of_section) - set(kmodule_configure_kernel_functions_one_of_section "TRUE") - set(kmodule_configure_kernel_functions_one_of_section_function) - elseif(arg STREQUAL "ONE_OF_END") - if(NOT kmodule_configure_kernel_functions_one_of_section) - message(FATAL_ERROR "ONE_OF_END without ONE_OF_BEGIN is not allowed.") - endif(NOT kmodule_configure_kernel_functions_one_of_section) - if(kmodule_configure_kernel_functions_one_of_section_function) - list(APPEND output_list_tmp ${kmodule_configure_kernel_functions_one_of_section_function}) - else(kmodule_configure_kernel_functions_one_of_section_function) - if(kmodule_configure_kernel_functions_mode STREQUAL "REQUIRED") - message(FATAL_ERROR -"None of the functions listed in ONE_OF section exist in the kernel but it is required." - ) - endif(kmodule_configure_kernel_functions_mode STREQUAL "REQUIRED") - endif(kmodule_configure_kernel_functions_one_of_section_function) - set(kmodule_configure_kernel_functions_one_of_section "FALSE") - else(arg STREQUAL "REQUIRED" OR arg STREQUAL "OPTIONAL") - set(kmodule_func_varname _KMODULE_IS_${arg}_EXIST) - kedr_find_function(${arg} ${kmodule_func_varname}) - if(kmodule_configure_kernel_functions_one_of_section) - if(${kmodule_func_varname}) - if(kmodule_configure_kernel_functions_one_of_section_function) - message(FATAL_ERROR "Two functions from ONE_OF sections exist in the kernel.") - else(kmodule_configure_kernel_functions_one_of_section_function) - set(kmodule_configure_kernel_functions_one_of_section_function ${arg}) - endif(kmodule_configure_kernel_functions_one_of_section_function) - endif(${kmodule_func_varname}) - else(kmodule_configure_kernel_functions_one_of_section) - if(${kmodule_func_varname}) - list(APPEND output_list_tmp ${arg}) - else(${kmodule_func_varname}) - if(kmodule_configure_kernel_functions_mode STREQUAL "REQUIRED") - message(FATAL_ERROR "Function ${arg} is not found in the kernel but it is required.") - endif(kmodule_configure_kernel_functions_mode STREQUAL "REQUIRED") - endif(${kmodule_func_varname}) - endif(kmodule_configure_kernel_functions_one_of_section) - endif(arg STREQUAL "REQUIRED" OR arg STREQUAL "OPTIONAL") - endforeach(arg ${ARGN}) - if(kmodule_configure_kernel_functions_one_of_section) - message(FATAL_ERROR "Found ONE_OF_BEGIN without ONE_OF_END") - endif(kmodule_configure_kernel_functions_one_of_section) - set(${output_list} ${output_list_tmp} PARENT_SCOPE) -endfunction(kmodule_configure_kernel_functions output_list) - -############################################################################ -# Utility macros to check for particular features. If the particular feature -# is supported, the macros will set the corresponding variable to TRUE, -# otherwise - to FALSE (the name of variable is mentioned in the comments -# for the macro). -############################################################################ - -# Check if the system has everything necessary to build at least simple -# kernel modules. -# The macro sets variable 'MODULE_BUILD_SUPPORTED'. -macro(check_module_build) - check_begin("Checking if kernel modules can be built on this system") - if (NOT MODULE_BUILD_SUPPORTED) - check_try() - kbuild_try_compile(module_build_supported_impl - "${CMAKE_BINARY_DIR}/check_module_build" - "${kmodule_test_sources_dir}/check_module_build/module.c" - ) - set_bool_string(MODULE_BUILD_SUPPORTED "yes" "no" ${module_build_supported_impl} - CACHE INTERNAL "Can kernel modules be built on this system?" - ) - endif (NOT MODULE_BUILD_SUPPORTED) - - check_end("${MODULE_BUILD_SUPPORTED}") - - if (NOT MODULE_BUILD_SUPPORTED) - message(FATAL_ERROR -"There are problems with building kernel modules on this system. " -"Please check that the appropriate kernel headers and build tools " -"are installed." - ) - endif (NOT MODULE_BUILD_SUPPORTED) -endmacro(check_module_build) - -# Check if reliable stack trace information can be obtained. -# This is the case, for example, if the kernel is compiled with support -# for frame pointers and/or stack unwind on. -# The macro sets variable 'STACK_TRACE_RELIABLE'. -macro(check_stack_trace) - check_begin("Checking if stack trace information is reliable") - if (NOT DEFINED STACK_TRACE_RELIABLE) - check_try() - kbuild_try_compile(stack_trace_reliable_impl - "${CMAKE_BINARY_DIR}/check_stack_trace" - "${kmodule_test_sources_dir}/check_stack_trace/module.c" - ) - set_bool_string(STACK_TRACE_RELIABLE "yes" "no" ${stack_trace_reliable_impl} - CACHE INTERNAL "Are stack traces reliable on this system?") - endif (NOT DEFINED STACK_TRACE_RELIABLE) - check_end("${STACK_TRACE_RELIABLE}") - - if (NOT STACK_TRACE_RELIABLE) - message ("\n[WARNING]\n" - "It looks like reliable stack traces cannot be obtained on this system.\n" - "The output of KEDR-based tools like LeakCheck will be less detailed\n" - "(each stack trace shown will contain only one frame).\n" - "If this is not acceptable, you could rebuild the kernel with\n" - "CONFIG_FRAME_POINTER or CONFIG_STACK_UNWIND (if available) set to \"y\"\n" - "and then reconfigure and rebuild KEDR.\n") - endif (NOT STACK_TRACE_RELIABLE) -endmacro(check_stack_trace) - -# Check whether ring buffer is implemented by the kernel. -# Set cache variable RING_BUFFER_IMPLEMENTED according to this checking. -function(check_ring_buffer) - check_begin("Checking if ring buffer is implemented in the kernel") - - if (NOT DEFINED RING_BUFFER_IMPLEMENTED) - check_try() - kbuild_try_compile(ring_buffer_implemented_impl - "${CMAKE_BINARY_DIR}/check_ring_buffer" - "${kmodule_test_sources_dir}/check_ring_buffer/module.c" - ) - - set_bool_string(RING_BUFFER_IMPLEMENTED "yes" "no" "${ring_buffer_implemented_impl}" - CACHE INTERNAL "Whether ring buffer is implemented in the kernel" - ) - endif (NOT DEFINED RING_BUFFER_IMPLEMENTED) - check_end(${RING_BUFFER_IMPLEMENTED}) - - if (NOT RING_BUFFER_IMPLEMENTED) - message("\n[WARNING]\nRing buffer is not supported by the system.\n" - "The tracing facilities as well as call monitoring plugins will not be built.\n" - "If this is not acceptable, you could rebuild the kernel with\n" - "CONFIG_RING_BUFFER set to \"y\" and then reconfigure and rebuild KEDR.\n") - endif (NOT RING_BUFFER_IMPLEMENTED) -endfunction(check_ring_buffer) - -# Check which memory allocator is used by the kernel. -# Set KERNEL_MEMORY_ALLOCATOR to 'slab', 'slub', 'slob' or 'other'. -# -# Some functions in that allocators may have same names, but different signatures. -function(check_allocator) - check_begin("Checking which memory allocator is used by the kernel") - if(NOT DEFINED KERNEL_MEMORY_ALLOCATOR) - check_try() - # Use local variable for detect allocator, - # Cache one will be set at the end - set(allocator "") - if(allocator STREQUAL "") - kbuild_try_compile(is_allocator_slab - "${CMAKE_BINARY_DIR}/check_allocator_slab" - "${kmodule_test_sources_dir}/check_allocator/module.c" - KBUILD_COMPILE_DEFINITIONS "-DIS_ALLOCATOR_SLAB" - ) - if (is_allocator_slab) - set(allocator "slab") - endif (is_allocator_slab) - endif(allocator STREQUAL "") - - if(allocator STREQUAL "") - kbuild_try_compile(is_allocator_slub - "${CMAKE_BINARY_DIR}/check_allocator_slub" - "${kmodule_test_sources_dir}/check_allocator/module.c" - KBUILD_COMPILE_DEFINITIONS "-DIS_ALLOCATOR_SLUB" - ) - if (is_allocator_slub) - set(allocator "slub") - endif (is_allocator_slub) - endif(allocator STREQUAL "") - - if(allocator STREQUAL "") - kbuild_try_compile(is_allocator_slob - "${CMAKE_BINARY_DIR}/check_allocator_slob" - "${kmodule_test_sources_dir}/check_allocator/module.c" - KBUILD_COMPILE_DEFINITIONS "-DIS_ALLOCATOR_SLOB" - ) - if (is_allocator_slob) - set(allocator "slob") - endif (is_allocator_slub) - endif(allocator STREQUAL "") - - if(allocator STREQUAL "") - set(allocator "other") - endif(allocator STREQUAL "") - - set(KERNEL_MEMORY_ALLOCATOR "${allocator}" CACHE INTERNAL - "Memory allocator which is used by the kernel" - ) - endif (NOT DEFINED KERNEL_MEMORY_ALLOCATOR) - check_end("${KERNEL_MEMORY_ALLOCATOR}") -endfunction(check_allocator) - -# Check if 'kfree_rcu' is available in the kernel (it is likely to be -# a macro or an inline). If it is available, we should handle it as -# 'free' in LeakCheck. As KEDR cannot normally intercept kfree_rcu() -# itself, it needs to intercept call_rcu/call_rcu_sched and check their -# arguments. -# The macro sets variable 'HAVE_KFREE_RCU'. -macro(check_kfree_rcu) - check_begin("Checking if kfree_rcu() is available") - - if (NOT DEFINED HAVE_KFREE_RCU) - check_try() - kbuild_try_compile(have_kfree_rcu_impl - "${CMAKE_BINARY_DIR}/check_kfree_rcu" - "${kmodule_test_sources_dir}/check_kfree_rcu/module.c" - ) - - set_bool_string(HAVE_KFREE_RCU "yes" "no" ${have_kfree_rcu_impl} - CACHE INTERNAL "Is kfree_rcu() available?" - ) - endif () - check_end("${HAVE_KFREE_RCU}") -endmacro(check_kfree_rcu) -############################################################################ - -# Check if posix_acl_from_xattr() accepts struct user_namespace as the -# first argument. -# The macro sets variable 'POSIX_ACL_XATTR_HAS_USER_NS'. -macro(check_xattr_user_ns) - check_begin("Checking if posix_acl_from_xattr() has struct user_namespace * argument") - if (NOT DEFINED POSIX_ACL_XATTR_HAS_USER_NS) - check_try() - kbuild_try_compile(have_xattr_user_ns_impl - "${CMAKE_BINARY_DIR}/check_xattr_user_ns" - "${kmodule_test_sources_dir}/check_xattr_user_ns/module.c" - ) - - set_bool_string(POSIX_ACL_XATTR_HAS_USER_NS "yes" "no" ${have_xattr_user_ns_impl} - CACHE INTERNAL "Does posix_acl_from_xattr() have struct user_namespace argument?" - ) - endif () - check_end("${POSIX_ACL_XATTR_HAS_USER_NS}") -endmacro(check_xattr_user_ns) -############################################################################ - -# Check if hlist_for_each_entry*() macros accept only 'type *pos' argument -# rather than both 'type *tpos' and 'hlist_node *pos' as the loop cursors. -# The macro sets variable 'HLIST_FOR_EACH_ENTRY_POS_ONLY'. -macro(check_hlist_for_each_entry) - check_begin("Checking the signatures of hlist_for_each_entry*() macros") - if (NOT DEFINED HLIST_FOR_EACH_ENTRY_POS_ONLY) - check_try() - kbuild_try_compile(pos_only_impl - "${CMAKE_BINARY_DIR}/check_hlist_for_each_entry" - "${kmodule_test_sources_dir}/check_hlist_for_each_entry/module.c" - ) - set_bool_string(HLIST_FOR_EACH_ENTRY_POS_ONLY "yes" "no" ${pos_only_impl} - CACHE INTERNAL - "Do hlist_for_each_entry*() macros have only 'type *pos' to use as a loop cursor?" - ) - endif () - set_bool_string(check_result "do not use additional loop cursor" "use additional loop cursor" - ${HLIST_FOR_EACH_ENTRY_POS_ONLY}) - check_end(${check_result}) -endmacro(check_hlist_for_each_entry) -############################################################################ - -# Check if 'random32' is available in the kernel. -# The macro sets variable 'KEDR_HAVE_RANDOM32'. -macro(check_random32) - check_begin("Checking if random32() is available") - if (NOT DEFINED KEDR_HAVE_RANDOM32) - check_try() - kbuild_try_compile(have_random32_impl - "${CMAKE_BINARY_DIR}/check_random32" - "${kmodule_test_sources_dir}/check_random32/module.c" - ) - set_bool_string(KEDR_HAVE_RANDOM32 "yes" "no" "${have_random32_impl}" - CACHE INTERNAL "Is random32() available?" - ) - endif () - check_end("${KEDR_HAVE_RANDOM32}") -endmacro(check_random32) -############################################################################ - -# The payload modules should call kedr_find_function() for each kernel -# function they would like to process. If the function is not known -# to KEDR (absent from the "function database", see "functions/" directory), -# kedr_find_function() issues a fatal error. -# -# 'func_name' is the name of the function, -# 'found_var' is the name of the output variable (the variable will evaluate -# as "true" if found, as "false" otherwise). -function (kedr_find_function func_name found_var) - if (NOT DEFINED KEDR_DATA_FILE_${func_name}) - message(FATAL_ERROR "Unsupported function: ${func_name}") - endif (NOT DEFINED KEDR_DATA_FILE_${func_name}) - - # OK, known function. - kmodule_is_function_exist(${func_name} ${found_var}) - if (${found_var}) - # Mark the function as used by at least one payload module. - # This can be used when preparing the tests for call interception. - # The actual value does not matter, it only matters that this - # variable is defined. - set(KEDR_FUNC_USED_${func_name} "yes" CACHE INTERNAL - "Is kernel function ${func_name} used by any payload module?") - set(${found_var} "${${found_var}}" PARENT_SCOPE) - else () - set(${found_var} "NO" PARENT_SCOPE) - endif (${found_var}) -endfunction (kedr_find_function func_name found_var) - -# Returns (in ${path_var}) the path to the .data file for the function -# ${func_name}. The function must be present in the system and -# kedr_find_function() must be called for it before kedr_get_data_for_func(). -function (kedr_get_data_for_func func_name path_var) - if (NOT DEFINED KEDR_FUNC_USED_${func_name}) - message(FATAL_ERROR -"Attempt to lookup data for a function that is not marked as used: " - "${func_name}") - endif (NOT DEFINED KEDR_FUNC_USED_${func_name}) - - set(${path_var} "${KEDR_DATA_FILE_${func_name}}" PARENT_SCOPE) -endfunction (kedr_get_data_for_func func_name path_var) - -# kedr_get_header_data_list(list_var func1 [func2 func3 ...]) -# Get the list of paths to the 'header.data' files for the given functions. -# The functions must be present in the system and # kedr_find_function() -# must be called for each of them before kedr_get_header_data_list() is -# called. -# The resulting list is returned in ${list_var}. It will contain at least -# one item. It will not contain duplicates. -function (kedr_get_header_data_list list_var) - set(hdata_list) - foreach (func ${ARGN}) - if (NOT DEFINED KEDR_FUNC_USED_${func}) - message(FATAL_ERROR -"Attempt to lookup header data for a function that is not marked as used: " - "${func}") - endif (NOT DEFINED KEDR_FUNC_USED_${func}) - list(APPEND hdata_list "${KEDR_HEADER_DATA_FILE_${func}}") - endforeach () - list(REMOVE_DUPLICATES hdata_list) - - list(LENGTH hdata_list hdata_list_len) - if (NOT hdata_list_len) - message(FATAL_ERROR - "kedr_get_header_data_list(): BUG: the output list is empty.") - endif (NOT hdata_list_len) - - set(${list_var} ${hdata_list} PARENT_SCOPE) -endfunction (kedr_get_header_data_list list_var) - -# kedr_create_header_rules( -# header_impl_file header_data_file func1 [func2 ...]) -# Create the rules to generate ${header_impl_file} from -# ${header_data_file} and the specific header files for the given -# functions. -function(kedr_create_header_rules header_impl_file header_data_file - functions) - set(hlist_data) - kedr_get_header_data_list(hlist_data ${functions} ${ARGN}) - to_abs_path(hdata_files_abs ${header_data_file} ${hlist_data}) - add_custom_command(OUTPUT ${header_impl_file} - COMMAND cat ${hdata_files_abs} > ${header_impl_file} - DEPENDS ${hdata_files_abs} - ) -endfunction(kedr_create_header_rules header_impl_file header_data_file - functions) - -# kedr_create_data_rules(func) -# Create the rules to generate ${func}_impl.data from -# ${func}.data (contains processing instructions specific to the current -# payload) and the .data file from "func_db" (contains function signature). -function(kedr_create_data_rules func) - set(func_db_data_file) - kedr_get_data_for_func(${func} func_db_data_file) - - set(func_proc_data_file) - to_abs_path(func_proc_data_file ${func}.data) - - add_custom_command(OUTPUT "${func}_impl.data" - COMMAND printf "\"[group]\\n\"" > "${func}_impl.data" - COMMAND grep -E -v '\\[group\\]' - "${func_db_data_file}" >> "${func}_impl.data" - COMMAND printf "\"\\n\"" >> "${func}_impl.data" - COMMAND grep -E -v '\\[group\\]' - "${func_proc_data_file}" >> "${func}_impl.data" - DEPENDS - "${func_proc_data_file}" - "${func_db_data_file}" - ) -endfunction(kedr_create_data_rules func) - -# kedr_create_payload_module(module_name payload_data_file template_dir) -# Create the rules to build a payload module with the given name. -# 'payload_data_file' defines how the kernel functions are to be processed -# by this payload module. -# 'template_dir' - path to the direcotry containing the templates to be used -# to prepare the source code of the module from 'payload_data_file'. -function(kedr_create_payload_module module_name payload_data_file - template_dir) - - # Rules to build the module - kbuild_add_module(${module_name} - "payload.c" - "functions_support.c" - ) - kbuild_link_module(${module_name} kedr) - - # Rules to obtain the source files of the module - kedr_generate("payload.c" ${payload_data_file} "${template_dir}") - kedr_generate("functions_support.c" ${payload_data_file} "${KEDR_GEN_TEMPLATES_DIR}/functions_support.c") -endfunction(kedr_create_payload_module module_name payload_data_file - template_dir) - -# kedr_create_payload_data(payload_data_file func1 [func2 ...]) -# Create .data files and the header data files for the functions and prepare -# the main .data file (${payload_data_file}) for the payload module. -function(kedr_create_payload_data header_data_file payload_data_file - functions) - set(header_impl_file "header_impl.data") - set(functions_data) - - foreach(func ${functions} ${ARGN}) - list(APPEND functions_data "${func}_impl.data") - kedr_create_data_rules(${func}) - endforeach(func ${functions} ${ARGN}) - - kedr_create_header_rules(${header_impl_file} ${header_data_file} - ${functions} ${ARGN}) - - to_abs_path(payload_data_file_abs ${payload_data_file}) - to_abs_path(source_files_abs ${header_impl_file} ${functions_data}) - - set(payload_data_file_abs "${CMAKE_CURRENT_BINARY_DIR}/${payload_data_file}") - add_custom_command(OUTPUT ${payload_data_file_abs} - COMMAND cat ${source_files_abs} > ${payload_data_file_abs} - DEPENDS ${source_files_abs} - ) -endfunction(kedr_create_payload_data header_data_file payload_data_file - functions) -############################################################################