{
ghobject_t obj;
try {
- obj = test_ops_get_object_name(*shard_services.get_osdmap(), cmdmap);
+ obj = test_ops_get_object_name(*shard_services.get_map(), cmdmap);
} catch (const std::invalid_argument& e) {
logger().info("error during data error injection: {}", e.what());
return seastar::make_ready_future<tell_result_t>(-EINVAL,
{
ghobject_t obj;
try {
- obj = test_ops_get_object_name(*shard_services.get_osdmap(), cmdmap);
+ obj = test_ops_get_object_name(*shard_services.get_map(), cmdmap);
} catch (const std::invalid_argument& e) {
logger().info("error during metadata error injection: {}", e.what());
return seastar::make_ready_future<tell_result_t>(-EINVAL,
tell_result_t{-EINVAL, fmt::format("couldn't parse pgid '{}'", pgid_str)});
}
// am i the primary for this pg?
- const auto osdmap = osd.get_shard_services().get_osdmap();
+ const auto osdmap = osd.get_shard_services().get_map();
spg_t spg_id;
if (!osdmap->get_primary_shard(pgid, &spg_id)) {
return seastar::make_ready_future<tell_result_t>(tell_result_t{
{
osds_t old_osds; // osds not added in this epoch
for (auto i = peers.begin(); i != peers.end(); ) {
- auto osdmap = service.get_osdmap_service().get_map();
+ auto osdmap = service.get_map();
const auto& [osd, peer] = *i;
if (!osdmap->is_up(osd)) {
i = peers.erase(i);
void Heartbeat::add_reporter_peers(int whoami)
{
- auto osdmap = service.get_osdmap_service().get_map();
+ auto osdmap = service.get_map();
// include next and previous up osds to ensure we have a fully-connected set
set<int> want;
if (auto next = osdmap->get_next_up_osd_after(whoami); next >= 0) {
remove_peer(osd);
}
// or too few?
- auto osdmap = service.get_osdmap_service().get_map();
+ auto osdmap = service.get_map();
auto epoch = osdmap->get_epoch();
for (auto next = osdmap->get_next_up_osd_after(whoami);
peers.size() < min_peers && next >= 0 && next != whoami;
auto reply =
crimson::make_message<MOSDPing>(
m->fsid,
- service.get_osdmap_service().get_map()->get_epoch(),
+ service.get_map()->get_epoch(),
MOSDPing::PING_REPLY,
m->ping_stamp,
m->mono_ping_stamp,
service.get_mnow(),
- service.get_osdmap_service().get_up_epoch(),
+ service.get_up_epoch(),
min_message);
return conn->send(std::move(reply));
}
entity_addr_t Heartbeat::Peer::get_peer_addr(type_t type)
{
- const auto osdmap = heartbeat.service.get_osdmap_service().get_map();
+ const auto osdmap = heartbeat.service.get_map();
if (type == type_t::front) {
return osdmap->get_hb_front_addrs(peer).front();
} else {
local_conf()->osd_heartbeat_min_size);
auto ping = crimson::make_message<MOSDPing>(
heartbeat.monc.get_fsid(),
- heartbeat.service.get_osdmap_service().get_map()->get_epoch(),
+ heartbeat.service.get_map()->get_epoch(),
MOSDPing::PING,
sent_stamp,
mnow,
mnow,
- heartbeat.service.get_osdmap_service().get_up_epoch(),
+ heartbeat.service.get_up_epoch(),
min_message);
if (futures) {
futures->push_back(conn.send(std::move(ping)));
}
auto failed_for = std::chrono::duration_cast<std::chrono::seconds>(
now - failed_since).count();
- auto osdmap = heartbeat.service.get_osdmap_service().get_map();
+ auto osdmap = heartbeat.service.get_map();
auto failure_report =
crimson::make_message<MOSDFailure>(heartbeat.monc.get_fsid(),
peer,
osd,
addrs,
0,
- heartbeat.service.get_osdmap_service().get_map()->get_epoch(),
+ heartbeat.service.get_map()->get_epoch(),
MOSDFailure::FLAG_ALIVE);
logger().info("{}: osd.{}", __func__, osd);
return heartbeat.monc.send_message(std::move(still_alive));
#include <utility>
#include <boost/intrusive_ptr.hpp>
#include <boost/smart_ptr/intrusive_ref_counter.hpp>
-#include <boost/smart_ptr/local_shared_ptr.hpp>
#include <seastar/core/chunked_fifo.hh>
#include <seastar/core/future.hh>
#include <seastar/core/shared_future.hh>
);
}).then([this](OSDSuperblock&& sb) {
superblock = std::move(sb);
- return pg_shard_manager.get_map(superblock.current_epoch);
- }).then([this](OSDMapService::cached_map_t&& map) {
- pg_shard_manager.update_map(map);
- pg_shard_manager.got_map(map->get_epoch());
- osdmap = std::move(map);
+ return pg_shard_manager.get_local_map(superblock.current_epoch);
+ }).then([this](OSDMapService::local_cached_map_t&& map) {
+ osdmap = make_local_shared_foreign(OSDMapService::local_cached_map_t(map));
+ return pg_shard_manager.update_map(std::move(map));
+ }).then([this] {
+ pg_shard_manager.got_map(osdmap->get_epoch());
bind_epoch = osdmap->get_epoch();
return pg_shard_manager.load_pgs();
}).then([this] {
void OSD::update_stats()
{
osd_stat_seq++;
- osd_stat.up_from = pg_shard_manager.get_up_epoch();
+ osd_stat.up_from = get_shard_services().get_up_epoch();
osd_stat.hb_peers = heartbeat->get_peers();
osd_stat.seq = (
- static_cast<uint64_t>(pg_shard_manager.get_up_epoch()) << 32
+ static_cast<uint64_t>(get_shard_services().get_up_epoch()) << 32
) | osd_stat_seq;
gate.dispatch_in_background("statfs", *this, [this] {
(void) store.stat().then([this](store_statfs_t&& st) {
return seastar::do_for_each(boost::make_counting_iterator(first),
boost::make_counting_iterator(last + 1),
[this](epoch_t cur) {
- return pg_shard_manager.get_map(cur).then([this](OSDMapService::cached_map_t&& o) {
- osdmap = std::move(o);
- pg_shard_manager.update_map(osdmap);
- if (pg_shard_manager.get_up_epoch() == 0 &&
- osdmap->is_up(whoami) &&
- osdmap->get_addrs(whoami) == public_msgr->get_myaddrs()) {
- pg_shard_manager.set_up_epoch(osdmap->get_epoch());
- if (!boot_epoch) {
- boot_epoch = osdmap->get_epoch();
- }
+ return pg_shard_manager.get_local_map(
+ cur
+ ).then([this](OSDMapService::local_cached_map_t&& o) {
+ osdmap = make_local_shared_foreign(OSDMapService::local_cached_map_t(o));
+ return pg_shard_manager.update_map(std::move(o));
+ }).then([this] {
+ if (get_shard_services().get_up_epoch() == 0 &&
+ osdmap->is_up(whoami) &&
+ osdmap->get_addrs(whoami) == public_msgr->get_myaddrs()) {
+ return pg_shard_manager.set_up_epoch(
+ osdmap->get_epoch()
+ ).then([this] {
+ if (!boot_epoch) {
+ boot_epoch = osdmap->get_epoch();
+ }
+ });
+ } else {
+ return seastar::now();
}
});
}).then([m, this] {
{
beacon_timer.cancel();
tick_timer.cancel();
- pg_shard_manager.set_up_epoch(0);
- bind_epoch = osdmap->get_epoch();
- // TODO: promote to shutdown if being marked down for multiple times
- // rebind messengers
- return start_boot();
+ return pg_shard_manager.set_up_epoch(
+ 0
+ ).then([this] {
+ bind_epoch = osdmap->get_epoch();
+ // TODO: promote to shutdown if being marked down for multiple times
+ // rebind messengers
+ return start_boot();
+ });
}
seastar::future<> OSD::shutdown()
if (auto& e = get_event().get_event();
e.dynamic_type() == MQuery::static_type()) {
const auto map_epoch =
- shard_services.get_osdmap_service().get_map()->get_epoch();
+ shard_services.get_map()->get_epoch();
const auto& q = static_cast<const MQuery&>(e);
const pg_info_t empty{spg_t{pgid.pgid, q.query.to}};
if (q.query.type == q.query.LOG ||
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
-#include <boost/smart_ptr/local_shared_ptr.hpp>
#include <seastar/core/future.hh>
#include "include/types.h"
#include "common/Formatter.h"
#include "crimson/osd/pg.h"
#include "crimson/osd/pg_shard_manager.h"
+#include "crimson/osd/osdmap_service.h"
#include "crimson/osd/osd_operations/pg_advance_map.h"
#include "crimson/osd/osd_operation_external_tracking.h"
#include "osd/PeeringState.h"
seastar::future<> PGAdvanceMap::start()
{
- using cached_map_t = boost::local_shared_ptr<const OSDMap>;
+ using cached_map_t = OSDMapService::cached_map_t;
logger().debug("{}: start", *this);
boost::make_counting_iterator(*from + 1),
boost::make_counting_iterator(to + 1),
[this](epoch_t next_epoch) {
- return shard_manager.get_map(next_epoch).then(
+ return shard_manager.get_shard_services().get_map(next_epoch).then(
[this] (cached_map_t&& next_map) {
logger().debug("{}: advancing map to {}",
*this, next_map->get_epoch());
#pragma once
-#include <boost/smart_ptr/local_shared_ptr.hpp>
-
#include "include/types.h"
+#include "osd/OSDMap.h"
class OSDMap;
class OSDMapService {
public:
- using cached_map_t = boost::local_shared_ptr<const OSDMap>;
+ using cached_map_t = OSDMapRef;
+ using local_cached_map_t = LocalOSDMapRef;
+
virtual ~OSDMapService() = default;
virtual seastar::future<cached_map_t> get_map(epoch_t e) = 0;
/// get the latest map
#include <memory>
#include <optional>
#include <boost/smart_ptr/intrusive_ref_counter.hpp>
-#include <boost/smart_ptr/local_shared_ptr.hpp>
#include <seastar/core/future.hh>
#include <seastar/core/shared_future.hh>
DoutPrefixProvider
{
using ec_profile_t = std::map<std::string,std::string>;
- using cached_map_t = boost::local_shared_ptr<const OSDMap>;
+ using cached_map_t = OSDMapService::cached_map_t;
ClientRequest::PGPipeline client_request_pg_pipeline;
PGPeeringPipeline peering_request_pg_pipeline;
#include <map>
#include <memory>
#include <string>
-#include <boost/smart_ptr/local_shared_ptr.hpp>
#include <boost/container/flat_set.hpp>
#include "include/rados.h"
shard_services(osd_singleton_state, local_state)
{}
+seastar::future<> PGShardManager::set_up_epoch(epoch_t e) {
+ local_state.set_up_epoch(e);
+ return seastar::now();
+}
+
}
ShardServices shard_services;
public:
+ using cached_map_t = OSDMapService::cached_map_t;
+ using local_cached_map_t = OSDMapService::local_cached_map_t;
+
PGShardManager(
const int whoami,
crimson::net::Messenger &cluster_msgr,
auto &get_shard_services() { return shard_services; }
- void update_map(OSDMapService::cached_map_t map) {
- osd_singleton_state.update_map(map);
- local_state.update_map(map);
+ seastar::future<> update_map(local_cached_map_t &&map) {
+ auto fmap = make_local_shared_foreign(std::move(map));
+ osd_singleton_state.update_map(fmap);
+ local_state.update_map(std::move(fmap));
+ return seastar::now();
}
auto stop_registries() {
FORWARD_TO_OSD_SINGLETON(get_meta_coll)
// Core OSDMap methods
- FORWARD_TO_OSD_SINGLETON(get_map)
+ FORWARD_TO_OSD_SINGLETON(get_local_map)
FORWARD_TO_OSD_SINGLETON(load_map_bl)
FORWARD_TO_OSD_SINGLETON(load_map_bls)
FORWARD_TO_OSD_SINGLETON(store_maps)
- FORWARD_TO_OSD_SINGLETON(get_up_epoch)
- FORWARD_TO_OSD_SINGLETON(set_up_epoch)
+
+ seastar::future<> set_up_epoch(epoch_t e);
FORWARD(pg_created, pg_created, osd_singleton_state.pg_map)
auto load_pgs() {
}
}
-OSDSingletonState::cached_map_t OSDSingletonState::get_map() const
-{
- return osdmap;
-}
-
-seastar::future<OSDSingletonState::cached_map_t> OSDSingletonState::get_map(epoch_t e)
+seastar::future<OSDSingletonState::local_cached_map_t>
+OSDSingletonState::get_local_map(epoch_t e)
{
// TODO: use LRU cache for managing osdmap, fallback to disk if we have to
if (auto found = osdmaps.find(e); found) {
- return seastar::make_ready_future<cached_map_t>(std::move(found));
+ return seastar::make_ready_future<local_cached_map_t>(std::move(found));
} else {
return load_map(e).then([e, this](std::unique_ptr<OSDMap> osdmap) {
- return seastar::make_ready_future<cached_map_t>(
- osdmaps.insert(e, std::move(osdmap)));
+ return seastar::make_ready_future<local_cached_map_t>(
+ osdmaps.insert(e, std::move(osdmap)));
});
}
}
std::move(info),
[this, &shard_manager, &shard_services](auto &info)
-> seastar::future<Ref<PG>> {
- return get_map(info->epoch).then(
+ return shard_services.get_map(info->epoch).then(
[&info, &shard_services, this](OSDMapService::cached_map_t startmap)
-> seastar::future<std::tuple<Ref<PG>, OSDMapService::cached_map_t>> {
const spg_t &pgid = info->pgid;
if (info->by_mon) {
int64_t pool_id = pgid.pgid.pool();
- const pg_pool_t *pool = get_osdmap()->get_pg_pool(pool_id);
+ const pg_pool_t *pool = shard_services.get_map()->get_pg_pool(pool_id);
if (!pool) {
logger().debug(
"{} ignoring pgid {}, pool dne",
return seastar::do_with(PGMeta(store, pgid), [](auto& pg_meta) {
return pg_meta.get_epoch();
- }).then([this](epoch_t e) {
- return get_map(e);
+ }).then([&shard_services](epoch_t e) {
+ return shard_services.get_map(e);
}).then([pgid, this, &shard_services] (auto&& create_map) {
return make_pg(shard_services, std::move(create_map), pgid, false);
}).then([this](Ref<PG> pg) {
class PerShardState {
friend class ShardServices;
friend class PGShardManager;
+ using cached_map_t = OSDMapService::cached_map_t;
+ using local_cached_map_t = OSDMapService::local_cached_map_t;
const int whoami;
crimson::common::CephContext cct;
OSDOperationRegistry registry;
OperationThrottler throttler;
+ epoch_t up_epoch = 0;
OSDMapService::cached_map_t osdmap;
- OSDMapService::cached_map_t &get_osdmap() { return osdmap; }
+ const auto &get_osdmap() const { return osdmap; }
void update_map(OSDMapService::cached_map_t new_osdmap) {
osdmap = std::move(new_osdmap);
}
+ void set_up_epoch(epoch_t epoch) { up_epoch = epoch; }
crimson::osd::ObjectContextRegistry obc_registry;
* OSD-wide singleton holding instances that need to be accessible
* from all PGs.
*/
-class OSDSingletonState : public md_config_obs_t, public OSDMapService {
+class OSDSingletonState : public md_config_obs_t {
friend class ShardServices;
friend class PGShardManager;
+ using cached_map_t = OSDMapService::cached_map_t;
+ using local_cached_map_t = OSDMapService::local_cached_map_t;
+
+public:
OSDSingletonState(
int whoami,
crimson::net::Messenger &cluster_msgr,
OSDState osd_state;
+ SharedLRU<epoch_t, OSDMap> osdmaps;
+ SimpleLRU<epoch_t, bufferlist, false> map_bl_cache;
+
cached_map_t osdmap;
cached_map_t &get_osdmap() { return osdmap; }
void update_map(cached_map_t new_osdmap) {
const ConfigProxy& conf,
const std::set <std::string> &changed) final;
- // OSDMapService
- epoch_t up_epoch = 0;
- epoch_t get_up_epoch() const final {
- return up_epoch;
- }
- void set_up_epoch(epoch_t e) {
- up_epoch = e;
- }
-
- SharedLRU<epoch_t, OSDMap> osdmaps;
- SimpleLRU<epoch_t, bufferlist, false> map_bl_cache;
-
- seastar::future<cached_map_t> get_map(epoch_t e) final;
- cached_map_t get_map() const final;
+ seastar::future<local_cached_map_t> get_local_map(epoch_t e);
seastar::future<std::unique_ptr<OSDMap>> load_map(epoch_t e);
seastar::future<bufferlist> load_map_bl(epoch_t e);
seastar::future<std::map<epoch_t, bufferlist>>
/**
* Represents services available to each PG
*/
-class ShardServices {
- using cached_map_t = boost::local_shared_ptr<const OSDMap>;
+class ShardServices : public OSDMapService {
+ using cached_map_t = OSDMapService::cached_map_t;
+ using local_cached_map_t = OSDMapService::local_cached_map_t;
OSDSingletonState &osd_singleton_state;
PerShardState &local_state;
+
+ template <typename F, typename... Args>
+ auto with_singleton(F &&f, Args&&... args) {
+ return std::invoke(f, osd_singleton_state, std::forward<Args>(args)...);
+ }
public:
ShardServices(
OSDSingletonState &osd_singleton_state,
return &(local_state.cct);
}
- // OSDMapService
- const OSDMapService &get_osdmap_service() const {
- return osd_singleton_state;
- }
-
template <typename T, typename... Args>
auto start_operation(Args&&... args) {
return local_state.start_operation<T>(std::forward<Args>(args)...);
return dispatch_context({}, std::move(ctx));
}
- FORWARD_TO_LOCAL(get_osdmap)
+ // OSDMapService
+ cached_map_t get_map() const final { return local_state.get_osdmap(); }
+ epoch_t get_up_epoch() const final { return local_state.up_epoch; }
+ seastar::future<cached_map_t> get_map(epoch_t e) final {
+ return with_singleton(
+ [](auto &sstate, epoch_t e) {
+ return sstate.get_local_map(
+ e
+ ).then([](auto lmap) {
+ return seastar::foreign_ptr<local_cached_map_t>(lmap);
+ });
+ }, e).then([](auto fmap) {
+ return make_local_shared_foreign(std::move(fmap));
+ });
+ }
+
FORWARD_TO_OSD_SINGLETON(get_pg_num)
FORWARD(with_throttle_while, with_throttle_while, local_state.throttler)
WRITE_CLASS_ENCODER_FEATURES(OSDMap::Incremental)
#ifdef WITH_SEASTAR
-using OSDMapRef = boost::local_shared_ptr<const OSDMap>;
+#include "crimson/common/local_shared_foreign_ptr.h"
+using LocalOSDMapRef = boost::local_shared_ptr<const OSDMap>;
+using OSDMapRef = crimson::local_shared_foreign_ptr<LocalOSDMapRef>;
#else
using OSDMapRef = std::shared_ptr<const OSDMap>;
#endif
projects / ceph.git / commitdiff