From 06eaf7232e9a920468c0f8d74dcf2fe8b555501c Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 13 Apr 2024 14:24:36 +0200 Subject: Adding upstream version 1:10.11.6. Signed-off-by: Daniel Baumann --- cmake/plugin.cmake | 331 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 331 insertions(+) create mode 100644 cmake/plugin.cmake (limited to 'cmake/plugin.cmake') diff --git a/cmake/plugin.cmake b/cmake/plugin.cmake new file mode 100644 index 00000000..813d8ef6 --- /dev/null +++ b/cmake/plugin.cmake @@ -0,0 +1,331 @@ +# Copyright (c) 2009, 2018, Oracle and/or its affiliates. +# Copyright (c) 2011, 2019, MariaDB Corporation. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; version 2 of the License. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA + + +INCLUDE(CMakeParseArguments) + +# MYSQL_ADD_PLUGIN(plugin_name source1...sourceN +# [STORAGE_ENGINE] +# [STATIC_ONLY|MODULE_ONLY] +# [MANDATORY|DEFAULT] +# [DISABLED] +# [NOT_EMBEDDED|RECOMPILE_FOR_EMBEDDED] +# [CLIENT] +# [MODULE_OUTPUT_NAME module_name] +# [STATIC_OUTPUT_NAME static_name] +# [COMPONENT component] +# [CONFIG cnf_file_name] +# [VERSION version_string] +# [LINK_LIBRARIES lib1...libN] +# [DEPENDS target1...targetN] + +MACRO(MYSQL_ADD_PLUGIN) + CMAKE_PARSE_ARGUMENTS(ARG + "STORAGE_ENGINE;STATIC_ONLY;MODULE_ONLY;MANDATORY;DEFAULT;DISABLED;NOT_EMBEDDED;RECOMPILE_FOR_EMBEDDED;CLIENT" + "MODULE_OUTPUT_NAME;STATIC_OUTPUT_NAME;COMPONENT;CONFIG;VERSION" + "LINK_LIBRARIES;DEPENDS" + ${ARGN} + ) + IF(NOT WITHOUT_SERVER OR ARG_CLIENT) + + # Add common include directories + INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/sql + ${PCRE_INCLUDES} + ${SSL_INCLUDE_DIRS} + ${ZLIB_INCLUDE_DIR}) + + LIST(GET ARG_UNPARSED_ARGUMENTS 0 plugin) + SET(SOURCES ${ARG_UNPARSED_ARGUMENTS}) + LIST(REMOVE_AT SOURCES 0) + STRING(TOUPPER ${plugin} plugin) + STRING(TOLOWER ${plugin} target) + + IF (ARG_MANDATORY) + UNSET(PLUGIN_${plugin} CACHE) + SET(PLUGIN_${plugin} "YES") + ELSE() + SET (compat ".") + # Figure out whether to build plugin. + # recognize and support the maze of old WITH/WITHOUT combinations + IF(WITHOUT_${plugin}_STORAGE_ENGINE + OR WITHOUT_${plugin} + OR WITHOUT_PLUGIN_${plugin} + OR WITH_NONE) + + SET(compat "${compat}without") + ENDIF() + IF(WITH_${plugin}_STORAGE_ENGINE + OR WITH_${plugin} + OR WITH_PLUGIN_${plugin} + OR WITH_ALL + OR WITH_MAX + OR WITH_MAX_NO_NDB + OR ARG_DEFAULT) + + SET(compat "with${compat}") + ENDIF() + + IF (ARG_DISABLED) + SET(howtobuild NO) + ELSEIF (compat STREQUAL ".") + SET(howtobuild DYNAMIC) + ELSEIF (compat STREQUAL "with.") + IF (NOT ARG_MODULE_ONLY) + SET(howtobuild STATIC) + ELSE() + SET(howtobuild DYNAMIC) + ENDIF() + ELSEIF (compat STREQUAL ".without") + SET(howtobuild NO) + ELSEIF (compat STREQUAL "with.without") + SET(howtobuild STATIC) + ENDIF() + + # NO - not at all + # YES - static if possible, otherwise dynamic if possible, otherwise abort + # AUTO - static if possible, otherwise dynamic, if possible + # STATIC - static if possible, otherwise not at all + # DYNAMIC - dynamic if possible, otherwise not at all + SET(PLUGIN_${plugin} ${howtobuild} + CACHE STRING "How to build plugin ${plugin}. Options are: NO STATIC DYNAMIC YES AUTO.") + ENDIF() + + IF (NOT PLUGIN_${plugin} MATCHES "^(NO|YES|AUTO|STATIC|DYNAMIC)$") + MESSAGE(FATAL_ERROR "Invalid value for PLUGIN_${plugin}") + ENDIF() + + IF(ARG_STORAGE_ENGINE) + SET(with_var "WITH_${plugin}_STORAGE_ENGINE" ) + ELSE() + SET(with_var "WITH_${plugin}") + ENDIF() + UNSET(${with_var} CACHE) + + IF(NOT ARG_DEPENDS) + SET(ARG_DEPENDS) + ENDIF() + + IF(ARG_VERSION) + SET(version_string ";PLUGIN_${plugin}_VERSION=\"${ARG_VERSION}\"") + ENDIF() + + IF(NOT ARG_MODULE_OUTPUT_NAME) + IF(ARG_STORAGE_ENGINE) + SET(ARG_MODULE_OUTPUT_NAME "ha_${target}") + ELSE() + SET(ARG_MODULE_OUTPUT_NAME "${target}") + ENDIF() + ENDIF() + + # Build either static library or module + IF (PLUGIN_${plugin} MATCHES "(STATIC|AUTO|YES)" AND NOT ARG_MODULE_ONLY + AND NOT ARG_CLIENT) + + IF(CMAKE_GENERATOR MATCHES "Makefiles|Ninja") + # If there is a shared library from previous shared build, + # remove it. This is done just for mysql-test-run.pl + # so it does not try to use stale shared lib as plugin + # in test. + FILE(REMOVE + ${CMAKE_CURRENT_BINARY_DIR}/${ARG_MODULE_OUTPUT_NAME}${CMAKE_SHARED_MODULE_SUFFIX}) + ENDIF() + + ADD_LIBRARY(${target} STATIC ${SOURCES}) + DTRACE_INSTRUMENT(${target}) + ADD_DEPENDENCIES(${target} GenError ${ARG_DEPENDS}) + RESTRICT_SYMBOL_EXPORTS(${target}) + IF(WITH_EMBEDDED_SERVER AND (NOT ARG_NOT_EMBEDDED)) + # Embedded library should contain PIC code and be linkable + # to shared libraries (on systems that need PIC) + IF(ARG_RECOMPILE_FOR_EMBEDDED OR NOT _SKIP_PIC) + # Recompile some plugins for embedded + ADD_CONVENIENCE_LIBRARY(${target}_embedded ${SOURCES}) + RESTRICT_SYMBOL_EXPORTS(${target}_embedded) + DTRACE_INSTRUMENT(${target}_embedded) + IF(ARG_RECOMPILE_FOR_EMBEDDED) + SET_TARGET_PROPERTIES(${target}_embedded + PROPERTIES COMPILE_DEFINITIONS "EMBEDDED_LIBRARY${version_string}") + ENDIF() + ADD_DEPENDENCIES(${target}_embedded GenError ${ARG_DEPENDS}) + ENDIF() + ENDIF() + + IF(ARG_STATIC_OUTPUT_NAME) + SET_TARGET_PROPERTIES(${target} PROPERTIES + OUTPUT_NAME ${ARG_STATIC_OUTPUT_NAME}) + ENDIF() + + IF(ARG_LINK_LIBRARIES) + TARGET_LINK_LIBRARIES (${target} ${ARG_LINK_LIBRARIES}) + ENDIF() + + SET(${with_var} ON CACHE INTERNAL "Link ${plugin} statically to the server" FORCE) + + # Update mysqld dependencies + SET (MYSQLD_STATIC_PLUGIN_LIBS ${MYSQLD_STATIC_PLUGIN_LIBS} + ${target} ${ARG_LINK_LIBRARIES} CACHE INTERNAL "" FORCE) + + IF(WITH_EMBEDDED_SERVER AND (NOT ARG_NOT_EMBEDDED)) + SET (EMBEDDED_PLUGIN_LIBS ${EMBEDDED_PLUGIN_LIBS} + ${target} ${ARG_LINK_LIBRARIES} CACHE INTERNAL "" FORCE) + ENDIF() + + IF(ARG_NOT_EMBEDDED) + SET(builtin_entry "#ifndef EMBEDDED_LIBRARY\n builtin_maria_${target}_plugin,\n#endif") + ELSE() + SET(builtin_entry " builtin_maria_${target}_plugin,") + ENDIF() + + IF(ARG_MANDATORY) + SET (mysql_mandatory_plugins + "${mysql_mandatory_plugins}${builtin_entry}\n") + SET (mysql_mandatory_plugins ${mysql_mandatory_plugins} PARENT_SCOPE) + ELSE() + SET (mysql_optional_plugins + "${mysql_optional_plugins}${builtin_entry}\n") + SET (mysql_optional_plugins ${mysql_optional_plugins} PARENT_SCOPE) + ENDIF() + ELSEIF(PLUGIN_${plugin} MATCHES "(DYNAMIC|AUTO|YES)" + AND NOT ARG_STATIC_ONLY AND NOT WITHOUT_DYNAMIC_PLUGINS) + + ADD_VERSION_INFO(${target} MODULE SOURCES) + ADD_LIBRARY(${target} MODULE ${SOURCES}) + DTRACE_INSTRUMENT(${target}) + + SET_TARGET_PROPERTIES (${target} PROPERTIES PREFIX "") + IF (NOT ARG_CLIENT) + SET_TARGET_PROPERTIES (${target} PROPERTIES + COMPILE_DEFINITIONS "MYSQL_DYNAMIC_PLUGIN${version_string}") + ENDIF() + + TARGET_LINK_LIBRARIES (${target} mysqlservices ${ARG_LINK_LIBRARIES}) + + IF(CMAKE_SYSTEM_NAME MATCHES AIX) + TARGET_LINK_OPTIONS(${target} PRIVATE "-Wl,-bE:${CMAKE_SOURCE_DIR}/libservices/mysqlservices_aix.def") + ENDIF() + + # Server plugins use symbols defined in mysqld executable. + # Some operating systems like Windows and OSX and are pretty strict about + # unresolved symbols. Others are less strict and allow unresolved symbols + # in shared libraries. On Linux for example, CMake does not even add + # executable to the linker command line (it would result into link error). + # Thus we skip TARGET_LINK_LIBRARIES on Linux, as it would only generate + # an additional dependency. + IF(ARG_RECOMPILE_FOR_EMBEDDED OR ARG_STORAGE_ENGINE) + IF(MSVC OR CMAKE_SYSTEM_NAME MATCHES AIX) + TARGET_LINK_LIBRARIES(${target} server) + ELSEIF(NOT CMAKE_SYSTEM_NAME STREQUAL "Linux") + TARGET_LINK_LIBRARIES (${target} mariadbd) + ENDIF() + ELSEIF(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT WITH_ASAN AND NOT WITH_TSAN AND NOT WITH_UBSAN AND NOT WITH_MSAN) + TARGET_LINK_LIBRARIES (${target} "-Wl,--no-undefined") + ENDIF() + + ADD_DEPENDENCIES(${target} GenError ${ARG_DEPENDS}) + + SET_TARGET_PROPERTIES(${target} PROPERTIES + OUTPUT_NAME "${ARG_MODULE_OUTPUT_NAME}") + # Install dynamic library + IF(ARG_COMPONENT) + IF(CPACK_COMPONENTS_ALL AND + NOT CPACK_COMPONENTS_ALL MATCHES ${ARG_COMPONENT} + AND INSTALL_SYSCONF2DIR) + IF (ARG_STORAGE_ENGINE) + STRING(REPLACE "-" "_" ver ${SERVER_VERSION}) + SET(ver " = ${ver}-%{release}") + ELSE() + SET(ver "") + ENDIF() + SET(CPACK_COMPONENTS_ALL ${CPACK_COMPONENTS_ALL} ${ARG_COMPONENT}) + SET(CPACK_COMPONENTS_ALL ${CPACK_COMPONENTS_ALL} PARENT_SCOPE) + + IF (NOT ARG_CLIENT) + SET(CPACK_RPM_${ARG_COMPONENT}_PACKAGE_REQUIRES "MariaDB-server${ver}" PARENT_SCOPE) + ENDIF() + SET(CPACK_RPM_${ARG_COMPONENT}_USER_FILELIST ${ignored} PARENT_SCOPE) + IF (ARG_VERSION) + SET(CPACK_RPM_${ARG_COMPONENT}_PACKAGE_VERSION ${SERVER_VERSION}_${ARG_VERSION} PARENT_SCOPE) + SET_PLUGIN_DEB_VERSION(${target} ${SERVER_VERSION}-${ARG_VERSION}) + ENDIF() + IF(NOT ARG_CLIENT AND UNIX) + IF (NOT ARG_CONFIG) + SET(ARG_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${target}.cnf") + FILE(WRITE ${ARG_CONFIG} "[mariadb]\nplugin-load-add=${ARG_MODULE_OUTPUT_NAME}.so\n") + ENDIF() + SET(CPACK_RPM_${ARG_COMPONENT}_USER_FILELIST ${ignored} "%config(noreplace) ${INSTALL_SYSCONF2DIR}/*" PARENT_SCOPE) + SET(CPACK_RPM_${ARG_COMPONENT}_POST_INSTALL_SCRIPT_FILE ${CMAKE_SOURCE_DIR}/support-files/rpm/plugin-postin.sh PARENT_SCOPE) + SET(CPACK_RPM_${ARG_COMPONENT}_POST_TRANS_SCRIPT_FILE ${CMAKE_SOURCE_DIR}/support-files/rpm/server-posttrans.sh PARENT_SCOPE) + ENDIF() + ENDIF() + ELSE() + SET(ARG_COMPONENT Server) + ENDIF() + MYSQL_INSTALL_TARGETS(${target} DESTINATION ${INSTALL_PLUGINDIR} COMPONENT ${ARG_COMPONENT}) + IF(ARG_CONFIG AND INSTALL_SYSCONF2DIR) + INSTALL(FILES ${ARG_CONFIG} COMPONENT ${ARG_COMPONENT} DESTINATION ${INSTALL_SYSCONF2DIR}) + ENDIF() + ENDIF() + + GET_FILENAME_COMPONENT(subpath ${CMAKE_CURRENT_SOURCE_DIR} NAME) + IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/mysql-test") + INSTALL_MYSQL_TEST("${CMAKE_CURRENT_SOURCE_DIR}/mysql-test/" "plugin/${subpath}") + ENDIF() + + IF(TARGET ${target}) + GET_TARGET_PROPERTY(plugin_type ${target} TYPE) + STRING(REPLACE "_LIBRARY" "" plugin_type ${plugin_type}) + SET(have_target 1) + ELSE() + SET(plugin_type) + SET(have_target 0) + ENDIF() + IF(ARG_STORAGE_ENGINE) + ADD_FEATURE_INFO(${plugin} ${have_target} "Storage Engine ${plugin_type}") + ELSEIF(ARG_CLIENT) + ADD_FEATURE_INFO(${plugin} ${have_target} "Client plugin ${plugin_type}") + ELSE() + ADD_FEATURE_INFO(${plugin} ${have_target} "Server plugin ${plugin_type}") + ENDIF() + ENDIF(NOT WITHOUT_SERVER OR ARG_CLIENT) +ENDMACRO() + + +# Add all CMake projects under storage and plugin +# subdirectories, configure sql_builtins.cc +MACRO(CONFIGURE_PLUGINS) + IF(NOT WITHOUT_SERVER) + FILE(GLOB dirs_storage ${CMAKE_SOURCE_DIR}/storage/*) + ENDIF() + + FILE(GLOB dirs_plugin ${CMAKE_SOURCE_DIR}/plugin/*) + FOREACH(dir ${dirs_storage} ${dirs_plugin}) + IF (EXISTS ${dir}/CMakeLists.txt) + ADD_SUBDIRECTORY(${dir}) + ENDIF() + ENDFOREACH() + + GET_CMAKE_PROPERTY(ALL_VARS VARIABLES) + FOREACH (V ${ALL_VARS}) + IF (V MATCHES "^PLUGIN_" AND ${V} MATCHES "YES") + STRING(SUBSTRING ${V} 7 -1 plugin) + STRING(TOLOWER ${plugin} target) + IF (NOT TARGET ${target}) + MESSAGE(FATAL_ERROR "Plugin ${plugin} cannot be built") + ENDIF() + ENDIF() + ENDFOREACH() +ENDMACRO() -- cgit v1.2.3