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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#pragma once
#include <iostream>
#include <boost/intrusive_ptr.hpp>
#include <boost/smart_ptr/intrusive_ref_counter.hpp>
#include <seastar/core/future.hh>
#include "include/ceph_assert.h"
#include "include/buffer_fwd.h"
#include "include/interval_set.h"
#include "common/interval_map.h"
#include "crimson/osd/exceptions.h"
#include "crimson/os/seastore/cache.h"
#include "crimson/os/seastore/seastore_types.h"
#include "crimson/os/seastore/segment_manager.h"
namespace crimson::os::seastore {
/**
* Abstract interface for managing the logical to physical mapping
*/
class LBAManager {
public:
using mkfs_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using mkfs_ret = mkfs_ertr::future<>;
virtual mkfs_ret mkfs(
Transaction &t
) = 0;
/**
* Fetches mappings for laddr_t in range [offset, offset + len)
*
* Future will not resolve until all pins have resolved (set_paddr called)
*/
using get_mapping_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using get_mapping_ret = get_mapping_ertr::future<lba_pin_list_t>;
virtual get_mapping_ret get_mapping(
Transaction &t,
laddr_t offset, extent_len_t length) = 0;
/**
* Fetches mappings for laddr_t in range [offset, offset + len)
*
* Future will not result until all pins have resolved (set_paddr called)
*/
using get_mappings_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using get_mappings_ret = get_mapping_ertr::future<lba_pin_list_t>;
virtual get_mappings_ret get_mappings(
Transaction &t,
laddr_list_t &&extent_lisk) = 0;
/**
* Allocates a new mapping referenced by LBARef
*
* Offset will be relative to the block offset of the record
* This mapping will block from transaction submission until set_paddr
* is called on the LBAPin.
*/
using alloc_extent_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using alloc_extent_ret = alloc_extent_ertr::future<LBAPinRef>;
virtual alloc_extent_ret alloc_extent(
Transaction &t,
laddr_t hint,
extent_len_t len,
paddr_t addr) = 0;
/**
* Creates a new absolute mapping.
*
* off~len must be unreferenced
*/
using set_extent_ertr = crimson::errorator<
crimson::ct_error::input_output_error,
crimson::ct_error::invarg>;
using set_extent_ret = set_extent_ertr::future<LBAPinRef>;
virtual set_extent_ret set_extent(
Transaction &t,
laddr_t off, extent_len_t len, paddr_t addr) = 0;
struct ref_update_result_t {
unsigned refcount = 0;
paddr_t addr;
};
using ref_ertr = crimson::errorator<
crimson::ct_error::enoent,
crimson::ct_error::input_output_error>;
using ref_ret = ref_ertr::future<ref_update_result_t>;
/**
* Decrements ref count on extent
*
* @return returns resulting refcount
*/
virtual ref_ret decref_extent(
Transaction &t,
laddr_t addr) = 0;
/**
* Increments ref count on extent
*
* @return returns resulting refcount
*/
virtual ref_ret incref_extent(
Transaction &t,
laddr_t addr) = 0;
using complete_transaction_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using complete_transaction_ret = complete_transaction_ertr::future<>;
virtual complete_transaction_ret complete_transaction(
Transaction &t) = 0;
/**
* Should be called after replay on each cached extent.
* Implementation must initialize the LBAPin on any
* LogicalCachedExtent's and may also read in any dependent
* structures, etc.
*/
using init_cached_extent_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using init_cached_extent_ret = init_cached_extent_ertr::future<>;
virtual init_cached_extent_ret init_cached_extent(
Transaction &t,
CachedExtentRef e) = 0;
/**
* Calls f for each mapping in [begin, end)
*/
using scan_mappings_ertr = SegmentManager::read_ertr;
using scan_mappings_ret = scan_mappings_ertr::future<>;
using scan_mappings_func_t = std::function<
void(laddr_t, paddr_t, extent_len_t)>;
virtual scan_mappings_ret scan_mappings(
Transaction &t,
laddr_t begin,
laddr_t end,
scan_mappings_func_t &&f) = 0;
/**
* Calls f for each mapped space usage in [begin, end)
*/
using scan_mapped_space_ertr = SegmentManager::read_ertr;
using scan_mapped_space_ret = scan_mapped_space_ertr::future<>;
using scan_mapped_space_func_t = std::function<
void(paddr_t, extent_len_t)>;
virtual scan_mapped_space_ret scan_mapped_space(
Transaction &t,
scan_mapped_space_func_t &&f) = 0;
/**
* rewrite_extent
*
* rewrite extent into passed transaction
*/
using rewrite_extent_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using rewrite_extent_ret = rewrite_extent_ertr::future<>;
virtual rewrite_extent_ret rewrite_extent(
Transaction &t,
CachedExtentRef extent) = 0;
/**
* get_physical_extent_if_live
*
* Returns extent at addr/laddr if still live (if laddr
* still points at addr). Extent must be an internal, physical
* extent.
*
* Returns a null CachedExtentRef if extent is not live.
*/
using get_physical_extent_if_live_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using get_physical_extent_if_live_ret =
get_physical_extent_if_live_ertr::future<CachedExtentRef>;
virtual get_physical_extent_if_live_ret get_physical_extent_if_live(
Transaction &t,
extent_types_t type,
paddr_t addr,
laddr_t laddr,
segment_off_t len) = 0;
virtual void add_pin(LBAPin &pin) = 0;
virtual ~LBAManager() {}
};
using LBAManagerRef = std::unique_ptr<LBAManager>;
class Cache;
namespace lba_manager {
LBAManagerRef create_lba_manager(
SegmentManager &segment_manager,
Cache &cache);
}
}
|
