ceph/src/crimson/osd/osdmap_gate.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "crimson/common/exception.h"
   5 #include "crimson/osd/osdmap_gate.h"
   6 #include "crimson/osd/shard_services.h"
   7 #include "common/Formatter.h"
   8
   9 namespace {
  10   seastar::logger& logger() {
  11     return crimson::get_logger(ceph_subsys_osd);
  12   }
  13 }
  14
  15 namespace crimson::osd {
  16
  17 template <OSDMapGateType OSDMapGateTypeV>
  18 void OSDMapGate<OSDMapGateTypeV>::OSDMapBlocker::dump_detail(Formatter *f) const
  19 {
  20   f->open_object_section("OSDMapGate");
  21   f->dump_int("epoch", epoch);
  22   f->close_section();
  23 }
  24
  25 template <OSDMapGateType OSDMapGateTypeV>
  26 seastar::future<epoch_t> OSDMapGate<OSDMapGateTypeV>::wait_for_map(
  27   typename OSDMapBlocker::BlockingEvent::TriggerI&& trigger,
  28   epoch_t epoch,
  29   ShardServices *shard_services)
  30 {
  31   if (__builtin_expect(stopping, false)) {
  32     return seastar::make_exception_future<epoch_t>(
  33         crimson::common::system_shutdown_exception());
  34   }
  35   if (current >= epoch) {
  36     return seastar::make_ready_future<epoch_t>(current);
  37   } else {
  38     logger().info("evt epoch is {}, i have {}, will wait", epoch, current);
  39     auto &blocker = waiting_peering.emplace(
  40       epoch, std::make_pair(blocker_type, epoch)).first->second;
  41     auto fut = blocker.promise.get_shared_future();
  42     if (shard_services) {
  43       return trigger.maybe_record_blocking(
  44         shard_services->osdmap_subscribe(current, true).then(
  45           [fut=std::move(fut)]() mutable {
  46             return std::move(fut);
  47           }),
  48         blocker);
  49     } else {
  50       return trigger.maybe_record_blocking(std::move(fut), blocker);
  51     }
  52   }
  53 }
  54
  55 template <OSDMapGateType OSDMapGateTypeV>
  56 void OSDMapGate<OSDMapGateTypeV>::got_map(epoch_t epoch) {
  57   current = epoch;
  58   auto first = waiting_peering.begin();
  59   auto last = waiting_peering.upper_bound(epoch);
  60   std::for_each(first, last, [epoch](auto& blocked_requests) {
  61     blocked_requests.second.promise.set_value(epoch);
  62   });
  63   waiting_peering.erase(first, last);
  64 }
  65
  66 template <OSDMapGateType OSDMapGateTypeV>
  67 seastar::future<> OSDMapGate<OSDMapGateTypeV>::stop() {
  68   logger().info("osdmap::stop");
  69   stopping = true;
  70   auto first = waiting_peering.begin();
  71   auto last = waiting_peering.end();
  72   std::for_each(first, last, [](auto& blocked_requests) {
  73     blocked_requests.second.promise.set_exception(
  74         crimson::common::system_shutdown_exception());
  75   });
  76   return seastar::now();
  77 }
  78
  79 template class OSDMapGate<OSDMapGateType::PG>;
  80 template class OSDMapGate<OSDMapGateType::OSD>;
  81
  82 } // namespace crimson::osd