From: Ali Maredia Date: Mon, 23 Jun 2014 22:32:32 +0000 (-0400) Subject: Combined CMake Build for Hammer X-Git-Tag: v0.93~265^2~27 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=0f6b9f28164535a62d24de4eb2aaa79dc2b91e91;p=ceph.git Combined CMake Build for Hammer CMake Ceph Build System (Firefly) CMake. Add tests. Respace src/CMakeLists.txt. CMake. Spacing cleanups. CMake for Firefly is Triumphant CMake for Giant Adapt to Giant. Fix installation for scripts and man pages Fix CEPH_LIBDIR and CEPH_PKGLIBDIR defines Add erasure-code libraries uses try_compile() to detect support for -msse flags Fix rados object classes Propagate Casey's cls library change to src/test. Fix CMake build for Hammer. Try-add rados and common to librbd link. Fix name and linkage of libec_lrc. Rename arch/neon.c arm.c Fix libcommon.a dependencies (some unit tests). Authors: Ali Maredia Casey Bodley Adam Emerson Marcus Watts Matt Benjamin Signed-off-by: Matt Benjamin --- diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 000000000000..1977c3ca287a --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,241 @@ +cmake_minimum_required(VERSION 2.8.11) + +project(Ceph) +set(VERSION "0.88") + +# Tweak policies (this one disables "missing" dependency warning) +cmake_policy(SET CMP0046 OLD) + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/") + +include_directories( + ${PROJECT_BINARY_DIR}/src/include + ${OFED_PREFIX}/include + ${LEVELDB_PREFIX}/include +) + +link_directories( + ${OFED_PREFIX}/lib + ${LEVELDB_PREFIX}/lib +) + +#Check Includes +include(CheckIncludeFiles) +include(CheckIncludeFileCXX) +include(CheckFunctionExists) + +CHECK_FUNCTION_EXISTS(fallocate CEPH_HAVE_FALLOCATE) +CHECK_FUNCTION_EXISTS(posix_fadvise HAVE_POSIX_FADVISE) +CHECK_FUNCTION_EXISTS(posix_fallocate HAVE_POSIX_FALLOCATE) +CHECK_FUNCTION_EXISTS(syncfs HAVE_SYS_SYNCFS) +CHECK_FUNCTION_EXISTS(sync_file_range HAVE_SYNC_FILE_RANGE) +CHECK_INCLUDE_FILES("arpa/inet.h" HAVE_ARPA_INET_H) +CHECK_INCLUDE_FILES("boost/random/discrete_distribution.hpp" HAVE_BOOST_RANDOM_DISCRETE_DISTRIBUTION) +CHECK_INCLUDE_FILES("dirent.h" HAVE_DIRENT_H) +CHECK_INCLUDE_FILES("dlfcn.h" HAVE_DLFCN_H) +CHECK_INCLUDE_FILES("inttypes.h" HAVE_INTTYPES_H) +CHECK_INCLUDE_FILES("linux/types.h" HAVE_LINUX_TYPES_H) +CHECK_INCLUDE_FILES("leveldb/filter_policy.h" HAVE_LEVELDB_FILTER_POLICY) +CHECK_INCLUDE_FILES("memory.h" HAVE_MEMORY_H) +CHECK_INCLUDE_FILES("ndir.h" HAVE_NDIR_H) +CHECK_INCLUDE_FILES("netdb.h" HAVE_NETDB_H) +CHECK_INCLUDE_FILES("netinet/in.h" HAVE_NETINET_IN_H) +CHECK_INCLUDE_FILES("stdint.h" HAVE_STDINT_H) +CHECK_INCLUDE_FILES("stdlib.h" HAVE_STDLIB_H) +CHECK_INCLUDE_FILES("arpa/inet.h" HAVE_ARPA_INET_H) +CHECK_INCLUDE_FILES("strings.h" HAVE_STRINGS_H) +CHECK_INCLUDE_FILES("string.h" HAVE_STRING_H) +CHECK_INCLUDE_FILES("syslog.h" HAVE_SYSLOG_H) +CHECK_INCLUDE_FILES("sys/dir.h" HAVE_SYS_DIR_H) +CHECK_INCLUDE_FILES("sys/file.h" HAVE_SYS_FILE_H) +CHECK_INCLUDE_FILES("sys/ioctl.h" HAVE_SYS_IOCTL_H) +CHECK_INCLUDE_FILES("sys/mount.h" HAVE_SYS_MOUNT_H) +CHECK_INCLUDE_FILES("sys/ndir.h" HAVE_SYS_NDIR_H) +CHECK_INCLUDE_FILES("sys/param.h" HAVE_SYS_PARAM_H) +CHECK_INCLUDE_FILES("sys/socket.h" HAVE_SYS_SOCKET_H) +CHECK_INCLUDE_FILES("sys/statvfs.h" HAVE_SYS_STATVFS_H) +CHECK_INCLUDE_FILES("sys/stat.h" HAVE_SYS_STAT_H) +CHECK_INCLUDE_FILES("sys/time.h" HAVE_SYS_TIME_H) +CHECK_INCLUDE_FILES("sys/types.h" HAVE_SYS_TYPES_H) +CHECK_INCLUDE_FILES("sys/vfs.h" HAVE_SYS_VFS_H) +CHECK_INCLUDE_FILES("sys/wait.h" HAVE_SYS_WAIT_H) +CHECK_INCLUDE_FILES("sys/xattr.h" HAVE_SYS_XATTR_H) +CHECK_INCLUDE_FILES("unistd.h" HAVE_UNISTD_H) +CHECK_INCLUDE_FILES("utime.h" HAVE_UTIME_H) +CHECK_INCLUDE_FILES("${CMAKE_SOURCE_DIR}/src/include/fiemap.h" HAVE_FIEMAP_H) +CHECK_INCLUDE_FILES("expat.h" HAVE_EXPAT_H) +CHECK_INCLUDE_FILES("fuse/fuse_lowlevel.h" HAVE_FUSE_LOWLEVEL_H) +CHECK_INCLUDE_FILES("curl/curl.h" HAVE_FUSE_LOWLEVEL_H) +CHECK_INCLUDE_FILES("fuse/fuse.h" HAVE_FUSE_H) +CHECK_INCLUDE_FILES("google/profiler.h" HAVE_PROFILER_H) +CHECK_INCLUDE_FILES("libedit/vis.h" HAVE_LIBEDIT_VIS_H) +CHECK_INCLUDE_FILES("fcgi_config.h" HAVE_FASTCGI_CONFIG_H) +CHECK_INCLUDE_FILES("fastcgi.h" HAVE_FASTCGI_H) +CHECK_INCLUDE_FILES("fcgiapp.h" FASTCGI_FASTCGI_APP_DIR) +CHECK_INCLUDE_FILES("fcgimisc.h" HAVE_FASTCGI_MISC_H) +CHECK_INCLUDE_FILES("fcgio.h" HAVE_FASTCGIO_H) +CHECK_INCLUDE_FILES("fcgios.h" FASTCGI_FASTCGIOS_DIR) +CHECK_INCLUDE_FILES("fcgi_stdio.h" HAVE_FASTCGI_STDIO_H) +CHECK_INCLUDE_FILES("openssl/ssl.h" HAVE_SSL_H) +CHECK_INCLUDE_FILES("snappy.h" HAVE_SNAPPY_H) +CHECK_INCLUDE_FILES("uuid/uuid.h" HAVE_UUID_H) +CHECK_INCLUDE_FILES("atomic_ops.h" HAVE_ATOMIC_OPS) +CHECK_INCLUDE_FILES("keyutils.h" HAVE_KEYUTILS_H) + +include(CheckSymbolExists) +CHECK_SYMBOL_EXISTS(__u8 "sys/types.h;linux/types.h" HAVE___U8) +CHECK_SYMBOL_EXISTS(__u64 "sys/types.h;linux/types.h" HAVE___U64) +CHECK_SYMBOL_EXISTS(__s64 "sys/types.h;linux/types.h" HAVE___S64) + +set(CEPH_MAN_DIR "share/man" CACHE STRING "Install location for man pages (relative to prefix).") + +option(ENABLE_SHARED "build shared libraries" ON) +if(${ENABLE_SHARED}) + set(CEPH_SHARED SHARED) +else(${ENABLE_SHARED}) + set(CEPH_SHARED STATIC) +endif(${ENABLE_SHARED}) + +find_package(udev REQUIRED) +set(HAVE_UDEV ${UDEV_FOUND}) +message(STATUS "${UDEV_LIBS}") + +option(WITH_AIO "AIO is here ON" ON) +if(${WITH_AIO}) +find_package(aio REQUIRED) +set(HAVE_LIBAIO ${AIO_FOUND}) +message(STATUS "${AIO_LIBS}") +endif(${WITH_AIO}) + +option(WITH_FUSE "Fuse is here" ON) +if(${WITH_FUSE}) +find_package(fuse REQUIRED) +set(HAVE_LIBFUSE ${FUSE_FOUND}) +CHECK_FUNCTION_EXISTS(fuse_getgroups HAVE_FUSE_GETGROUPS) +endif(${WITH_FUSE}) + +# probably fuse etc need this -- how to check? XXX +option(WITH_MDS "MDS is here" ON) + +# needs mds and? XXX +option(WITH_CLIENT "Client is here" ON) +option(WITH_LIBCEPHFS "libcephfs client library" ON) + +# key-value store +option(WITH_KVS "Key value store is here" ON) + +# remote block storage +option(WITH_RBD "Remote block storage is here" ON) +if(${WITH_RBD}) +find_package(blkid REQUIRED) +set(HAVE_LIBBLKID ${BLKID_FOUND}) +endif(${WITH_RBD}) + +option(WITH_LEVELDB "LevelDB is here" ON) +if(${WITH_LEVELDB}) +find_package(leveldb REQUIRED) +set(HAVE_LIBLEVELDB ${LEVELDB_FOUND}) +CHECK_INCLUDE_FILES("leveldb/filter_policy.h" HAVE_LEVELDB_FILTER_POLICY) +endif(${WITH_LEVELDB}) + +option(WITH_EXPAT "EXPAT is here" ON) +if(${WITH_EXPAT}) +find_package(expat REQUIRED) +set(HAVE_EXPAT ${EXPAT_FOUND}) +endif(${WITH_EXPAT}) + +option(WITH_FCGI "FCGI is here" ON) +if(${WITH_FCGI}) +find_package(fcgi REQUIRED) +set(HAVE_FCGI ${FCGI_FOUND}) +endif(${WITH_FCGI}) + +option(WITH_ATOMICS_OPS "Atomic Ops is here" ON) +if(${WITH_ATOMIC_OPS}) +find_package(atomic_ops REQUIRED) +set(HAVE_ATOMIC_OPS ${ATOMIC_OPS_FOUND}) +endif(${WITH_ATOMIC_OPS}) + +option(WITH_PROFILER "The Profiler is here" ON) +if(${WITH_PROFILER}) +find_package(profiler REQUIRED) +set(HAVE_PROFILER ${PROFILER_FOUND}) +endif(${WITH_PROFILER}) + +option(WITH_SNAPPY "Snappy is here" ON) +if(${WITH_SNAPPY}) +find_package(snappy REQUIRED) +set(HAVE_LIBSNAPPY ${SNAPPY_FOUND}) +endif(${WITH_SNAPPY}) + +option(WITH_TCMALLOC "Use TCMalloc as Allocator" ON) +if(${WITH_TCMALLOC}) +find_package(tcmalloc REQUIRED) +set(HAVE_LIBTCMALLOC ${Tcmalloc_FOUND}) +endif(${WITH_TCMALLOC}) + +option(USE_CRYPTOPP "Cryptopp is ON" ON) +find_package(cryptopp) +if(CRYPTOPP_FOUND) + MESSAGE(STATUS "${CRYPTOPP_LIBRARIES}") + set(CRYPTO_LIBS ${CRYPTOPP_LIBRARIES}) + set(USE_NSS 0) +else() + MESSAGE(STATUS "Cryptopp not here using NSS instead") + set(USE_NSS 1) + MESSAGE(STATUS "${NSS_LIBRARIES}") + find_package(NSS) + if(NSS_FOUND) + MESSAGE(STATUS "${NSS_LIBRARIES}") + #It is known to be false why the test + if(NOT CRYPTOPP_FOUND) + set(CRYPTO_LIBS ${NSS_LIBRARIES}) + add_definitions(-DUSE_NSS) + endif(NOT CRYPTOPP_FOUND) + endif(NSS_FOUND) +endif(CRYPTOPP_FOUND) + +option(WITH_XIO "Enable XIO messaging" ON) +if(WITH_XIO) +find_package(xio) +set(HAVE_XIO ${Xio_FOUND}) +endif(WITH_XIO) + +#option for RGW +option(WITH_RADOSGW "Rados Gateway is enabled" ON) + +# Now create a useable config.h +configure_file( + ${PROJECT_SOURCE_DIR}/src/include/config-h.in.cmake + ${PROJECT_BINARY_DIR}/include/acconfig.h +) +include_directories(${PROJECT_BINARY_DIR}/include) + +add_definitions(-D__linux__) + +if(${ENABLE_SHARED}) + set(Boost_USE_STATIC_LIBS OFF) +else(${ENABLE_SHARED}) + set(Boost_USE_STATIC_LIBS ON) +endif(${ENABLE_SHARED}) + +set(Boost_USE_MULTITHREADED ON) +find_package(Boost COMPONENTS thread system REQUIRED) +include_directories(${Boost_INCLUDE_DIRS}) + +find_package(Threads REQUIRED) + +# find out which platform we are building on +if(${CMAKE_SYSTEM_NAME} MATCHES "Linux") + set(LINUX ON) + set(UNIX ON) + FIND_PACKAGE(Threads) +endif(${CMAKE_SYSTEM_NAME} MATCHES "Linux") + +# find out which platform we are building on +if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") +set(OperatingSystem "Mac OS X") +endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") + +add_subdirectory(src) +add_subdirectory(man) diff --git a/README.cmake b/README.cmake new file mode 100644 index 000000000000..ad1aa01a9ab2 --- /dev/null +++ b/README.cmake @@ -0,0 +1,62 @@ +Overview +======== +This is a work in progress Cmake build system. Currently it builds alimited set of targets, +and only on Linux/posix. The goals include faster builds (see for yourself), cleaner +builds (no libtool), and improved portability (e.g., Windows). + +Building Ceph +============= +To build out of source make an empty directory called "build" and run: +$ cmake [path to top level ceph-local directory] + +To build in source make an empty directory called "build" and run: +$ cmake .. + +Once the Configuring is done and the Build files have been written to the current +build directory run: +$ make + +To build only certain targets type in: +$ make [target name] + +To install, once all the targets are built run: +$ make install + +Options +======= +There is an option to build the Rados Gateway that is defaulted to ON +To build without the Rados Gateway: +$ cmake [path to top level ceph-local directory] -DWITH_RADOSGW=OFF + +To build with debugging and alternate locations for (a couple of) +external dependencies: +$ cmake -DLEVELDB_PREFIX="/opt/hyperleveldb" -DOFED_PREFIX="/opt/ofed" \ + -DCMAKE_INSTALL_PREFIX=/opt/accelio -DCMAKE_C_FLAGS="-O0 -g3 -gdwarf-4" \ + .. + +With future development efforts more options will be implemented + +Targets Built +============== +ceph-mon +ceph-osd +ceph-mds +cephfs +ceph-syn +rados +radosgw (set ON as a default) +librados-config +ceph-conf +monmaptool +osdmaptool +crushtool +ceph-authtool +init-ceph +mkcephfs +mon_store_converter +ceph-fuse + +Future work will be done to build more targets, check for libraries and headers more thoroughly +and include tests to make this build become more robust. CMake allows ceph to build onto many +platforms such as Windows though the shell scripts need bash/unix to run. + diff --git a/cmake/modules/FindNSS.cmake b/cmake/modules/FindNSS.cmake new file mode 100644 index 000000000000..e42907c1a0b9 --- /dev/null +++ b/cmake/modules/FindNSS.cmake @@ -0,0 +1,122 @@ +# - Try to find NSS +# Once done this will define +# +# NSS_FOUND - system has NSS +# NSS_INCLUDE_DIRS - the NSS include directory +# NSS_LIBRARIES - Link these to use NSS +# NSS_DEFINITIONS - Compiler switches required for using NSS +# +# Copyright (c) 2010 Andreas Schneider +# +# Redistribution and use is allowed according to the terms of the New +# BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. +# + + +if (NSS_LIBRARIES AND NSS_INCLUDE_DIRS) + # in cache already + set(NSS_FOUND TRUE) +else (NSS_LIBRARIES AND NSS_INCLUDE_DIRS) + find_package(PkgConfig) + if (PKG_CONFIG_FOUND) + pkg_check_modules(_NSS nss) + endif (PKG_CONFIG_FOUND) + + find_path(NSS_INCLUDE_DIR + NAMES + nss.h + PATHS + ${_NSS_INCLUDEDIR} + /usr/include + /usr/local/include + /opt/local/include + /sw/include + PATH_SUFFIXES + nss3 + ) + + find_library(SSL3_LIBRARY + NAMES + ssl3 + PATHS + ${_NSS_LIBDIR} + /usr/lib + /usr/local/lib + /opt/local/lib + /sw/lib + ) + + find_library(SMIME3_LIBRARY + NAMES + smime3 + PATHS + ${_NSS_LIBDIR} + /usr/lib + /usr/local/lib + /opt/local/lib + /sw/lib + ) + + find_library(NSS3_LIBRARY + NAMES + nss3 + PATHS + ${_NSS_LIBDIR} + /usr/lib + /usr/local/lib + /opt/local/lib + /sw/lib + /usr/lib/x86_64-linux-gnu + ) + + find_library(NSSUTIL3_LIBRARY + NAMES + nssutil3 + PATHS + ${_NSS_LIBDIR} + /usr/lib + /usr/local/lib + /opt/local/lib + /sw/lib + ) + + set(NSS_INCLUDE_DIRS + ${NSS_INCLUDE_DIR} + ) + + if (SSL3_LIBRARY) + set(NSS_LIBRARIES + ${NSS_LIBRARIES} + ${SSL3_LIBRARY} + ) + endif (SSL3_LIBRARY) + + if (SMIME3_LIBRARY) + set(NSS_LIBRARIES + ${NSS_LIBRARIES} + ${SMIME3_LIBRARY} + ) + endif (SMIME3_LIBRARY) + + if (NSS3_LIBRARY) + set(NSS_LIBRARIES + ${NSS_LIBRARIES} + ${NSS3_LIBRARY} + ) + endif (NSS3_LIBRARY) + + if (NSSUTIL3_LIBRARY) + set(NSS_LIBRARIES + ${NSS_LIBRARIES} + ${NSSUTIL3_LIBRARY} + ) + endif (NSSUTIL3_LIBRARY) + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(NSS DEFAULT_MSG NSS_LIBRARIES NSS_INCLUDE_DIRS) + + # show the NSS_INCLUDE_DIRS and NSS_LIBRARIES variables only in the advanced view + mark_as_advanced(NSS_INCLUDE_DIRS NSS_LIBRARIES) + +endif (NSS_LIBRARIES AND NSS_INCLUDE_DIRS) diff --git a/cmake/modules/Findaio.cmake b/cmake/modules/Findaio.cmake new file mode 100644 index 000000000000..ae2e36d3e164 --- /dev/null +++ b/cmake/modules/Findaio.cmake @@ -0,0 +1,45 @@ +# - Find AIO +# +# AIO_INCLUDE - Where to find AIO/aio.h +# AIO_LIBS - List of libraries when using AIO. +# AIO_FOUND - True if AIO found. + +get_filename_component(module_file_path ${CMAKE_CURRENT_LIST_FILE} PATH) + +# Look for the header file. +find_path(AIO_INCLUDE +NAMES aio.h +PATHS /usr/include $ENV{AIO_ROOT}/include /opt/local/include /usr/local/include +DOC "Path in which the file AIO/aio.h is located." ) + +mark_as_advanced(AIO_INCLUDE) + +# Look for the library. +# Does this work on UNIX systems? (LINUX) +find_library(AIO_LIBS +NAMES aio +PATHS /usr/lib /usr/lib/x86_64-linux-gnu $ENV{AIO_ROOT}/lib +DOC "Path to AIO library.") + +mark_as_advanced(AIO_LIBS) + +# Copy the results to the output variables. +if (AIO_INCLUDE AND AIO_LIBS) + message(STATUS "Found AIO in ${AIO_INCLUDE} ${AIO_LIBS}") + set(AIO_FOUND 1) + include(CheckCXXSourceCompiles) + set(CMAKE_REQUIRED_LIBRARY ${AIO_LIBS} pthread) + set(CMAKE_REQUIRED_INCLUDES ${AIO_INCLUDE}) + else () + set(AIO_FOUND 0) + endif () + + # Report the results. + if (NOT AIO_FOUND) + set(AIO_DIR_MESSAGE "AIO was not found. Make sure AIO_LIBS and AIO_INCLUDE are set.") + if (AIO_FIND_REQUIRED) + message(FATAL_ERROR "${AIO_DIR_MESSAGE}") + elseif (NOT AIO_FIND_QUIETLY) + message(STATUS "${AIO_DIR_MESSAGE}") + endif () + endif () diff --git a/cmake/modules/Findatomicops.cmake b/cmake/modules/Findatomicops.cmake new file mode 100644 index 000000000000..18e8b03bc25f --- /dev/null +++ b/cmake/modules/Findatomicops.cmake @@ -0,0 +1,28 @@ +# - Find atomic_ops +# Find the native ATOMIC_OPS headers and libraries. +# +# ATOMIC_OPS_INCLUDE_DIRS - where to find atomic_ops.h, etc. +# ATOMIC_OPS_LIBRARIES - List of libraries when using atomic_ops. +# ATOMIC_OPS_FOUND - True if atomic_ops found. + +# Look for the header file. +FIND_PATH(ATOMIC_OPS_INCLUDE_DIR NAMES atomic_ops.h) + +# Look for the library. +FIND_LIBRARY(ATOMIC_OPS_LIBRARY NAMES atomic_ops) + +# handle the QUIETLY and REQUIRED arguments and set ATOMIC_OPS_FOUND to TRUE if +# all listed variables are TRUE +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(ATOMIC_OPS DEFAULT_MSG ATOMIC_OPS_LIBRARY ATOMIC_OPS_INCLUDE_DIR) + +# Copy the results to the output variables. +IF(ATOMIC_OPS_FOUND) + SET(ATOMIC_OPS_LIBRARIES ${ATOMIC_OPS_LIBRARY}) + SET(ATOMIC_OPS_INCLUDE_DIRS ${ATOMIC_OPS_INCLUDE_DIR}) +ELSE(ATOMIC_OPS_FOUND) + SET(ATOMIC_OPS_LIBRARIES) + SET(ATOMIC_OPS_INCLUDE_DIRS) +ENDIF(ATOMIC_OPS_FOUND) + +MARK_AS_ADVANCED(ATOMIC_OPS_INCLUDE_DIR ATOMIC_OPS_LIBRARY) diff --git a/cmake/modules/Findblkid.cmake b/cmake/modules/Findblkid.cmake new file mode 100644 index 000000000000..aa1518b5da36 --- /dev/null +++ b/cmake/modules/Findblkid.cmake @@ -0,0 +1,52 @@ +# Copyright (C) 2007-2012 Hypertable, Inc. +# +# This file is part of Hypertable. +# +# Hypertable 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; either version 3 +# of the License, or any later version. +# +# Hypertable 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 Hypertable. If not, see +# + +# - Find libblkid +# Find the blkid library and includes +# +# BLKID_INCLUDE_DIR - where to find blkid.h, etc. +# BLKID_LIBRARIES - List of libraries when using blkid. +# BLKID_FOUND - True if blkid found. + +find_path(BLKID_INCLUDE_DIR blkid/blkid.h) + +set(BLKID_NAMES ${BLKID_NAMES} blkid) +find_library(BLKID_LIBRARY NAMES ${BLKID_NAMES}) + +if (BLKID_INCLUDE_DIR AND BLKID_LIBRARY) + set(BLKID_FOUND TRUE) + set( BLKID_LIBRARIES ${BLKID_LIBRARY} ) +else () + set(BLKID_FOUND FALSE) + set( BLKID_LIBRARIES ) +endif () + +if (BLKID_FOUND) + message(STATUS "Found libblkid: ${BLKID_LIBRARY}") +else () + message(STATUS "Not Found libblkid: ${BLKID_LIBRARY}") + if (BLKID_FIND_REQUIRED) + message(STATUS "Looked for libblkid named ${BLKID_NAMES}.") + message(FATAL_ERROR "Could NOT find libblkid") + endif () +endif () + +mark_as_advanced( + BLKID_LIBRARY + BLKID_I +) diff --git a/cmake/modules/Findcds.cmake b/cmake/modules/Findcds.cmake new file mode 100644 index 000000000000..b22dc025b9de --- /dev/null +++ b/cmake/modules/Findcds.cmake @@ -0,0 +1,37 @@ +# - Find cds +# +# CDS_INCLUDE_DIR - where to find cds/init.h +# FIO_FOUND - True if found. + +find_path(CDS_INC_DIR cds/init.h NO_DEFAULT_PATH PATHS + /usr/include + /opt/local/include + /usr/local/include + /opt/cds +) + +if (CDS_INC_DIR) + set(CDS_FOUND TRUE) +else () + set(CDS_FOUND FALSE) +endif () + +if (CDS_FOUND) + message(STATUS "Found cds: ${CDS_INC_DIR}") +else () + message(STATUS "Failed to find cds/init.h") + if (CDS_FIND_REQUIRED) + message(FATAL_ERROR "Missing required cds/init.h") + endif () +endif () + +find_library(CDS_LIBS + NAMES cds + PATHS /usr/lib /usr/lib/x86_64-linux-gnu /opt/cds/bin/gcc-amd64-linux-64 +) + +mark_as_advanced( + CDS_INC_DIR + CDS_LIBS +) + diff --git a/cmake/modules/Findcryptopp.cmake b/cmake/modules/Findcryptopp.cmake new file mode 100644 index 000000000000..74a01e83ac3d --- /dev/null +++ b/cmake/modules/Findcryptopp.cmake @@ -0,0 +1,108 @@ +# Module for locating the Crypto++ encryption library. +# +# Customizable variables: +# CRYPTOPP_ROOT_DIR +# This variable points to the CryptoPP root directory. On Windows the +# library location typically will have to be provided explicitly using the +# -D command-line option. The directory should include the include/cryptopp, +# lib and/or bin sub-directories. +# +# Read-only variables: +# CRYPTOPP_FOUND +# Indicates whether the library has been found. +# +# CRYPTOPP_INCLUDE_DIRS +# Points to the CryptoPP include directory. +# +# CRYPTOPP_LIBRARIES +# Points to the CryptoPP libraries that should be passed to +# target_link_libararies. +# +# +# Copyright (c) 2012 Sergiu Dotenco +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +INCLUDE (FindPackageHandleStandardArgs) + +FIND_PATH (CRYPTOPP_ROOT_DIR + NAMES cryptopp/cryptlib.h include/cryptopp/cryptlib.h + PATHS ENV CRYPTOPPROOT + DOC "CryptoPP root directory") + +# Re-use the previous path: +FIND_PATH (CRYPTOPP_INCLUDE_DIR + NAMES cryptopp/cryptlib.h + HINTS ${CRYPTOPP_ROOT_DIR} + PATH_SUFFIXES include + DOC "CryptoPP include directory") + +FIND_LIBRARY (CRYPTOPP_LIBRARY_DEBUG + NAMES cryptlibd cryptoppd + HINTS ${CRYPTOPP_ROOT_DIR} + PATH_SUFFIXES lib + DOC "CryptoPP debug library") + +FIND_LIBRARY (CRYPTOPP_LIBRARY_RELEASE + NAMES cryptlib cryptopp + HINTS ${CRYPTOPP_ROOT_DIR} + PATH_SUFFIXES lib + DOC "CryptoPP release library") + +IF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE) + SET (CRYPTOPP_LIBRARY + optimized ${CRYPTOPP_LIBRARY_RELEASE} + debug ${CRYPTOPP_LIBRARY_DEBUG} CACHE DOC "CryptoPP library") +ELSEIF (CRYPTOPP_LIBRARY_RELEASE) + SET (CRYPTOPP_LIBRARY ${CRYPTOPP_LIBRARY_RELEASE} CACHE DOC + "CryptoPP library") +ENDIF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE) + +IF (CRYPTOPP_INCLUDE_DIR) + SET (_CRYPTOPP_VERSION_HEADER ${CRYPTOPP_INCLUDE_DIR}/cryptopp/config.h) + + IF (EXISTS ${_CRYPTOPP_VERSION_HEADER}) + FILE (STRINGS ${_CRYPTOPP_VERSION_HEADER} _CRYPTOPP_VERSION_TMP REGEX + "^#define CRYPTOPP_VERSION[ \t]+[0-9]+$") + + STRING (REGEX REPLACE + "^#define CRYPTOPP_VERSION[ \t]+([0-9]+)" "\\1" _CRYPTOPP_VERSION_TMP + ${_CRYPTOPP_VERSION_TMP}) + + STRING (REGEX REPLACE "([0-9]+)[0-9][0-9]" "\\1" CRYPTOPP_VERSION_MAJOR + ${_CRYPTOPP_VERSION_TMP}) + STRING (REGEX REPLACE "[0-9]([0-9])[0-9]" "\\1" CRYPTOPP_VERSION_MINOR + ${_CRYPTOPP_VERSION_TMP}) + STRING (REGEX REPLACE "[0-9][0-9]([0-9])" "\\1" CRYPTOPP_VERSION_PATCH + ${_CRYPTOPP_VERSION_TMP}) + + SET (CRYPTOPP_VERSION_COUNT 3) + SET (CRYPTOPP_VERSION + ${CRYPTOPP_VERSION_MAJOR}.${CRYPTOPP_VERSION_MINOR}.${CRYPTOPP_VERSION_PATCH}) + ENDIF (EXISTS ${_CRYPTOPP_VERSION_HEADER}) +ENDIF (CRYPTOPP_INCLUDE_DIR) + +SET (CRYPTOPP_INCLUDE_DIRS ${CRYPTOPP_INCLUDE_DIR}) +SET (CRYPTOPP_LIBRARIES ${CRYPTOPP_LIBRARY}) + +MARK_AS_ADVANCED (CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY CRYPTOPP_LIBRARY_DEBUG + CRYPTOPP_LIBRARY_RELEASE) + +FIND_PACKAGE_HANDLE_STANDARD_ARGS (CryptoPP REQUIRED_VARS CRYPTOPP_ROOT_DIR + CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY VERSION_VAR CRYPTOPP_VERSION) diff --git a/cmake/modules/Findexpat.cmake b/cmake/modules/Findexpat.cmake new file mode 100644 index 000000000000..951fb25978c7 --- /dev/null +++ b/cmake/modules/Findexpat.cmake @@ -0,0 +1,29 @@ +# - Find expat +# Find the native EXPAT headers and libraries. +# +# EXPAT_INCLUDE_DIRS - where to find expat.h, etc. +# EXPAT_LIBRARIES - List of libraries when using expat. +# EXPAT_FOUND - True if expat found. + +# Look for the header file. +FIND_PATH(EXPAT_INCLUDE_DIR NAMES expat.h) + +# Look for the library. +FIND_LIBRARY(EXPAT_LIBRARY NAMES expat) + +# handle the QUIETLY and REQUIRED arguments and set EXPAT_FOUND to TRUE if +# all listed variables are TRUE +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(EXPAT DEFAULT_MSG EXPAT_LIBRARY EXPAT_INCLUDE_DIR) + +# Copy the results to the output variables. +IF(EXPAT_FOUND) + SET(EXPAT_LIBRARIES ${EXPAT_LIBRARY}) + SET(EXPAT_INCLUDE_DIRS ${EXPAT_INCLUDE_DIR}) +ELSE(EXPAT_FOUND) + SET(EXPAT_LIBRARIES) + SET(EXPAT_INCLUDE_DIRS) +ENDIF(EXPAT_FOUND) + +MARK_AS_ADVANCED(EXPAT_INCLUDE_DIR EXPAT_LIBRARY) + diff --git a/cmake/modules/Findfcgi.cmake b/cmake/modules/Findfcgi.cmake new file mode 100644 index 000000000000..0d07dce9374f --- /dev/null +++ b/cmake/modules/Findfcgi.cmake @@ -0,0 +1,35 @@ +# CMake module to search for FastCGI headers +# +# If it's found it sets FCGI_FOUND to TRUE +# and following variables are set: +# FCGI_INCLUDE_DIR +# FCGI_LIBRARY +FIND_PATH(FCGI_INCLUDE_DIR + fcgio.h + PATHS + /usr/include + /usr/local/include + /usr/include/fastcgi + "$ENV{LIB_DIR}/include" + $ENV{INCLUDE} + ) +FIND_LIBRARY(FCGI_LIBRARY NAMES fcgi libfcgi PATHS + /usr/local/lib + /usr/lib + "$ENV{LIB_DIR}/lib" + "$ENV{LIB}" + ) + +IF (FCGI_INCLUDE_DIR AND FCGI_LIBRARY) + SET(FCGI_FOUND TRUE) +ENDIF (FCGI_INCLUDE_DIR AND FCGI_LIBRARY) + +IF (FCGI_FOUND) + IF (NOT FCGI_FIND_QUIETLY) + MESSAGE(STATUS "Found FCGI: ${FCGI_LIBRARY}") + ENDIF (NOT FCGI_FIND_QUIETLY) +ELSE (FCGI_FOUND) + IF (FCGI_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find FCGI") + ENDIF (FCGI_FIND_REQUIRED) +ENDIF (FCGI_FOUND) diff --git a/cmake/modules/Findfio.cmake b/cmake/modules/Findfio.cmake new file mode 100644 index 000000000000..7a40b77cd69c --- /dev/null +++ b/cmake/modules/Findfio.cmake @@ -0,0 +1,29 @@ +# - Find fio +# +# FIO_INCLUDE_DIR - where to find fio.h +# FIO_FOUND - True if found. + +find_path(FIO_INCLUDE_DIR fio.h NO_DEFAULT_PATH PATHS + /usr/include + /opt/local/include + /usr/local/include +) + +if (FIO_INCLUDE_DIR) + set(FIO_FOUND TRUE) +else () + set(FIO_FOUND FALSE) +endif () + +if (FIO_FOUND) + message(STATUS "Found fio: ${FIO_INCLUDE_DIR}") +else () + message(STATUS "Failed to find fio.h") + if (FIO_FIND_REQUIRED) + message(FATAL_ERROR "Missing required fio.h") + endif () +endif () + +mark_as_advanced( + FIO_INCLUDE_DIR +) diff --git a/cmake/modules/Findfuse.cmake b/cmake/modules/Findfuse.cmake new file mode 100644 index 000000000000..7c1a8789b28e --- /dev/null +++ b/cmake/modules/Findfuse.cmake @@ -0,0 +1,167 @@ +# This module can find FUSE Library +# +# Requirements: +# - CMake >= 2.8.3 +# +# The following variables will be defined for your use: +# - FUSE_FOUND : was FUSE found? +# - FUSE_INCLUDE_DIRS : FUSE include directory +# - FUSE_LIBRARIES : FUSE library +# - FUSE_DEFINITIONS : FUSE cflags +# - FUSE_VERSION : complete version of FUSE (major.minor) +# - FUSE_MAJOR_VERSION : major version of FUSE +# - FUSE_MINOR_VERSION : minor version of FUSE +# +# Example Usage: +# +# 1. Copy this file in the root of your project source directory +# 2. Then, tell CMake to search this non-standard module in your project directory by adding to your CMakeLists.txt: +# set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}) +# 3. Finally call find_package() once, here are some examples to pick from +# +# Require FUSE 2.6 or later +# find_package(FUSE 2.6 REQUIRED) +# +# if(FUSE_FOUND) +# add_definitions(${FUSE_DEFINITIONS}) +# include_directories(${FUSE_INCLUDE_DIRS}) +# add_executable(myapp myapp.c) +# target_link_libraries(myapp ${FUSE_LIBRARIES}) +# endif() + +#============================================================================= +# Copyright (c) 2012, julp +# +# Distributed under the OSI-approved BSD License +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +#============================================================================= + +cmake_minimum_required(VERSION 2.8.3) + +########## Private ########## +function(fusedebug _varname) + if(FUSE_DEBUG) + message("${_varname} = ${${_varname}}") + endif(FUSE_DEBUG) +endfunction(fusedebug) + +########## Public ########## +set(FUSE_FOUND TRUE) +set(FUSE_LIBRARIES ) +set(FUSE_DEFINITIONS ) +set(FUSE_INCLUDE_DIRS ) + +find_package(PkgConfig) + +set(PC_FUSE_INCLUDE_DIRS ) +set(PC_FUSE_LIBRARY_DIRS ) +if(PKG_CONFIG_FOUND) + pkg_check_modules(PC_FUSE "fuse" QUIET) + if(PC_FUSE_FOUND) +# fusedebug(PC_FUSE_LIBRARIES) +# fusedebug(PC_FUSE_LIBRARY_DIRS) +# fusedebug(PC_FUSE_LDFLAGS) +# fusedebug(PC_FUSE_LDFLAGS_OTHER) +# fusedebug(PC_FUSE_INCLUDE_DIRS) +# fusedebug(PC_FUSE_CFLAGS) +# fusedebug(PC_FUSE_CFLAGS_OTHER) + set(FUSE_DEFINITIONS "${PC_FUSE_CFLAGS_OTHER}") + endif(PC_FUSE_FOUND) +endif(PKG_CONFIG_FOUND) + +find_path( + FUSE_INCLUDE_DIRS + NAMES fuse.h + PATHS "${PC_FUSE_INCLUDE_DIRS}" + DOC "Include directories for FUSE" +) + +if(NOT FUSE_INCLUDE_DIRS) + set(FUSE_FOUND FALSE) +endif(NOT FUSE_INCLUDE_DIRS) + +find_library( + FUSE_LIBRARIES + NAMES "fuse" + PATHS "${PC_FUSE_LIBRARY_DIRS}" + DOC "Libraries for FUSE" +) + +if(NOT FUSE_LIBRARIES) + set(FUSE_FOUND FALSE) +endif(NOT FUSE_LIBRARIES) + +if(FUSE_FOUND) + if(EXISTS "${FUSE_INCLUDE_DIRS}/fuse/fuse_common.h") + file(READ "${FUSE_INCLUDE_DIRS}/fuse/fuse_common.h" _contents) + string(REGEX REPLACE ".*# *define *FUSE_MAJOR_VERSION *([0-9]+).*" "\\1" FUSE_MAJOR_VERSION "${_contents}") + string(REGEX REPLACE ".*# *define *FUSE_MINOR_VERSION *([0-9]+).*" "\\1" FUSE_MINOR_VERSION "${_contents}") + set(FUSE_VERSION "${FUSE_MAJOR_VERSION}.${FUSE_MINOR_VERSION}") + endif() + + include(CheckCSourceCompiles) + # Backup CMAKE_REQUIRED_* + set(OLD_CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}") + set(OLD_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}") + set(OLD_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}") + # Add FUSE compilation flags + set(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}" "${FUSE_INCLUDE_DIRS}") + set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}" "${FUSE_LIBRARIES}") + set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}" "${FUSE_DEFINITIONS}") + check_c_source_compiles("#include +#include +#include +#include +#include +#include + +int main(void) { +return 0; +}" FUSE_CFLAGS_CHECK) + if(NOT FUSE_CFLAGS_CHECK) + set(FUSE_DEFINITIONS "-D_FILE_OFFSET_BITS=64") + # Should we run again previous test to assume the failure was due to missing definition -D_FILE_OFFSET_BITS=64? + endif(NOT FUSE_CFLAGS_CHECK) + # Restore CMAKE_REQUIRED_* + set(CMAKE_REQUIRED_INCLUDES "${OLD_CMAKE_REQUIRED_INCLUDES}") + set(CMAKE_REQUIRED_LIBRARIES "${OLD_CMAKE_REQUIRED_LIBRARIES}") + set(CMAKE_REQUIRED_DEFINITIONS "${OLD_CMAKE_REQUIRED_DEFINITIONS}") +endif(FUSE_FOUND) + +if(FUSE_INCLUDE_DIRS) + include(FindPackageHandleStandardArgs) + if(FUSE_FIND_REQUIRED AND NOT FUSE_FIND_QUIETLY) + find_package_handle_standard_args(FUSE REQUIRED_VARS FUSE_LIBRARIES FUSE_INCLUDE_DIRS VERSION_VAR FUSE_VERSION) + else() + find_package_handle_standard_args(FUSE "FUSE not found" FUSE_LIBRARIES FUSE_INCLUDE_DIRS) + endif() +else(FUSE_INCLUDE_DIRS) + if(FUSE_FIND_REQUIRED AND NOT FUSE_FIND_QUIETLY) + message(FATAL_ERROR "Could not find FUSE include directory") + endif() +endif(FUSE_INCLUDE_DIRS) + +mark_as_advanced( + FUSE_INCLUDE_DIRS + FUSE_LIBRARIES +) + +# IN (args) +fusedebug("FUSE_FIND_COMPONENTS") +fusedebug("FUSE_FIND_REQUIRED") +fusedebug("FUSE_FIND_QUIETLY") +fusedebug("FUSE_FIND_VERSION") +# OUT +# Found +fusedebug("FUSE_FOUND") +# Definitions +fusedebug("FUSE_DEFINITIONS") +# Linking +fusedebug("FUSE_INCLUDE_DIRS") +fusedebug("FUSE_LIBRARIES") +# Version +fusedebug("FUSE_MAJOR_VERSION") +fusedebug("FUSE_MINOR_VERSION") +fusedebug("FUSE_VERSION") diff --git a/cmake/modules/Findleveldb.cmake b/cmake/modules/Findleveldb.cmake new file mode 100644 index 000000000000..8a3130241efe --- /dev/null +++ b/cmake/modules/Findleveldb.cmake @@ -0,0 +1,37 @@ +# - Find LevelDB +# +# LEVELDB_INCLUDE - Where to find leveldb/db.h +# LEVELDB_LIBS - List of libraries when using LevelDB. +# LEVELDB_FOUND - True if LevelDB found. + +get_filename_component(module_file_path ${CMAKE_CURRENT_LIST_FILE} PATH) + +# Look for the header file. +find_path(LEVELDB_INCLUDE NAMES leveldb/db.h PATHS $ENV{LEVELDB_ROOT}/include /opt/local/include /usr/local/include /usr/include DOC "Path in which the file leveldb/db.h is located." ) +mark_as_advanced(LEVELDB_INCLUDE) + +# Look for the library. +# Does this work on UNIX systems? (LINUX) +find_library(LEVELDB_LIBS NAMES leveldb PATHS /usr/lib $ENV{LEVELDB_ROOT}/lib DOC "Path to leveldb library." ) +mark_as_advanced(LEVELDB_LIBS) + +# Copy the results to the output variables. +if (LEVELDB_INCLUDE AND LEVELDB_LIBS) + message(STATUS "Found leveldb in ${LEVELDB_INCLUDE} ${LEVELDB_LIBS}") + set(LEVELDB_FOUND 1) + include(CheckCXXSourceCompiles) + set(CMAKE_REQUIRED_LIBRARY ${LEVELDB_LIBS} pthread) + set(CMAKE_REQUIRED_INCLUDES ${LEVELDB_INCLUDE}) + else () + set(LEVELDB_FOUND 0) + endif () + + # Report the results. + if (NOT LEVELDB_FOUND) + set(LEVELDB_DIR_MESSAGE "LEVELDB was not found. Make sure LEVELDB_LIBS and LEVELDB_INCLUDE are set.") + if (LEVELDB_FIND_REQUIRED) + message(FATAL_ERROR "${LEVELDB_DIR_MESSAGE}") + elseif (NOT LEVELDB_FIND_QUIETLY) + message(STATUS "${LEVELDB_DIR_MESSAGE}") + endif () + endif () diff --git a/cmake/modules/Findprofiler.cmake b/cmake/modules/Findprofiler.cmake new file mode 100644 index 000000000000..ca54227f56bc --- /dev/null +++ b/cmake/modules/Findprofiler.cmake @@ -0,0 +1,34 @@ +# Try to find Profiler +# Once done, this will define +# +# PROFILER_FOUND - system has Profiler +# PROFILER_INCLUDE_DIR - the Profiler include directories +# PROFILER_LIBRARIES - link these to use Profiler + +if(PROFILER_INCLUDE_DIR AND PROFILER_LIBRARIES) +set(PROFILER_FIND_QUIETLY TRUE) +endif(PROFILER_INCLUDE_DIR AND PROFILER_LIBRARIES) + +INCLUDE(CheckCXXSymbolExists) + +# include dir + +find_path(PROFILER_INCLUDE_DIR profiler.h NO_DEFAULT_PATH PATHS + ${HT_DEPENDENCY_INCLUDE_DIR} + /usr/include + /usr/include/google + /opt/local/include + /usr/local/include +) + + +# finally the library itself +find_library(LIBPROFILER NAMES profiler) +set(PROFILER_LIBRARIES ${LIBPROFILER}) + +# handle the QUIETLY and REQUIRED arguments and set PROFILER_FOUND to TRUE if +# all listed variables are TRUE +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(PROFILER DEFAULT_MSG PROFILER_LIBRARIES PROFILER_INCLUDE_DIR) + +mark_as_advanced(PROFILER_LIBRARIES PROFILER_INCLUDE_DIR) diff --git a/cmake/modules/Findsnappy.cmake b/cmake/modules/Findsnappy.cmake new file mode 100644 index 000000000000..0ce92a8172da --- /dev/null +++ b/cmake/modules/Findsnappy.cmake @@ -0,0 +1,62 @@ +# Copyright (C) 2007-2012 Hypertable, Inc. +# +# This file is part of Hypertable. +# +# Hypertable 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; either version 3 +# of the License, or any later version. +# +# Hypertable 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 Hypertable. If not, see +# + +# - Find Snappy +# Find the snappy compression library and includes +# +# SNAPPY_INCLUDE_DIR - where to find snappy.h, etc. +# SNAPPY_LIBRARIES - List of libraries when using snappy. +# SNAPPY_FOUND - True if snappy found. + +find_path(SNAPPY_INCLUDE_DIR snappy.h NO_DEFAULT_PATH PATHS + ${HT_DEPENDENCY_INCLUDE_DIR} + /usr/include + /opt/local/include + /usr/local/include +) + +set(SNAPPY_NAMES ${SNAPPY_NAMES} snappy) +find_library(SNAPPY_LIBRARY NAMES ${SNAPPY_NAMES} NO_DEFAULT_PATH PATHS + ${HT_DEPENDENCY_LIB_DIR} + /usr/local/lib + /opt/local/lib + /usr/lib + ) + +if (SNAPPY_INCLUDE_DIR AND SNAPPY_LIBRARY) + set(SNAPPY_FOUND TRUE) + set( SNAPPY_LIBRARIES ${SNAPPY_LIBRARY} ) +else () + set(SNAPPY_FOUND FALSE) + set( SNAPPY_LIBRARIES ) +endif () + +if (SNAPPY_FOUND) + message(STATUS "Found Snappy: ${SNAPPY_LIBRARY}") +else () + message(STATUS "Not Found Snappy: ${SNAPPY_LIBRARY}") + if (SNAPPY_FIND_REQUIRED) + message(STATUS "Looked for Snappy libraries named ${SNAPPY_NAMES}.") + message(FATAL_ERROR "Could NOT find Snappy library") + endif () +endif () + +mark_as_advanced( + SNAPPY_LIBRARY + SNAPPY_I +) diff --git a/cmake/modules/Findtcmalloc.cmake b/cmake/modules/Findtcmalloc.cmake new file mode 100644 index 000000000000..d9b3a456f5c3 --- /dev/null +++ b/cmake/modules/Findtcmalloc.cmake @@ -0,0 +1,47 @@ +# - Find Tcmalloc +# Find the native Tcmalloc includes and library +# +# Tcmalloc_INCLUDE_DIR - where to find Tcmalloc.h, etc. +# Tcmalloc_LIBRARIES - List of libraries when using Tcmalloc. +# Tcmalloc_FOUND - True if Tcmalloc found. + +find_path(Tcmalloc_INCLUDE_DIR google/tcmalloc.h NO_DEFAULT_PATH PATHS + ${HT_DEPENDENCY_INCLUDE_DIR} + /usr/include + /opt/local/include + /usr/local/include +) + +if (USE_TCMALLOC) + set(Tcmalloc_NAMES tcmalloc) +else () + set(Tcmalloc_NAMES tcmalloc_minimal tcmalloc) +endif () + +find_library(Tcmalloc_LIBRARY NO_DEFAULT_PATH + NAMES ${Tcmalloc_NAMES} + PATHS ${HT_DEPENDENCY_LIB_DIR} /lib /usr/lib /usr/local/lib /opt/local/lib +) + +if (Tcmalloc_INCLUDE_DIR AND Tcmalloc_LIBRARY) + set(Tcmalloc_FOUND TRUE) + set( Tcmalloc_LIBRARIES ${Tcmalloc_LIBRARY} ) +else () + set(Tcmalloc_FOUND FALSE) + set( Tcmalloc_LIBRARIES ) +endif () + +if (Tcmalloc_FOUND) + message(STATUS "Found Tcmalloc: ${Tcmalloc_LIBRARY}") +else () + message(STATUS "Not Found Tcmalloc: ${Tcmalloc_LIBRARY}") + if (Tcmalloc_FIND_REQUIRED) + message(STATUS "Looked for Tcmalloc libraries named ${Tcmalloc_NAMES}.") + message(FATAL_ERROR "Could NOT find Tcmalloc library") + endif () +endif () + +mark_as_advanced( + Tcmalloc_LIBRARY + Tcmalloc_INCLUDE_DIR + ) diff --git a/cmake/modules/Findudev.cmake b/cmake/modules/Findudev.cmake new file mode 100644 index 000000000000..0e95f15804eb --- /dev/null +++ b/cmake/modules/Findudev.cmake @@ -0,0 +1,52 @@ +# Copyright (C) 2007-2012 Hypertable, Inc. +# +# This file is part of Hypertable. +# +# Hypertable 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; either version 3 +# of the License, or any later version. +# +# Hypertable 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 Hypertable. If not, see +# + +# - Find libudev +# Find the udev library and includes +# +# UDEV_INCLUDE_DIR - where to find libudev.h, etc. +# UDEV_LIBRARIES - List of libraries when using udev. +# UDEV_FOUND - True if udev found. + +find_path(UDEV_INCLUDE_DIR libudev.h) + +set(UDEV_NAMES ${UDEV_NAMES} udev) +find_library(UDEV_LIBRARY NAMES ${UDEV_NAMES}) + +if(UDEV_INCLUDE_DIR AND UDEV_LIBRARY) + set(UDEV_FOUND TRUE) + set(UDEV_LIBRARIES ${UDEV_LIBRARY}) +else() + set(UDEV_FOUND FALSE) + set(UDEV_LIBRARIES) +endif() + +if(UDEV_FOUND) + message(STATUS "Found libudev: ${UDEV_LIBRARY}") +else() + message(STATUS "Not Found libudev: ${UDEV_LIBRARY}") + if(UDEV_FIND_REQUIRED) + message(STATUS "Looked for libudev named ${UDEV_NAMES}.") + message(FATAL_ERROR "Could NOT find libudev") + endif() +endif() + +mark_as_advanced( + UDEV_LIBRARY + UDEV_I +) diff --git a/cmake/modules/Findxio.cmake b/cmake/modules/Findxio.cmake new file mode 100644 index 000000000000..11fd892d8b3d --- /dev/null +++ b/cmake/modules/Findxio.cmake @@ -0,0 +1,43 @@ +# - Find libxio +# Find libxio transport library +# +# Xio_INCLUDE_DIR - libxio include dir +# Xio_LIBRARIES - List of libraries +# Xio_FOUND - True if libxio found. + +set(_xio_include_path ${HT_DEPENDENCY_INCLUDE_DIR}) +set(_xio_lib_path ${HT_DEPENDENCY_LIB_DIR}) +if (EXISTS ${WITH_XIO}) + list(APPEND _xio_include_path "${WITH_XIO}/include") + list(APPEND _xio_lib_path "${WITH_XIO}/lib") +else() + list(APPEND _xio_include_path /usr/include /usr/local/include /opt/accelio/include) + list(APPEND _xio_lib_path /lib /usr/lib /usr/local/lib /opt/accelio/lib) +endif() + +find_path(Xio_INCLUDE_DIR libxio.h NO_DEFAULT_PATH PATHS ${_xio_include_path}) + +find_library(Xio_LIBRARY NO_DEFAULT_PATH NAMES xio PATHS ${_xio_lib_path}) + +if (Xio_INCLUDE_DIR AND Xio_LIBRARY) + set(Xio_FOUND TRUE) + set(Xio_LIBRARIES ${Xio_LIBRARY} ) +else () + set(Xio_FOUND FALSE) + set(Xio_LIBRARIES ) +endif () + +if (Xio_FOUND) + message(STATUS "Found Xio: ${Xio_INCLUDE_DIR} ${Xio_LIBRARY}") +else () + message(STATUS "Not Found Xio: ${Xio_INCLUDE_DIR} ${Xio_LIBRARY}") + if (Xio_FIND_REQUIRED) + message(STATUS "Looked for Xio libraries named ${Xio_NAMES}.") + message(FATAL_ERROR "Could NOT find Xio library") + endif () +endif () + +mark_as_advanced( + Xio_LIBRARY + Xio_INCLUDE_DIR + ) diff --git a/cmake/modules/GetGitRevisionDescription.cmake b/cmake/modules/GetGitRevisionDescription.cmake new file mode 100644 index 000000000000..c8d27f2e8ce4 --- /dev/null +++ b/cmake/modules/GetGitRevisionDescription.cmake @@ -0,0 +1,130 @@ +# - Returns a version string from Git +# +# These functions force a re-configure on each git commit so that you can +# trust the values of the variables in your build system. +# +# get_git_head_revision( [ ...]) +# +# Returns the refspec and sha hash of the current head revision +# +# git_describe( [ ...]) +# +# Returns the results of git describe on the source tree, and adjusting +# the output so that it tests false if an error occurs. +# +# git_get_exact_tag( [ ...]) +# +# Returns the results of git describe --exact-match on the source tree, +# and adjusting the output so that it tests false if there was no exact +# matching tag. +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2010 Ryan Pavlik +# http://academic.cleardefinition.com +# Iowa State University HCI Graduate Program/VRAC +# +# Copyright Iowa State University 2009-2010. +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +if(__get_git_revision_description) + return() +endif() +set(__get_git_revision_description YES) + +# We must run the following at "include" time, not at function call time, +# to find the path to this module rather than the path to a calling list file +get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH) + +function(get_git_head_revision _refspecvar _hashvar) + set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}") + set(GIT_DIR "${GIT_PARENT_DIR}/.git") + while(NOT EXISTS "${GIT_DIR}") # .git dir not found, search parent directories + set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}") + get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH) + if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT) + # We have reached the root directory, we are not in git + set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE) + set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE) + return() + endif() + set(GIT_DIR "${GIT_PARENT_DIR}/.git") + endwhile() + # check if this is a submodule + if(NOT IS_DIRECTORY ${GIT_DIR}) + file(READ ${GIT_DIR} submodule) + string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule}) + get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH) + get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE) + endif() + set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data") + if(NOT EXISTS "${GIT_DATA}") + file(MAKE_DIRECTORY "${GIT_DATA}") + endif() + + if(NOT EXISTS "${GIT_DIR}/HEAD") + return() + endif() + set(HEAD_FILE "${GIT_DATA}/HEAD") + configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY) + + configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" + "${GIT_DATA}/grabRef.cmake" + @ONLY) + include("${GIT_DATA}/grabRef.cmake") + + set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE) + set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE) +endfunction() + +function(git_describe _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + get_git_head_revision(refspec hash) + if(NOT GIT_FOUND) + set(${_var} "GIT-NOTFOUND" PARENT_SCOPE) + return() + endif() + if(NOT hash) + set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE) + return() + endif() + + # TODO sanitize + #if((${ARGN}" MATCHES "&&") OR + # (ARGN MATCHES "||") OR + # (ARGN MATCHES "\\;")) + # message("Please report the following error to the project!") + # message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}") + #endif() + + #message(STATUS "Arguments to execute_process: ${ARGN}") + + execute_process(COMMAND + "${GIT_EXECUTABLE}" + describe + ${hash} + ${ARGN} + WORKING_DIRECTORY + "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE + res + OUTPUT_VARIABLE + out + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT res EQUAL 0) + set(out "${out}-${res}-NOTFOUND") + endif() + + set(${_var} "${out}" PARENT_SCOPE) +endfunction() + +function(git_get_exact_tag _var) + git_describe(out --exact-match ${ARGN}) + set(${_var} "${out}" PARENT_SCOPE) +endfunction() diff --git a/cmake/modules/GetGitRevisionDescription.cmake.in b/cmake/modules/GetGitRevisionDescription.cmake.in new file mode 100644 index 000000000000..6faa374a8d9e --- /dev/null +++ b/cmake/modules/GetGitRevisionDescription.cmake.in @@ -0,0 +1,38 @@ +# +# Internal file for GetGitRevisionDescription.cmake +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2010 Ryan Pavlik +# http://academic.cleardefinition.com +# Iowa State University HCI Graduate Program/VRAC +# +# Copyright Iowa State University 2009-2010. +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +set(HEAD_HASH) + +file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024) + +string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS) +if(HEAD_CONTENTS MATCHES "ref") + # named branch + string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}") + if(EXISTS "@GIT_DIR@/${HEAD_REF}") + configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) + elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}") + configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) + set(HEAD_HASH "${HEAD_REF}") + endif() +else() + # detached HEAD + configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY) +endif() + +if(NOT HEAD_HASH) + file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024) + string(STRIP "${HEAD_HASH}" HEAD_HASH) +endif() diff --git a/man/CMakeLists.txt b/man/CMakeLists.txt new file mode 100644 index 000000000000..f7896d6c7164 --- /dev/null +++ b/man/CMakeLists.txt @@ -0,0 +1,30 @@ +install(FILES + ceph-osd.8 + ceph-mds.8 + ceph-mon.8 + ceph-fuse.8 + ceph-syn.8 + crushtool.8 + osdmaptool.8 + monmaptool.8 + ceph-conf.8 + ceph-run.8 + ceph.8 + mount.ceph.8 + radosgw.8 + radosgw-admin.8 + ceph-authtool.8 + rados.8 + librados-config.8 + rbd.8 + ceph-clsinfo.8 + ceph-debugpack.8 + cephfs.8 + ceph-dencoder.8 + ceph-rest-api.8 + ceph-rbdnamer.8 + ceph-post-file.8 + rbd-fuse.8 + rbd-replay.8 + rbd-replay-prep.8 + DESTINATION ${CEPH_MAN_DIR}/man8) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 000000000000..a5adfc709882 --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,776 @@ +include(GetGitRevisionDescription) + +set(bindir ${CMAKE_INSTALL_PREFIX}/bin) +set(sbindir ${CMAKE_INSTALL_PREFIX}/sbin) +set(libdir ${CMAKE_INSTALL_PREFIX}/lib) +set(sysconfdir ${CMAKE_INSTALL_PREFIX}/etc) +set(pkgdatadir ${CMAKE_INSTALL_PREFIX}/share) +set(prefix ${CMAKE_INSTALL_PREFIX}) + +add_definitions("-DCEPH_LIBDIR=\"${libdir}\"") +add_definitions("-DCEPH_PKGLIBDIR=\"${libdir}\"") +add_definitions("-DHAVE_CONFIG_H -D__CEPH__ -D_FILE_OFFSET_BITS=64 -D_REENTRANT -D_THREAD_SAFE -D__STDC_FORMAT_MACROS -D_GNU_SOURCE") + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -rdynamic -Wall -Wtype-limits -Wignored-qualifiers -Winit-self -Wpointer-arith -Werror=format-security -fno-strict-aliasing -fsigned-char -fPIC") + +set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -ftemplate-depth-1024 -Wno-invalid-offsetof -Wnon-virtual-dtor -Wno-invalid-offsetof -Wstrict-null-sentinel -Woverloaded-virtual") + +set(EXTRALIBS uuid rt dl) + +if(${WITH_PROFILER}) + list(APPEND EXTRALIBS profiler) +endif(${WITH_PROFILER}) + +if(WITH_CDS) + list(APPEND EXTRALIBS ${CDS_LIBS}) +endif(WITH_CDS) + +set(CRYPTO_LIBS cryptopp) + +if(${HAVE_ATOMIC_OPS}) + set(EXTRALIBS + atomic_ops + ${EXTRALIBS}) +endif(${HAVE_ATOMIC_OPS}) + +set(GCOV_PREFIX_STRIP 4) + +get_git_head_revision(GIT_REFSPEC CEPH_GIT_VER) +git_describe(CEPH_GIT_NICE_VER --always) + +# Python stuff +find_package(PythonInterp 2 QUIET) +if(NOT PYTHONINTERP_FOUND) + message(FATAL_ERROR "Python 2 interpreter not found.") +endif(NOT PYTHONINTERP_FOUND) + +# if CMAKE_INSTALL_PREFIX is an empty string, must replace +# it with "/" to make PYTHON_INSTALL_TEMPLATE an absolute path to be +# consistent with all other installation paths. +if(CMAKE_INSTALL_PREFIX) + set(PYTHON_INSTALL_TEMPLATE "${CMAKE_INSTALL_PREFIX}") +else(CMAKE_INSTALL_PREFIX) + set(PYTHON_INSTALL_TEMPLATE "/") +endif(CMAKE_INSTALL_PREFIX) + +execute_process( + COMMAND + ${PYTHON_EXECUTABLE} -c "from distutils import sysconfig; print sysconfig.get_python_lib(1,0,prefix='${PYTHON_INSTALL_TEMPLATE}')" + OUTPUT_VARIABLE PYTHON_INSTDIR + OUTPUT_STRIP_TRAILING_WHITESPACE) + +include_directories(".") + +if(${WITH_TCMALLOC}) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free") + set(TCMALLOC_LIBS tcmalloc) + set(TCMALLOC_srcs perfglue/heap_profiler.cc) +else() + set(TCMALLOC_srcs perfglue/disabled_heap_profiler.cc) +endif(${WITH_TCMALLOC}) + +# tcmalloc heap profiler +set(heap_profiler_files ${TCMALLOC_srcs}) +add_library(heap_profiler_objs OBJECT ${heap_profiler_files}) + +set(LIBEDIT_LIBS edit) + +# Common infrastructure +configure_file( + ${CMAKE_SOURCE_DIR}/src/ceph_ver.h.in.cmake + ${CMAKE_BINARY_DIR}/src/include/ceph_ver.h + @ONLY) + +set(arch_files + arch/arm.c + arch/intel.c + arch/probe.cc) + +set(auth_files + auth/AuthAuthorizeHandler.cc + auth/AuthClientHandler.cc + auth/AuthSessionHandler.cc + auth/AuthMethodList.cc + auth/cephx/CephxAuthorizeHandler.cc + auth/cephx/CephxClientHandler.cc + auth/cephx/CephxProtocol.cc + auth/cephx/CephxSessionHandler.cc + auth/none/AuthNoneAuthorizeHandler.cc + auth/unknown/AuthUnknownAuthorizeHandler.cc + auth/Crypto.cc + auth/KeyRing.cc + auth/RotatingKeyRing.cc) + +set(mds_files) +list(APPEND mds_files + mds/MDSMap.cc + mds/inode_backtrace.cc + mds/mdstypes.cc) + +set(crush_srcs + crush/builder.c + crush/mapper.c + crush/crush.c + crush/hash.c + crush/CrushWrapper.cc + crush/CrushCompiler.cc + crush/CrushTester.cc) + +add_subdirectory(json_spirit) + +set(libcommon_files + ${CMAKE_BINARY_DIR}/src/include/ceph_ver.h + ceph_ver.c + common/DecayCounter.cc + common/LogClient.cc + common/LogEntry.cc + common/PrebufferedStreambuf.cc + common/BackTrace.cc + common/perf_counters.cc + common/Mutex.cc + common/OutputDataSocket.cc + common/admin_socket.cc + common/admin_socket_client.cc + common/bloom_filter.cc + common/Readahead.cc + ${crush_srcs} + common/cmdparse.cc + common/escape.c + common/io_priority.cc + common/Clock.cc + common/Throttle.cc + common/Timer.cc + common/Finisher.cc + common/environment.cc + common/sctp_crc32.c + common/crc32c.cc + common/crc32c_intel_baseline.c + common/crc32c_intel_fast.c + common/assert.cc + common/run_cmd.cc + common/WorkQueue.cc + common/ConfUtils.cc + common/MemoryModel.cc + common/fd.cc + common/xattr.c + common/str_list.cc + common/str_map.cc + common/snap_types.cc + common/errno.cc + common/TrackedOp.cc + common/SloppyCRCMap.cc + common/types.cc + log/Log.cc + log/SubsystemMap.cc + mon/MonCap.cc + mon/MonClient.cc + mon/MonMap.cc + msg/simple/Accepter.cc + msg/simple/DispatchQueue.cc + msg/Message.cc + osd/ECMsgTypes.cc + osd/HitSet.cc + common/RefCountedObj.cc + msg/Messenger.cc + msg/simple/Pipe.cc + msg/simple/PipeConnection.cc + msg/simple/SimpleMessenger.cc + msg/async/AsyncConnection.cc + msg/async/AsyncMessenger.cc + msg/async/Event.cc + msg/async/EventEpoll.cc + msg/async/EventSelect.cc + msg/async/net_handler.cc + ${xio_common_srcs} + msg/msg_types.cc + common/hobject.cc + osd/OSDMap.cc + common/histogram.cc + osd/osd_types.cc + common/blkdev.cc + common/common_init.cc + common/pipe.c + common/ceph_argparse.cc + common/ceph_context.cc + common/buffer.cc + common/code_environment.cc + common/dout.cc + common/signal.cc + common/simple_spin.cc + common/Thread.cc + common/Formatter.cc + common/HeartbeatMap.cc + common/ceph_fs.cc + common/ceph_hash.cc + common/ceph_strings.cc + common/ceph_frag.cc + common/config.cc + common/utf8.c + common/mime.c + common/strtol.cc + common/page.cc + common/lockdep.cc + common/version.cc + common/hex.cc + common/entity_name.cc + common/ceph_crypto.cc + common/ceph_crypto_cms.cc + common/ceph_json.cc + common/ipaddr.cc + common/pick_address.cc + common/linux_version.c + osdc/Striper.cc + osdc/Objecter.cc + ${arch_files} + ${auth_files} + ${mds_files}) +set(mon_common_files + auth/AuthSessionHandler.cc + auth/cephx/CephxSessionHandler.cc + erasure-code/ErasureCodePlugin.cc) +add_library(mon_common_objs OBJECT ${mon_common_files}) +set(common_mountcephfs_files + common/armor.c + common/safe_io.c + common/module.c + common/addr_parsing.c) +add_library(common_mountcephfs_objs OBJECT + ${common_mountcephfs_files}) + +if(${WITH_PROFILER}) + list(APPEND libcommon_files + perfglue/cpu_profiler.cc) +else() + list(APPEND libcommon_files + perfglue/disabled_stubs.cc) +endif(${WITH_PROFILER}) + +if(${ENABLE_SHARED}) + list(APPEND libcommon_files + $) +endif(${ENABLE_SHARED}) + +add_library(common STATIC ${libcommon_files} + $ + $) + +set_source_files_properties(${CMAKE_SOURCE_DIR}/src/ceph_ver.c + ${CMAKE_SOURCE_DIR}/src/common/version.cc + ${CMAKE_SOURCE_DIR}/src/test/encoding/ceph_dencoder.cc + APPEND PROPERTY OBJECT_DEPENDS ${CMAKE_BINARY_DIR}/src/include/ceph_ver.h) + +if(${WITH_PROFILER}) + target_link_libraries(common profiler) +endif(${WITH_PROFILER}) + +target_link_libraries(common json_spirit erasure_code rt uuid ${CRYPTO_LIBS} ${Boost_LIBRARIES}) + +set(libglobal_srcs + global/global_init.cc + global/pidfile.cc + global/signal_handler.cc) +set(global_common_files + global/global_context.cc) +add_library(global_common_objs OBJECT ${global_common_files}) +add_library(global STATIC ${libglobal_srcs} + $) +target_link_libraries(global common ${CMAKE_THREAD_LIBS_INIT} ${CRYPTO_LIBS} + ${EXTRALIBS}) +if(${ENABLE_SHARED}) + set_target_properties(global PROPERTIES + OUTPUT_NAME ceph-global VERSION "1.0.0" SOVERSION "1") +endif(${ENABLE_SHARED}) + +# rados object classes +add_subdirectory(cls) + +# RADOS client/library +set(osdc_files + osdc/Objecter.cc) +set(osdc_rbd_files + osdc/ObjectCacher.cc + osdc/Striper.cc) +if(${WITH_CLIENT}) + list(APPEND osdc_files + osdc/Filer.cc) +endif(${WITH_CLIENT}) +add_library(osdc_rbd_objs OBJECT ${osdc_rbd_files}) +add_library(osdc STATIC ${osdc_files} $) + +set(librados_srcs + librados/librados.cc + librados/RadosClient.cc + librados/IoCtxImpl.cc + librados/snap_set_diff.cc + librados/RadosXattrIter.cc + ) +add_library(librados ${CEPH_SHARED} ${librados_srcs} + $ + $) +add_dependencies(librados osdc) +target_link_libraries(librados PRIVATE osdc osd os global common cls_lock_client + ${CRYPTO_LIBS} ${EXTRALIBS} ${TCMALLOC_LIBS}) +if(${ENABLE_SHARED}) + set_target_properties(librados PROPERTIES OUTPUT_NAME rados VERSION 2.0.0 + SOVERSION 2) +endif(${ENABLE_SHARED}) +install(FILES include/rados/librados.h + include/rados/rados_types.h + include/rados/rados_types.hpp + include/rados/librados.hpp + include/buffer.h + include/page.h + include/crc32c.h + DESTINATION include/rados) +install(TARGETS librados DESTINATION lib) + +set(rados_srcs + tools/rados/rados.cc + tools/rados/rados_sync.cc + tools/rados/rados_import.cc + tools/rados/rados_export.cc + common/obj_bencher.cc) +add_executable(rados ${rados_srcs} $) +target_link_libraries(rados librados global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +set(librados_config_srcs + librados-config.cc) +add_executable(librados-config ${librados_config_srcs} + $) +target_link_libraries(librados-config librados global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS}) + +install(TARGETS rados librados-config DESTINATION bin) + +install(DIRECTORY ${CMAKE_SOURCE_DIR}/src/pybind/ + DESTINATION ${PYTHON_INSTDIR}) + +# Monitor +set(lib_mon_srcs + auth/cephx/CephxKeyServer.cc + auth/cephx/CephxServiceHandler.cc + auth/AuthServiceHandler.cc + ${osd_mon_files} mon/Paxos.cc + mon/PaxosService.cc + mon/OSDMonitor.cc + mon/MDSMonitor.cc + mon/MonmapMonitor.cc + mon/LogMonitor.cc + mon/AuthMonitor.cc + mon/Elector.cc + mon/MonitorStore.cc + mon/HealthMonitor.cc + ${os_mon_files} + mon/DataHealthService.cc + mon/PGMonitor.cc + mon/PGMap.cc + mon/ConfigKeyService.cc) + +set(common_util_src + common/util.cc) +set(monitorstore_src + mon/MonitorStore.cc) +add_library(common_util_obj OBJECT ${common_util_src}) +add_library(monitorstore_obj OBJECT ${monitorstore_src}) +add_library(mon STATIC ${lib_mon_srcs} $ + $ $ + $ $) + +set(ceph_mon_srcs + ceph_mon.cc + common/TextTable.cc) +add_executable(ceph-mon ${ceph_mon_srcs} $) +target_link_libraries(ceph-mon mon boost_thread common os global ${EXTRALIBS} + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) +install(TARGETS ceph-mon DESTINATION bin) + +# OSD +set(libos_srcs + os/FileJournal.cc + os/FileStore.cc + os/chain_xattr.cc + os/ObjectStore.cc + os/JournalingObjectStore.cc + os/LFNIndex.cc + os/IndexManager.cc + os/FlatIndex.cc + os/LevelDBStore.cc + os/DBObjectMap.cc + os/Transaction.cc + os/WBThrottle.cc + os/GenericFileStoreBackend.cc + os/BtrfsFileStoreBackend.cc + os/ZFSFileStoreBackend.cc + os/KeyValueStore.cc + os/KeyValueDB.cc + os/MemStore.cc + os/GenericObjectMap.cc + os/HashIndex.cc) +set(os_mon_files + os/LevelDBStore.cc) +add_library(os_mon_objs OBJECT ${os_mon_files}) +add_library(os STATIC ${libos_srcs} $) +if(${HAVE_LIBAIO}) + target_link_libraries(os aio) +endif(${HAVE_LIBAIO}) +target_link_libraries(os leveldb snappy) + +set(cls_references_files objclass/class_api.cc) +add_library(cls_references_objs OBJECT ${cls_references_files}) + +set(osdc_osd_srcs + osdc/Objecter.cc + osdc/Striper.cc) + +set(osd_srcs + osd/OSD.cc + osd/Watch.cc + osd/ClassHandler.cc + osd/OpRequest.cc + osd/PG.cc + osd/PGLog.cc + osd/ReplicatedPG.cc + osd/ReplicatedBackend.cc + osd/ECBackend.cc + osd/ECTransaction.cc + osd/PGBackend.cc + osd/Ager.cc + osd/OSD.cc + osd/OSDCap.cc + osd/Watch.cc + osd/ClassHandler.cc + osd/OpRequest.cc + common/TrackedOp.cc + osd/SnapMapper.cc + osd/osd_types.cc + osd/ECUtil.cc + objclass/class_api.cc + ${osdc_osd_srcs}) +set(osd_mon_files + mon/Monitor.cc) +add_library(osd_mon_objs OBJECT ${osd_mon_files}) +add_library(osd STATIC ${osd_srcs} $ + $) +target_link_libraries(osd dl leveldb) + +set(ceph_osd_srcs + ceph_osd.cc + objclass/class_api.cc) +add_executable(ceph-osd ${ceph_osd_srcs} $) +target_link_libraries(ceph-osd osd os global ${TCMALLOC_LIBS}) +install(TARGETS ceph-osd DESTINATION bin) + +# MDS +if(${WITH_MDS}) + set(mds_srcs + mds/Capability.cc + mds/MDS.cc + mds/Beacon.cc + mds/flock.cc + mds/locks.c + mds/journal.cc + mds/Server.cc + mds/Mutation.cc + mds/MDCache.cc + mds/RecoveryQueue.cc + mds/Locker.cc + mds/Migrator.cc + mds/MDBalancer.cc + mds/CDentry.cc + mds/CDir.cc + mds/CInode.cc + mds/LogEvent.cc + mds/MDSTable.cc + mds/InoTable.cc + mds/MDSTableClient.cc + mds/MDSTableServer.cc + mds/SnapRealm.cc + mds/SnapServer.cc + mds/snap.cc + mds/SessionMap.cc + mds/MDSContext.cc + mds/MDSAuthCaps.cc + mds/MDLog.cc + mds/JournalPointer.cc + ${CMAKE_SOURCE_DIR}/src/osdc/Journaler.cc) + add_library(mds ${mds_srcs}) + set(ceph_mds_srcs + ceph_mds.cc) + add_executable(ceph-mds ${ceph_mds_srcs} $) + target_link_libraries(ceph-mds mds osdc ${CMAKE_DL_LIBS} global + ${TCMALLOC_LIBS} boost_thread) + install(TARGETS ceph-mds DESTINATION bin) +endif(${WITH_MDS}) + +add_subdirectory(erasure-code) + +# Support/Tools +add_subdirectory(gtest) +add_subdirectory(test) +set(cephfs_srcs cephfs.cc) +add_executable(cephfstool ${cephfs_srcs}) +target_link_libraries(cephfstool common ${EXTRALIBS}) +set_target_properties(cephfstool PROPERTIES OUTPUT_NAME cephfs) +install(TARGETS cephfstool DESTINATION bin) + +#set(ceph_srcs tools/ceph.cc tools/common.cc) +#add_executable(ceph ${ceph_srcs}) +#target_link_libraries(ceph global ${LIBEDIT_LIBS}) + +set(ceph_conf_srcs + tools/ceph_conf.cc) +add_executable(ceph-conf ${ceph_conf_srcs}) +target_link_libraries(ceph-conf global) +install(TARGETS ceph-conf DESTINATION bin) + +set(monmaptool_srcs + tools/monmaptool.cc) +add_executable(monmaptool ${monmaptool_srcs}) +target_link_libraries(monmaptool global) +install(TARGETS monmaptool DESTINATION bin) + +set(osdomaptool_srcs + tools/osdmaptool.cc) +add_executable(osdmaptool ${osdomaptool_srcs}) +target_link_libraries(osdmaptool global ${CMAKE_DL_LIBS}) +install(TARGETS osdmaptool DESTINATION bin) + +set(ceph_authtool_srcs + tools/ceph_authtool.cc) +add_executable(ceph-authtool ${ceph_authtool_srcs}) +target_link_libraries(ceph-authtool global ${EXTRALIBS}) +install(TARGETS ceph-authtool DESTINATION bin) + +set(ceph_mon_store_converter_srcs + tools/mon_store_converter.cc) +add_executable(ceph_mon_store_converter ${ceph_mon_store_converter_srcs} + $) +target_link_libraries(ceph_mon_store_converter os global) +install(TARGETS ceph_mon_store_converter DESTINATION bin) + +configure_file(${CMAKE_SOURCE_DIR}/src/ceph-coverage.in + ${CMAKE_BINARY_DIR}/ceph-coverage @ONLY) + +configure_file(${CMAKE_SOURCE_DIR}/src/ceph-debugpack.in + ${CMAKE_BINARY_DIR}/ceph-debugpack @ONLY) + +configure_file(${CMAKE_SOURCE_DIR}/src/ceph.in.cmake + ${CMAKE_BINARY_DIR}/ceph @ONLY) + +configure_file(${CMAKE_SOURCE_DIR}/src/ceph-crush-location.in + ${CMAKE_BINARY_DIR}/ceph-crush-location @ONLY) + +configure_file(${CMAKE_SOURCE_DIR}/src/init-ceph.in + ${CMAKE_BINARY_DIR}/init-ceph @ONLY) + +install(PROGRAMS + ${CMAKE_BINARY_DIR}/ceph + ${CMAKE_BINARY_DIR}/ceph-debugpack + ${CMAKE_BINARY_DIR}/ceph-coverage + ${CMAKE_BINARY_DIR}/init-ceph + ${CMAKE_SOURCE_DIR}/src/ceph-run + ${CMAKE_SOURCE_DIR}/src/vstart.sh + ${CMAKE_SOURCE_DIR}/src/ceph-clsinfo + DESTINATION bin) + +install(FILES + ${CMAKE_SOURCE_DIR}/doc/start/ceph.conf + DESTINATION ${sysconfdir}/ceph/ RENAME ceph.conf.example) + +install(PROGRAMS + ${CMAKE_SOURCE_DIR}/src/ceph_common.sh + DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/ceph) + +install(PROGRAMS + ${CMAKE_SOURCE_DIR}/src/ceph-create-keys + ${CMAKE_SOURCE_DIR}/src/ceph-disk + ${CMAKE_SOURCE_DIR}/src/ceph-disk-activate + ${CMAKE_SOURCE_DIR}/src/ceph-disk-prepare + ${CMAKE_SOURCE_DIR}/src/ceph-disk-udev + DESTINATION sbin) + +if(WITH_LIBCEPHFS) + set(libclient_srcs + client/Client.cc + client/Dentry.cc + client/Inode.cc + client/MetaRequest.cc + client/ClientSnapRealm.cc + client/MetaSession.cc + client/Trace.cc) + add_library(client ${libclient_srcs}) + target_link_libraries(client osdc mds ${LIBEDIT_LIBS}) + set(libcephfs_srcs libcephfs.cc) + add_library(cephfs SHARED ${libcephfs_srcs}) + target_link_libraries(cephfs client global) + install(TARGETS cephfs DESTINATION lib) + install(DIRECTORY + "${CMAKE_SOURCE_DIR}/src/include/cephfs" + DESTINATION include) + set(ceph_syn_srcs + ceph_syn.cc + client/SyntheticClient.cc) + add_executable(ceph-syn ${ceph_syn_srcs}) + target_link_libraries(ceph-syn client global) + + set(mount_ceph_srcs + mount/mount.ceph.c) + add_executable(mount.ceph ${mount_ceph_srcs} + $ + $) + target_link_libraries(mount.ceph keyutils) + + install(TARGETS ceph-syn DESTINATION bin) + install(TARGETS mount.ceph DESTINATION sbin) + + if(WITH_FUSE) + set(ceph_fuse_srcs + ceph_fuse.cc + client/fuse_ll.cc) + add_executable(ceph-fuse ${ceph_fuse_srcs}) + target_link_libraries(ceph-fuse fuse client global) + install(TARGETS ceph-fuse DESTINATION bin) + endif(WITH_FUSE) +endif(WITH_LIBCEPHFS) + +if(${WITH_RBD}) + set(librbd_srcs + librbd/librbd.cc + krbd.cc + librbd/AioCompletion.cc + librbd/AioRequest.cc + librbd/ImageCtx.cc + librbd/internal.cc + librbd/LibrbdWriteback.cc + librbd/WatchCtx.cc) + add_library(librbd ${CEPH_SHARED} ${librbd_srcs} + $ + $) + target_link_libraries(librbd PRIVATE librados common cls_lock_client cls_rbd_client + ${CMAKE_DL_LIBS}) + if(${ENABLE_SHARED}) + set_target_properties(librbd PROPERTIES VERSION "1.0.0" SOVERSION "1" + OUTPUT_NAME rbd) + endif(${ENABLE_SHARED}) + install(TARGETS librados librbd DESTINATION lib) + set(rbd_srcs + rbd.cc common/TextTable.cc) + set(rbd_mountcephfs_files + common/secret.c) + add_library(rbd_mountcephfs_objs OBJECT ${rbd_mountcephfs_files}) + add_executable(rbd ${rbd_srcs} $ + $ + $) + set_target_properties(rbd PROPERTIES OUTPUT_NAME rbd) + target_link_libraries(rbd global librbd librados common keyutils udev + ${BLKID_LIBRARIES} ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + install(TARGETS rbd DESTINATION bin) + install(PROGRAMS ${CMAKE_SOURCE_DIR}/src/ceph-rbdnamer DESTINATION bin) +endif(${WITH_RBD}) + +# RadosGW +if(${WITH_KVS}) + set(kvs_srcs + key_value_store/cls_kvs.cc) + add_library(cls_kvs SHARED ${kvs_srcs}) + set_target_properties(cls_kvs PROPERTIES VERSION "1.0.0" SOVERSION "1") + install(TARGETS cls_kvs DESTINATION lib/rados-classes) +endif(${WITH_KVS}) + +if(${WITH_RADOSGW}) + set(rgw_a_srcs + rgw/librgw.cc + rgw/rgw_acl.cc + rgw/rgw_acl_s3.cc + rgw/rgw_acl_swift.cc + rgw/rgw_client_io.cc + rgw/rgw_fcgi.cc + rgw/rgw_xml.cc + rgw/rgw_usage.cc + rgw/rgw_json_enc.cc + rgw/rgw_user.cc + rgw/rgw_bucket.cc + rgw/rgw_tools.cc + rgw/rgw_rados.cc + rgw/rgw_http_client.cc + rgw/rgw_rest_client.cc + rgw/rgw_rest_conn.cc + rgw/rgw_op.cc + rgw/rgw_common.cc + rgw/rgw_cache.cc + rgw/rgw_formats.cc + rgw/rgw_log.cc + rgw/rgw_multi.cc + rgw/rgw_policy_s3.cc + rgw/rgw_gc.cc + rgw/rgw_multi_del.cc + rgw/rgw_env.cc + rgw/rgw_cors.cc + rgw/rgw_cors_s3.cc + rgw/rgw_auth_s3.cc + rgw/rgw_metadata.cc + rgw/rgw_replica_log.cc + rgw/rgw_keystone.cc + rgw/rgw_quota.cc + rgw/rgw_dencoder.cc) + + add_library(rgw_a STATIC ${rgw_a_srcs}) + + include_directories("${CMAKE_SOURCE_DIR}/src/civetweb/include") + + set(radosgw_srcs + rgw/rgw_civetweb.cc + rgw/rgw_resolve.cc + rgw/rgw_rest.cc + rgw/rgw_rest_swift.cc + rgw/rgw_rest_s3.cc + rgw/rgw_rest_usage.cc + rgw/rgw_rest_user.cc + rgw/rgw_rest_bucket.cc + rgw/rgw_http_client.cc + rgw/rgw_swift.cc + rgw/rgw_swift_auth.cc + rgw/rgw_main.cc + rgw/rgw_keystone.cc + rgw/rgw_loadgen.cc + rgw/rgw_rest_client.cc + rgw/rgw_metadata.cc + rgw/rgw_rest_config.cc + rgw/rgw_rest_conn.cc + rgw/rgw_rest_log.cc + rgw/rgw_rest_metadata.cc + rgw/rgw_rest_opstate.cc + rgw/rgw_rest_replica_log.cc + ${kvs_srcs}) + + set(radosgw_srcs + rgw/rgw_resolve.cc + rgw/rgw_rest.cc + rgw/rgw_rest_swift.cc + rgw/rgw_rest_s3.cc + rgw/rgw_rest_usage.cc + rgw/rgw_rest_user.cc + rgw/rgw_rest_bucket.cc + rgw/rgw_rest_metadata.cc + rgw/rgw_replica_log.cc + rgw/rgw_rest_log.cc + rgw/rgw_rest_opstate.cc + rgw/rgw_rest_replica_log.cc + rgw/rgw_rest_config.cc + rgw/rgw_http_client.cc + rgw/rgw_swift.cc + rgw/rgw_swift_auth.cc + rgw/rgw_loadgen.cc + rgw/rgw_civetweb.cc + rgw/rgw_civetweb_log.cc + civetweb/src/civetweb.c + rgw/rgw_main.cc) + + add_executable(radosgw ${radosgw_srcs} $) + target_link_libraries(radosgw rgw_a librados + cls_rgw_client cls_lock_client cls_refcount_client + cls_log_client cls_statelog_client cls_version_client + cls_replica_log_client cls_user_client + curl expat global fcgi resolv ${TCMALLOC_LIBS}) + install(TARGETS radosgw DESTINATION bin) +endif(${WITH_RADOSGW}) diff --git a/src/ceph.in.cmake b/src/ceph.in.cmake new file mode 100755 index 000000000000..295450e6ab7a --- /dev/null +++ b/src/ceph.in.cmake @@ -0,0 +1,821 @@ +#!@PYTHON_EXECUTABLE@ +# -*- mode:python -*- +# vim: ts=4 sw=4 smarttab expandtab +# +# Processed in Makefile to add python #! line and version variable +# +# + + +""" +ceph.in becomes ceph, the command-line management tool for Ceph clusters. +This is a replacement for tools/ceph.cc and tools/common.cc. + +Copyright (C) 2013 Inktank Storage, Inc. + +This is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public +License version 2, as published by the Free Software +Foundation. See file COPYING. +""" + +import os +import sys + +# Make life easier on developers: +# If in src/, and .libs and pybind exist here, assume we're running +# from a Ceph source dir and tweak PYTHONPATH and LD_LIBRARY_PATH +# to use local files + +MYPATH = os.path.abspath(__file__) +MYDIR = os.path.dirname(MYPATH) +DEVMODEMSG = '*** DEVELOPER MODE: setting PATH, PYTHONPATH and LD_LIBRARY_PATH ***' + +if MYDIR.endswith('src') and \ + os.path.exists(os.path.join(MYDIR, '.libs')) and \ + os.path.exists(os.path.join(MYDIR, 'pybind')): + MYLIBPATH = os.path.join(MYDIR, '.libs') + if 'LD_LIBRARY_PATH' in os.environ: + if MYLIBPATH not in os.environ['LD_LIBRARY_PATH']: + os.environ['LD_LIBRARY_PATH'] += ':' + MYLIBPATH + print >> sys.stderr, DEVMODEMSG + os.execvp('python', ['python'] + sys.argv) + else: + os.environ['LD_LIBRARY_PATH'] = MYLIBPATH + print >> sys.stderr, DEVMODEMSG + os.execvp('python', ['python'] + sys.argv) + sys.path.insert(0, os.path.join(MYDIR, 'pybind')) + if MYDIR not in os.environ['PATH']: + os.environ['PATH'] += ':' + MYDIR + +import argparse +import errno +import json +import rados +import signal +import socket +import string +import struct +import subprocess + +from ceph_argparse import \ + concise_sig, descsort, parse_json_funcsigs, \ + matchnum, validate_command, find_cmd_target, \ + send_command, json_command + +# just a couple of globals + +verbose = False +cluster_handle = None + +############################################################################ + +def osdids(): + ret, outbuf, outs = json_command(cluster_handle, prefix='osd ls') + if ret == -errno.EINVAL: + # try old mon + ret, outbuf, outs = send_command(cluster_handle, cmd=['osd', 'ls']) + if ret: + raise RuntimeError('Can\'t contact mon for osd list') + return [i for i in outbuf.split('\n') if i != ''] + +def monids(): + ret, outbuf, outs = json_command(cluster_handle, prefix='mon dump', + argdict={'format':'json'}) + if ret == -errno.EINVAL: + # try old mon + ret, outbuf, outs = send_command(cluster_handle, + cmd=['mon', 'dump', '--format=json']) + if ret: + raise RuntimeError('Can\'t contact mon for mon list') + d = json.loads(outbuf) + return [m['name'] for m in d['mons']] + +def mdsids(): + ret, outbuf, outs = json_command(cluster_handle, prefix='mds dump', + argdict={'format':'json'}) + if ret == -errno.EINVAL: + # try old mon + ret, outbuf, outs = send_command(cluster_handle, + cmd=['mds', 'dump', '--format=json']) + if ret: + raise RuntimeError('Can\'t contact mon for mds list') + d = json.loads(outbuf) + l = [] + infodict = d['info'] + for mdsdict in infodict.values(): + l.append(mdsdict['name']) + return l + +def parse_cmdargs(args=None, target=''): + # alias: let the line-wrapping be sane + AP = argparse.ArgumentParser + + # format our own help + parser = AP(description='Ceph administration tool', add_help=False) + + parser.add_argument('--completion', action='store_true', + help=argparse.SUPPRESS) + + parser.add_argument('-h', '--help', help='request mon help', + action='store_true') + + parser.add_argument('-c', '--conf', dest='cephconf', + help='ceph configuration file') + parser.add_argument('-i', '--in-file', dest='input_file', + help='input file') + parser.add_argument('-o', '--out-file', dest='output_file', + help='output file') + + parser.add_argument('--id', '--user', dest='client_id', + help='client id for authentication') + parser.add_argument('--name', '-n', dest='client_name', + help='client name for authentication') + parser.add_argument('--cluster', help='cluster name') + + parser.add_argument('--admin-daemon', dest='admin_socket', + help='submit admin-socket commands (\"help\" for help') + parser.add_argument('--admin-socket', dest='admin_socket_nope', + help='you probably mean --admin-daemon') + + parser.add_argument('-s', '--status', action='store_true', + help='show cluster status') + + parser.add_argument('-w', '--watch', action='store_true', + help='watch live cluster changes') + parser.add_argument('--watch-debug', action='store_true', + help='watch debug events') + parser.add_argument('--watch-info', action='store_true', + help='watch info events') + parser.add_argument('--watch-sec', action='store_true', + help='watch security events') + parser.add_argument('--watch-warn', action='store_true', + help='watch warn events') + parser.add_argument('--watch-error', action='store_true', + help='watch error events') + + parser.add_argument('--version', '-v', action="store_true", help="display version") + parser.add_argument('--verbose', action="store_true", help="make verbose") + parser.add_argument('--concise', dest='verbose', action="store_false", + help="make less verbose") + + parser.add_argument('-f', '--format', choices=['json', 'json-pretty', + 'xml', 'xml-pretty', 'plain'], dest='output_format') + + parser.add_argument('--connect-timeout', dest='cluster_timeout', + type=int, + help='set a timeout for connecting to the cluster') + + # returns a Namespace with the parsed args, and a list of all extras + parsed_args, extras = parser.parse_known_args(args) + + return parser, parsed_args, extras + + +def hdr(s): + print '\n', s, '\n', '=' * len(s) + +def do_basic_help(parser, args): + """ + Print basic parser help + If the cluster is available, get and print monitor help + """ + hdr('General usage:') + parser.print_help() + +def do_extended_help(parser, args): + def help_for_sigs(sigs, partial=None): + sys.stdout.write(format_help(parse_json_funcsigs(sigs, 'cli'), + partial=partial)) + + def help_for_target(target, partial=None): + ret, outbuf, outs = json_command(cluster_handle, target=target, + prefix='get_command_descriptions', + timeout=10) + if ret: + print >> sys.stderr, \ + "couldn't get command descriptions for {0}: {1}".\ + format(target, outs) + else: + help_for_sigs(outbuf, partial) + + partial = ' '.join(args) + if (cluster_handle.state == "connected"): + help_for_target(target=('mon', ''), partial=partial) + return 0 + +DONTSPLIT = string.letters + '{[<>]}' + +def wrap(s, width, indent): + """ + generator to transform s into a sequence of strings width or shorter, + for wrapping text to a specific column width. + Attempt to break on anything but DONTSPLIT characters. + indent is amount to indent 2nd-through-nth lines. + + so "long string long string long string" width=11 indent=1 becomes + 'long string', ' long string', ' long string' so that it can be printed + as + long string + long string + long string + + Consumes s. + """ + result = '' + leader = '' + while len(s): + + if (len(s) <= width): + # no splitting; just possibly indent + result = leader + s + s = '' + yield result + + else: + splitpos = width + while (splitpos > 0) and (s[splitpos-1] in DONTSPLIT): + splitpos -= 1 + + if splitpos == 0: + splitpos = width + + if result: + # prior result means we're mid-iteration, indent + result = leader + else: + # first time, set leader and width for next + leader = ' ' * indent + width -= 1 # for subsequent space additions + + # remove any leading spaces in this chunk of s + result += s[:splitpos].lstrip() + s = s[splitpos:] + + yield result + + raise StopIteration + +def format_help(cmddict, partial=None): + """ + Formats all the cmdsigs and helptexts from cmddict into a sorted-by- + cmdsig 2-column display, with each column wrapped and indented to + fit into 40 characters. + """ + + fullusage = '' + for cmd in sorted(cmddict.itervalues(), cmp=descsort): + + if not cmd['help']: + continue + concise = concise_sig(cmd['sig']) + if partial and not concise.startswith(partial): + continue + siglines = [l for l in wrap(concise, 40, 1)] + helplines = [l for l in wrap(cmd['help'], 39, 1)] + + # make lists the same length + maxlen = max(len(siglines), len(helplines)) + siglines.extend([''] * (maxlen - len(siglines))) + helplines.extend([''] * (maxlen - len(helplines))) + + # so we can zip them for output + for (s, h) in zip(siglines, helplines): + fullusage += '{0:40s} {1}\n'.format(s, h) + + return fullusage + +def admin_socket(asok_path, cmd, format=''): + """ + Send a daemon (--admin-daemon) command 'cmd'. asok_path is the + path to the admin socket; cmd is a list of strings; format may be + set to one of the formatted forms to get output in that form + (daemon commands don't support 'plain' output). + """ + + def do_sockio(path, cmd): + """ helper: do all the actual low-level stream I/O """ + sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + sock.connect(path) + try: + sock.sendall(cmd + '\0') + len_str = sock.recv(4) + if len(len_str) < 4: + raise RuntimeError("no data returned from admin socket") + l, = struct.unpack(">I", len_str) + ret = '' + + got = 0 + while got < l: + bit = sock.recv(l - got) + ret += bit + got += len(bit) + + except Exception as e: + raise RuntimeError('exception: ' + str(e)) + return ret + + try: + cmd_json = do_sockio(asok_path, + json.dumps({"prefix":"get_command_descriptions"})) + except Exception as e: + raise RuntimeError('exception getting command descriptions: ' + str(e)) + + if cmd == 'get_command_descriptions': + return cmd_json + + sigdict = parse_json_funcsigs(cmd_json, 'cli') + valid_dict = validate_command(sigdict, cmd) + if not valid_dict: + raise RuntimeError('invalid command') + + if format: + valid_dict['format'] = format + + try: + ret = do_sockio(asok_path, json.dumps(valid_dict)) + except Exception as e: + raise RuntimeError('exception: ' + str(e)) + + return ret + + +def ceph_conf(field, name): + p = subprocess.Popen( + args=[ + 'ceph-conf', + '--show-config-value', + field, + '-n', + name, + ], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + outdata, errdata = p.communicate() + if (len(errdata)): + raise RuntimeError('unable to get conf option %s for %s: %s' % (field, name, errdata)) + return outdata.rstrip() + +def new_style_command(parsed_args, cmdargs, target, sigdict, inbuf, verbose): + """ + Do new-style command dance. + target: daemon to receive command: mon (any) or osd.N + sigdict - the parsed output from the new monitor describing commands + inbuf - any -i input file data + verbose - bool + """ + if verbose: + for cmdtag in sorted(sigdict.keys()): + cmd = sigdict[cmdtag] + sig = cmd['sig'] + print '{0}: {1}'.format(cmdtag, concise_sig(sig)) + + got_command = False + + if not got_command: + if cmdargs: + # Validate input args against list of sigs + valid_dict = validate_command(sigdict, cmdargs, verbose) + if valid_dict: + got_command = True + if parsed_args.output_format: + valid_dict['format'] = parsed_args.output_format + else: + return -errno.EINVAL, '', 'invalid command' + else: + # do the command-interpreter looping + # for raw_input to do readline cmd editing + import readline + while True: + interactive_input = raw_input('ceph> ') + if interactive_input in ['q', 'quit', 'Q']: + return 0, '', '' + cmdargs = parse_cmdargs(interactive_input.split())[2] + target = find_cmd_target(cmdargs) + valid_dict = validate_command(sigdict, cmdargs, verbose) + if valid_dict: + if parsed_args.output_format: + valid_dict['format'] = parsed_args.output_format + if verbose: + print >> sys.stderr, "Submitting command ", valid_dict + ret, outbuf, outs = json_command(cluster_handle, + target=target, + argdict=valid_dict) + if ret: + ret = abs(ret) + print >> sys.stderr, \ + 'Error: {0} {1}'.format(ret, errno.errorcode[ret]) + if outbuf: + print outbuf + if outs: + print >> sys.stderr, 'Status:\n', outs + else: + print >> sys.stderr, "Invalid command" + + if verbose: + print >> sys.stderr, "Submitting command ", valid_dict + return json_command(cluster_handle, target=target, argdict=valid_dict, + inbuf=inbuf) + +def complete(sigdict, args, target): + """ + Command completion. Match as much of [args] as possible, + and print every possible match separated by newlines. + Return exitcode. + """ + # XXX this looks a lot like the front of validate_command(). Refactor? + + complete_verbose = 'COMPVERBOSE' in os.environ + + # Repulsive hack to handle tell: lop off 'tell' and target + # and validate the rest of the command. 'target' is already + # determined in our callers, so it's ok to remove it here. + if len(args) and args[0] == 'tell': + args = args[2:] + # look for best match, accumulate possibles in bestcmds + # (so we can maybe give a more-useful error message) + best_match_cnt = 0 + bestcmds = [] + for cmdtag, cmd in sigdict.iteritems(): + sig = cmd['sig'] + matched = matchnum(args, sig, partial=True) + if (matched > best_match_cnt): + if complete_verbose: + print >> sys.stderr, \ + "better match: {0} > {1}: {2}:{3} ".format(matched, + best_match_cnt, cmdtag, concise_sig(sig)) + best_match_cnt = matched + bestcmds = [{cmdtag:cmd}] + elif matched == best_match_cnt: + if complete_verbose: + print >> sys.stderr, \ + "equal match: {0} > {1}: {2}:{3} ".format(matched, + best_match_cnt, cmdtag, concise_sig(sig)) + bestcmds.append({cmdtag:cmd}) + + # look through all matching sigs + comps = [] + for cmddict in bestcmds: + for cmd in cmddict.itervalues(): + sig = cmd['sig'] + # either: + # we match everything fully, so we want the next desc, or + # we match more partially, so we want the partial match + fullindex = matchnum(args, sig, partial=False) - 1 + partindex = matchnum(args, sig, partial=True) - 1 + if complete_verbose: + print >> sys.stderr, '{}: f {} p {} len {}'.format(sig, fullindex, partindex, len(sig)) + if fullindex == partindex and fullindex + 1 < len(sig): + d = sig[fullindex + 1] + else: + d = sig[partindex] + comps.append(str(d)) + if complete_verbose: + print >> sys.stderr, '\n'.join(comps) + print '\n'.join(comps) + + return 0 + +### +# ping a monitor +### +def ping_monitor(cluster_handle, name): + if 'mon.' not in name: + print >> sys.stderr, '"ping" expects a monitor to ping; try "ping mon."' + return 1 + + mon_id = name[len('mon.'):] + s = cluster_handle.ping_monitor(mon_id) + print s + return 0 + +### +# main +### + +def main(): + ceph_args = os.environ.get('CEPH_ARGS') + if ceph_args: + sys.argv.extend(ceph_args.split()) + + parser, parsed_args, childargs = parse_cmdargs() + + if parsed_args.version: + print 'ceph version {0} ({1})'.format(CEPH_GIT_NICE_VER, CEPH_GIT_VER) + return 0 + + global verbose + verbose = parsed_args.verbose + + if parsed_args.admin_socket_nope: + print >> sys.stderr, '--admin-socket is used by daemons; '\ + 'you probably mean --admin-daemon/daemon' + return 1 + + # pass on --id, --name, --conf + name = 'client.admin' + if parsed_args.client_id: + name = 'client.' + parsed_args.client_id + if parsed_args.client_name: + name = parsed_args.client_name + + # default '' means default conf search + conffile = '' + if parsed_args.cephconf: + conffile = parsed_args.cephconf + # For now, --admin-daemon is handled as usual. Try it + # first in case we can't connect() to the cluster + + format = parsed_args.output_format + + sockpath = None + if parsed_args.admin_socket: + sockpath = parsed_args.admin_socket + elif len(childargs) > 0 and childargs[0] == "daemon": + # Treat "daemon " or "daemon " like --admin_daemon + if len(childargs) > 2: + if childargs[1].find('/') >= 0: + sockpath = childargs[1] + else: + # try resolve daemon name + try: + sockpath = ceph_conf('admin_socket', childargs[1]) + except Exception as e: + print >> sys.stderr, \ + 'Can\'t get admin socket path: ' + str(e) + return errno.EINVAL + # for both: + childargs = childargs[2:] + else: + print >> sys.stderr, 'daemon requires at least 3 arguments' + return errno.EINVAL + + if sockpath: + try: + print admin_socket(sockpath, childargs, format) + except Exception as e: + print >> sys.stderr, 'admin_socket: {0}'.format(e) + return errno.EINVAL + return 0 + + timeout = None + if parsed_args.cluster_timeout: + timeout = parsed_args.cluster_timeout + + # basic help + if parsed_args.help: + do_basic_help(parser, childargs) + + # handle any 'generic' ceph arguments that we didn't parse here + global cluster_handle + + # rados.Rados() will call rados_create2, and then read the conf file, + # and then set the keys from the dict. So we must do these + # "pre-file defaults" first (see common_preinit in librados) + conf_defaults = { + 'log_to_stderr':'true', + 'err_to_stderr':'true', + 'log_flush_on_exit':'true', + } + + clustername = 'ceph' + if parsed_args.cluster: + clustername = parsed_args.cluster + + try: + cluster_handle = rados.Rados(name=name, clustername=clustername, + conf_defaults=conf_defaults, + conffile=conffile) + retargs = cluster_handle.conf_parse_argv(childargs) + except rados.Error as e: + print >> sys.stderr, 'Error initializing cluster client: {0}'.\ + format(e.__class__.__name__) + return 1 + + #tmp = childargs + childargs = retargs + if not childargs: + childargs = [] + + # -- means "stop parsing args", but we don't want to see it either + if '--' in childargs: + childargs.remove('--') + + # special deprecation warning for 'ceph tell' + # someday 'mds' will be here too + if len(childargs) >= 2 and \ + childargs[0] in ['mon', 'osd'] and \ + childargs[1] == 'tell': + print >> sys.stderr, '"{0} tell" is deprecated; try "tell {0}." instead (id can be "*") '.format(childargs[0]) + return 1 + + if parsed_args.help: + # short default timeout for -h + if not timeout: + timeout = 5 + + hdr('Monitor commands:') + print '[Contacting monitor, timeout after %d seconds]' % timeout + + if childargs and childargs[0] == 'ping': + if len(childargs) < 2: + print >> sys.stderr, '"ping" requires a monitor name as argument: "ping mon."' + return 1 + + try: + if childargs and childargs[0] == 'ping': + return ping_monitor(cluster_handle, childargs[1]) + cluster_handle.connect(timeout=timeout) + except KeyboardInterrupt: + print >> sys.stderr, 'Cluster connection aborted' + return 1 + except Exception as e: + print >> sys.stderr, 'Error connecting to cluster: {0}'.\ + format(e.__class__.__name__) + return 1 + + if parsed_args.help: + return do_extended_help(parser, childargs) + + # implement -w/--watch_* + # This is ugly, but Namespace() isn't quite rich enough. + level = '' + for k, v in parsed_args._get_kwargs(): + if k.startswith('watch') and v: + if k == 'watch': + level = 'info' + else: + level = k.replace('watch_', '') + if level: + + # an awfully simple callback + def watch_cb(arg, line, who, stamp_sec, stamp_nsec, seq, level, msg): + print line + sys.stdout.flush() + + # first do a ceph status + ret, outbuf, outs = json_command(cluster_handle, prefix='status') + if ret == -errno.EINVAL: + # try old mon + ret, outbuf, outs = send_command(cluster_handle, cmd=['status']) + # old mon returns status to outs...ick + if ret == 0: + outbuf += outs + if ret: + print >> sys.stderr, "status query failed: ", outs + return ret + print outbuf + + # this instance keeps the watch connection alive, but is + # otherwise unused + logwatch = rados.MonitorLog(cluster_handle, level, watch_cb, 0) + + # loop forever letting watch_cb print lines + try: + signal.pause() + except KeyboardInterrupt: + # or until ^C, at least + return 0 + + # read input file, if any + inbuf = '' + if parsed_args.input_file: + try: + with open(parsed_args.input_file, 'r') as f: + inbuf = f.read() + except Exception as e: + print >> sys.stderr, 'Can\'t open input file {0}: {1}'.format(parsed_args.input_file, e) + return 1 + + # prepare output file, if any + if parsed_args.output_file: + try: + outf = open(parsed_args.output_file, 'w') + except Exception as e: + print >> sys.stderr, \ + 'Can\'t open output file {0}: {1}'.\ + format(parsed_args.output_file, e) + return 1 + + # -s behaves like a command (ceph status). + if parsed_args.status: + childargs.insert(0, 'status') + + target = find_cmd_target(childargs) + + # Repulsive hack to handle tell: lop off 'tell' and target + # and validate the rest of the command. 'target' is already + # determined in our callers, so it's ok to remove it here. + if len(childargs) and childargs[0] == 'tell': + childargs = childargs[2:] + + # fetch JSON sigs from command + # each line contains one command signature (a placeholder name + # of the form 'cmdNNN' followed by an array of argument descriptors) + # as part of the validated argument JSON object + + targets = [target] + + if target[1] == '*': + if target[0] == 'osd': + targets = [(target[0], o) for o in osdids()] + elif target[0] == 'mon': + targets = [(target[0], m) for m in monids()] + + final_ret = 0 + for target in targets: + # prettify? prefix output with target, if there was a wildcard used + prefix = '' + suffix = '' + if not parsed_args.output_file and len(targets) > 1: + prefix = '{0}.{1}: '.format(*target) + suffix = '\n' + + ret, outbuf, outs = json_command(cluster_handle, target=target, + prefix='get_command_descriptions') + compat = False + if ret == -errno.EINVAL: + # send command to old monitor or OSD + if verbose: + print prefix + '{0} to old {1}'.format(' '.join(childargs), target[0]) + compat = True + if parsed_args.output_format: + childargs.extend(['--format', parsed_args.output_format]) + ret, outbuf, outs = send_command(cluster_handle, target, childargs, + inbuf) + + if ret == -errno.EINVAL: + # did we race with a mon upgrade? try again! + ret, outbuf, outs = json_command(cluster_handle, target=target, + prefix='get_command_descriptions') + if ret == 0: + compat = False # yep, carry on + if not compat: + if ret: + if ret < 0: + outs = 'problem getting command descriptions from {0}.{1}'.format(*target) + else: + sigdict = parse_json_funcsigs(outbuf, 'cli') + + if parsed_args.completion: + return complete(sigdict, childargs, target) + + ret, outbuf, outs = new_style_command(parsed_args, childargs, target, + sigdict, inbuf, verbose) + + # debug tool: send any successful command *again* to + # verify that it is idempotent. + if not ret and 'CEPH_CLI_TEST_DUP_COMMAND' in os.environ: + ret, outbuf, outs = new_style_command(parsed_args, childargs, target, + sigdict, inbuf, verbose) + if ret < 0: + ret = -ret + print >> sys.stderr, prefix + 'Second attempt of previously successful command failed with {0}: {1}'.format(errno.errorcode[ret], outs) + + if ret < 0: + ret = -ret + print >> sys.stderr, prefix + 'Error {0}: {1}'.format(errno.errorcode[ret], outs) + if len(targets) > 1: + final_ret = ret + else: + return ret + + # this assumes outs never has useful command output, only status + if compat: + if ret == 0: + # old cli/mon would send status string to stdout on non-error + print outs + else: + if outs: + print >> sys.stderr, prefix + outs + + if (parsed_args.output_file): + outf.write(outbuf) + else: + # hack: old code printed status line before many json outputs + # (osd dump, etc.) that consumers know to ignore. Add blank line + # to satisfy consumers that skip the first line, but not annoy + # consumers that don't. + if parsed_args.output_format and \ + parsed_args.output_format.startswith('json') and \ + not compat: + sys.stdout.write('\n') + + # if we are prettifying things, normalize newlines. sigh. + if suffix != '': + outbuf = outbuf.rstrip() + if outbuf != '': + sys.stdout.write(prefix + outbuf + suffix) + + sys.stdout.flush() + + if (parsed_args.output_file): + outf.close() + + if final_ret: + return final_ret + + return 0 + +if __name__ == '__main__': + sys.exit(main()) diff --git a/src/ceph_ver.h.in.cmake b/src/ceph_ver.h.in.cmake new file mode 100644 index 000000000000..9c269cdf500c --- /dev/null +++ b/src/ceph_ver.h.in.cmake @@ -0,0 +1,7 @@ +#ifndef CEPH_VERSION_H +#define CEPH_VERSION_H + +#define CEPH_GIT_VER @CEPH_GIT_VER@ +#define CEPH_GIT_NICE_VER "@CEPH_GIT_NICE_VER@" + +#endif diff --git a/src/cls/CMakeLists.txt b/src/cls/CMakeLists.txt new file mode 100644 index 000000000000..2c9c305b2ff2 --- /dev/null +++ b/src/cls/CMakeLists.txt @@ -0,0 +1,98 @@ +## Rados object classes + +# cls_hello +add_library(cls_hello SHARED hello/cls_hello.cc) +set_target_properties(cls_hello PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_hello DESTINATION lib/rados-classes) + +# cls_rbd +if (WITH_RBD) + add_library(cls_rbd SHARED rbd/cls_rbd.cc) + set_target_properties(cls_rbd PROPERTIES VERSION "1.0.0" SOVERSION "1") + install(TARGETS cls_rbd DESTINATION lib/rados-classes) + + add_library(cls_rbd_client rbd/cls_rbd_client.cc) +endif (WITH_RBD) + +# cls_lock +add_library(cls_lock SHARED lock/cls_lock.cc) +set_target_properties(cls_lock PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_lock DESTINATION lib/rados-classes) + +add_library(cls_lock_client + lock/cls_lock_client.cc + lock/cls_lock_types.cc + lock/cls_lock_ops.cc) + +# cls_refcount +add_library(cls_refcount SHARED + refcount/cls_refcount.cc + refcount/cls_refcount_ops.cc + ${CMAKE_SOURCE_DIR}/src/common/ceph_json.cc) +target_link_libraries(cls_refcount json_spirit) +set_target_properties(cls_refcount PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_refcount DESTINATION lib/rados-classes) + +add_library(cls_refcount_client + refcount/cls_refcount_client.cc + refcount/cls_refcount_ops.cc) + +# cls_version +add_library(cls_version SHARED version/cls_version.cc) +set_target_properties(cls_version PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_version DESTINATION lib/rados-classes) + +add_library(cls_version_client + version/cls_version_client.cc + version/cls_version_types.cc) + +# cls_log +add_library(cls_log SHARED log/cls_log.cc) +set_target_properties(cls_log PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_log DESTINATION lib/rados-classes) + +add_library(cls_log_client log/cls_log_client.cc) + +# cls_statelog +add_library(cls_statelog SHARED statelog/cls_statelog.cc) +set_target_properties(cls_statelog PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_statelog DESTINATION lib/rados-classes) + +add_library(cls_statelog_client statelog/cls_statelog_client.cc) + +# cls_replica_log +add_library(cls_replica_log SHARED replica_log/cls_replica_log.cc) +set_target_properties(cls_replica_log PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_replica_log DESTINATION lib/rados-classes) + +add_library(cls_replica_log_client + replica_log/cls_replica_log_types.cc + replica_log/cls_replica_log_ops.cc + replica_log/cls_replica_log_client.cc) + +# cls_user +add_library(cls_user SHARED user/cls_user.cc) +set_target_properties(cls_user PROPERTIES VERSION "1.0.0" SOVERSION "1") +install(TARGETS cls_user DESTINATION lib/rados-classes) + +add_library(cls_user_client + user/cls_user_client.cc + user/cls_user_types.cc + user/cls_user_ops.cc) + +# cls_rgw +if (WITH_RADOSGW) + add_library(cls_rgw SHARED + rgw/cls_rgw.cc + rgw/cls_rgw_ops.cc + rgw/cls_rgw_types.cc + ${CMAKE_SOURCE_DIR}/src/common/ceph_json.cc) + target_link_libraries(cls_rgw json_spirit) + set_target_properties(cls_rgw PROPERTIES VERSION "1.0.0" SOVERSION "1") + install(TARGETS cls_rgw DESTINATION lib/rados-classes) + + add_library(cls_rgw_client + rgw/cls_rgw_client.cc + rgw/cls_rgw_types.cc + rgw/cls_rgw_ops.cc) +endif (WITH_RADOSGW) diff --git a/src/erasure-code/CMakeLists.txt b/src/erasure-code/CMakeLists.txt new file mode 100644 index 000000000000..ba31afdd778b --- /dev/null +++ b/src/erasure-code/CMakeLists.txt @@ -0,0 +1,16 @@ +## erasure code plugins + +set(erasure_codelibdir ${LIBRARY_OUTPUT_PATH}/erasure-code) + +add_subdirectory(jerasure) +add_subdirectory(lrc) + +if (WITH_BETTER_YASM_ELF64) # TODO: check for yasm support + add_subdirectory(isa) +endif (WITH_BETTER_YASM_ELF64) + +add_library(erasure_code ErasureCodePlugin.cc) +target_link_libraries(erasure_code dl) +add_dependencies(erasure_code ${CMAKE_SOURCE_DIR}/src/ceph_ver.h) + +add_library(erasure_code_objs OBJECT ErasureCode.cc) diff --git a/src/erasure-code/isa/CMakeLists.txt b/src/erasure-code/isa/CMakeLists.txt new file mode 100644 index 000000000000..f6eae7d669de --- /dev/null +++ b/src/erasure-code/isa/CMakeLists.txt @@ -0,0 +1,39 @@ +# ISA + +include_directories(isa-l/include) + +set(isa_srcs + isa-l/erasure_code/ec_base.c + isa-l/erasure_code/ec_highlevel_func.c + isa-l/erasure_code/ec_multibinary.asm.s + isa-l/erasure_code/gf_2vect_dot_prod_avx2.asm.s + isa-l/erasure_code/gf_2vect_dot_prod_avx.asm.s + isa-l/erasure_code/gf_2vect_dot_prod_sse.asm.s + isa-l/erasure_code/gf_3vect_dot_prod_avx2.asm.s + isa-l/erasure_code/gf_3vect_dot_prod_avx.asm.s + isa-l/erasure_code/gf_3vect_dot_prod_sse.asm.s + isa-l/erasure_code/gf_4vect_dot_prod_avx2.asm.s + isa-l/erasure_code/gf_4vect_dot_prod_avx.asm.s + isa-l/erasure_code/gf_4vect_dot_prod_sse.asm.s + isa-l/erasure_code/gf_5vect_dot_prod_avx2.asm.s + isa-l/erasure_code/gf_5vect_dot_prod_avx.asm.s + isa-l/erasure_code/gf_5vect_dot_prod_sse.asm.s + isa-l/erasure_code/gf_6vect_dot_prod_avx2.asm.s + isa-l/erasure_code/gf_6vect_dot_prod_avx.asm.s + isa-l/erasure_code/gf_6vect_dot_prod_sse.asm.s + isa-l/erasure_code/gf_vect_dot_prod_avx2.asm.s + isa-l/erasure_code/gf_vect_dot_prod_avx.asm.s + isa-l/erasure_code/gf_vect_dot_prod_sse.asm.s + isa-l/erasure_code/gf_vect_mul_avx.asm.s + isa-l/erasure_code/gf_vect_mul_sse.asm.s + ErasureCodeIsa.cc + ErasureCodePluginIsa.cc + xor_op.cc + $ +) + +add_library(ec_isa SHARED ${isa_srcs}) +add_dependencies(ec_isa ${CMAKE_SOURCE_DIR}/src/ceph_ver.h) +target_link_libraries(ec_isa ${EXTRALIBS}) +set_target_properties(ec_isa PROPERTIES VERSION 2.10.0 SOVERSION 2) +install(TARGETS ec_isa DESTINATION lib/erasure-code) diff --git a/src/erasure-code/jerasure/CMakeLists.txt b/src/erasure-code/jerasure/CMakeLists.txt new file mode 100644 index 000000000000..f53c6c1db7d1 --- /dev/null +++ b/src/erasure-code/jerasure/CMakeLists.txt @@ -0,0 +1,100 @@ +# jerasure plugin + +include_directories(gf-complete/include) +include_directories(jerasure/include) + +## detect sse support + +# create a tmp file with an empty main() +set(sse_srcs "${CMAKE_BINARY_DIR}/src/erasure-code/jerasure/tmp_sse.c") +file(WRITE ${sse_srcs} "void main() {}") + +# try each -msse flag +try_compile(INTEL_SSE ${CMAKE_BINARY_DIR} ${sse_srcs} + COMPILE_DEFINITIONS "-msse") +try_compile(INTEL_SSE2 ${CMAKE_BINARY_DIR} ${sse_srcs} + COMPILE_DEFINITIONS "-msse2") +try_compile(INTEL_SSE3 ${CMAKE_BINARY_DIR} ${sse_srcs} + COMPILE_DEFINITIONS "-msse3") +try_compile(INTEL_SSSE3 ${CMAKE_BINARY_DIR} ${sse_srcs} + COMPILE_DEFINITIONS "-mssse3") +try_compile(INTEL_SSE4_1 ${CMAKE_BINARY_DIR} ${sse_srcs} + COMPILE_DEFINITIONS "-msse4.1") +try_compile(INTEL_SSE4_2 ${CMAKE_BINARY_DIR} ${sse_srcs} + COMPILE_DEFINITIONS "-msse4.2") + +# clean up tmp file +file(REMOVE ${sse_srcs}) + + +set(jerasure_srcs + jerasure/src/cauchy.c + jerasure/src/galois.c + jerasure/src/jerasure.c + jerasure/src/liberation.c + jerasure/src/reed_sol.c + gf-complete/src/gf_wgen.c + gf-complete/src/gf_method.c + gf-complete/src/gf_w16.c + gf-complete/src/gf.c + gf-complete/src/gf_w32.c + gf-complete/src/gf_w64.c + gf-complete/src/gf_w128.c + gf-complete/src/gf_general.c + gf-complete/src/gf_w4.c + gf-complete/src/gf_rand.c + gf-complete/src/gf_w8.c + ErasureCodePluginJerasure.cc + ErasureCodeJerasure.cc + $ +) + +add_library(ec_jerasure_generic SHARED ${jerasure_srcs}) +add_dependencies(ec_jerasure_generic ${CMAKE_SOURCE_DIR}/src/ceph_ver.h) +target_link_libraries(ec_jerasure_generic ${EXTRALIBS}) +set_target_properties(ec_jerasure_generic PROPERTIES VERSION 2.0.0 SOVERSION 2) +install(TARGETS ec_jerasure_generic DESTINATION lib/erasure-code) + +# ec_jerasure_sse3 +if(INTEL_SSE) + set(JERASURE_SSE3_FLAGS "-msse") + if (INTEL_SSE2) + set(JERASURE_SSE3_FLAGS "${JERASURE_SSE3_FLAGS} -msse2") + endif (INTEL_SSE2) + if (INTEL_SSE3) + set(JERASURE_SSE3_FLAGS "${JERASURE_SSE3_FLAGS} -msse3") + endif (INTEL_SSE3) + if (INTEL_SSSE3) + set(JERASURE_SSE3_FLAGS "${JERASURE_SSE3_FLAGS} -mssse3") + endif (INTEL_SSSE3) + add_library(ec_jerasure_sse3 SHARED ${jerasure_srcs}) + add_dependencies(ec_jerasure_sse3 ${CMAKE_SOURCE_DIR}/src/ceph_ver.h) + target_link_libraries(ec_jerasure_sse3 ${EXTRALIBS}) + set_target_properties(ec_jerasure_sse3 PROPERTIES VERSION 2.0.0 SOVERSION 2 + COMPILE_FLAGS ${JERASURE_SSE3_FLAGS}) + install(TARGETS ec_jerasure_sse3 DESTINATION lib/erasure-code) +else(INTEL_SSE) + message(STATUS "Skipping target ec_jerasure_sse3: -msse not supported") +endif(INTEL_SSE) + +# ec_jerasure_sse4 +if(INTEL_SSE4_1) + set(JERASURE_SSE4_FLAGS "${JERASURE_SSE3_FLAGS} -msse4.1") + if (INTEL_SSE4_2) + set(JERASURE_SSE4_FLAGS "${JERASURE_SSE4_FLAGS} -msse4.2") + endif (INTEL_SSE4_2) + add_library(ec_jerasure_sse4 SHARED ${jerasure_srcs}) + add_dependencies(ec_jerasure_sse4 ${CMAKE_SOURCE_DIR}/src/ceph_ver.h) + target_link_libraries(ec_jerasure_sse4 ${EXTRALIBS}) + set_target_properties(ec_jerasure_sse4 PROPERTIES VERSION 2.0.0 SOVERSION 2 + COMPILE_FLAGS ${JERASURE_SSE4_FLAGS}) + install(TARGETS ec_jerasure_sse4 DESTINATION lib/erasure-code) +else(INTEL_SSE4_1) + message(STATUS "Skipping target ec_jerasure_sse4: -msse4.1 not supported") +endif(INTEL_SSE4_1) + +add_library(ec_jerasure SHARED ErasureCodePluginSelectJerasure.cc) +add_dependencies(ec_jerasure ${CMAKE_SOURCE_DIR}/src/ceph_ver.h) +target_link_libraries(ec_jerasure ${EXTRALIBS}) +set_target_properties(ec_jerasure PROPERTIES VERSION 2.0.0 SOVERSION 2) +install(TARGETS ec_jerasure DESTINATION lib/erasure-code) diff --git a/src/erasure-code/lrc/CMakeLists.txt b/src/erasure-code/lrc/CMakeLists.txt new file mode 100644 index 000000000000..e6c799850e11 --- /dev/null +++ b/src/erasure-code/lrc/CMakeLists.txt @@ -0,0 +1,12 @@ +# LRC plugin + +set(lrc_srcs + ErasureCodePluginLrc.cc + ErasureCodeLrc.cc + $ +) + +add_library(ec_LRC SHARED ${lrc_srcs}) +add_dependencies(ec_LRC ${CMAKE_SOURCE_DIR}/src/ceph_ver.h) +set_target_properties(ec_LRC PROPERTIES VERSION 1.0.0 SOVERSION 1) +install(TARGETS ec_LRC DESTINATION lib/erasure-code) diff --git a/src/include/config-h.in.cmake b/src/include/config-h.in.cmake new file mode 100644 index 000000000000..a4afaa515752 --- /dev/null +++ b/src/include/config-h.in.cmake @@ -0,0 +1,238 @@ +/* config.h file expanded by Cmake for build */ + +#ifndef CONFIG_H +#define CONFIG_H + +/* fallocate(2) is supported */ +#cmakedefine CEPH_HAVE_FALLOCATE + +/* posix_fadvise is supported */ +#cmakedefine HAVE_POSIX_FADVISE + +/* posix_fallocate is supported */ +#cmakedefine HAVE_POSIX_FALLOCATE + +/* Define if darwin/osx */ +#cmakedefine DARWIN + +/* Define if you want C_Gather debugging */ +#cmakedefine DEBUG_GATHER + +/* Define if enabling coverage. */ +#cmakedefine ENABLE_COVERAGE + +/* FastCGI headers are in /usr/include/fastcgi */ +#cmakedefine FASTCGI_INCLUDE_DIR + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_ARPA_INET_H 1 + +/* have boost::random::discrete_distribution */ +#cmakedefine HAVE_BOOST_RANDOM_DISCRETE_DISTRIBUTION + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +#cmakedefine HAVE_DIRENT_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_DLFCN_H 1 + +/* linux/fiemap.h was found, fiemap ioctl will be used */ +#cmakedefine HAVE_FIEMAP_H 1 + +/* Define to 1 if you have the `fuse_getgroups' function. */ +#cmakedefine HAVE_FUSE_GETGROUPS 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_LINUX_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_INTTYPES_H 1 + +/* Defined if LevelDB supports bloom filters */ +#cmakedefine HAVE_LEVELDB_FILTER_POLICY + +/* Defined if you don't have atomic_ops */ +#cmakedefine HAVE_LIBAIO + +/* Define to 1 if you have the `boost_system' library (-lboost_system). */ +#cmakedefine HAVE_LIBBOOST_SYSTEM 1 + +/* Define to 1 if you have the `boost_system-mt' library (-lboost_system-mt). + */ +#cmakedefine HAVE_LIBBOOST_SYSTEM_MT 1 + +/* Define to 1 if you have the `boost_thread' library (-lboost_thread). */ +#cmakedefine HAVE_LIBBOOST_THREAD 1 + +/* Define to 1 if you have the `boost_thread-mt' library (-lboost_thread-mt). + */ +#cmakedefine HAVE_LIBBOOST_THREAD_MT 1 + +/* Define if you have fuse */ +#cmakedefine HAVE_LIBFUSE + +/* Define to 1 if you have the `leveldb' library (-lleveldb). */ +#cmakedefine HAVE_LIBLEVELDB 1 + +/* Define to 1 if you have the `profiler' library (-lprofiler). */ +#cmakedefine HAVE_LIBPROFILER 1 + +/* Define to 1 if you have the `snappy' library (-lsnappy). */ +#cmakedefine HAVE_LIBSNAPPY 1 + +/* Define if you have tcmalloc */ +#cmakedefine HAVE_LIBTCMALLOC + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_MEMORY_H 1 + +/* Define to 1 if you have the header file, and it defines `DIR'. */ +#cmakedefine HAVE_NDIR_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_NETDB_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_NETINET_IN_H 1 + +/* Define if you have perftools profiler enabled */ +#cmakedefine HAVE_PROFILER + +/* Define if you have POSIX threads libraries and header files. */ +#cmakedefine HAVE_PTHREAD + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STDLIB_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STRINGS_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STRING_H 1 + +/* Define to 1 if you have the `syncfs' function. */ +#cmakedefine HAVE_SYNCFS 1 + +/* sync_file_range(2) is supported */ +#cmakedefine HAVE_SYNC_FILE_RANGE + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYSLOG_H 1 + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +#cmakedefine HAVE_SYS_DIR_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_FILE_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_IOCTL_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_MOUNT_H 1 + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +#cmakedefine HAVE_SYS_NDIR_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_PARAM_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_SOCKET_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_STATVFS_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_STAT_H 1 + +/* we have syncfs */ +#cmakedefine HAVE_SYS_SYNCFS + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_TIME_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_VFS_H 1 + +/* Define to 1 if you have that is POSIX.1 compatible. */ +#cmakedefine HAVE_SYS_WAIT_H + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_XATTR_H + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_UNISTD_H + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_UTIME_H + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#cmakedefine LT_OBJDIR + +/* Defined if you do not have atomic_ops */ +#cmakedefine NO_ATOMIC_OPS + +/* Define to 1 if your C compiler doesn't accept -c and -o together. */ +#cmakedefine NO_MINUS_C_MINUS_O + +/* Name of package */ +#cmakedefine PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#cmakedefine PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#cmakedefine PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#cmakedefine PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#cmakedefine PACKAGE_TARNAME + +/* Define to the home page for this package. */ +#cmakedefine PACKAGE_URL + +/* Define to the version of this package. */ +#cmakedefine PACKAGE_VERSION + +/* Defined if you want pg ref debugging */ +#cmakedefine PG_DEBUG_REFS + +/* Define to necessary symbol if this constant uses a non-standard name on + your system. */ +#cmakedefine PTHREAD_CREATE_JOINABLE + +/* Define to 1 if you have the ANSI C header files. */ +#cmakedefine STDC_HEADERS + +/* Define if using CryptoPP. */ +#cmakedefine USE_CRYPTOPP + +/* Define if using NSS. */ +#cmakedefine USE_NSS + +/* Version number of package */ +#cmakedefine VERSION "@VERSION@" + +/* define if radosgw enabled */ +#cmakedefine WITH_RADOSGW + +/* Defined if XIO */ +#cmakedefine WITH_XIO + +/* Defined if CDS */ +#cmakedefine HAVE_CDS + +#endif /* CONFIG_H */ diff --git a/src/include/rados/librados.h b/src/include/rados/librados.h index 4a603c8b754b..9a35307f2b33 100644 --- a/src/include/rados/librados.h +++ b/src/include/rados/librados.h @@ -25,6 +25,7 @@ extern "C" { #elif defined(__FreeBSD__) #include #endif +#include #include #include "rados_types.h" diff --git a/src/json_spirit/CMakeLists.txt b/src/json_spirit/CMakeLists.txt new file mode 100644 index 000000000000..1bc0ade2206d --- /dev/null +++ b/src/json_spirit/CMakeLists.txt @@ -0,0 +1,3 @@ +add_library(json_spirit + json_spirit_reader.cpp + json_spirit_writer.cpp) diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt new file mode 100644 index 000000000000..df2c9d4e9dcb --- /dev/null +++ b/src/test/CMakeLists.txt @@ -0,0 +1,1730 @@ +# test_timers +add_executable(test_timers + TestTimers.cc + $ + ) +target_link_libraries(test_timers global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# test_signal_handlers +add_executable(test_signal_handlers + TestSignalHandlers.cc + $ + ) +target_link_libraries(test_signal_handlers global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS}) + +# test_msgr +add_executable(test_msgr + testmsgr.cc + $ + ) +target_link_libraries(test_msgr global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# test_crypt +add_executable(test_crypt + testcrypto.cc + $ + ) +target_link_libraries(test_crypt + global + ${CRYPTO_LIBS} + m + ${EXTRALIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ) + +# test_rados +add_executable(test_rados + osd/TestRados.cc + osd/TestOpStat.cc + osd/Object.cc osd/RadosModel.cc + $ + ) +target_link_libraries(test_rados + librados + global + ${CMAKE_DL_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ) + +# test_mutate +add_executable(test_mutate + test_mutate.cc + $ + ) +target_link_libraries(test_mutate global librados ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS}) + +# test_rewrite_latency +add_executable(test_rewrite_latency + test_rewrite_latency.cc + $ + ) +target_link_libraries(test_rewrite_latency common ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CMAKE_THREAD_LIBS_INIT} ${CRYPTO_LIBS} m ${EXTRALIBS}) + +# streamtest +add_executable(streamtest + streamtest.cc + $ + ) +target_link_libraries(streamtest os global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# test_trans +add_executable(test_trans + test_trans.cc + $ + ) +target_link_libraries(test_trans os global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# test_keys +add_executable(test_keys + testkeys.cc + $ + ) +target_link_libraries(test_keys mon global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +## dencoder +set(dencoder_srcs + encoding/ceph_dencoder.cc + ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc + ) +if(${WITH_RADOSGW}) + list(APPEND dencoder_srcs + ${CMAKE_SOURCE_DIR}/src/rgw/rgw_dencoder.cc + ${CMAKE_SOURCE_DIR}/src/rgw/rgw_acl.cc + ${CMAKE_SOURCE_DIR}/src/rgw/rgw_common.cc + ${CMAKE_SOURCE_DIR}/src/rgw/rgw_env.cc + ${CMAKE_SOURCE_DIR}/src/rgw/rgw_json_enc.cc + ) +endif(${WITH_RADOSGW}) +add_executable(dencoder ${dencoder_srcs} $) +target_link_libraries(dencoder + librados + global + osd + mds + mon + osdc + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) +if(${WITH_RADOSGW}) + target_link_libraries(dencoder + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + rgw_a + cls_rgw_client + cls_lock_client + cls_refcount_client + cls_log_client + cls_statelog_client + cls_version_client + cls_replica_log_client + cls_kvs + cls_user_client + curl + expat + fcgi + resolv + ) +endif(${WITH_RADOSGW}) + +# get_command_descriptions +add_executable(get_command_descriptions + common/get_command_descriptions.cc + ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc + $ + $ + ) +target_link_libraries(get_command_descriptions + mon + global + leveldb + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +## Benchmarks + +# smalliobench +set(smalliobench_srcs + bench/small_io_bench.cc + bench/rados_backend.cc + bench/detailed_stat_collector.cc + bench/bencher.cc + ) +add_executable(smalliobench + ${smalliobench_srcs} + $ + ) +target_link_libraries(smalliobench librados boost_program_options global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# smalliobenchfs +set(smalliobenchfs_srcs + bench/small_io_bench_fs.cc + bench/testfilestore_backend.cc + bench/detailed_stat_collector.cc + bench/bencher.cc + ) +add_executable(smalliobenchfs + ${smalliobenchfs_srcs} + $ + ) +target_link_libraries(smalliobenchfs librados boost_program_options os global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# smalliobenchdumb +set(smalliobenchdumb_srcs + bench/small_io_bench_dumb.cc + bench/dumb_backend.cc + bench/detailed_stat_collector.cc + bench/bencher.cc + ) +add_executable(smalliobenchdumb + ${smalliobenchdumb_srcs} + $ + ) +target_link_libraries(smalliobenchdumb librados boost_program_options os global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# smalliobenchrbd +set(smalliobenchrbd_srcs + bench/small_io_bench_rbd.cc + bench/rbd_backend.cc + bench/detailed_stat_collector.cc + bench/bencher.cc + ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc + ${CMAKE_SOURCE_DIR}/src/common/secret.c +) +add_executable(smalliobenchrbd + ${smalliobenchrbd_srcs} + $ + ) +target_link_libraries(smalliobenchrbd + librbd + librados + os + global + boost_program_options + blkid + udev + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + keyutils + ) + +# tpbench +set(tpbench_srcs + bench/tp_bench.cc + bench/detailed_stat_collector.cc) +add_executable(tpbench + ${tpbench_srcs} + $ + ) +target_link_libraries(tpbench librados boost_program_options os global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# omapbench +set(omapbench_srcs + omap_bench.cc + ) +add_executable(omapbench + ${omapbench_srcs} + $ + ) +target_link_libraries(omapbench + librados + boost_program_options + os + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ) + +# kvstorebench +set(kvstorebench_srcs + kv_store_bench.cc + ${CMAKE_SOURCE_DIR}/src/key_value_store/kv_flat_btree_async.cc + ) +add_executable(kvstorebench + ${kvstorebench_srcs} + $ + ) +target_link_libraries(kvstorebench librados global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS}) + +## System tests + +# systest +set(libsystest_srcs system/cross_process_sem.cc + system/systest_runnable.cc + system/systest_settings.cc + system/st_rados_create_pool.cc + system/st_rados_delete_pool.cc + system/st_rados_list_objects.cc + system/st_rados_watch.cc + system/st_rados_notify.cc) +add_library(systest STATIC ${libsystest_srcs}) + +# test_rados_list_parallel +add_executable(test_rados_list_parallel + system/rados_list_parallel.cc + $ + ) +target_link_libraries(test_rados_list_parallel librados systest global pthread + rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# test_rados_open_pools_parallel +set(test_rados_open_pools_parallel_srcs system/rados_open_pools_parallel.cc) +add_executable(test_rados_open_pools_parallel + ${test_rados_open_pools_parallel_srcs} + $ + ) +target_link_libraries(test_rados_open_pools_parallel librados systest global + pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# test_rados_delete_pools_parallel +set(test_rados_delete_pools_parallel_srcs + system/rados_delete_pools_parallel.cc + system/st_rados_create_pool.cc + system/st_rados_delete_pool.cc + system/st_rados_list_objects.cc + + ) +add_executable(test_rados_delete_pools_parallel + ${test_rados_delete_pools_parallel_srcs} + $ + ) +target_link_libraries(test_rados_delete_pools_parallel librados systest global + pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# test_rados_watch_notify +set(test_rados_watch_notify_srcs + system/rados_watch_notify.cc + system/st_rados_create_pool.cc + system/st_rados_delete_pool.cc + system/st_rados_delete_objs.cc + system/st_rados_watch.cc + system/st_rados_notify.cc + ) +add_executable(test_rados_watch_notify + ${test_rados_watch_notify_srcs} + $ + ) +target_link_libraries(test_rados_watch_notify librados systest global + pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +# bench_log +set(bench_log_srcs + bench_log.cc + ) +add_executable(bench_log + ${bench_log_srcs} + $ + ) +target_link_libraries(bench_log global pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +## Unit tests + +set(UNITTEST_LIBS gtest_main ${PTHREAD_LIBS}) +set(UNITTEST_CXX_FLAGS "-I${CMAKE_SOURCE_DIR}/src/gtest/include -I${CMAKE_BINARY_DIR}/src/gtest/include -fno-strict-aliasing") + +# unittest_encoding +set(unittest_encoding_srcs + encoding.cc + ) +add_executable(unittest_encoding + ${unittest_encoding_srcs} + $ + ) +target_link_libraries(unittest_encoding cephfs librados pthread rt m + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_encoding + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_addrs +set(unittest_addrs_srcs + test_addrs.cc + ) +add_executable(unittest_addrs + ${unittest_addrs_srcs} + $ + ) +target_link_libraries(unittest_addrs cephfs librados pthread rt m + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_addrs + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_bloom_filter +set(unittest_bloom_filter_srcs + common/test_bloom_filter.cc + ) +add_executable(unittest_bloom_filter + ${unittest_bloom_filter_srcs} + $ + ) +target_link_libraries(unittest_bloom_filter global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_bloom_filter + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_histogram +add_executable(unittest_histogram + common/histogram.cc + $ + ) +target_link_libraries(unittest_histogram global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_histogram + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_str_map +set(unittest_str_map_srcs + common/test_str_map.cc + ) +add_executable(unittest_str_map + ${unittest_str_map_srcs} + $ + ) +target_link_libraries(unittest_str_map global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_str_map + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_sharedptr_registry +set(unittest_sharedptr_registry_srcs + common/test_sharedptr_registry.cc + ) +add_executable(unittest_sharedptr_registry + ${unittest_sharedptr_registry_srcs} + $ + ) +target_link_libraries(unittest_sharedptr_registry global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_sharedptr_registry + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_sloppy_crc_map +set(unittest_sloppy_crc_map_srcs + common/test_sloppy_crc_map.cc + ) +add_executable(unittest_sloppy_crc_map + ${unittest_sloppy_crc_map_srcs} + $ + ) +target_link_libraries(unittest_sloppy_crc_map global + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_sloppy_crc_map + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_util +set(unittest_util_srcs + common/test_util.cc + ${CMAKE_SOURCE_DIR}/src/common/util.cc + ) +add_executable(unittest_util + ${unittest_util_srcs} + $ + ) +target_link_libraries(unittest_util + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ) +set_target_properties(unittest_util + PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_osdmap +set(unittest_osdmap_srcs osd/TestOSDMap.cc) +add_executable(unittest_osdmap + ${unittest_osdmap_srcs} + $ + ) +target_link_libraries(unittest_osdmap global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_osdmap PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_workqueue +set(unittest_workqueue_srcs test_workqueue.cc) +add_executable(unittest_workqueue + ${unittest_workqueue_srcs} + $ + ) +target_link_libraries(unittest_workqueue global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_workqueue PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_striper +set(unittest_striper_srcs test_striper.cc) +add_executable(unittest_striper + ${unittest_striper_srcs} + $ + ) +target_link_libraries(unittest_striper global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_striper PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_prebufferedstreambuf +set(unittest_prebufferedstreambuf_srcs test_prebufferedstreambuf.cc) +add_executable(unittest_prebufferedstreambuf + ${unittest_prebufferedstreambuf_srcs} + $ + ) +target_link_libraries(unittest_prebufferedstreambuf global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_prebufferedstreambuf PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_str_list +set(unittest_str_list_srcs test_str_list.cc) +add_executable(unittest_str_list + ${unittest_str_list_srcs} + $ + ) +target_link_libraries(unittest_str_list global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_str_list PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_log +set(unittest_log_srcs ${CMAKE_SOURCE_DIR}/src/log/test.cc) +add_executable(unittest_log + ${unittest_log_srcs} + $ + ) +target_link_libraries(unittest_log global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_log PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_throttle +set(unittest_throttle_srcs common/Throttle.cc) +add_executable(unittest_throttle + ${unittest_throttle_srcs} + $ + ) +target_link_libraries(unittest_throttle global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_throttle PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_base64 +set(unittest_base64_srcs base64.cc) +add_executable(unittest_base64 + ${unittest_base64_srcs} + $ + ) +target_link_libraries(unittest_base64 global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_base64 PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# unittest_ceph_argparse +set(unittest_ceph_argparse_srcs ceph_argparse.cc) +add_executable(unittest_ceph_argparse + ${unittest_ceph_argparse_srcs} + $ + ) +target_link_libraries(unittest_ceph_argparse global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_ceph_argparse PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_ceph_compatset +set(unittest_ceph_compatset_srcs ceph_compatset.cc) +add_executable(unittest_ceph_compatset + ${unittest_ceph_compatset_srcs} + $ + ) +target_link_libraries(unittest_ceph_compatset global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_ceph_compatset PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_osd_types +set(unittest_osd_types_srcs osd/types.cc) +add_executable(unittest_osd_types + ${unittest_osd_types_srcs} + $ + ) +target_link_libraries(unittest_osd_types global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_osd_types PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_gather +set(unittest_gather_srcs gather.cc) +add_executable(unittest_gather + ${unittest_gather_srcs} + $ + ) +target_link_libraries(unittest_gather global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_gather PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# run_cmd +set(unittest_run_cmd_srcs run_cmd.cc) +add_executable(unittest_run_cmd + ${unittest_run_cmd_srcs} + $ + ) +target_link_libraries(unittest_run_cmd global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_run_cmd PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# signals +set(unittest_signals_srcs signals.cc) +add_executable(unittest_signals + ${unittest_signals_srcs} + $ + ) +target_link_libraries(unittest_signals global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_signals PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_simple_spin +set(unittest_simple_spin_srcs simple_spin.cc) +add_executable(unittest_simple_spin + ${unittest_simple_spin_srcs} + $ + ) +target_link_libraries(unittest_simple_spin global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_simple_spin PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_librados +set(unittest_librados_srcs librados/librados.cc) +add_executable(unittest_librados + ${unittest_librados_srcs} + $ + ) +target_link_libraries(unittest_librados + librados + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ) +set_target_properties(unittest_librados PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_bufferlist +set(unittest_bufferlist_srcs bufferlist.cc) +add_executable(unittest_bufferlist + ${unittest_bufferlist_srcs} + $ + ) +target_link_libraries(unittest_bufferlist global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_bufferlist PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_crc32 +set(unittest_crc32_srcs common/test_crc32c.cc) +add_executable(unittest_crc32 + ${unittest_crc32_srcs} + $ + ) +target_link_libraries(unittest_crc32 global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_crc32 PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_arch +set(unittest_arch_srcs test_arch.cc) +add_executable(unittest_arch + ${unittest_arch_srcs} + $ + ) +target_link_libraries(unittest_arch global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_arch PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_crypto_init +set(unittest_crypto_init_srcs crypto_init.cc) +add_executable(unittest_crypto_init + ${unittest_crypto_init_srcs} + $ + ) +target_link_libraries(unittest_crypto_init global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_crypto_init PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_perf_counters +set(unittest_perf_counters_srcs perf_counters.cc) +add_executable(unittest_perf_counters + ${unittest_perf_counters_srcs} + $ + ) +target_link_libraries(unittest_perf_counters global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_perf_counters PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_admin_socket +set(unittest_admin_socket_srcs admin_socket.cc) +add_executable(unittest_admin_socket + ${unittest_admin_socket_srcs} + $ + ) +target_link_libraries(unittest_admin_socket global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_admin_socket PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_ceph_crypto +set(unittest_ceph_crypto_srcs ceph_crypto.cc) +add_executable(unittest_ceph_crypto + ${unittest_ceph_crypto_srcs} + $ + ) +target_link_libraries(unittest_ceph_crypto global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_ceph_crypto PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_utf8 +set(unittest_utf8_srcs utf8.cc) +add_executable(unittest_utf8 + ${unittest_utf8_srcs} + $ + ) +target_link_libraries(unittest_utf8 global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_utf8 PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_mime +set(unittest_mime_srcs mime.cc) +add_executable(unittest_mime + ${unittest_mime_srcs} + $ + ) +target_link_libraries(unittest_mime global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_mime PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_escape +set(unittest_escape_srcs escape.cc) +add_executable(unittest_escape + ${unittest_escape_srcs} + $ + ) +target_link_libraries(unittest_escape global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_escape PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_chain_xattr +set(unittest_chain_xattr_srcs + objectstore/chain_xattr.cc + ) +add_executable(unittest_chain_xattr + ${unittest_chain_xattr_srcs} + $ + ) +set_target_properties(unittest_chain_xattr PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(unittest_chain_xattr + os + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ) + +# unittest_flatindex +set(unittest_flatindex_srcs + os/TestFlatIndex.cc + ) +add_executable(unittest_flatindex + ${unittest_flatindex_srcs} + $ + ) +target_link_libraries(unittest_flatindex + os + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ) +set_target_properties(unittest_flatindex PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_strtol +set(unittest_strtol_srcs strtol.cc) +add_executable(unittest_strtol + ${unittest_strtol_srcs} + $ + ) +target_link_libraries(unittest_strtol global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_strtol PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_confutils +set(unittest_confutils_srcs confutils.cc) +add_executable(unittest_confutils + ${unittest_confutils_srcs} + $ + ) +target_link_libraries(unittest_confutils global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_confutils PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_config +set(unittest_config_srcs common/test_config.cc) +add_executable(unittest_config + ${unittest_config_srcs} + $ + ) +target_link_libraries(unittest_config global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_config PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_context +set(unittest_context_srcs common/test_context.cc) +add_executable(unittest_context + ${unittest_context_srcs} + $ + ) +target_link_libraries(unittest_context global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_context PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_heartbeatmap +set(unittest_heartbeatmap_srcs heartbeat_map.cc) +add_executable(unittest_heartbeatmap + ${unittest_heartbeatmap_srcs} + $ + ) +target_link_libraries(unittest_heartbeatmap global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_heartbeatmap PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +if(${WITH_RADOSGW}) + # unittest_formatter + set(unittest_formatter_srcs formatter.cc + ${CMAKE_SOURCE_DIR}/src/rgw/rgw_formats.cc) + add_executable(unittest_formatter + ${unittest_formatter_srcs} + $ + ) + target_link_libraries(unittest_formatter global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) + set_target_properties(unittest_formatter PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +endif(${WITH_RADOSGW}) + +# unittest_libcephfs_config +set(unittest_libcephfs_config_srcs libcephfs_config.cc) +add_executable(unittest_libcephfs_config + ${unittest_libcephfs_config_srcs} + $ + ) +target_link_libraries(unittest_libcephfs_config cephfs ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_libcephfs_config PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_lfnindex +set(unittest_lfnindex_srcs os/TestLFNIndex.cc) +add_executable(unittest_lfnindex + ${unittest_lfnindex_srcs} + $ + ) +target_link_libraries(unittest_lfnindex os global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_lfnindex PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_librados_config +set(unittest_librados_config_srcs librados/librados_config.cc) +add_executable(unittest_librados_config + ${unittest_librados_config_srcs} + $ + ) +target_link_libraries(unittest_librados_config + librados + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ) +set_target_properties(unittest_librados_config PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_daemon_config +set(unittest_daemon_config_srcs daemon_config.cc) +add_executable(unittest_daemon_config + ${unittest_daemon_config_srcs} + $ + ) +target_link_libraries(unittest_daemon_config + common + global + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${EXTRALIBS} + ) +set_target_properties(unittest_daemon_config PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_mon_moncap +set(unittest_mon_moncap_srcs mon/moncap.cc) +add_executable(unittest_mon_moncap + ${unittest_mon_moncap_srcs} + $ + ) +target_link_libraries(unittest_mon_moncap mon global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_mon_moncap PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_ipaddr +add_executable(unittest_ipaddr test_ipaddr.cc) +target_link_libraries(unittest_ipaddr mon global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_ipaddr PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_texttable +set(unittest_texttable_srcs + test_texttable.cc + ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc + ) +add_executable(unittest_texttable + ${unittest_texttable_srcs} + $ + ) +target_link_libraries(unittest_texttable mon global ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) +set_target_properties(unittest_texttable PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +# unittest_on_exit +set(unittest_on_exit_srcs on_exit.cc) +add_executable(unittest_on_exit + ${unittest_on_exit_srcs} + $ + ) +target_link_libraries(unittest_on_exit + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS}) +set_target_properties(unittest_on_exit PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + +if(${WITH_RADOSGW}) + # test_cors + set(test_cors_srcs test_cors.cc) + add_executable(test_cors + ${test_cors_srcs} + $ + ) + target_link_libraries(test_cors + librados + rgw_a + global + curl + uuid + expat + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS}) + set_target_properties(test_cors PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + + # test_rgw_manifest + set(test_rgw_manifest_srcs rgw/test_rgw_manifest.cc) + add_executable(test_rgw_manifest + ${test_rgw_manifest_srcs} + $ + ) + target_link_libraries(test_rgw_manifest + rgw_a + cls_rgw_client + cls_lock_client + cls_refcount_client + cls_log_client + cls_statelog_client + cls_version_client + cls_replica_log_client + cls_kvs + cls_user_client + librados + global + curl + uuid + expat + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ${CRYPTO_LIBS} + ) + set_target_properties(test_rgw_manifest PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + + # test_cls_rgw_meta + set(test_cls_rgw_meta_srcs test_rgw_admin_meta.cc) + add_executable(test_cls_rgw_meta + ${test_cls_rgw_meta_srcs} + $ + ) + target_link_libraries(test_cls_rgw_meta + librados + rgw_a + global + curl + uuid + expat + cls_version_client + cls_log_client + cls_statelog_client + cls_refcount_client + cls_rgw_client + cls_user_client + cls_lock_client + boost_regex + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS} ${CRYPTO_LIBS}) + set_target_properties(test_cls_rgw_meta PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + + # test_cls_rgw_log + set(test_cls_rgw_log_srcs + test_rgw_admin_log.cc + ) + add_executable(test_cls_rgw_log + ${test_cls_rgw_log_srcs} + $ + ) + target_link_libraries(test_cls_rgw_log + librados + rgw_a + global + curl + uuid + expat + cls_version_client + cls_log_client + cls_statelog_client + cls_refcount_client + cls_rgw_client + cls_user_client + cls_lock_client + boost_regex + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${CRYPTO_LIBS} + ) + set_target_properties(test_cls_rgw_log PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + + # test_cls_rgw_opstate + set(test_cls_rgw_opstate_srcs test_rgw_admin_opstate.cc) + add_executable(test_cls_rgw_opstate + ${test_cls_rgw_opstate_srcs} + $ + ) + target_link_libraries(test_cls_rgw_opstate + rgw_a + librados + cls_version_client + cls_log_client + cls_statelog_client + cls_refcount_client + cls_rgw_client + cls_user_client + cls_lock_client + global + curl + uuid + expat + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${UNITTEST_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + ) + set_target_properties(test_cls_rgw_opstate PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +endif(${WITH_RADOSGW}) + +# radostest +set(libradostest_srcs librados/test.cc librados/TestCase.cc) +add_library(radostest STATIC ${libradostest_srcs}) +set_target_properties(radostest PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) + +# multi_stress_watch +add_executable(multi_stress_watch + multi_stress_watch.cc + $ + ) +target_link_libraries(multi_stress_watch librados global radostest + ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}) + +add_executable(test_librbd + librbd/test_librbd.cc + $ + ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc + ${CMAKE_SOURCE_DIR}/src/common/secret.c + ) +set_target_properties(test_librbd PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_librbd + librbd + librados + ${UNITTEST_LIBS} + global + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + blkid + udev + keyutils + radostest + ) + +add_executable(test_librbd_fsx + librbd/fsx.c + $ + ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc + ${CMAKE_SOURCE_DIR}/src/common/secret.c + ) +target_link_libraries(test_librbd_fsx + librbd + librados + global + m + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + blkid + udev + keyutils + ) + +add_executable(test_cls_rbd + cls_rbd/test_cls_rbd.cc + $ + ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc + ${CMAKE_SOURCE_DIR}/src/common/secret.c + ) +set_target_properties(test_cls_rbd PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_rbd + librbd + cls_rbd + cls_lock + librados + global + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + radostest + blkid + udev + keyutils + ) + +add_executable(test_cls_refcount + cls_refcount/test_cls_refcount.cc + $ + ) +set_target_properties(test_cls_refcount PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_refcount + librados + cls_refcount_client + global + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + radostest + ) + +add_executable(test_cls_version + cls_version/test_cls_version.cc + $ + ) +set_target_properties(test_cls_version PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_version + librados + cls_version_client + global + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + radostest + ) + +add_executable(test_cls_log + cls_log/test_cls_log.cc + $ + ) +set_target_properties(test_cls_log PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_log + librados + cls_log_client + global + radostest + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + ) + +add_executable(test_cls_statelog + cls_statelog/test_cls_statelog.cc + $ + ) +set_target_properties(test_cls_statelog PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_statelog + librados + cls_statelog_client + global + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + radostest + ) + +add_executable(test_cls_replica_log + cls_replica_log/test_cls_replica_log.cc + $ + ) +set_target_properties(test_cls_replica_log PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_replica_log + librados + cls_replica_log_client + global + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + radostest + ) + +add_executable(test_cls_lock + cls_lock/test_cls_lock.cc + $ + ) +set_target_properties(test_cls_lock PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_lock + cls_lock + librados + global + ${UNITTEST_LIBS} + ${CMAKE_DL_LIBS} + ${TCMALLOC_LIBS} + ${CRYPTO_LIBS} + ${EXTRALIBS} + radostest + ) + +add_executable(test_cls_hello + cls_hello/test_cls_hello.cc + $ + ) +set_target_properties(test_cls_hello PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_cls_hello + librados + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ${UNITTEST_LIBS} + ) + +if(${WITH_RADOSGW}) + add_executable(test_cls_rgw + cls_rgw/test_cls_rgw.cc + $ + ) + set_target_properties(test_cls_rgw PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + target_link_libraries(test_cls_rgw + cls_rgw_client + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest) +endif(${WITH_RADOSGW}) + +add_executable(test_mon_workloadgen + mon/test_mon_workloadgen.cc + $ + ) +target_link_libraries(test_mon_workloadgen + os + osdc + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_rados_api_cmd + librados/cmd.cc + $ + ) +set_target_properties(test_rados_api_cmd PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_cmd + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest) + +add_executable(test_rados_api_io + librados/io.cc + $ + ) +set_target_properties(test_rados_api_io PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_io + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_c_write_operations + librados/c_write_operations.cc + $ + ) +set_target_properties(test_rados_api_c_write_operations PROPERTIES + COMPILE_FLAGS ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_c_write_operations + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest) + +add_executable(test_rados_api_c_read_operations + librados/c_read_operations.cc + $ + ) +set_target_properties(test_rados_api_c_read_operations PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_c_read_operations + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_aio + librados/aio.cc + $ + ) +set_target_properties(test_rados_api_aio PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_aio + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_list + librados/list.cc + $ + ) +set_target_properties(test_rados_api_list PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_list + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest) + +add_executable(test_rados_api_pool + librados/pool.cc + $ + ) +set_target_properties(test_rados_api_pool PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS} + ) +target_link_libraries(test_rados_api_pool + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_stat + librados/stat.cc + $ + ) +set_target_properties(test_rados_api_stat PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_stat + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_watch_notify + librados/watch_notify.cc + $ + ) +set_target_properties(test_rados_api_watch_notify PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_watch_notify + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_cls + librados/cls.cc + $ + ) +set_target_properties(test_rados_api_cls PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_cls + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_misc + librados/misc.cc + $ + ) +set_target_properties(test_rados_api_misc PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_misc + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +add_executable(test_rados_api_lock + librados/lock.cc + $ + ) +set_target_properties(test_rados_api_lock PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_rados_api_lock + librados + global + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + radostest + ) + +if(${WITH_CEPHFS}) + add_executable(test_libcephfs + libcephfs/test.cc + libcephfs/readdir_r_cb.cc + libcephfs/caps.cc + libcephfs/multiclient.cc + $ + ) + set_target_properties(test_libcephfs PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) + target_link_libraries(test_libcephfs + libcephfs + ${UNITTEST_LIBS} + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) +endif(${WITH_CEPHFS}) + +add_executable(test_objectstore + objectstore/store_test.cc + $ + ) +set_target_properties(test_objectstore PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_objectstore + os + common + ${UNITTEST_LIBS} + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_objectstore_workloadgen + objectstore/workload_generator.cc + objectstore/TestObjectStoreState.cc + $ + ) +target_link_libraries(test_objectstore_workloadgen + os + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_filestore_idempotent + objectstore/test_idempotent.cc + objectstore/FileStoreTracker.cc + common/ObjectContents.cc + $ + ) +target_link_libraries(test_filestore_idempotent + os + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_filestore_idempotent_sequence + objectstore/test_idempotent_sequence.cc + objectstore/DeterministicOpSequence.cc + objectstore/TestObjectStoreState.cc + objectstore/FileStoreDiff.cc + $ + ) +target_link_libraries(test_filestore_idempotent_sequence + os + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_xattr_bench + xattr_bench.cc + $ + ) +set_target_properties(test_xattr_bench PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_xattr_bench + os + common + ${UNITTEST_LIBS} + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_filejournal + test_filejournal.cc + $ + ) +set_target_properties(test_filejournal PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_filejournal + os + common + ${UNITTEST_LIBS} + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ${EXTRALIBS} + ) + +add_executable(test_stress_watch + test_stress_watch.cc + $ + ) +set_target_properties(test_stress_watch PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_stress_watch + librados + global + ${UNITTEST_LIBS} + radostest + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_objectcacher_stress + osdc/object_cacher_stress.cc + osdc/FakeWriteback.cc + $ + ) +target_link_libraries(test_objectcacher_stress + osdc + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_object_map + ObjectMap/test_object_map.cc + ObjectMap/KeyValueDBMemory.cc + $ + ) +set_target_properties(test_object_map PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_object_map + os + common + ${UNITTEST_LIBS} + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_keyvaluedb_atomicity + ObjectMap/test_keyvaluedb_atomicity.cc + $ + ) +set_target_properties(test_keyvaluedb_atomicity PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_keyvaluedb_atomicity + os + common + ${UNITTEST_LIBS} + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +add_executable(test_keyvaluedb_iterators + ObjectMap/test_keyvaluedb_iterators.cc + ObjectMap/KeyValueDBMemory.cc + $ + ) +set_target_properties(test_keyvaluedb_iterators PROPERTIES COMPILE_FLAGS + ${UNITTEST_CXX_FLAGS}) +target_link_libraries(test_keyvaluedb_iterators + os + common + ${UNITTEST_LIBS} + global + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) + +if(${WITH_FUSE}) + add_executable(test_cfuse_cache_invalidate + test_cfuse_cache_invalidate.cc + ) + target_link_libraries(test_cfuse_cache_invalidate + global + os + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) +endif(${WITH_FUSE}) + +if(${WITH_CEPHFS}) + add_executable(test_c_headers + test_c_headers.c + $ + ) + target_link_libraries(test_c_headers + librados + rados + libcephfs + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + ) +endif(${WITH_CEPHFS}) + +add_executable(test_get_blkdev_size + test_get_blkdev_size.cc + $ + ) +target_link_libraries(test_get_blkdev_size + common + ${EXTRALIBS} + ${TCMALLOC_LIBS} + ${CMAKE_DL_LIBS} + )