]>
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 | #include "include/compat.h" | |
5 | #include "CloseImageRequest.h" | |
6 | #include "IsPrimaryRequest.h" | |
7 | #include "OpenLocalImageRequest.h" | |
8 | #include "common/errno.h" | |
9 | #include "common/WorkQueue.h" | |
10 | #include "librbd/ExclusiveLock.h" | |
11 | #include "librbd/ImageCtx.h" | |
12 | #include "librbd/ImageState.h" | |
13 | #include "librbd/Journal.h" | |
14 | #include "librbd/Utils.h" | |
15 | #include "librbd/exclusive_lock/Policy.h" | |
16 | #include "librbd/journal/Policy.h" | |
17 | #include <type_traits> | |
18 | ||
19 | #define dout_context g_ceph_context | |
20 | #define dout_subsys ceph_subsys_rbd_mirror | |
21 | #undef dout_prefix | |
22 | #define dout_prefix *_dout << "rbd::mirror::image_replayer::OpenLocalImageRequest: " \ | |
23 | << this << " " << __func__ << " " | |
24 | ||
25 | namespace rbd { | |
26 | namespace mirror { | |
27 | namespace image_replayer { | |
28 | ||
29 | using librbd::util::create_context_callback; | |
30 | ||
31 | namespace { | |
32 | ||
31f18b77 | 33 | template <typename I> |
7c673cae | 34 | struct MirrorExclusiveLockPolicy : public librbd::exclusive_lock::Policy { |
31f18b77 FG |
35 | I *image_ctx; |
36 | ||
37 | MirrorExclusiveLockPolicy(I *image_ctx) : image_ctx(image_ctx) { | |
38 | } | |
7c673cae FG |
39 | |
40 | bool may_auto_request_lock() override { | |
41 | return false; | |
42 | } | |
43 | ||
44 | int lock_requested(bool force) override { | |
31f18b77 FG |
45 | int r = -EROFS; |
46 | { | |
47 | RWLock::RLocker owner_locker(image_ctx->owner_lock); | |
48 | RWLock::RLocker snap_locker(image_ctx->snap_lock); | |
49 | if (image_ctx->journal == nullptr || image_ctx->journal->is_tag_owner()) { | |
50 | r = 0; | |
51 | } | |
52 | } | |
53 | ||
54 | if (r == 0) { | |
55 | // if the local image journal has been closed or if it was (force) | |
56 | // promoted allow the lock to be released to another client | |
57 | image_ctx->exclusive_lock->release_lock(nullptr); | |
58 | } | |
59 | return r; | |
7c673cae FG |
60 | } |
61 | ||
62 | }; | |
63 | ||
64 | struct MirrorJournalPolicy : public librbd::journal::Policy { | |
65 | ContextWQ *work_queue; | |
66 | ||
67 | MirrorJournalPolicy(ContextWQ *work_queue) : work_queue(work_queue) { | |
68 | } | |
69 | ||
70 | bool append_disabled() const override { | |
71 | // avoid recording any events to the local journal | |
72 | return true; | |
73 | } | |
74 | bool journal_disabled() const override { | |
75 | return false; | |
76 | } | |
77 | ||
78 | void allocate_tag_on_lock(Context *on_finish) override { | |
79 | // rbd-mirror will manually create tags by copying them from the peer | |
80 | work_queue->queue(on_finish, 0); | |
81 | } | |
82 | }; | |
83 | ||
84 | } // anonymous namespace | |
85 | ||
86 | template <typename I> | |
87 | OpenLocalImageRequest<I>::OpenLocalImageRequest(librados::IoCtx &local_io_ctx, | |
88 | I **local_image_ctx, | |
89 | const std::string &local_image_id, | |
90 | ContextWQ *work_queue, | |
91 | Context *on_finish) | |
92 | : m_local_io_ctx(local_io_ctx), m_local_image_ctx(local_image_ctx), | |
93 | m_local_image_id(local_image_id), m_work_queue(work_queue), | |
94 | m_on_finish(on_finish) { | |
95 | } | |
96 | ||
97 | template <typename I> | |
98 | void OpenLocalImageRequest<I>::send() { | |
99 | send_open_image(); | |
100 | } | |
101 | ||
102 | template <typename I> | |
103 | void OpenLocalImageRequest<I>::send_open_image() { | |
104 | dout(20) << dendl; | |
105 | ||
106 | *m_local_image_ctx = I::create("", m_local_image_id, nullptr, | |
107 | m_local_io_ctx, false); | |
108 | { | |
109 | RWLock::WLocker owner_locker((*m_local_image_ctx)->owner_lock); | |
110 | RWLock::WLocker snap_locker((*m_local_image_ctx)->snap_lock); | |
111 | (*m_local_image_ctx)->set_exclusive_lock_policy( | |
31f18b77 | 112 | new MirrorExclusiveLockPolicy<I>(*m_local_image_ctx)); |
7c673cae FG |
113 | (*m_local_image_ctx)->set_journal_policy( |
114 | new MirrorJournalPolicy(m_work_queue)); | |
115 | } | |
116 | ||
117 | Context *ctx = create_context_callback< | |
118 | OpenLocalImageRequest<I>, &OpenLocalImageRequest<I>::handle_open_image>( | |
119 | this); | |
120 | (*m_local_image_ctx)->state->open(false, ctx); | |
121 | } | |
122 | ||
123 | template <typename I> | |
124 | void OpenLocalImageRequest<I>::handle_open_image(int r) { | |
125 | dout(20) << ": r=" << r << dendl; | |
126 | ||
127 | if (r < 0) { | |
128 | derr << ": failed to open image '" << m_local_image_id << "': " | |
129 | << cpp_strerror(r) << dendl; | |
130 | (*m_local_image_ctx)->destroy(); | |
131 | *m_local_image_ctx = nullptr; | |
132 | finish(r); | |
133 | return; | |
134 | } | |
135 | ||
136 | send_is_primary(); | |
137 | } | |
138 | ||
139 | template <typename I> | |
140 | void OpenLocalImageRequest<I>::send_is_primary() { | |
141 | dout(20) << dendl; | |
142 | ||
143 | Context *ctx = create_context_callback< | |
144 | OpenLocalImageRequest<I>, &OpenLocalImageRequest<I>::handle_is_primary>( | |
145 | this); | |
146 | IsPrimaryRequest<I> *request = IsPrimaryRequest<I>::create(*m_local_image_ctx, | |
147 | &m_primary, ctx); | |
148 | request->send(); | |
149 | } | |
150 | ||
151 | template <typename I> | |
152 | void OpenLocalImageRequest<I>::handle_is_primary(int r) { | |
153 | dout(20) << ": r=" << r << dendl; | |
154 | ||
28e407b8 AA |
155 | if (r == -ENOENT) { |
156 | dout(5) << ": local image is not mirrored" << dendl; | |
157 | send_close_image(r); | |
158 | return; | |
159 | } else if (r < 0) { | |
7c673cae FG |
160 | derr << ": error querying local image primary status: " << cpp_strerror(r) |
161 | << dendl; | |
162 | send_close_image(r); | |
163 | return; | |
164 | } | |
165 | ||
166 | // if the local image owns the tag -- don't steal the lock since | |
167 | // we aren't going to mirror peer data into this image anyway | |
168 | if (m_primary) { | |
169 | dout(10) << ": local image is primary -- skipping image replay" << dendl; | |
170 | send_close_image(-EREMOTEIO); | |
171 | return; | |
172 | } | |
173 | ||
174 | send_lock_image(); | |
175 | } | |
176 | ||
177 | template <typename I> | |
178 | void OpenLocalImageRequest<I>::send_lock_image() { | |
179 | dout(20) << dendl; | |
180 | ||
181 | RWLock::RLocker owner_locker((*m_local_image_ctx)->owner_lock); | |
182 | if ((*m_local_image_ctx)->exclusive_lock == nullptr) { | |
183 | derr << ": image does not support exclusive lock" << dendl; | |
184 | send_close_image(-EINVAL); | |
185 | return; | |
186 | } | |
187 | ||
188 | // disallow any proxied maintenance operations before grabbing lock | |
189 | (*m_local_image_ctx)->exclusive_lock->block_requests(-EROFS); | |
190 | ||
191 | Context *ctx = create_context_callback< | |
192 | OpenLocalImageRequest<I>, &OpenLocalImageRequest<I>::handle_lock_image>( | |
193 | this); | |
194 | ||
195 | (*m_local_image_ctx)->exclusive_lock->acquire_lock(ctx); | |
196 | } | |
197 | ||
198 | template <typename I> | |
199 | void OpenLocalImageRequest<I>::handle_lock_image(int r) { | |
200 | dout(20) << ": r=" << r << dendl; | |
201 | ||
202 | if (r < 0) { | |
203 | derr << ": failed to lock image '" << m_local_image_id << "': " | |
204 | << cpp_strerror(r) << dendl; | |
205 | send_close_image(r); | |
206 | return; | |
207 | } | |
208 | ||
209 | { | |
210 | RWLock::RLocker owner_locker((*m_local_image_ctx)->owner_lock); | |
211 | if ((*m_local_image_ctx)->exclusive_lock == nullptr || | |
212 | !(*m_local_image_ctx)->exclusive_lock->is_lock_owner()) { | |
213 | derr << ": image is not locked" << dendl; | |
214 | send_close_image(-EBUSY); | |
215 | return; | |
216 | } | |
217 | } | |
218 | ||
219 | finish(0); | |
220 | } | |
221 | ||
222 | template <typename I> | |
223 | void OpenLocalImageRequest<I>::send_close_image(int r) { | |
224 | dout(20) << dendl; | |
225 | ||
226 | if (m_ret_val == 0 && r < 0) { | |
227 | m_ret_val = r; | |
228 | } | |
229 | ||
230 | Context *ctx = create_context_callback< | |
231 | OpenLocalImageRequest<I>, &OpenLocalImageRequest<I>::handle_close_image>( | |
232 | this); | |
233 | CloseImageRequest<I> *request = CloseImageRequest<I>::create( | |
234 | m_local_image_ctx, ctx); | |
235 | request->send(); | |
236 | } | |
237 | ||
238 | template <typename I> | |
239 | void OpenLocalImageRequest<I>::handle_close_image(int r) { | |
240 | dout(20) << dendl; | |
241 | ||
242 | assert(r == 0); | |
243 | finish(m_ret_val); | |
244 | } | |
245 | ||
246 | template <typename I> | |
247 | void OpenLocalImageRequest<I>::finish(int r) { | |
248 | dout(20) << ": r=" << r << dendl; | |
249 | ||
250 | m_on_finish->complete(r); | |
251 | delete this; | |
252 | } | |
253 | ||
254 | } // namespace image_replayer | |
255 | } // namespace mirror | |
256 | } // namespace rbd | |
257 | ||
258 | template class rbd::mirror::image_replayer::OpenLocalImageRequest<librbd::ImageCtx>; |