ceph/src/tools/rbd_ggate/Driver.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include <stdlib.h>
   5
   6 #include "common/debug.h"
   7 #include "common/errno.h"
   8 #include "Driver.h"
   9 #include "Request.h"
  10
  11 #define dout_context g_ceph_context
  12 #define dout_subsys ceph_subsys_rbd
  13 #undef dout_prefix
  14 #define dout_prefix *_dout << "rbd::ggate::Driver: " << this \
  15                            << " " << __func__ << ": "
  16
  17 namespace rbd {
  18 namespace ggate {
  19
  20 int Driver::load() {
  21
  22   return ggate_drv_load();
  23 }
  24
  25 int Driver::kill(const std::string &devname) {
  26
  27   int r = ggate_drv_kill(devname.c_str());
  28
  29   return r;
  30 }
  31
  32 int Driver::list(std::list<std::string> &devs) {
  33   size_t size = 1024;
  34   char **devs_ = nullptr;
  35   int r;
  36
  37   while (size <= 1024 * 1024) {
  38     devs_ = static_cast<char **>(
  39         realloc(static_cast<void *>(devs_), size * sizeof(*devs_)));
  40     r = ggate_drv_list(devs_, &size);
  41     if (r != -ERANGE) {
  42       break;
  43     }
  44     size *= 2;
  45   }
  46   if (r < 0) {
  47     goto free;
  48   }
  49
  50   devs.clear();
  51   for (size_t i = 0; i < size; i++) {
  52     devs.push_back(devs_[i]);
  53   }
  54
  55   ggate_drv_list_free(devs_, size);
  56 free:
  57   free(devs_);
  58
  59   return r;
  60 }
  61
  62 Driver::Driver(const std::string &devname, size_t sectorsize, size_t mediasize,
  63                bool readonly, const std::string &info)
  64   : m_devname(devname), m_sectorsize(sectorsize), m_mediasize(mediasize),
  65     m_readonly(readonly), m_info(info) {
  66 }
  67
  68 int Driver::init() {
  69   dout(20) << dendl;
  70
  71   char name[PATH_MAX];
  72   size_t namelen;
  73
  74   if (m_devname.empty()) {
  75     name[0] = '\0';
  76     namelen = PATH_MAX;
  77   } else {
  78     namelen = m_devname.size();
  79     if (namelen >= PATH_MAX) {
  80       return -ENAMETOOLONG;
  81     }
  82     strncpy(name, m_devname.c_str(), namelen + 1);
  83   }
  84
  85   int r = ggate_drv_create(name, namelen, m_sectorsize, m_mediasize, m_readonly,
  86                            m_info.c_str(), &m_drv);
  87   if (r < 0) {
  88     return r;
  89   }
  90
  91   if (m_devname.empty()) {
  92     m_devname = name;
  93   }
  94
  95   return 0;
  96 }
  97
  98 std::string Driver::get_devname() const {
  99   dout(30) << m_devname << dendl;
 100
 101   return m_devname;
 102 }
 103
 104 void Driver::shut_down() {
 105   dout(20) << dendl;
 106
 107   ggate_drv_destroy(m_drv);
 108 }
 109
 110 int Driver::resize(size_t newsize) {
 111   dout(20) << "newsize=" << newsize << dendl;
 112
 113   int r = ggate_drv_resize(m_drv, newsize);
 114   if (r < 0) {
 115     return r;
 116   }
 117
 118   m_mediasize = newsize;
 119   return 0;
 120 }
 121
 122 int Driver::recv(Request **req) {
 123   dout(20) << dendl;
 124
 125   ggate_drv_req_t req_;
 126
 127   int r = ggate_drv_recv(m_drv, &req_);
 128   if (r < 0) {
 129     return r;
 130   }
 131
 132   *req = new Request(req_);
 133
 134   dout(20) << "req=" << *req << dendl;
 135
 136   if (ggate_drv_req_cmd(req_) == GGATE_DRV_CMD_WRITE) {
 137     bufferptr ptr(buffer::claim_malloc(
 138                     ggate_drv_req_length(req_),
 139                     static_cast<char *>(ggate_drv_req_release_buf(req_))));
 140     (*req)->bl.push_back(ptr);
 141   }
 142
 143   return 0;
 144 }
 145
 146 int Driver::send(Request *req) {
 147   dout(20) << "req=" << req << dendl;
 148
 149   if (ggate_drv_req_cmd(req->req) == GGATE_DRV_CMD_READ &&
 150       ggate_drv_req_error(req->req) == 0) {
 151     assert(req->bl.length() == ggate_drv_req_length(req->req));
 152     // TODO: avoid copying?
 153     req->bl.copy(0, ggate_drv_req_length(req->req),
 154                  static_cast<char *>(ggate_drv_req_buf(req->req)));
 155     dout(20) << "copied resulting " << req->bl.length() << " bytes to "
 156              << ggate_drv_req_buf(req->req) << dendl;
 157   }
 158
 159   int r = ggate_drv_send(m_drv, req->req);
 160
 161   delete req;
 162   return r;
 163 }
 164
 165 } // namespace ggate
 166 } // namespace rbd