Add automatic generation of version and build type headers for compilation

This change replaces the static version and build type header file generation
by CMake with dynamic CMake targets to generate the version file whenever a Make
target is executed. Thus, there is no need anymore to reconfigure and rerun
CMake after the repository version or build configuration has changed.

5 files changed, 32 insertions, 70 deletions

diff --git a/src/kernel/CMakeLists.txt b/src/kernel/CMakeLists.txt
index dd12c80..2f1446a 100644
--- a/src/kernel/CMakeLists.txt
+++ b/src/kernel/CMakeLists.txt
@@ -3,20 +3,26 @@ cmake_minimum_required(VERSION 3.10)
 # set the project name
 project(xloop-kernel)
 
-set (CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-include(kernel)
+# include macros to define Linux kernel build targets
+include(Kernel)
 
 # set C flags for a Linux kernel module
-set(KERNEL_C_FLAGS "-DCONFIG_BLK_DEV_XLOOP_MIN_COUNT=${BLK_DEV_XLOOP_MIN_COUNT} -DXLOOP_MAJOR=${XLOOP_MAJOR} -DXLOOP_CTRL_MINOR=${XLOOP_CTRL_MINOR} -DVERSION=${VERSION}"
-      CACHE STRING "C flags to be used for building the kernel module")
+set(KERNEL_C_FLAGS "-DCONFIG_BLK_DEV_XLOOP_MIN_COUNT=${BLK_DEV_XLOOP_MIN_COUNT} -DXLOOP_MAJOR=${XLOOP_MAJOR} -DXLOOP_CTRL_MINOR=${XLOOP_CTRL_MINOR} -I ${PROJECT_INCLUDE_GEN_DIR}"
+    CACHE STRING "C flags to be used for building the kernel module")
 # set C flags for the debug mode of a Linux kernel module
 set(KERNEL_C_FLAGS_DEBUG "-g -DDEBUG"
-            CACHE STRING "Additional C flags to be used for building the kernel module in debug mode")
+    CACHE STRING "Additional C flags to be used for building the kernel module in debug mode")
+
+# append include directories to the C flags
+get_property(KERNEL_INCLUDE_DIRS DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
+foreach(KERNEL_INCLUDE_DIR ${KERNEL_INCLUDE_DIRS})
+    set(KERNEL_C_FLAGS "${KERNEL_C_FLAGS} -I ${KERNEL_INCLUDE_DIR}")
+endforeach(KERNEL_INCLUDE_DIR ${KERNEL_INCLUDE_DIRS})
 
 # append debug C flags if debug mode is enabled
-if(CMAKE_BUILD_TYPE MATCHES Debug)
+if(CMAKE_BUILD_TYPE MATCHES "Debug")
     set(KERNEL_C_FLAGS "${KERNEL_C_FLAGS} ${KERNEL_C_FLAGS_DEBUG}")
-endif(CMAKE_BUILD_TYPE MATCHES Debug)
+endif(CMAKE_BUILD_TYPE MATCHES "Debug")
 
 # xloop main Linux kernel module
 set(KERNEL_MODULE_XLOOP_SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/xloop_file_fmt.c
@@ -30,6 +36,8 @@ add_kernel_module(xloop "${KERNEL_BUILD_DIR}"
                         "${KERNEL_MODULE_XLOOP_SOURCE_FILES}"
                         "${KERNEL_MODULE_XLOOP_HEADER_FILES}"
                         ${CMAKE_CURRENT_SOURCE_DIR}/Kbuild)
+# add dependency to generate project version header before xloop.ko is built
+add_dependencies(xloop xloop-generate-version)
 
 # xloop_file_fmt_raw Linux kernel module
 set(KERNEL_MODULE_XLOOP_RAW_SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/xloop_file_fmt_raw.c)
@@ -43,6 +51,8 @@ add_kernel_module(xloop_file_fmt_raw "${KERNEL_BUILD_DIR}"
                                      "${KERNEL_MODULE_XLOOP_RAW_HEADER_FILES}"
                                      ${CMAKE_CURRENT_SOURCE_DIR}/Kbuild
                                      xloop)
+# add dependency to generate project version header before xloop_file_fmt_raw.ko is built
+add_dependencies(xloop_file_fmt_raw xloop-generate-version)
 
 # xloop_file_fmt_qcow Linux kernel module
 set(KERNEL_MODULE_XLOOP_QCOW_SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/xloop_file_fmt_qcow_cache.c
@@ -61,13 +71,15 @@ add_kernel_module(xloop_file_fmt_qcow "${KERNEL_BUILD_DIR}"
                                       "${KERNEL_MODULE_XLOOP_QCOW_HEADER_FILES}"
                                       ${CMAKE_CURRENT_SOURCE_DIR}/Kbuild
                                       xloop)
+# add dependency to generate project version header before xloop_file_fmt_qcow.ko is built
+add_dependencies(xloop_file_fmt_qcow xloop-generate-version)
 
-if(${CMAKE_BUILD_TYPE} MATCHES Debug)
+if(CMAKE_BUILD_TYPE MATCHES "Debug")
     add_subdirectory(tests)
-endif()
+endif(CMAKE_BUILD_TYPE MATCHES "Debug")
 
 # install udev rules for xloop devices exposed by the xloop kernel module
 install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/udev/50-xloop.rules
         DESTINATION /lib/udev/rules.d
         PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-        COMPONENT main)
+        COMPONENT kernel)
diff --git a/src/kernel/cmake/kernel.cmake b/src/kernel/cmake/kernel.cmake
deleted file mode 100644
index 811ce86..0000000
--- a/src/kernel/cmake/kernel.cmake
+++ /dev/null
@@ -1,56 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0
-#
-# CMake macros to build and install Linux kernel modules
-# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de>
-#
-
-# macro to define kernel module targets
-macro(add_kernel_module MODULE_NAME KERNEL_BUILD_DIR KERNEL_INSTALL_DIR MODULE_MACRO MODULE_SOURCE_FILES MODULE_HEADER_FILES BUILD_SOURCE_FILE)
-    # create directory for kernel module
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME})
-    # copy build source file
-    get_filename_component(BUILD_SOURCE_FILENAME ${BUILD_SOURCE_FILE} NAME)
-    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${BUILD_SOURCE_FILENAME}
-                       COMMAND ${CMAKE_COMMAND} -E copy_if_different ${BUILD_SOURCE_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}
-                       DEPENDS ${BUILD_SOURCE_FILE})
-    set(BUILD_SOURCE_FILE_PREPARED ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${BUILD_SOURCE_FILENAME})
-    # copy source files
-    foreach(MODULE_SOURCE_FILE ${MODULE_SOURCE_FILES})
-        get_filename_component(MODULE_SOURCE_FILENAME ${MODULE_SOURCE_FILE} NAME)
-        add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_SOURCE_FILENAME}
-                           COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MODULE_SOURCE_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}
-                           DEPENDS ${MODULE_SOURCE_FILE})
-        set(MODULE_SOURCE_FILES_PREPARED ${MODULE_SOURCE_FILES_PREPARED}
-                                         ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_SOURCE_FILENAME})
-    endforeach()
-    # copy header files
-    foreach(MODULE_HEADER_FILE ${MODULE_HEADER_FILES})
-        get_filename_component(MODULE_HEADER_FILENAME ${MODULE_HEADER_FILE} NAME)
-        add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_HEADER_FILENAME}
-                           COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MODULE_HEADER_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}
-                           DEPENDS ${MODULE_HEADER_FILE})
-        set(MODULE_HEADER_FILES_PREPARED ${MODULE_HEADER_FILES_PREPARED}
-                                         ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_HEADER_FILENAME})
-    endforeach()
-    # check if module depends on another module
-    if(NOT ${ARGV7} STREQUAL "")
-        set(MODULE_EXTRA_SYMBOLS ${CMAKE_CURRENT_BINARY_DIR}/${ARGV7}/Module.symvers)
-    endif()
-    # define build command
-    set(MODULE_BUILD_COMMAND ${CMAKE_MAKE_PROGRAM} ${MODULE_MACRO}
-                                                   -C ${KERNEL_BUILD_DIR}
-                                                    M=${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME} modules
-                                                    EXTRA_CFLAGS=${KERNEL_C_FLAGS}
-                                                    KBUILD_EXTRA_SYMBOLS=${MODULE_EXTRA_SYMBOLS})
-    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_NAME}.ko
-                       COMMAND ${MODULE_BUILD_COMMAND}
-                       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}
-                       COMMENT "Build kernel module ${MODULE_NAME}"
-                       DEPENDS ${BUILD_SOURCE_FILE_PREPARED} ${MODULE_HEADER_FILES_PREPARED} ${MODULE_SOURCE_FILES_PREPARED}
-                       VERBATIM)
-    add_custom_target(${MODULE_NAME} ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_NAME}.ko ${ARGV7})
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_NAME}.ko
-            DESTINATION ${KERNEL_INSTALL_DIR}
-            PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-            COMPONENT main)
-endmacro(add_kernel_module)
diff --git a/src/kernel/xloop_file_fmt_qcow_main.c b/src/kernel/xloop_file_fmt_qcow_main.c
index 38fe1af..dfde76d 100644
--- a/src/kernel/xloop_file_fmt_qcow_main.c
+++ b/src/kernel/xloop_file_fmt_qcow_main.c
@@ -27,6 +27,8 @@
 #include <linux/zstd.h>
 #endif
 
