1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 #ifndef CEPH_LIBRBD_UTILS_H
5 #define CEPH_LIBRBD_UTILS_H
7 #include "include/rados/librados.hpp"
8 #include "include/rbd_types.h"
9 #include "include/Context.h"
10 #include "common/zipkin_trace.h"
13 #include <type_traits>
24 void rados_callback(rados_completion_t c, void *arg) {
25 reinterpret_cast<T*>(arg)->complete(rados_aio_get_return_value(c));
28 template <typename T, void(T::*MF)(int)>
29 void rados_callback(rados_completion_t c, void *arg) {
30 T *obj = reinterpret_cast<T*>(arg);
31 int r = rados_aio_get_return_value(c);
35 template <typename T, Context*(T::*MF)(int*), bool destroy>
36 void rados_state_callback(rados_completion_t c, void *arg) {
37 T *obj = reinterpret_cast<T*>(arg);
38 int r = rados_aio_get_return_value(c);
39 Context *on_finish = (obj->*MF)(&r);
40 if (on_finish != nullptr) {
41 on_finish->complete(r);
48 template <typename T, void (T::*MF)(int)>
49 class C_CallbackAdapter : public Context {
52 C_CallbackAdapter(T *obj) : obj(obj) {
56 void finish(int r) override {
61 template <typename T, Context*(T::*MF)(int*), bool destroy>
62 class C_StateCallbackAdapter : public Context {
65 C_StateCallbackAdapter(T *obj) : obj(obj){
69 void complete(int r) override {
70 Context *on_finish = (obj->*MF)(&r);
71 if (on_finish != nullptr) {
72 on_finish->complete(r);
79 void finish(int r) override {
83 template <typename WQ>
84 struct C_AsyncCallback : public Context {
88 C_AsyncCallback(WQ *op_work_queue, Context *on_finish)
89 : op_work_queue(op_work_queue), on_finish(on_finish) {
91 void finish(int r) override {
92 op_work_queue->queue(on_finish, r);
98 std::string generate_image_id(librados::IoCtx &ioctx);
100 template <typename T>
101 inline std::string generate_image_id(librados::IoCtx &ioctx) {
102 return generate_image_id(ioctx);
105 const std::string group_header_name(const std::string &group_id);
106 const std::string id_obj_name(const std::string &name);
107 const std::string header_name(const std::string &image_id);
108 const std::string old_header_name(const std::string &image_name);
109 std::string unique_lock_name(const std::string &name, void *address);
111 librados::AioCompletion *create_rados_callback(Context *on_finish);
113 template <typename T>
114 librados::AioCompletion *create_rados_callback(T *obj) {
115 return librados::Rados::aio_create_completion(
116 obj, &detail::rados_callback<T>, nullptr);
119 template <typename T, void(T::*MF)(int)>
120 librados::AioCompletion *create_rados_callback(T *obj) {
121 return librados::Rados::aio_create_completion(
122 obj, &detail::rados_callback<T, MF>, nullptr);
125 template <typename T, Context*(T::*MF)(int*), bool destroy=true>
126 librados::AioCompletion *create_rados_callback(T *obj) {
127 return librados::Rados::aio_create_completion(
128 obj, &detail::rados_state_callback<T, MF, destroy>, nullptr);
131 template <typename T, void(T::*MF)(int) = &T::complete>
132 Context *create_context_callback(T *obj) {
133 return new detail::C_CallbackAdapter<T, MF>(obj);
136 template <typename T, Context*(T::*MF)(int*), bool destroy=true>
137 Context *create_context_callback(T *obj) {
138 return new detail::C_StateCallbackAdapter<T, MF, destroy>(obj);
141 template <typename I>
142 Context *create_async_context_callback(I &image_ctx, Context *on_finish) {
143 // use async callback to acquire a clean lock context
144 return new detail::C_AsyncCallback<
145 typename std::decay<decltype(*image_ctx.op_work_queue)>::type>(
146 image_ctx.op_work_queue, on_finish);
149 template <typename WQ>
150 Context *create_async_context_callback(WQ *work_queue, Context *on_finish) {
151 // use async callback to acquire a clean lock context
152 return new detail::C_AsyncCallback<WQ>(work_queue, on_finish);
155 // TODO: temporary until AioCompletion supports templated ImageCtx
156 inline ImageCtx *get_image_ctx(ImageCtx *image_ctx) {
160 /// helper for tracking in-flight async ops when coordinating
161 /// a shut down of the invoking class instance
162 class AsyncOpTracker {
169 if (--m_refs == 0 && m_on_finish != nullptr) {
170 Context *on_finish = nullptr;
171 std::swap(on_finish, m_on_finish);
172 on_finish->complete(0);
176 template <typename I>
177 void wait(I &image_ctx, Context *on_finish) {
178 assert(m_on_finish == nullptr);
180 on_finish = create_async_context_callback(image_ctx, on_finish);
182 on_finish->complete(0);
185 m_on_finish = on_finish;
189 std::atomic<uint64_t> m_refs = { 0 };
190 Context *m_on_finish = nullptr;
193 uint64_t get_rbd_default_features(CephContext* cct);
195 bool calc_sparse_extent(const bufferptr &bp,
198 size_t *write_offset,
199 size_t *write_length,
202 template <typename I>
203 inline ZTracer::Trace create_trace(const I &image_ctx, const char *trace_name,
204 const ZTracer::Trace &parent_trace) {
205 if (parent_trace.valid()) {
206 return ZTracer::Trace(trace_name, &image_ctx.trace_endpoint, &parent_trace);
208 return ZTracer::Trace();
213 } // namespace librbd
215 #endif // CEPH_LIBRBD_UTILS_H