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