Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 262 insertions, 0 deletions

diff --git a/src/librbd/io/ReadResult.cc b/src/librbd/io/ReadResult.cc
new file mode 100644
index 000000000..c4053fee6
--- /dev/null
+++ b/src/librbd/io/ReadResult.cc
@@ -0,0 +1,262 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#include "librbd/io/ReadResult.h"
+#include "include/buffer.h"
+#include "common/dout.h"
+#include "librbd/io/AioCompletion.h"
+#include "librbd/io/Utils.h"
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+#define dout_subsys ceph_subsys_rbd
+#undef dout_prefix
+#define dout_prefix *_dout << "librbd::io::ReadResult: " << this \
+                           << " " << __func__ << ": "
+
+namespace librbd {
+namespace io {
+
+struct ReadResult::SetImageExtentsVisitor : public boost::static_visitor<void> {
+  Extents image_extents;
+
+  explicit SetImageExtentsVisitor(const Extents& image_extents)
+    : image_extents(image_extents) {
+  }
+
+  void operator()(Linear &linear) const {
+    uint64_t length = util::get_extents_length(image_extents);
+
+    ceph_assert(length <= linear.buf_len);
+    linear.buf_len = length;
+  }
+
+  void operator()(SparseBufferlist &sbl) const {
+    sbl.image_extents = image_extents;
+  }
+
+  template <typename T>
+  void operator()(T &t) const {
+  }
+};
+
+struct ReadResult::AssembleResultVisitor : public boost::static_visitor<void> {
+  CephContext *cct;
+  Striper::StripedReadResult &destriper;
+
+  AssembleResultVisitor(CephContext *cct, Striper::StripedReadResult &destriper)
+    : cct(cct), destriper(destriper) {
+  }
+
+  void operator()(Empty &empty) const {
+    ldout(cct, 20) << "dropping read result" << dendl;
+  }
+
+  void operator()(Linear &linear) const {
+    ldout(cct, 20) << "copying resulting bytes to "
+                   << reinterpret_cast<void*>(linear.buf) << dendl;
+    destriper.assemble_result(cct, linear.buf, linear.buf_len);
+  }
+
+  void operator()(Vector &vector) const {
+    bufferlist bl;
+    destriper.assemble_result(cct, bl, true);
+
+    ldout(cct, 20) << "copying resulting " << bl.length() << " bytes to iovec "
+                   << reinterpret_cast<const void*>(vector.iov) << dendl;
+
+    bufferlist::iterator it = bl.begin();
+    size_t length = bl.length();
+    size_t offset = 0;
+    int idx = 0;
+    for (; offset < length && idx < vector.iov_count; idx++) {
+      size_t len = std::min(vector.iov[idx].iov_len, length - offset);
+      it.copy(len, static_cast<char *>(vector.iov[idx].iov_base));
+      offset += len;
+    }
+    ceph_assert(offset == bl.length());
+  }
+
+  void operator()(Bufferlist &bufferlist) const {
+    bufferlist.bl->clear();
+    destriper.assemble_result(cct, *bufferlist.bl, true);
+
+    ldout(cct, 20) << "moved resulting " << bufferlist.bl->length() << " "
+                   << "bytes to bl " << reinterpret_cast<void*>(bufferlist.bl)
+                   << dendl;
+  }
+
+  void operator()(SparseBufferlist &sparse_bufferlist) const {
+    sparse_bufferlist.bl->clear();
+
+    ExtentMap buffer_extent_map;
+    auto buffer_extents_length = destriper.assemble_result(
+      cct, &buffer_extent_map, sparse_bufferlist.bl);
+
+    ldout(cct, 20) << "image_extents="
+                   << sparse_bufferlist.image_extents << ", "
+                   << "buffer_extent_map=" << buffer_extent_map << dendl;
+
+    sparse_bufferlist.extent_map->clear();
+    sparse_bufferlist.extent_map->reserve(buffer_extent_map.size());
+
+    // The extent-map is logically addressed by buffer-extents not image- or
+    // object-extents. Translate this address mapping to image-extent
+    // logical addressing since it's tied to an image-extent read
+    uint64_t buffer_offset = 0;
+    auto bem_it = buffer_extent_map.begin();
+    for (auto [image_offset, image_length] : sparse_bufferlist.image_extents) {
+      while (bem_it != buffer_extent_map.end()) {
+        auto [buffer_extent_offset, buffer_extent_length] = *bem_it;
+
+        if (buffer_offset + image_length <= buffer_extent_offset) {
+          // skip any image extent that is not included in the results
+          break;
+        }
+
+        // current buffer-extent should be within the current image-extent
+        ceph_assert(buffer_offset <= buffer_extent_offset &&
+                    buffer_offset + image_length >=
+                      buffer_extent_offset + buffer_extent_length);
+        auto image_extent_offset =
+          image_offset + (buffer_extent_offset - buffer_offset);
+        ldout(cct, 20) << "mapping buffer extent " << buffer_extent_offset
+                       << "~" << buffer_extent_length << " to image extent "
+                       << image_extent_offset << "~" << buffer_extent_length
+                       << dendl;
+        sparse_bufferlist.extent_map->emplace_back(
+          image_extent_offset, buffer_extent_length);
+        ++bem_it;
+      }
+
+      buffer_offset += image_length;
+    }
+    ceph_assert(buffer_offset == buffer_extents_length);
+    ceph_assert(bem_it == buffer_extent_map.end());
+
+    ldout(cct, 20) << "moved resulting " << *sparse_bufferlist.extent_map
+                   << " extents of total " << sparse_bufferlist.bl->length()
+                   << " bytes to bl "
+                   << reinterpret_cast<void*>(sparse_bufferlist.bl) << dendl;
+  }
+};
+
+ReadResult::C_ImageReadRequest::C_ImageReadRequest(
+    AioCompletion *aio_completion, uint64_t buffer_offset,
+    const Extents image_extents)
+  : aio_completion(aio_completion), buffer_offset(buffer_offset),
+    image_extents(image_extents) {
+  aio_completion->add_request();
+}
+
+void ReadResult::C_ImageReadRequest::finish(int r) {
+  CephContext *cct = aio_completion->ictx->cct;
+  ldout(cct, 10) << "C_ImageReadRequest: r=" << r
+                 << dendl;
+  if (r >= 0 || (ignore_enoent && r == -ENOENT)) {
+    striper::LightweightBufferExtents buffer_extents;
+    size_t length = 0;
+    for (auto &image_extent : image_extents) {
+      buffer_extents.emplace_back(buffer_offset + length, image_extent.second);
+      length += image_extent.second;
+    }
+    ceph_assert(r == -ENOENT || length == bl.length());
+
+    aio_completion->lock.lock();
+    aio_completion->read_result.m_destriper.add_partial_result(
+      cct, std::move(bl), buffer_extents);
+    aio_completion->lock.unlock();
+    r = length;
+  }
+
+  aio_completion->complete_request(r);
+}
+
+ReadResult::C_ObjectReadRequest::C_ObjectReadRequest(
+    AioCompletion *aio_completion, ReadExtents&& extents)
+  : aio_completion(aio_completion), extents(std::move(extents)) {
+  aio_completion->add_request();
+}
+
+void ReadResult::C_ObjectReadRequest::finish(int r) {
+  CephContext *cct = aio_completion->ictx->cct;
+  ldout(cct, 10) << "C_ObjectReadRequest: r=" << r
+                 << dendl;
+
+  if (r == -ENOENT) {
+    r = 0;
+  }
+  if (r >= 0) {
+    uint64_t object_len = 0;
+    aio_completion->lock.lock();
+    for (auto& extent: extents) {
+      ldout(cct, 10) << " got " << extent.extent_map
+                     << " for " << extent.buffer_extents
+                     << " bl " << extent.bl.length() << dendl;
+
+      aio_completion->read_result.m_destriper.add_partial_sparse_result(
+              cct, std::move(extent.bl), extent.extent_map, extent.offset,
+              extent.buffer_extents);
+
+      object_len += extent.length;
+    }
+    aio_completion->lock.unlock();
+    r = object_len;
+  }
+
+  aio_completion->complete_request(r);
+}
+
+ReadResult::C_ObjectReadMergedExtents::C_ObjectReadMergedExtents(
+        CephContext* cct, ReadExtents* extents, Context* on_finish)
+        : cct(cct), extents(extents), on_finish(on_finish) {
+}
+
+void ReadResult::C_ObjectReadMergedExtents::finish(int r) {
+  if (r >= 0) {
+    for (auto& extent: *extents) {
+      if (bl.length() < extent.length) {
+        lderr(cct) << "Merged extents length is less than expected" << dendl;
+        r = -EIO;
+        break;
+      }
+      bl.splice(0, extent.length, &extent.bl);
+    }
+    if (bl.length() != 0) {
+      lderr(cct) << "Merged extents length is greater than expected" << dendl;
+      r = -EIO;
+    }
+  }
+  on_finish->complete(r);
+}
+
+ReadResult::ReadResult() : m_buffer(Empty()) {
+}
+
+ReadResult::ReadResult(char *buf, size_t buf_len)
+  : m_buffer(Linear(buf, buf_len)) {
+}
+
+ReadResult::ReadResult(const struct iovec *iov, int iov_count)
+  : m_buffer(Vector(iov, iov_count)) {
+}
+
+ReadResult::ReadResult(ceph::bufferlist *bl)
+  : m_buffer(Bufferlist(bl)) {
+}
+
+ReadResult::ReadResult(Extents* extent_map, ceph::bufferlist* bl)
+  : m_buffer(SparseBufferlist(extent_map, bl)) {
+}
+
+void ReadResult::set_image_extents(const Extents& image_extents) {
+  boost::apply_visitor(SetImageExtentsVisitor(image_extents), m_buffer);
+}
+
+void ReadResult::assemble_result(CephContext *cct) {
+  boost::apply_visitor(AssembleResultVisitor(cct, m_destriper), m_buffer);
+}
+
+} // namespace io
+} // namespace librbd
+