blob: e189d1d32da03dfb550358d8d1b532ebf13835d2 (
plain)
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
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#pragma once
#include <iostream>
#include "crimson/os/seastore/seastore_types.h"
#include "crimson/os/seastore/cached_extent.h"
#include "crimson/os/seastore/root_block.h"
namespace crimson::os::seastore {
/**
* Transaction
*
* Representation of in-progress mutation. Used exclusively through Cache methods.
*/
class Transaction {
public:
using Ref = std::unique_ptr<Transaction>;
enum class get_extent_ret {
PRESENT,
ABSENT,
RETIRED
};
get_extent_ret get_extent(paddr_t addr, CachedExtentRef *out) {
if (retired_set.count(addr)) {
return get_extent_ret::RETIRED;
} else if (auto iter = write_set.find_offset(addr);
iter != write_set.end()) {
if (out)
*out = CachedExtentRef(&*iter);
return get_extent_ret::PRESENT;
} else if (
auto iter = read_set.find(addr);
iter != read_set.end()) {
if (out)
*out = CachedExtentRef(*iter);
return get_extent_ret::PRESENT;
} else {
return get_extent_ret::ABSENT;
}
}
void add_to_retired_set(CachedExtentRef ref) {
ceph_assert(!is_weak());
if (!ref->is_initial_pending()) {
// && retired_set.count(ref->get_paddr()) == 0
// If it's already in the set, insert here will be a noop,
// which is what we want.
retired_set.insert(ref);
} else {
ref->state = CachedExtent::extent_state_t::INVALID;
}
if (ref->is_pending()) {
write_set.erase(*ref);
}
}
void add_to_read_set(CachedExtentRef ref) {
if (is_weak()) return;
ceph_assert(read_set.count(ref) == 0);
read_set.insert(ref);
}
void add_fresh_extent(CachedExtentRef ref) {
ceph_assert(!is_weak());
fresh_block_list.push_back(ref);
ref->set_paddr(make_record_relative_paddr(offset));
offset += ref->get_length();
write_set.insert(*ref);
}
void add_mutated_extent(CachedExtentRef ref) {
ceph_assert(!is_weak());
mutated_block_list.push_back(ref);
write_set.insert(*ref);
}
void mark_segment_to_release(segment_id_t segment) {
assert(to_release == NULL_SEG_ID);
to_release = segment;
}
segment_id_t get_segment_to_release() const {
return to_release;
}
const auto &get_fresh_block_list() {
return fresh_block_list;
}
const auto &get_mutated_block_list() {
return mutated_block_list;
}
const auto &get_retired_set() {
return retired_set;
}
bool is_weak() const {
return weak;
}
private:
friend class Cache;
friend Ref make_transaction();
friend Ref make_weak_transaction();
/**
* If set, *this may not be used to perform writes and will not provide
* consistentency allowing operations using to avoid maintaining a read_set.
*/
const bool weak;
RootBlockRef root; ///< ref to root if read or written by transaction
segment_off_t offset = 0; ///< relative offset of next block
pextent_set_t read_set; ///< set of extents read by paddr
ExtentIndex write_set; ///< set of extents written by paddr
std::list<CachedExtentRef> fresh_block_list; ///< list of fresh blocks
std::list<CachedExtentRef> mutated_block_list; ///< list of mutated blocks
pextent_set_t retired_set; ///< list of extents mutated by this transaction
///< if != NULL_SEG_ID, release this segment after completion
segment_id_t to_release = NULL_SEG_ID;
Transaction(bool weak) : weak(weak) {}
};
using TransactionRef = Transaction::Ref;
inline TransactionRef make_transaction() {
return std::unique_ptr<Transaction>(new Transaction(false));
}
inline TransactionRef make_weak_transaction() {
return std::unique_ptr<Transaction>(new Transaction(true));
}
}
|
