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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#pragma once
#include <iostream>
#include <seastar/core/future.hh>
#include "crimson/osd/object_context_loader.h"
#include "crimson/osd/osdmap_gate.h"
#include "crimson/osd/osd_operation.h"
#include "crimson/common/subop_blocker.h"
#include "crimson/osd/pg.h"
#include "crimson/osd/pg_activation_blocker.h"
#include "osd/osd_types.h"
#include "osd/PGPeeringEvent.h"
#include "osd/PeeringState.h"
namespace ceph {
class Formatter;
}
class SnapMapper;
namespace crimson::osd {
class OSD;
class ShardServices;
// trim up to `max` objects for snapshot `snapid
class SnapTrimEvent final : public PhasedOperationT<SnapTrimEvent> {
public:
using remove_or_update_ertr =
crimson::errorator<crimson::ct_error::enoent>;
using remove_or_update_iertr =
crimson::interruptible::interruptible_errorator<
IOInterruptCondition, remove_or_update_ertr>;
using snap_trim_iertr = remove_or_update_iertr;
using snap_trim_event_ret_t =
snap_trim_iertr::future<seastar::stop_iteration>;
using snap_trim_obj_subevent_ret_t =
remove_or_update_iertr::future<>;
static constexpr OperationTypeCode type = OperationTypeCode::snaptrim_event;
SnapTrimEvent(Ref<PG> pg,
SnapMapper& snap_mapper,
const snapid_t snapid,
const bool needs_pause)
: pg(std::move(pg)),
snap_mapper(snap_mapper),
snapid(snapid),
needs_pause(needs_pause) {}
void print(std::ostream &) const final;
void dump_detail(ceph::Formatter* f) const final;
snap_trim_event_ret_t start();
private:
CommonPGPipeline& client_pp();
SubOpBlocker<snap_trim_obj_subevent_ret_t> subop_blocker;
Ref<PG> pg;
PipelineHandle handle;
SnapMapper& snap_mapper;
const snapid_t snapid;
const bool needs_pause;
public:
PipelineHandle& get_handle() { return handle; }
std::tuple<
StartEvent,
PG::BackgroundProcessLock::Wait::BlockingEvent,
CompletionEvent
> tracking_events;
friend class PG::BackgroundProcessLock;
};
// remove single object. a SnapTrimEvent can create multiple subrequests.
// the division of labour is needed because of the restriction that an Op
// cannot revisite a pipeline's stage it already saw.
class SnapTrimObjSubEvent : public PhasedOperationT<SnapTrimObjSubEvent> {
public:
using remove_or_update_ertr =
crimson::errorator<crimson::ct_error::enoent>;
using remove_or_update_iertr =
crimson::interruptible::interruptible_errorator<
IOInterruptCondition, remove_or_update_ertr>;
using snap_trim_obj_subevent_ret_t =
remove_or_update_iertr::future<>;
static constexpr OperationTypeCode type =
OperationTypeCode::snaptrimobj_subevent;
SnapTrimObjSubEvent(
Ref<PG> pg,
const hobject_t& coid,
snapid_t snap_to_trim)
: pg(std::move(pg)),
coid(coid),
snap_to_trim(snap_to_trim) {
}
void print(std::ostream &) const final;
void dump_detail(ceph::Formatter* f) const final;
snap_trim_obj_subevent_ret_t start();
CommonPGPipeline& client_pp();
private:
object_stat_sum_t delta_stats;
snap_trim_obj_subevent_ret_t remove_clone(
ObjectContextRef obc,
ObjectContextRef head_obc,
ceph::os::Transaction& txn);
void remove_head_whiteout(
ObjectContextRef obc,
ObjectContextRef head_obc,
ceph::os::Transaction& txn);
interruptible_future<> adjust_snaps(
ObjectContextRef obc,
ObjectContextRef head_obc,
const std::set<snapid_t>& new_snaps,
ceph::os::Transaction& txn);
void update_head(
ObjectContextRef obc,
ObjectContextRef head_obc,
ceph::os::Transaction& txn);
remove_or_update_iertr::future<ceph::os::Transaction>
remove_or_update(ObjectContextRef obc, ObjectContextRef head_obc);
pg_log_entry_t& add_log_entry(
int _op,
const hobject_t& _soid,
const eversion_t& pv,
version_t uv,
const osd_reqid_t& rid,
const utime_t& mt,
int return_code) {
log_entries.emplace_back(
_op,
_soid,
osd_op_p.at_version,
pv,
uv,
rid,
mt,
return_code);
return log_entries.back();
}
Ref<PG> pg;
std::optional<ObjectContextLoader::Orderer> obc_orderer;
PipelineHandle handle;
osd_op_params_t osd_op_p;
const hobject_t coid;
const snapid_t snap_to_trim;
std::vector<pg_log_entry_t> log_entries;
public:
PipelineHandle& get_handle() { return handle; }
std::tuple<
StartEvent,
CommonOBCPipeline::Process::BlockingEvent,
CommonOBCPipeline::WaitRepop::BlockingEvent,
CompletionEvent
> tracking_events;
};
} // namespace crimson::osd
#if FMT_VERSION >= 90000
template <> struct fmt::formatter<crimson::osd::SnapTrimEvent> : fmt::ostream_formatter {};
template <> struct fmt::formatter<crimson::osd::SnapTrimObjSubEvent> : fmt::ostream_formatter {};
#endif
|
