]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | /* | |
4 | * Ceph - scalable distributed file system | |
5 | * | |
6 | * Copyright (C) 2014 Adam Crume <adamcrume@gmail.com> | |
7 | * | |
8 | * This is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU Lesser General Public | |
10 | * License version 2.1, as published by the Free Software | |
11 | * Foundation. See file COPYING. | |
12 | * | |
13 | */ | |
14 | ||
15 | #ifndef _INCLUDED_RBD_REPLAY_IOS_HPP | |
16 | #define _INCLUDED_RBD_REPLAY_IOS_HPP | |
17 | ||
18 | // This code assumes that IO IDs and timestamps are related monotonically. | |
19 | // In other words, (a.id < b.id) == (a.timestamp < b.timestamp) for all IOs a and b. | |
20 | ||
21 | #include "include/buffer_fwd.h" | |
22 | #include <boost/enable_shared_from_this.hpp> | |
23 | #include <boost/shared_ptr.hpp> | |
24 | #include <iostream> | |
25 | #include <map> | |
26 | #include <set> | |
27 | #include <vector> | |
28 | #include "actions.hpp" | |
29 | ||
30 | ||
31 | namespace rbd_replay { | |
32 | ||
33 | class IO; | |
34 | ||
35 | typedef std::set<boost::shared_ptr<IO> > io_set_t; | |
36 | ||
37 | typedef std::map<action_id_t, boost::shared_ptr<IO> > io_map_t; | |
38 | ||
39 | /** | |
40 | Used by rbd-replay-prep for processing the raw trace. | |
41 | Corresponds to the Action class, except that Actions are executed by rbd-replay, | |
42 | and IOs are used by rbd-replay-prep for processing the raw trace. | |
43 | */ | |
44 | class IO : public boost::enable_shared_from_this<IO> { | |
45 | public: | |
46 | typedef boost::shared_ptr<IO> ptr; | |
47 | typedef std::vector<ptr> ptrs; | |
48 | ||
49 | /** | |
50 | @param ionum ID of this %IO | |
51 | @param start_time time the %IO started, in nanoseconds | |
52 | @param thread_id ID of the thread that issued the %IO | |
53 | */ | |
54 | IO(action_id_t ionum, | |
55 | uint64_t start_time, | |
56 | thread_id_t thread_id, | |
57 | const io_set_t& deps) | |
58 | : m_ionum(ionum), | |
59 | m_start_time(start_time), | |
60 | m_dependencies(deps), | |
61 | m_thread_id(thread_id), | |
62 | m_completed(false) { | |
63 | } | |
64 | ||
65 | virtual ~IO() { | |
66 | } | |
67 | ||
68 | uint64_t start_time() const { | |
69 | return m_start_time; | |
70 | } | |
71 | ||
72 | io_set_t& dependencies() { | |
73 | return m_dependencies; | |
74 | } | |
75 | ||
76 | const io_set_t& dependencies() const { | |
77 | return m_dependencies; | |
78 | } | |
79 | ||
80 | virtual void encode(bufferlist &bl) const = 0; | |
81 | ||
82 | void set_ionum(action_id_t ionum) { | |
83 | m_ionum = ionum; | |
84 | } | |
85 | ||
86 | action_id_t ionum() const { | |
87 | return m_ionum; | |
88 | } | |
89 | ||
90 | thread_id_t thread_id() const { | |
91 | return m_thread_id; | |
92 | } | |
93 | ||
94 | virtual void write_debug(std::ostream& out) const = 0; | |
95 | ||
96 | protected: | |
97 | void write_debug_base(std::ostream& out, std::string iotype) const; | |
98 | ||
99 | private: | |
100 | action_id_t m_ionum; | |
101 | uint64_t m_start_time; | |
102 | io_set_t m_dependencies; | |
103 | thread_id_t m_thread_id; | |
104 | bool m_completed; | |
105 | }; | |
106 | ||
107 | /// Used for dumping debug info. | |
108 | /// @related IO | |
109 | std::ostream& operator<<(std::ostream &out, const IO::ptr &io); | |
110 | ||
111 | ||
112 | class StartThreadIO : public IO { | |
113 | public: | |
114 | StartThreadIO(action_id_t ionum, | |
115 | uint64_t start_time, | |
116 | thread_id_t thread_id) | |
117 | : IO(ionum, start_time, thread_id, io_set_t()) { | |
118 | } | |
119 | ||
120 | void encode(bufferlist &bl) const override; | |
121 | ||
122 | void write_debug(std::ostream& out) const override; | |
123 | }; | |
124 | ||
125 | class StopThreadIO : public IO { | |
126 | public: | |
127 | StopThreadIO(action_id_t ionum, | |
128 | uint64_t start_time, | |
129 | thread_id_t thread_id, | |
130 | const io_set_t& deps) | |
131 | : IO(ionum, start_time, thread_id, deps) { | |
132 | } | |
133 | ||
134 | void encode(bufferlist &bl) const override; | |
135 | ||
136 | void write_debug(std::ostream& out) const override; | |
137 | }; | |
138 | ||
139 | class ReadIO : public IO { | |
140 | public: | |
141 | ReadIO(action_id_t ionum, | |
142 | uint64_t start_time, | |
143 | thread_id_t thread_id, | |
144 | const io_set_t& deps, | |
145 | imagectx_id_t imagectx, | |
146 | uint64_t offset, | |
147 | uint64_t length) | |
148 | : IO(ionum, start_time, thread_id, deps), | |
149 | m_imagectx(imagectx), | |
150 | m_offset(offset), | |
151 | m_length(length) { | |
152 | } | |
153 | ||
154 | void encode(bufferlist &bl) const override; | |
155 | ||
156 | void write_debug(std::ostream& out) const override; | |
157 | ||
158 | private: | |
159 | imagectx_id_t m_imagectx; | |
160 | uint64_t m_offset; | |
161 | uint64_t m_length; | |
162 | }; | |
163 | ||
164 | class WriteIO : public IO { | |
165 | public: | |
166 | WriteIO(action_id_t ionum, | |
167 | uint64_t start_time, | |
168 | thread_id_t thread_id, | |
169 | const io_set_t& deps, | |
170 | imagectx_id_t imagectx, | |
171 | uint64_t offset, | |
172 | uint64_t length) | |
173 | : IO(ionum, start_time, thread_id, deps), | |
174 | m_imagectx(imagectx), | |
175 | m_offset(offset), | |
176 | m_length(length) { | |
177 | } | |
178 | ||
179 | void encode(bufferlist &bl) const override; | |
180 | ||
181 | void write_debug(std::ostream& out) const override; | |
182 | ||
183 | private: | |
184 | imagectx_id_t m_imagectx; | |
185 | uint64_t m_offset; | |
186 | uint64_t m_length; | |
187 | }; | |
188 | ||
189 | class DiscardIO : public IO { | |
190 | public: | |
191 | DiscardIO(action_id_t ionum, | |
192 | uint64_t start_time, | |
193 | thread_id_t thread_id, | |
194 | const io_set_t& deps, | |
195 | imagectx_id_t imagectx, | |
196 | uint64_t offset, | |
197 | uint64_t length) | |
198 | : IO(ionum, start_time, thread_id, deps), | |
199 | m_imagectx(imagectx), | |
200 | m_offset(offset), | |
201 | m_length(length) { | |
202 | } | |
203 | ||
204 | void encode(bufferlist &bl) const override; | |
205 | ||
206 | void write_debug(std::ostream& out) const override; | |
207 | ||
208 | private: | |
209 | imagectx_id_t m_imagectx; | |
210 | uint64_t m_offset; | |
211 | uint64_t m_length; | |
212 | }; | |
213 | ||
214 | class AioReadIO : public IO { | |
215 | public: | |
216 | AioReadIO(action_id_t ionum, | |
217 | uint64_t start_time, | |
218 | thread_id_t thread_id, | |
219 | const io_set_t& deps, | |
220 | imagectx_id_t imagectx, | |
221 | uint64_t offset, | |
222 | uint64_t length) | |
223 | : IO(ionum, start_time, thread_id, deps), | |
224 | m_imagectx(imagectx), | |
225 | m_offset(offset), | |
226 | m_length(length) { | |
227 | } | |
228 | ||
229 | void encode(bufferlist &bl) const override; | |
230 | ||
231 | void write_debug(std::ostream& out) const override; | |
232 | ||
233 | private: | |
234 | imagectx_id_t m_imagectx; | |
235 | uint64_t m_offset; | |
236 | uint64_t m_length; | |
237 | }; | |
238 | ||
239 | class AioWriteIO : public IO { | |
240 | public: | |
241 | AioWriteIO(action_id_t ionum, | |
242 | uint64_t start_time, | |
243 | thread_id_t thread_id, | |
244 | const io_set_t& deps, | |
245 | imagectx_id_t imagectx, | |
246 | uint64_t offset, | |
247 | uint64_t length) | |
248 | : IO(ionum, start_time, thread_id, deps), | |
249 | m_imagectx(imagectx), | |
250 | m_offset(offset), | |
251 | m_length(length) { | |
252 | } | |
253 | ||
254 | void encode(bufferlist &bl) const override; | |
255 | ||
256 | void write_debug(std::ostream& out) const override; | |
257 | ||
258 | private: | |
259 | imagectx_id_t m_imagectx; | |
260 | uint64_t m_offset; | |
261 | uint64_t m_length; | |
262 | }; | |
263 | ||
264 | class AioDiscardIO : public IO { | |
265 | public: | |
266 | AioDiscardIO(action_id_t ionum, | |
267 | uint64_t start_time, | |
268 | thread_id_t thread_id, | |
269 | const io_set_t& deps, | |
270 | imagectx_id_t imagectx, | |
271 | uint64_t offset, | |
272 | uint64_t length) | |
273 | : IO(ionum, start_time, thread_id, deps), | |
274 | m_imagectx(imagectx), | |
275 | m_offset(offset), | |
276 | m_length(length) { | |
277 | } | |
278 | ||
279 | void encode(bufferlist &bl) const override; | |
280 | ||
281 | void write_debug(std::ostream& out) const override; | |
282 | ||
283 | private: | |
284 | imagectx_id_t m_imagectx; | |
285 | uint64_t m_offset; | |
286 | uint64_t m_length; | |
287 | }; | |
288 | ||
289 | class OpenImageIO : public IO { | |
290 | public: | |
291 | OpenImageIO(action_id_t ionum, | |
292 | uint64_t start_time, | |
293 | thread_id_t thread_id, | |
294 | const io_set_t& deps, | |
295 | imagectx_id_t imagectx, | |
296 | const std::string& name, | |
297 | const std::string& snap_name, | |
298 | bool readonly) | |
299 | : IO(ionum, start_time, thread_id, deps), | |
300 | m_imagectx(imagectx), | |
301 | m_name(name), | |
302 | m_snap_name(snap_name), | |
303 | m_readonly(readonly) { | |
304 | } | |
305 | ||
306 | void encode(bufferlist &bl) const override; | |
307 | ||
308 | imagectx_id_t imagectx() const { | |
309 | return m_imagectx; | |
310 | } | |
311 | ||
312 | void write_debug(std::ostream& out) const override; | |
313 | ||
314 | private: | |
315 | imagectx_id_t m_imagectx; | |
316 | std::string m_name; | |
317 | std::string m_snap_name; | |
318 | bool m_readonly; | |
319 | }; | |
320 | ||
321 | class CloseImageIO : public IO { | |
322 | public: | |
323 | CloseImageIO(action_id_t ionum, | |
324 | uint64_t start_time, | |
325 | thread_id_t thread_id, | |
326 | const io_set_t& deps, | |
327 | imagectx_id_t imagectx) | |
328 | : IO(ionum, start_time, thread_id, deps), | |
329 | m_imagectx(imagectx) { | |
330 | } | |
331 | ||
332 | void encode(bufferlist &bl) const override; | |
333 | ||
334 | imagectx_id_t imagectx() const { | |
335 | return m_imagectx; | |
336 | } | |
337 | ||
338 | void write_debug(std::ostream& out) const override; | |
339 | ||
340 | private: | |
341 | imagectx_id_t m_imagectx; | |
342 | }; | |
343 | ||
344 | class AioOpenImageIO : public IO { | |
345 | public: | |
346 | AioOpenImageIO(action_id_t ionum, | |
347 | uint64_t start_time, | |
348 | thread_id_t thread_id, | |
349 | const io_set_t& deps, | |
350 | imagectx_id_t imagectx, | |
351 | const std::string& name, | |
352 | const std::string& snap_name, | |
353 | bool readonly) | |
354 | : IO(ionum, start_time, thread_id, deps), | |
355 | m_imagectx(imagectx), | |
356 | m_name(name), | |
357 | m_snap_name(snap_name), | |
358 | m_readonly(readonly) { | |
359 | } | |
360 | ||
361 | void encode(bufferlist &bl) const override; | |
362 | ||
363 | imagectx_id_t imagectx() const { | |
364 | return m_imagectx; | |
365 | } | |
366 | ||
367 | void write_debug(std::ostream& out) const override; | |
368 | ||
369 | private: | |
370 | imagectx_id_t m_imagectx; | |
371 | std::string m_name; | |
372 | std::string m_snap_name; | |
373 | bool m_readonly; | |
374 | }; | |
375 | ||
376 | class AioCloseImageIO : public IO { | |
377 | public: | |
378 | AioCloseImageIO(action_id_t ionum, | |
379 | uint64_t start_time, | |
380 | thread_id_t thread_id, | |
381 | const io_set_t& deps, | |
382 | imagectx_id_t imagectx) | |
383 | : IO(ionum, start_time, thread_id, deps), | |
384 | m_imagectx(imagectx) { | |
385 | } | |
386 | ||
387 | void encode(bufferlist &bl) const override; | |
388 | ||
389 | imagectx_id_t imagectx() const { | |
390 | return m_imagectx; | |
391 | } | |
392 | ||
393 | void write_debug(std::ostream& out) const override; | |
394 | ||
395 | private: | |
396 | imagectx_id_t m_imagectx; | |
397 | }; | |
398 | ||
399 | } | |
400 | ||
401 | #endif |