ceph/src/tools/rbd_ggate/main.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 "include/int_types.h"
   5
   6 #include <sys/types.h>
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <stddef.h>
  11 #include <errno.h>
  12 #include <string.h>
  13 #include <assert.h>
  14
  15 #include <iostream>
  16 #include <boost/regex.hpp>
  17
  18 #include "common/Preforker.h"
  19 #include "common/ceph_argparse.h"
  20 #include "common/config.h"
  21 #include "common/debug.h"
  22 #include "common/errno.h"
  23 #include "global/global_init.h"
  24 #include "global/signal_handler.h"
  25
  26 #include "include/rados/librados.hpp"
  27 #include "include/rbd/librbd.hpp"
  28
  29 #include "Driver.h"
  30 #include "Server.h"
  31 #include "Watcher.h"
  32
  33 #define dout_context g_ceph_context
  34 #define dout_subsys ceph_subsys_rbd
  35 #undef dout_prefix
  36 #define dout_prefix *_dout << "rbd-ggate: " << __func__ << ": "
  37
  38 static void usage() {
  39   std::cout << "Usage: rbd-ggate [options] map <image-or-snap-spec>  Map an image to ggate device\n"
  40             << "                           unmap <device path>       Unmap ggate device\n"
  41             << "                           list                      List mapped ggate devices\n"
  42             << "Options:\n"
  43             << "  --device <device path>  Specify ggate device path\n"
  44             << "  --read-only             Map readonly\n"
  45             << "  --exclusive             Forbid writes by other clients\n"
  46             << std::endl;
  47   generic_server_usage();
  48 }
  49
  50 static std::string devpath, poolname("rbd"), imgname, snapname;
  51 static bool readonly = false;
  52 static bool exclusive = false;
  53
  54 static std::unique_ptr<rbd::ggate::Driver> drv;
  55
  56 static void handle_signal(int signum)
  57 {
  58   derr << "*** Got signal " << sig_str(signum) << " ***" << dendl;
  59
  60   assert(signum == SIGINT || signum == SIGTERM);
  61   assert(drv);
  62
  63   drv->shut_down();
  64 }
  65
  66 static int do_map(int argc, const char *argv[])
  67 {
  68   int r;
  69
  70   librados::Rados rados;
  71   librbd::RBD rbd;
  72   librados::IoCtx io_ctx;
  73   librbd::Image image;
  74
  75   librbd::image_info_t info;
  76   std::string desc;
  77
  78   Preforker forker;
  79
  80   vector<const char*> args;
  81   argv_to_vec(argc, argv, args);
  82   env_to_vec(args);
  83
  84   auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
  85                          CODE_ENVIRONMENT_DAEMON,
  86                          CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
  87   g_ceph_context->_conf->set_val_or_die("pid_file", "");
  88
  89   if (global_init_prefork(g_ceph_context) >= 0) {
  90     std::string err;
  91     r = forker.prefork(err);
  92     if (r < 0) {
  93       cerr << err << std::endl;
  94       return r;
  95     }
  96
  97     if (forker.is_parent()) {
  98       global_init_postfork_start(g_ceph_context);
  99       if (forker.parent_wait(err) != 0) {
 100         return -ENXIO;
 101       }
 102       return 0;
 103     }
 104   }
 105
 106   common_init_finish(g_ceph_context);
 107   global_init_chdir(g_ceph_context);
 108
 109   std::string devname = (devpath.compare(0, 5, "/dev/") == 0) ?
 110     devpath.substr(5) : devpath;
 111   std::unique_ptr<rbd::ggate::Watcher> watcher;
 112   uint64_t handle;
 113
 114   r = rados.init_with_context(g_ceph_context);
 115   if (r < 0) {
 116     goto done;
 117   }
 118
 119   r = rados.connect();
 120   if (r < 0) {
 121     goto done;
 122   }
 123
 124   r = rados.ioctx_create(poolname.c_str(), io_ctx);
 125   if (r < 0) {
 126     goto done;
 127   }
 128
 129   r = rbd.open(io_ctx, image, imgname.c_str());
 130   if (r < 0) {
 131     goto done;
 132   }
 133
 134   if (exclusive) {
 135     r = image.lock_acquire(RBD_LOCK_MODE_EXCLUSIVE);
 136     if (r < 0) {
 137       cerr << "rbd-ggate: failed to acquire exclusive lock: " << cpp_strerror(r)
 138            << std::endl;
 139       goto done;
 140     }
 141   }
 142
 143   desc = "RBD " + poolname + "/" + imgname;
 144
 145   if (!snapname.empty()) {
 146     r = image.snap_set(snapname.c_str());
 147     if (r < 0) {
 148       goto done;
 149     }
 150     readonly = true;
 151     desc += "@" + snapname;
 152   }
 153
 154   r = image.stat(info, sizeof(info));
 155   if (r < 0) {
 156     goto done;
 157   }
 158
 159   rbd::ggate::Driver::load();
 160   drv.reset(new rbd::ggate::Driver(devname, 512, info.size, readonly, desc));
 161   r = drv->init();
 162   if (r < 0) {
 163     r = -errno;
 164     goto done;
 165   }
 166
 167   watcher.reset(new rbd::ggate::Watcher(drv.get(), io_ctx, image, info.size));
 168   r = image.update_watch(watcher.get(), &handle);
 169   if (r < 0) {
 170     drv->shut_down();
 171     goto done;
 172   }
 173
 174   std::cout << "/dev/" << drv->get_devname() << std::endl;
 175
 176   if (g_conf->daemonize) {
 177     forker.daemonize();
 178     global_init_postfork_start(g_ceph_context);
 179     global_init_postfork_finish(g_ceph_context);
 180   }
 181
 182   init_async_signal_handler();
 183   register_async_signal_handler(SIGHUP, sighup_handler);
 184   register_async_signal_handler_oneshot(SIGINT, handle_signal);
 185   register_async_signal_handler_oneshot(SIGTERM, handle_signal);
 186
 187   rbd::ggate::Server(drv.get(), image).run();
 188
 189   unregister_async_signal_handler(SIGHUP, sighup_handler);
 190   unregister_async_signal_handler(SIGINT, handle_signal);
 191   unregister_async_signal_handler(SIGTERM, handle_signal);
 192   shutdown_async_signal_handler();
 193
 194   r = image.update_unwatch(handle);
 195   assert(r == 0);
 196
 197 done:
 198   image.close();
 199   io_ctx.close();
 200   rados.shutdown();
 201
 202   forker.exit(r < 0 ? EXIT_FAILURE : 0);
 203   // Unreachable;
 204   return r;
 205 }
 206
 207 static int do_unmap()
 208 {
 209   std::string devname = (devpath.compare(0, 5, "/dev/") == 0) ?
 210     devpath.substr(5) : devpath;
 211
 212   int r = rbd::ggate::Driver::kill(devname);
 213   if (r < 0) {
 214     cerr << "rbd-ggate: failed to destroy " << devname << ": "
 215          << cpp_strerror(r) << std::endl;
 216     return r;
 217   }
 218
 219   return 0;
 220 }
 221
 222 static int parse_imgpath(const std::string &imgpath)
 223 {
 224   boost::regex pattern("^(?:([^/@]+)/)?([^/@]+)(?:@([^/@]+))?$");
 225   boost::smatch match;
 226   if (!boost::regex_match(imgpath, match, pattern)) {
 227     std::cerr << "rbd-ggate: invalid spec '" << imgpath << "'" << std::endl;
 228     return -EINVAL;
 229   }
 230
 231   if (match[1].matched) {
 232     poolname = match[1];
 233   }
 234
 235   imgname = match[2];
 236
 237   if (match[3].matched) {
 238     snapname = match[3];
 239   }
 240
 241   return 0;
 242 }
 243
 244 static int do_list()
 245 {
 246   rbd::ggate::Driver::load();
 247
 248   std::list<std::string> devs;
 249   int r = rbd::ggate::Driver::list(devs);
 250   if (r < 0) {
 251     return -r;
 252   }
 253
 254   for (auto &devname : devs) {
 255     cout << "/dev/" << devname << std::endl;
 256   }
 257   return 0;
 258 }
 259
 260 int main(int argc, const char *argv[]) {
 261   int r;
 262   enum {
 263     None,
 264     Connect,
 265     Disconnect,
 266     List
 267   } cmd = None;
 268
 269   vector<const char*> args;
 270
 271   argv_to_vec(argc, argv, args);
 272   md_config_t().parse_argv(args);
 273
 274   std::vector<const char*>::iterator i;
 275
 276   for (i = args.begin(); i != args.end(); ) {
 277     if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
 278       usage();
 279       return 0;
 280     } else if (ceph_argparse_witharg(args, i, &devpath, "--device",
 281                                      (char *)NULL)) {
 282     } else if (ceph_argparse_flag(args, i, "--read-only", (char *)NULL)) {
 283       readonly = true;
 284     } else if (ceph_argparse_flag(args, i, "--exclusive", (char *)NULL)) {
 285       exclusive = true;
 286     } else {
 287       ++i;
 288     }
 289   }
 290
 291   if (args.begin() != args.end()) {
 292     if (strcmp(*args.begin(), "map") == 0) {
 293       cmd = Connect;
 294     } else if (strcmp(*args.begin(), "unmap") == 0) {
 295       cmd = Disconnect;
 296     } else if (strcmp(*args.begin(), "list") == 0) {
 297       cmd = List;
 298     } else {
 299       cerr << "rbd-ggate: unknown command: " << *args.begin() << std::endl;
 300       return EXIT_FAILURE;
 301     }
 302     args.erase(args.begin());
 303   }
 304
 305   if (cmd == None) {
 306     cerr << "rbd-ggate: must specify command" << std::endl;
 307     return EXIT_FAILURE;
 308   }
 309
 310   switch (cmd) {
 311     case Connect:
 312       if (args.begin() == args.end()) {
 313         cerr << "rbd-ggate: must specify image-or-snap-spec" << std::endl;
 314         return EXIT_FAILURE;
 315       }
 316       if (parse_imgpath(string(*args.begin())) < 0)
 317         return EXIT_FAILURE;
 318       args.erase(args.begin());
 319       break;
 320     case Disconnect:
 321       if (args.begin() == args.end()) {
 322         cerr << "rbd-ggate: must specify ggate device path" << std::endl;
 323         return EXIT_FAILURE;
 324       }
 325       devpath = *args.begin();
 326       args.erase(args.begin());
 327       break;
 328     default:
 329       break;
 330   }
 331
 332   if (args.begin() != args.end()) {
 333     cerr << "rbd-ggate: unknown args: " << *args.begin() << std::endl;
 334     return EXIT_FAILURE;
 335   }
 336
 337   switch (cmd) {
 338     case Connect:
 339       if (imgname.empty()) {
 340         cerr << "rbd-ggate: image name was not specified" << std::endl;
 341         return EXIT_FAILURE;
 342       }
 343
 344       r = do_map(argc, argv);
 345       if (r < 0)
 346         return EXIT_FAILURE;
 347       break;
 348     case Disconnect:
 349       r = do_unmap();
 350       if (r < 0)
 351         return EXIT_FAILURE;
 352       break;
 353     case List:
 354       r = do_list();
 355       if (r < 0)
 356         return EXIT_FAILURE;
 357       break;
 358     default:
 359       usage();
 360       return EXIT_FAILURE;
 361   }
 362
 363   return 0;
 364 }