1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <seastar/core/future.hh>
#include "messages/MOSDOp.h"
#include "crimson/osd/pg.h"
#include "crimson/osd/shard_services.h"
#include "common/Formatter.h"
#include "crimson/osd/osd_operations/background_recovery.h"
namespace {
seastar::logger& logger() {
return crimson::get_logger(ceph_subsys_osd);
}
}
namespace crimson::osd {
BackgroundRecovery::BackgroundRecovery(
Ref<PG> pg,
ShardServices &ss,
epoch_t epoch_started,
crimson::osd::scheduler::scheduler_class_t scheduler_class)
: pg(pg),
epoch_started(epoch_started),
ss(ss),
scheduler_class(scheduler_class)
{}
void BackgroundRecovery::print(std::ostream &lhs) const
{
lhs << "BackgroundRecovery(" << pg->get_pgid() << ")";
}
void BackgroundRecovery::dump_detail(Formatter *f) const
{
f->dump_stream("pgid") << pg->get_pgid();
f->open_object_section("recovery_detail");
{
// TODO pg->dump_recovery_state(f);
}
f->close_section();
}
seastar::future<> BackgroundRecovery::start()
{
logger().debug("{}: start", *this);
IRef ref = this;
return ss.throttler.with_throttle_while(
this, get_scheduler_params(), [this] {
return do_recovery();
}).handle_exception_type([ref, this](const std::system_error& err) {
if (err.code() == std::make_error_code(std::errc::interrupted)) {
logger().debug("{} recovery interruped: {}", *pg, err.what());
return seastar::now();
}
return seastar::make_exception_future<>(err);
});
}
seastar::future<bool> UrgentRecovery::do_recovery()
{
if (!pg->has_reset_since(epoch_started)) {
return with_blocking_future(
pg->get_recovery_handler()->recover_missing(soid, need)
).then([] {
return seastar::make_ready_future<bool>(false);
});
}
return seastar::make_ready_future<bool>(false);
}
void UrgentRecovery::print(std::ostream &lhs) const
{
lhs << "UrgentRecovery(" << pg->get_pgid() << ", "
<< soid << ", v" << need << ")";
}
void UrgentRecovery::dump_detail(Formatter *f) const
{
f->dump_stream("pgid") << pg->get_pgid();
f->open_object_section("recovery_detail");
{
f->dump_stream("oid") << soid;
f->dump_stream("version") << need;
}
f->close_section();
}
PglogBasedRecovery::PglogBasedRecovery(
Ref<PG> pg,
ShardServices &ss,
const epoch_t epoch_started)
: BackgroundRecovery(
std::move(pg),
ss,
epoch_started,
crimson::osd::scheduler::scheduler_class_t::background_recovery)
{}
seastar::future<bool> PglogBasedRecovery::do_recovery()
{
if (pg->has_reset_since(epoch_started))
return seastar::make_ready_future<bool>(false);
return with_blocking_future(
pg->get_recovery_handler()->start_recovery_ops(
crimson::common::local_conf()->osd_recovery_max_single_start));
}
BackfillRecovery::BackfillRecoveryPipeline &BackfillRecovery::bp(PG &pg)
{
return pg.backfill_pipeline;
}
seastar::future<bool> BackfillRecovery::do_recovery()
{
logger().debug("{}", __func__);
if (pg->has_reset_since(epoch_started)) {
logger().debug("{}: pg got reset since epoch_started={}",
__func__, epoch_started);
return seastar::make_ready_future<bool>(false);
}
// TODO: limits
return with_blocking_future(
// process_event() of our boost::statechart machine is non-reentrant.
// with the backfill_pipeline we protect it from a second entry from
// the implementation of BackfillListener.
// additionally, this stage serves to synchronize with PeeringEvent.
handle.enter(bp(*pg).process)
).then([this] {
pg->get_recovery_handler()->dispatch_backfill_event(std::move(evt));
return seastar::make_ready_future<bool>(false);
});
}
} // namespace crimson::osd
|
