ceph/src/test/librgw_file_gp.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2015 Red Hat, Inc.
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #include <stdint.h>
  16 #include <tuple>
  17 #include <iostream>
  18 #include <vector>
  19 #include <map>
  20 #include <random>
  21 #include "xxhash.h"
  22
  23 #include "include/rados/librgw.h"
  24 #include "include/rados/rgw_file.h"
  25
  26 #include "gtest/gtest.h"
  27 #include "common/ceph_argparse.h"
  28 #include "common/debug.h"
  29
  30 #define dout_context g_ceph_context
  31 #define dout_subsys ceph_subsys_rgw
  32
  33 using namespace std;
  34
  35 namespace {
  36   librgw_t rgw = nullptr;
  37   string uid("testuser");
  38   string access_key("");
  39   string secret_key("");
  40   struct rgw_fs *fs = nullptr;
  41
  42   bool do_pre_list = false;
  43   bool do_put = false;
  44   bool do_bulk = false;
  45   bool do_writev = false;
  46   bool do_readv = false;
  47   bool do_verify = false;
  48   bool do_get = false;
  49   bool do_create = false;
  50   bool do_delete = false;
  51   bool do_stat = false; // stat objects (not buckets)
  52   bool do_hexdump = false;
  53
  54   bool object_open = false;
  55
  56   uint32_t owner_uid = 867;
  57   uint32_t owner_gid = 5309;
  58   uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
  59
  60   string bucket_name = "blastoff";
  61   string object_name = "jocaml";
  62
  63   struct rgw_file_handle *bucket_fh = nullptr;
  64   struct rgw_file_handle *object_fh = nullptr;
  65
  66   typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
  67   std::vector<fid_type> fids;
  68
  69   std::uniform_int_distribution<uint8_t> uint_dist;
  70   std::mt19937 rng;
  71
  72   constexpr int iovcnt = 16;
  73   constexpr int page_size = 65536;
  74   constexpr int seed = 8675309;
  75
  76   struct ZPage
  77   {
  78     char data[page_size];
  79     uint64_t cksum;
  80   }; /* ZPage */
  81
  82   struct ZPageSet
  83   {
  84     std::vector<ZPage*> pages;
  85     struct iovec* iovs;
  86
  87     explicit ZPageSet(int n) {
  88       pages.reserve(n);
  89       iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
  90       for (int page_ix = 0; page_ix < n; ++page_ix) {
  91         ZPage* p = new ZPage();
  92         for (int data_ix = 0; data_ix < page_size; ++data_ix) {
  93           p->data[data_ix] = uint_dist(rng);
  94         } // data_ix
  95         p->cksum = XXH64(p->data, page_size, seed);
  96         pages.emplace_back(p);
  97         // and iovs
  98         struct iovec* iov = &iovs[page_ix];
  99         iov->iov_base = p->data;
 100         iov->iov_len = page_size;
 101       } // page_ix
 102     }
 103
 104     int size() { return pages.size(); }
 105
 106     struct iovec* get_iovs() { return iovs; }
 107
 108     bool operator==(const ZPageSet& rhs) {
 109       int n = size();
 110       for (int page_ix = 0; page_ix < n; ++page_ix) {
 111         ZPage* p1 = pages[page_ix];
 112         ZPage* p2 = rhs.pages[page_ix];
 113         if (p1->cksum != p2->cksum)
 114           return false;
 115       }
 116       return true;
 117     }
 118
 119     bool operator==(const rgw_uio* uio) {
 120       uint64_t cksum;
 121       int vix = 0, off = 0;
 122       rgw_vio* vio = &uio->uio_vio[vix];
 123       int vio_len = vio->vio_len;
 124       char *data;
 125
 126       for (int ix = 0; ix < iovcnt; ++ix) {
 127         ZPage* p1 = pages[ix];
 128         data = static_cast<char*>(vio->vio_base) + off;
 129         cksum = XXH64(data, page_size, seed);
 130
 131         if (p1->cksum != cksum) {
 132           int r = memcmp(data, p1->data, page_size);
 133           std::cout << "problem at ix " << ix << " r " << r<< std::endl;
 134           return false;
 135         }
 136
 137         off += page_size;
 138         if (off >= vio_len) {
 139           vio = &uio->uio_vio[++vix];
 140           vio_len = vio->vio_len;
 141           off = 0;
 142         }
 143       }
 144       return true;
 145     }
 146
 147     void cksum() {
 148       int n = size();
 149       for (int page_ix = 0; page_ix < n; ++page_ix) {
 150         ZPage* p = pages[page_ix];
 151         p->cksum = XXH64(p->data, page_size, seed);
 152       }
 153     }
 154
 155     void reset_iovs() { // VOP_READ and VOP_WRITE update
 156       int n = size();
 157       for (int page_ix = 0; page_ix < n; ++page_ix) {
 158         ZPage* p = pages[page_ix];
 159         struct iovec* iov = &iovs[page_ix];
 160         iov->iov_base = p->data;
 161         iov->iov_len = page_size;
 162       }
 163     }
 164
 165     ~ZPageSet() {
 166       for (unsigned int ix = 0; ix < pages.size(); ++ix)
 167         delete pages[ix];
 168       free(iovs);
 169     }
 170   }; /* ZPageSet */
 171
 172   rgw_uio uio[1];
 173   ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
 174
 175   struct {
 176     int argc;
 177     char **argv;
 178   } saved_args;
 179 }
 180
 181 TEST(LibRGW, INIT) {
 182   int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
 183   ASSERT_EQ(ret, 0);
 184   ASSERT_NE(rgw, nullptr);
 185 }
 186
 187 TEST(LibRGW, MOUNT) {
 188   int ret = rgw_mount2(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
 189                        "/", &fs, RGW_MOUNT_FLAG_NONE);
 190   ASSERT_EQ(ret, 0);
 191   ASSERT_NE(fs, nullptr);
 192 }
 193
 194 TEST(LibRGW, CREATE_BUCKET) {
 195   if (do_create) {
 196     struct stat st;
 197     struct rgw_file_handle *fh;
 198
 199     st.st_uid = owner_uid;
 200     st.st_gid = owner_gid;
 201     st.st_mode = 755;
 202
 203     int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
 204                         &fh, RGW_MKDIR_FLAG_NONE);
 205     ASSERT_EQ(ret, 0);
 206   }
 207 }
 208
 209 TEST(LibRGW, LOOKUP_BUCKET) {
 210   int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
 211                        nullptr, 0, RGW_LOOKUP_FLAG_NONE);
 212   ASSERT_EQ(ret, 0);
 213 }
 214
 215 extern "C" {
 216   static int r2_cb(const char* name, void *arg, uint64_t offset,
 217                     struct stat *st, uint32_t st_mask,
 218                     uint32_t flags) {
 219     // don't need arg--it would point to fids
 220     fids.push_back(fid_type(name, offset, nullptr));
 221     return true; /* XXX ? */
 222   }
 223 }
 224
 225 TEST(LibRGW, LIST_OBJECTS) {
 226   if (do_pre_list) {
 227     /* list objects via readdir, bucketwise */
 228     using std::get;
 229
 230     ldout(g_ceph_context, 0) << __func__ << " readdir on bucket "
 231                              << bucket_name << dendl;
 232     bool eof = false;
 233     uint64_t offset = 0;
 234     int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &fids,
 235                           &eof, RGW_READDIR_FLAG_NONE);
 236     for (auto& fid : fids) {
 237       std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
 238                 << std::endl;
 239     }
 240     ASSERT_EQ(ret, 0);
 241   }
 242 }
 243
 244 TEST(LibRGW, LOOKUP_OBJECT) {
 245   if (do_get || do_stat || do_put || do_bulk || do_readv || do_writev) {
 246     int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
 247                          nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
 248     ASSERT_EQ(ret, 0);
 249   }
 250 }
 251
 252 TEST(LibRGW, OBJ_OPEN) {
 253   if (do_get || do_put || do_readv || do_writev) {
 254     int ret = rgw_open(fs, object_fh, 0 /* posix flags */, 0 /* flags */);
 255     ASSERT_EQ(ret, 0);
 256     object_open = true;
 257   }
 258 }
 259
 260 TEST(LibRGW, PUT_OBJECT) {
 261   if (do_put) {
 262     size_t nbytes;
 263     string data = "hi mom"; // fix this
 264     int ret = rgw_write(fs, object_fh, 0, data.length(), &nbytes,
 265                         (void*) data.c_str(), RGW_WRITE_FLAG_NONE);
 266     ASSERT_EQ(ret, 0);
 267     ASSERT_EQ(nbytes, data.length());
 268     /* commit write transaction */
 269     ret = rgw_close(fs, object_fh, 0 /* flags */);
 270     ASSERT_EQ(ret, 0);
 271   }
 272 }
 273
 274 TEST(LibRGW, GET_OBJECT) {
 275   if (do_get) {
 276     char sbuf[512];
 277     memset(sbuf, 0, 512);
 278     size_t nread;
 279     int ret = rgw_read(fs, object_fh, 0 /* off */, 512 /* len */, &nread, sbuf,
 280                        RGW_READ_FLAG_NONE);
 281     ASSERT_EQ(ret, 0);
 282     buffer::list bl;
 283     bl.push_back(buffer::create_static(nread, sbuf));
 284     if (do_hexdump) {
 285       dout(15) << "";
 286       bl.hexdump(*_dout);
 287       *_dout << dendl;
 288     }
 289   }
 290 }
 291
 292 TEST(LibRGW, STAT_OBJECT) {
 293   if (do_stat) {
 294     struct stat st;
 295     int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
 296     ASSERT_EQ(ret, 0);
 297     dout(15) << "rgw_getattr on " << object_name << " size = "
 298              << st.st_size << dendl;
 299   }
 300 }
 301
 302 TEST(LibRGW, WRITE_READ_VERIFY)
 303 {
 304   if (do_bulk && do_put) {
 305     ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
 306     struct iovec *iovs = zp_set1.get_iovs();
 307
 308     /* read after write POSIX-style */
 309     size_t nbytes, off = 0;
 310     for (int ix = 0; ix < 16; ++ix, off += page_size) {
 311       struct iovec *iov = &iovs[ix];
 312       int ret = rgw_write(fs, object_fh, off, page_size, &nbytes,
 313                           iov->iov_base, RGW_WRITE_FLAG_NONE);
 314       ASSERT_EQ(ret, 0);
 315       ASSERT_EQ(nbytes, size_t(page_size));
 316     }
 317     zp_set1.reset_iovs();
 318   }
 319 }
 320
 321 /* "functions that call alloca are not inlined"
 322  * --alexandre oliva
 323  * http://gcc.gnu.org/ml/gcc-help/2004-04/msg00158.html
 324  */
 325 #define alloca_uio()                            \
 326   do {\
 327     int uiosz = sizeof(rgw_uio) + iovcnt*sizeof(rgw_vio);               \
 328     uio = static_cast<rgw_uio*>(alloca(uiosz));                         \
 329     memset(uio, 0, uiosz);                                              \
 330     uio->uio_vio = reinterpret_cast<rgw_vio*>(uio+sizeof(rgw_uio));     \
 331   } while (0);                                                          \
 332
 333 TEST(LibRGW, WRITEV)
 334 {
 335   if (do_writev) {
 336     rgw_uio* uio;
 337     struct iovec *iovs = zp_set1.get_iovs();
 338     alloca_uio();
 339     ASSERT_NE(uio, nullptr);
 340
 341     for (int ix = 0; ix < iovcnt; ++ix) {
 342       struct iovec *iov = &iovs[ix];
 343       rgw_vio *vio = &(uio->uio_vio[ix]);
 344       vio->vio_base = iov->iov_base;
 345       vio->vio_len = iov->iov_len;
 346       vio->vio_u1 = iov; // private data
 347     }
 348     uio->uio_cnt = iovcnt;
 349     uio->uio_offset = iovcnt * page_size;
 350
 351     int ret = rgw_writev(fs, object_fh, uio, RGW_WRITE_FLAG_NONE);
 352     ASSERT_EQ(ret, 0);
 353   }
 354 }
 355
 356 TEST(LibRGW, READV)
 357 {
 358   if (do_readv) {
 359     memset(uio, 0, sizeof(rgw_uio));
 360     uio->uio_offset = 0; // ok, it was already 0
 361     uio->uio_resid = UINT64_MAX;
 362     int ret = rgw_readv(fs, object_fh, uio, RGW_READ_FLAG_NONE);
 363     ASSERT_EQ(ret, 0);
 364     buffer::list bl;
 365     for (unsigned int ix = 0; ix < uio->uio_cnt; ++ix) {
 366       rgw_vio *vio = &(uio->uio_vio[ix]);
 367       bl.push_back(
 368         buffer::create_static(vio->vio_len,
 369                               static_cast<char*>(vio->vio_base)));
 370     }
 371
 372     /* length check */
 373     ASSERT_EQ(uint32_t{bl.length()}, uint32_t{iovcnt*page_size});
 374
 375     if (do_hexdump) {
 376       dout(15) << "";
 377       bl.hexdump(*_dout);
 378       *_dout << dendl;
 379     }
 380   }
 381 }
 382
 383 TEST(LibRGW, READV_AFTER_WRITEV)
 384 {
 385   /* checksum data */
 386   if (do_readv && do_writev && do_verify) {
 387     ASSERT_TRUE(zp_set1 == uio);
 388   }
 389 }
 390
 391 TEST(LibRGW, DELETE_OBJECT) {
 392   if (do_delete) {
 393     int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
 394                          RGW_UNLINK_FLAG_NONE);
 395     ASSERT_EQ(ret, 0);
 396   }
 397 }
 398
 399 TEST(LibRGW, DELETE_BUCKET) {
 400   if (do_delete) {
 401     int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
 402                          RGW_UNLINK_FLAG_NONE);
 403     ASSERT_EQ(ret, 0);
 404   }
 405 }
 406
 407 TEST(LibRGW, CLEANUP) {
 408   if (do_readv) {
 409     // release resources
 410     ASSERT_NE(uio->uio_rele, nullptr);
 411     if (uio->uio_rele) {
 412       uio->uio_rele(uio, RGW_UIO_NONE);
 413     }
 414   }
 415   int ret;
 416   if (object_open) {
 417     ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
 418     ASSERT_EQ(ret, 0);
 419   }
 420   if (object_fh) {
 421     ret = rgw_fh_rele(fs, object_fh, 0 /* flags */);
 422     ASSERT_EQ(ret, 0);
 423   }
 424   ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
 425   ASSERT_EQ(ret, 0);
 426 }
 427
 428 TEST(LibRGW, UMOUNT) {
 429   if (! fs)
 430     return;
 431
 432   int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
 433   ASSERT_EQ(ret, 0);
 434 }
 435
 436 TEST(LibRGW, SHUTDOWN) {
 437   librgw_shutdown(rgw);
 438 }
 439
 440 int main(int argc, char *argv[])
 441 {
 442   auto args = argv_to_vec(argc, argv);
 443   env_to_vec(args);
 444
 445   char* v = getenv("AWS_ACCESS_KEY_ID");
 446   if (v) {
 447     access_key = v;
 448   }
 449
 450   v = getenv("AWS_SECRET_ACCESS_KEY");
 451   if (v) {
 452     secret_key = v;
 453   }
 454
 455   string val;
 456   for (auto arg_iter = args.begin(); arg_iter != args.end();) {
 457     if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
 458                               (char*) nullptr)) {
 459       access_key = val;
 460     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
 461                                      (char*) nullptr)) {
 462       secret_key = val;
 463     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
 464                                      (char*) nullptr)) {
 465       uid = val;
 466     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
 467                                      (char*) nullptr)) {
 468       bucket_name = val;
 469     } else if (ceph_argparse_flag(args, arg_iter, "--get",
 470                                             (char*) nullptr)) {
 471       do_get = true;
 472     } else if (ceph_argparse_flag(args, arg_iter, "--stat",
 473                                             (char*) nullptr)) {
 474       do_stat = true;
 475     } else if (ceph_argparse_flag(args, arg_iter, "--put",
 476                                             (char*) nullptr)) {
 477       do_put = true;
 478     } else if (ceph_argparse_flag(args, arg_iter, "--bulk",
 479                                             (char*) nullptr)) {
 480       do_bulk = true;
 481     } else if (ceph_argparse_flag(args, arg_iter, "--writev",
 482                                             (char*) nullptr)) {
 483       do_writev = true;
 484     } else if (ceph_argparse_flag(args, arg_iter, "--readv",
 485                                             (char*) nullptr)) {
 486       do_readv = true;
 487     } else if (ceph_argparse_flag(args, arg_iter, "--verify",
 488                                             (char*) nullptr)) {
 489       do_verify = true;
 490     } else if (ceph_argparse_flag(args, arg_iter, "--delete",
 491                                             (char*) nullptr)) {
 492       do_delete = true;
 493     } else if (ceph_argparse_flag(args, arg_iter, "--prelist",
 494                                             (char*) nullptr)) {
 495       do_pre_list = true;
 496     } else if (ceph_argparse_flag(args, arg_iter, "--create",
 497                                             (char*) nullptr)) {
 498       do_create = true;
 499     } else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
 500                                             (char*) nullptr)) {
 501       do_hexdump = true;
 502     } else {
 503       ++arg_iter;
 504     }
 505   }
 506
 507   /* don't accidentally run as anonymous */
 508   if ((access_key == "") ||
 509       (secret_key == "")) {
 510     std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
 511     return EPERM;
 512   }
 513
 514   saved_args.argc = argc;
 515   saved_args.argv = argv;
 516
 517   ::testing::InitGoogleTest(&argc, argv);
 518   return RUN_ALL_TESTS();
 519 }