include(CMakeDependentOption)
-CMAKE_DEPENDENT_OPTION(WITH_ZBD "Enable libzbd bluestore backend" OFF
- "WITH_BLUESTORE" OFF)
-if(WITH_ZBD)
- find_package(zbd REQUIRED)
- set(HAVE_LIBZBD ${ZBD_FOUND})
-endif()
-
CMAKE_DEPENDENT_OPTION(WITH_LIBURING "Enable io_uring bluestore backend" ON
"WITH_BLUESTORE;HAVE_LIBAIO" OFF)
set(HAVE_LIBURING ${WITH_LIBURING})
# https://rpm-software-management.github.io/rpm/manual/conditionalbuilds.html
#################################################################################
%bcond_with make_check
-%bcond_with zbd
%bcond_with cmake_verbose_logging
%bcond_without ceph_test_package
%ifarch s390
BuildRequires: python%{python3_pkgversion}-asyncssh
BuildRequires: python%{python3_pkgversion}-natsort
%endif
-%if 0%{with zbd}
-BuildRequires: libzbd-devel
-%endif
%if 0%{?suse_version}
BuildRequires: libthrift-devel >= 0.13.0
%else
%if 0%{without lua_packages}
-DWITH_RADOSGW_LUA_PACKAGES:BOOL=OFF \
%endif
-%if 0%{with zbd}
- -DWITH_ZBD:BOOL=ON \
-%endif
%if 0%{with cmake_verbose_logging}
-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON \
%endif
function munge_ceph_spec_in {
local with_seastar=$1
shift
- local with_zbd=$1
- shift
local for_make_check=$1
shift
local OUTFILE=$1
if $with_seastar; then
sed -i -e 's/%bcond_with seastar/%bcond_without seastar/g' $OUTFILE
fi
- if $with_zbd; then
- sed -i -e 's/%bcond_with zbd/%bcond_without zbd/g' $OUTFILE
- fi
if $for_make_check; then
sed -i -e 's/%bcond_with make_check/%bcond_without make_check/g' $OUTFILE
fi
}
-function install_libzbd_on_ubuntu {
- ci_debug "Running install_libzbd_on_ubuntu() in install-deps.sh"
- local codename=$1
- local project=libzbd
- local sha1=1fadde94b08fab574b17637c2bebd2b1e7f9127b
- install_pkg_on_ubuntu \
- $project \
- $sha1 \
- $codename \
- check \
- libzbd-dev
-}
-
motr_pkgs_url='https://github.com/Seagate/cortx-motr/releases/download/2.0.0-rgw'
function install_cortx_motr_on_ubuntu {
exit
else
[ $WITH_SEASTAR ] && with_seastar=true || with_seastar=false
- [ $WITH_ZBD ] && with_zbd=true || with_zbd=false
[ $WITH_PMEM ] && with_pmem=true || with_pmem=false
[ $WITH_RADOSGW_MOTR ] && with_rgw_motr=true || with_rgw_motr=false
source /etc/os-release
*Bionic*)
ensure_decent_gcc_on_ubuntu 9 bionic
[ ! $NO_BOOST_PKGS ] && install_boost_on_ubuntu bionic
- $with_zbd && install_libzbd_on_ubuntu bionic
;;
*Focal*)
ensure_decent_gcc_on_ubuntu 11 focal
[ ! $NO_BOOST_PKGS ] && install_boost_on_ubuntu focal
- $with_zbd && install_libzbd_on_ubuntu focal
;;
*Jammy*)
[ ! $NO_BOOST_PKGS ] && install_boost_on_ubuntu jammy
if [ "$INSTALL_EXTRA_PACKAGES" ]; then
$SUDO dnf install -y $INSTALL_EXTRA_PACKAGES
fi
- munge_ceph_spec_in $with_seastar $with_zbd $for_make_check $DIR/ceph.spec
+ munge_ceph_spec_in $with_seastar $for_make_check $DIR/ceph.spec
# for python3_pkgversion macro defined by python-srpm-macros, which is required by python3-devel
$SUDO dnf install -y python3-devel
$SUDO $builddepcmd $DIR/ceph.spec 2>&1 | tee $DIR/yum-builddep.out
#include "pmem/PMEMDevice.h"
#endif
-#if defined(HAVE_LIBZBD)
-#include "zoned/HMSMRDevice.h"
-#endif
-
#include "common/debug.h"
#include "common/EventTrace.h"
#include "common/errno.h"
return block_device_t::pmem;
}
#endif
-#if (defined(HAVE_LIBAIO) || defined(HAVE_POSIXAIO)) && defined(HAVE_LIBZBD)
- if (HMSMRDevice::support(path)) {
- return block_device_t::hm_smr;
- }
-#endif
#if defined(HAVE_LIBAIO) || defined(HAVE_POSIXAIO)
return block_device_t::aio;
#else
if (blk_dev_name == "pmem") {
return block_device_t::pmem;
}
-#endif
-#if (defined(HAVE_LIBAIO) || defined(HAVE_POSIXAIO)) && defined(HAVE_LIBZBD)
- if (blk_dev_name == "hm_smr") {
- return block_device_t::hm_smr;
- }
#endif
return block_device_t::unknown;
}
#if defined(HAVE_BLUESTORE_PMEM)
case block_device_t::pmem:
return new PMEMDevice(cct, cb, cbpriv);
-#endif
-#if (defined(HAVE_LIBAIO) || defined(HAVE_POSIXAIO)) && defined(HAVE_LIBZBD)
- case block_device_t::hm_smr:
- return new HMSMRDevice(cct, cb, cbpriv, d_cb, d_cbpriv);
#endif
default:
ceph_abort_msg("unsupported device");
unknown,
#if defined(HAVE_LIBAIO) || defined(HAVE_POSIXAIO)
aio,
-#if defined(HAVE_LIBZBD)
- hm_smr,
-#endif
#endif
#if defined(HAVE_SPDK)
spdk,
spdk/NVMEDevice.cc)
endif()
-if(WITH_ZBD)
- list(APPEND libblk_srcs
- zoned/HMSMRDevice.cc)
-endif()
-
if(libblk_srcs)
add_library(blk STATIC ${libblk_srcs})
target_include_directories(blk PRIVATE "./")
PRIVATE spdk::spdk)
endif()
-if(WITH_ZBD)
- target_link_libraries(blk PRIVATE ${ZBD_LIBRARIES})
-endif()
-
if(WITH_BLUESTORE_PMEM)
if(HAVE_LIBDML)
target_link_libraries(blk PRIVATE dml::dml dml::dmlhl)
+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph - scalable distributed file system
- *
- * Copyright (C) 2014 Red Hat
- * Copyright (C) 2020 Abutalib Aghayev
- *
- * This is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software
- * Foundation. See file COPYING.
- *
- */
-
-#include "HMSMRDevice.h"
-extern "C" {
-#include <libzbd/zbd.h>
-}
-#include "common/debug.h"
-#include "common/errno.h"
-
-#define dout_context cct
-#define dout_subsys ceph_subsys_bdev
-#undef dout_prefix
-#define dout_prefix *_dout << "smrbdev(" << this << " " << path << ") "
-
-using namespace std;
-
-HMSMRDevice::HMSMRDevice(CephContext* cct,
- aio_callback_t cb,
- void *cbpriv,
- aio_callback_t d_cb,
- void *d_cbpriv)
- : KernelDevice(cct, cb, cbpriv, d_cb, d_cbpriv)
-{
-}
-
-bool HMSMRDevice::support(const std::string& path)
-{
- return zbd_device_is_zoned(path.c_str()) == 1;
-}
-
-int HMSMRDevice::_post_open()
-{
- dout(10) << __func__ << dendl;
-
- zbd_fd = zbd_open(path.c_str(), O_RDWR | O_DIRECT | O_LARGEFILE, nullptr);
- int r;
- if (zbd_fd < 0) {
- r = errno;
- derr << __func__ << " zbd_open failed on " << path << ": "
- << cpp_strerror(r) << dendl;
- return -r;
- }
-
- unsigned int nr_zones = 0;
- std::vector<zbd_zone> zones;
- if (zbd_report_nr_zones(zbd_fd, 0, 0, ZBD_RO_NOT_WP, &nr_zones) != 0) {
- r = -errno;
- derr << __func__ << " zbd_report_nr_zones failed on " << path << ": "
- << cpp_strerror(r) << dendl;
- goto fail;
- }
-
- zones.resize(nr_zones);
- if (zbd_report_zones(zbd_fd, 0, 0, ZBD_RO_NOT_WP, zones.data(), &nr_zones) != 0) {
- r = -errno;
- derr << __func__ << " zbd_report_zones failed on " << path << dendl;
- goto fail;
- }
-
- zone_size = zbd_zone_len(&zones[0]);
- conventional_region_size = nr_zones * zone_size;
-
- dout(10) << __func__ << " setting zone size to " << zone_size
- << " and conventional region size to " << conventional_region_size
- << dendl;
-
- return 0;
-
-fail:
- zbd_close(zbd_fd);
- zbd_fd = -1;
- return r;
-}
-
-
-void HMSMRDevice::_pre_close()
-{
- if (zbd_fd >= 0) {
- zbd_close(zbd_fd);
- zbd_fd = -1;
- }
-}
-
-void HMSMRDevice::reset_all_zones()
-{
- dout(10) << __func__ << dendl;
- zbd_reset_zones(zbd_fd, conventional_region_size, 0);
-}
-
-void HMSMRDevice::reset_zone(uint64_t zone)
-{
- dout(10) << __func__ << " zone 0x" << std::hex << zone << std::dec << dendl;
- if (zbd_reset_zones(zbd_fd, zone * zone_size, zone_size) != 0) {
- derr << __func__ << " resetting zone failed for zone 0x" << std::hex
- << zone << std::dec << dendl;
- ceph_abort("zbd_reset_zones failed");
- }
-}
-
-std::vector<uint64_t> HMSMRDevice::get_zones()
-{
- std::vector<zbd_zone> zones;
- unsigned int num_zones = size / zone_size;
- zones.resize(num_zones);
-
- int r = zbd_report_zones(zbd_fd, 0, 0, ZBD_RO_ALL, zones.data(), &num_zones);
- if (r != 0) {
- derr << __func__ << " zbd_report_zones failed on " << path << ": "
- << cpp_strerror(errno) << dendl;
- ceph_abort("zbd_report_zones failed");
- }
-
- std::vector<uint64_t> wp(num_zones);
- for (unsigned i = 0; i < num_zones; ++i) {
- wp[i] = zones[i].wp;
- }
- return wp;
-}
+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph - scalable distributed file system
- *
- * Copyright (C) 2014 Red Hat
- * Copyright (C) 2020 Abutalib Aghayev
- *
- * This is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software
- * Foundation. See file COPYING.
- *
- */
-
-#ifndef CEPH_BLK_HMSMRDEVICE_H
-#define CEPH_BLK_HMSMRDEVICE_H
-
-#include <atomic>
-
-#include "include/types.h"
-#include "include/interval_set.h"
-#include "common/Thread.h"
-#include "include/utime.h"
-
-#include "aio/aio.h"
-#include "BlockDevice.h"
-#include "../kernel/KernelDevice.h"
-
-
-class HMSMRDevice final : public KernelDevice {
- int zbd_fd = -1; ///< fd for the zoned block device
-
-public:
- HMSMRDevice(CephContext* cct, aio_callback_t cb, void *cbpriv,
- aio_callback_t d_cb, void *d_cbpriv);
-
- static bool support(const std::string& path);
-
- // open/close hooks for libzbd
- int _post_open() override;
- void _pre_close() override;
-
- // smr-specific methods
- bool is_smr() const final { return true; }
- void reset_all_zones() override;
- void reset_zone(uint64_t zone) override;
- std::vector<uint64_t> get_zones() override;
-
-};
-
-#endif //CEPH_BLK_HMSMRDEVICE_H
${PROJECT_SOURCE_DIR}/src/os/bluestore/StupidAllocator.cc
${PROJECT_SOURCE_DIR}/src/os/bluestore/BitmapAllocator.cc
${PROJECT_SOURCE_DIR}/src/os/memstore/MemStore.cc)
-if(WITH_ZBD)
- list(APPEND alien_store_srcs
- ${PROJECT_SOURCE_DIR}/src/os/bluestore/ZonedFreelistManager.cc
- ${PROJECT_SOURCE_DIR}/src/os/bluestore/ZonedAllocator.cc)
-endif()
add_library(crimson-alienstore STATIC
${alien_store_srcs})
if(WITH_LTTNG)
/* Defined if you have libdml */
#cmakedefine HAVE_LIBDML
-/* Defined if you have libzbd */
-#cmakedefine HAVE_LIBZBD
-
/* Defined if you have liburing */
#cmakedefine HAVE_LIBURING
#include "AvlAllocator.h"
#include "BtreeAllocator.h"
#include "HybridAllocator.h"
-#ifdef HAVE_LIBZBD
-#include "ZonedAllocator.h"
-#endif
#include "common/debug.h"
#include "common/admin_socket.h"
#define dout_subsys ceph_subsys_bluestore
#include "FreelistManager.h"
#include "BitmapFreelistManager.h"
-#ifdef HAVE_LIBZBD
-#include "ZonedFreelistManager.h"
-#endif
FreelistManager *FreelistManager::create(
CephContext* cct,
void FreelistManager::setup_merge_operators(KeyValueDB *db,
const std::string& type)
{
-#ifdef HAVE_LIBZBD
- if (type == "zoned")
- ZonedFreelistManager::setup_merge_operator(db, "z");
- else
-#endif
- BitmapFreelistManager::setup_merge_operator(db, "b");
+ BitmapFreelistManager::setup_merge_operator(db, "b");
}
void init_alloc(int64_t size, uint64_t min_alloc_size) {
std::cout << "Creating alloc type " << string(GetParam()) << " \n";
alloc.reset(Allocator::create(g_ceph_context, GetParam(), size,
- min_alloc_size,
- 256*1048576, 100*256*1048576ull));
+ min_alloc_size));
}
void init_close() {
std::string_view alloc_name) {
alloc.reset(
Allocator::create(
- g_ceph_context, alloc_type, capacity, alloc_unit, 0, 0, alloc_name));
+ g_ceph_context, alloc_type, capacity, alloc_unit, alloc_name));
};
auto add_fn = [&](uint64_t offset,
uint64_t len) {
uint64_t shared_alloc_unit = 4096;
shared_alloc.set(
Allocator::create(g_ceph_context, g_ceph_context->_conf->bluefs_allocator,
- size, shared_alloc_unit, 0, 0, "test shared allocator"),
+ size, shared_alloc_unit, "test shared allocator"),
shared_alloc_unit);
shared_alloc.a->init_add_free(0, size);
bluefs_shared_alloc_context_t shared_alloc;
shared_alloc.set(
Allocator::create(g_ceph_context, g_ceph_context->_conf->bluefs_allocator,
- size, main_unit, 0, 0, "test shared allocator"),
+ size, main_unit, "test shared allocator"),
main_unit);
// prepare sparse free space but let's have a continuous chunk at
// the beginning to fit initial log's fnode into superblock,
bluefs_shared_alloc_context_t shared_alloc;
shared_alloc.set(
Allocator::create(g_ceph_context, g_ceph_context->_conf->bluefs_allocator,
- size, main_unit, 0, 0, "test shared allocator"),
+ size, main_unit, "test shared allocator"),
main_unit);
shared_alloc.a->init_add_free(bluefs_alloc_unit, size - bluefs_alloc_unit);
lockdep=${LOCKDEP:-1}
spdk_enabled=0 # disable SPDK by default
pmem_enabled=0
-zoned_enabled=0
io_uring_enabled=0
with_jaeger=0
BLUESTORE_OPTS=""
fi
fi
- if [ "$zoned_enabled" -eq 1 ]; then
- BLUESTORE_OPTS+="
- bluestore min alloc size = 65536
- bluestore prefer deferred size = 0
- bluestore prefer deferred size hdd = 0
- bluestore prefer deferred size ssd = 0
- fi
if [ "$io_uring_enabled" -eq 1 ]; then
BLUESTORE_OPTS+="
bdev ioring = true"
projects / ceph.git / commitdiff