+#include <xloop/version.h>
+
 #include "xloop_file_fmt.h"
 #include "xloop_file_fmt_qcow_main.h"
 #include "xloop_file_fmt_qcow_cache.h"
@@ -1280,4 +1282,4 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Manuel Bentele <development@manuel-bentele.de>");
 MODULE_DESCRIPTION("xloop device QCOW file format driver");
 MODULE_SOFTDEP("pre: xloop");
-MODULE_VERSION(__stringify(VERSION));
+MODULE_VERSION(XLOOP_VERSION);
diff --git a/src/kernel/xloop_file_fmt_raw.c b/src/kernel/xloop_file_fmt_raw.c
index 76ab39e..12914e8 100644
--- a/src/kernel/xloop_file_fmt_raw.c
+++ b/src/kernel/xloop_file_fmt_raw.c
@@ -23,6 +23,8 @@
 #include <linux/uio.h>
 #include <linux/version.h>
 
+#include <xloop/version.h>
+
 #include "xloop_file_fmt.h"
 
 static inline loff_t __raw_file_fmt_rq_get_pos(struct xloop_file_fmt *xlo_fmt,
@@ -473,4 +475,4 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Manuel Bentele <development@manuel-bentele.de>");
 MODULE_DESCRIPTION("xloop device RAW file format driver");
 MODULE_SOFTDEP("pre: xloop");
-MODULE_VERSION(__stringify(VERSION));
+MODULE_VERSION(XLOOP_VERSION);
diff --git a/src/kernel/xloop_main.c b/src/kernel/xloop_main.c
index a3e20a6..300554f 100644
--- a/src/kernel/xloop_main.c
+++ b/src/kernel/xloop_main.c
@@ -88,6 +88,8 @@
 #include <linux/debugfs.h>
 #endif
 
+#include <xloop/version.h>
+
 #include "xloop_file_fmt.h"
 #include "xloop_main.h"
 
@@ -1719,7 +1721,7 @@ module_param(max_part, int, 0444);
 MODULE_PARM_DESC(max_part, "Maximum number of partitions per xloop device");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Manuel Bentele <development@manuel-bentele.de>");
-MODULE_VERSION(__stringify(VERSION));
+MODULE_VERSION(XLOOP_VERSION);
 MODULE_ALIAS_BLOCKDEV_MAJOR(XLOOP_MAJOR);
 
 int xloop_register_transfer(struct xloop_func_table *funcs)
@@ -2189,7 +2191,7 @@ static int __init xloop_init(void)
 		xloop_add(&xlo, i);
 	mutex_unlock(&xloop_ctl_mutex);
 
-	pr_info("module in version %s loaded\n", __stringify(VERSION));
+	pr_info("module in version %s loaded\n", XLOOP_VERSION);
 	return 0;
 
 misc_out: