ceph/src/test/libradosstriper/aio.cc

   1 #include "include/rados/librados.h"
   2 #include "include/rados/librados.hpp"
   3 #include "include/radosstriper/libradosstriper.h"
   4 #include "include/radosstriper/libradosstriper.hpp"
   5 #include "test/librados/test.h"
   6 #include "test/libradosstriper/TestCase.h"
   7
   8 #include <boost/scoped_ptr.hpp>
   9 #include <fcntl.h>
  10 #include <semaphore.h>
  11 #include <errno.h>
  12
  13 using namespace librados;
  14 using namespace libradosstriper;
  15 using std::pair;
  16
  17 class AioTestData
  18 {
  19 public:
  20   AioTestData() : m_complete(false), m_safe(false) {
  21     m_sem = sem_open("test_libradosstriper_aio_sem", O_CREAT, 0644, 0);
  22   }
  23
  24   ~AioTestData() {
  25     sem_unlink("test_libradosstriper_aio_sem");
  26     sem_close(m_sem);
  27   }
  28
  29   sem_t *m_sem;
  30   bool m_complete;
  31   bool m_safe;
  32 };
  33
  34 void set_completion_complete(rados_completion_t cb, void *arg)
  35 {
  36   AioTestData *test = static_cast<AioTestData*>(arg);
  37   test->m_complete = true;
  38   sem_post(test->m_sem);
  39 }
  40
  41 void set_completion_safe(rados_completion_t cb, void *arg)
  42 {
  43   AioTestData *test = static_cast<AioTestData*>(arg);
  44   test->m_safe = true;
  45   sem_post(test->m_sem);
  46 }
  47
  48 TEST_F(StriperTest, SimpleWrite) {
  49   AioTestData test_data;
  50   rados_completion_t my_completion;
  51   ASSERT_EQ(0, rados_aio_create_completion
  52             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
  53   char buf[128];
  54   memset(buf, 0xcc, sizeof(buf));
  55   ASSERT_EQ(0, rados_striper_aio_write(striper, "StriperTest", my_completion, buf, sizeof(buf), 0));
  56   TestAlarm alarm;
  57   sem_wait(test_data.m_sem);
  58   sem_wait(test_data.m_sem);
  59   rados_aio_release(my_completion);
  60 }
  61
  62 TEST_F(StriperTestPP, SimpleWritePP) {
  63   AioTestData test_data;
  64   AioCompletion *my_completion = librados::Rados::aio_create_completion
  65     ((void*)&test_data, set_completion_complete, set_completion_safe);
  66   char buf[128];
  67   memset(buf, 0xcc, sizeof(buf));
  68   bufferlist bl1;
  69   bl1.append(buf, sizeof(buf));
  70   ASSERT_EQ(0, striper.aio_write("SimpleWritePP", my_completion, bl1, sizeof(buf), 0));
  71   TestAlarm alarm;
  72   sem_wait(test_data.m_sem);
  73   sem_wait(test_data.m_sem);
  74   my_completion->release();
  75 }
  76
  77 TEST_F(StriperTest, WaitForSafe) {
  78   AioTestData test_data;
  79   rados_completion_t my_completion;
  80   ASSERT_EQ(0, rados_aio_create_completion
  81             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
  82   char buf[128];
  83   memset(buf, 0xcc, sizeof(buf));
  84   ASSERT_EQ(0, rados_striper_aio_write(striper, "WaitForSafe", my_completion, buf, sizeof(buf), 0));
  85   TestAlarm alarm;
  86   rados_aio_wait_for_safe(my_completion);
  87   sem_wait(test_data.m_sem);
  88   sem_wait(test_data.m_sem);
  89   rados_aio_release(my_completion);
  90 }
  91
  92 TEST_F(StriperTestPP, WaitForSafePP) {
  93   AioTestData test_data;
  94   AioCompletion *my_completion = librados::Rados::aio_create_completion
  95     ((void*)&test_data, set_completion_complete, set_completion_safe);
  96   char buf[128];
  97   memset(buf, 0xcc, sizeof(buf));
  98   bufferlist bl1;
  99   bl1.append(buf, sizeof(buf));
 100   ASSERT_EQ(0, striper.aio_write("WaitForSafePP", my_completion, bl1, sizeof(buf), 0));
 101   TestAlarm alarm;
 102   my_completion->wait_for_safe();
 103   sem_wait(test_data.m_sem);
 104   sem_wait(test_data.m_sem);
 105   my_completion->release();
 106 }
 107
 108 TEST_F(StriperTest, RoundTrip) {
 109   AioTestData test_data;
 110   rados_completion_t my_completion;
 111   ASSERT_EQ(0, rados_aio_create_completion
 112             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
 113   char buf[128];
 114   memset(buf, 0xcc, sizeof(buf));
 115   ASSERT_EQ(0, rados_striper_aio_write(striper, "RoundTrip", my_completion, buf, sizeof(buf), 0));
 116   {
 117     TestAlarm alarm;
 118     sem_wait(test_data.m_sem);
 119     sem_wait(test_data.m_sem);
 120   }
 121   char buf2[128];
 122   memset(buf2, 0, sizeof(buf2));
 123   rados_completion_t my_completion2;
 124   ASSERT_EQ(0, rados_aio_create_completion
 125             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion2));
 126   ASSERT_EQ(0, rados_striper_aio_read(striper, "RoundTrip", my_completion2, buf2, sizeof(buf2), 0));
 127   {
 128     TestAlarm alarm;
 129     rados_aio_wait_for_complete(my_completion2);
 130   }
 131   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
 132   sem_wait(test_data.m_sem);
 133   sem_wait(test_data.m_sem);
 134   rados_aio_release(my_completion);
 135   rados_aio_release(my_completion2);
 136 }
 137
 138 TEST_F(StriperTest, RoundTrip2) {
 139   AioTestData test_data;
 140   rados_completion_t my_completion;
 141   ASSERT_EQ(0, rados_aio_create_completion
 142             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
 143   char buf[128];
 144   memset(buf, 0xcc, sizeof(buf));
 145   ASSERT_EQ(0, rados_striper_aio_write(striper, "RoundTrip2", my_completion, buf, sizeof(buf), 0));
 146   {
 147     TestAlarm alarm;
 148     sem_wait(test_data.m_sem);
 149     sem_wait(test_data.m_sem);
 150   }
 151   char buf2[128];
 152   memset(buf2, 0, sizeof(buf2));
 153   rados_completion_t my_completion2;
 154   ASSERT_EQ(0, rados_aio_create_completion
 155             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion2));
 156   ASSERT_EQ(0, rados_striper_aio_read(striper, "RoundTrip2", my_completion2, buf2, sizeof(buf2), 0));
 157   {
 158     TestAlarm alarm;
 159     rados_aio_wait_for_safe(my_completion2);
 160   }
 161   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
 162   sem_wait(test_data.m_sem);
 163   sem_wait(test_data.m_sem);
 164   rados_aio_release(my_completion);
 165   rados_aio_release(my_completion2);
 166 }
 167
 168 TEST_F(StriperTestPP, RoundTripPP) {
 169   AioTestData test_data;
 170   AioCompletion *my_completion = librados::Rados::aio_create_completion
 171     ((void*)&test_data, set_completion_complete, set_completion_safe);
 172   char buf[128];
 173   memset(buf, 0xcc, sizeof(buf));
 174   bufferlist bl1;
 175   bl1.append(buf, sizeof(buf));
 176   ASSERT_EQ(0, striper.aio_write("RoundTripPP", my_completion, bl1, sizeof(buf), 0));
 177   {
 178     TestAlarm alarm;
 179     sem_wait(test_data.m_sem);
 180     sem_wait(test_data.m_sem);
 181   }
 182   bufferlist bl2;
 183   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
 184     ((void*)&test_data, set_completion_complete, set_completion_safe);
 185   ASSERT_EQ(0, striper.aio_read("RoundTripPP", my_completion2, &bl2, sizeof(buf), 0));
 186   {
 187     TestAlarm alarm;
 188     my_completion2->wait_for_complete();
 189   }
 190   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
 191   sem_wait(test_data.m_sem);
 192   sem_wait(test_data.m_sem);
 193   my_completion->release();
 194   my_completion2->release();
 195 }
 196
 197 TEST_F(StriperTestPP, RoundTripPP2) {
 198   AioTestData test_data;
 199   AioCompletion *my_completion = librados::Rados::aio_create_completion
 200     ((void*)&test_data, set_completion_complete, set_completion_safe);
 201   char buf[128];
 202   memset(buf, 0xcc, sizeof(buf));
 203   bufferlist bl1;
 204   bl1.append(buf, sizeof(buf));
 205   ASSERT_EQ(0, striper.aio_write("RoundTripPP2", my_completion, bl1, sizeof(buf), 0));
 206   {
 207     TestAlarm alarm;
 208     sem_wait(test_data.m_sem);
 209     sem_wait(test_data.m_sem);
 210   }
 211   bufferlist bl2;
 212   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
 213     ((void*)&test_data, set_completion_complete, set_completion_safe);
 214   ASSERT_EQ(0, striper.aio_read("RoundTripPP2", my_completion2, &bl2, sizeof(buf), 0));
 215   {
 216     TestAlarm alarm;
 217     my_completion2->wait_for_safe();
 218   }
 219   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
 220   sem_wait(test_data.m_sem);
 221   sem_wait(test_data.m_sem);
 222   my_completion->release();
 223   my_completion2->release();
 224 }
 225
 226 TEST_F(StriperTest, IsComplete) {
 227   AioTestData test_data;
 228   rados_completion_t my_completion;
 229   ASSERT_EQ(0, rados_aio_create_completion
 230             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
 231   char buf[128];
 232   memset(buf, 0xcc, sizeof(buf));
 233   ASSERT_EQ(0, rados_striper_aio_write(striper, "IsComplete", my_completion, buf, sizeof(buf), 0));
 234   {
 235     TestAlarm alarm;
 236     sem_wait(test_data.m_sem);
 237     sem_wait(test_data.m_sem);
 238   }
 239   char buf2[128];
 240   memset(buf2, 0, sizeof(buf2));
 241   rados_completion_t my_completion2;
 242   ASSERT_EQ(0, rados_aio_create_completion
 243             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion2));
 244   ASSERT_EQ(0, rados_striper_aio_read(striper, "IsComplete", my_completion2, buf2, sizeof(buf2), 0));
 245   {
 246     TestAlarm alarm;
 247     // Busy-wait until the AIO completes.
 248     // Normally we wouldn't do this, but we want to test rados_aio_is_complete.
 249     while (true) {
 250       int is_complete = rados_aio_is_complete(my_completion2);
 251       if (is_complete)
 252         break;
 253     }
 254   }
 255   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
 256   sem_wait(test_data.m_sem);
 257   sem_wait(test_data.m_sem);
 258   rados_aio_release(my_completion);
 259   rados_aio_release(my_completion2);
 260 }
 261
 262 TEST_F(StriperTestPP, IsCompletePP) {
 263   AioTestData test_data;
 264   AioCompletion *my_completion = librados::Rados::aio_create_completion
 265     ((void*)&test_data, set_completion_complete, set_completion_safe);
 266   char buf[128];
 267   memset(buf, 0xcc, sizeof(buf));
 268   bufferlist bl1;
 269   bl1.append(buf, sizeof(buf));
 270   ASSERT_EQ(0, striper.aio_write("IsCompletePP", my_completion, bl1, sizeof(buf), 0));
 271   {
 272     TestAlarm alarm;
 273     sem_wait(test_data.m_sem);
 274     sem_wait(test_data.m_sem);
 275   }
 276   bufferlist bl2;
 277   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
 278     ((void*)&test_data, set_completion_complete, set_completion_safe);
 279   ASSERT_EQ(0, striper.aio_read("IsCompletePP", my_completion2, &bl2, sizeof(buf), 0));
 280   {
 281     TestAlarm alarm;
 282     // Busy-wait until the AIO completes.
 283     // Normally we wouldn't do this, but we want to test rados_aio_is_complete.
 284     while (true) {
 285       int is_complete = my_completion2->is_complete();
 286       if (is_complete)
 287         break;
 288     }
 289   }
 290   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
 291   sem_wait(test_data.m_sem);
 292   sem_wait(test_data.m_sem);
 293   my_completion->release();
 294   my_completion2->release();
 295 }
 296
 297 TEST_F(StriperTest, IsSafe) {
 298   AioTestData test_data;
 299   rados_completion_t my_completion;
 300   ASSERT_EQ(0, rados_aio_create_completion
 301             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
 302   char buf[128];
 303   memset(buf, 0xcc, sizeof(buf));
 304   ASSERT_EQ(0, rados_striper_aio_write(striper, "IsSafe", my_completion, buf, sizeof(buf), 0));
 305   {
 306     TestAlarm alarm;
 307     // Busy-wait until the AIO completes.
 308     // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
 309     while (true) {
 310       int is_safe = rados_aio_is_safe(my_completion);
 311       if (is_safe)
 312         break;
 313     }
 314   }
 315   char buf2[128];
 316   memset(buf2, 0, sizeof(buf2));
 317   rados_completion_t my_completion2;
 318   ASSERT_EQ(0, rados_aio_create_completion
 319             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion2));
 320   ASSERT_EQ(0, rados_striper_aio_read(striper, "IsSafe", my_completion2, buf2, sizeof(buf2), 0));
 321   {
 322     TestAlarm alarm;
 323     rados_aio_wait_for_complete(my_completion2);
 324   }
 325   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
 326   sem_wait(test_data.m_sem);
 327   sem_wait(test_data.m_sem);
 328   rados_aio_release(my_completion);
 329   rados_aio_release(my_completion2);
 330 }
 331
 332 TEST_F(StriperTestPP, IsSafePP) {
 333   AioTestData test_data;
 334   AioCompletion *my_completion = librados::Rados::aio_create_completion
 335     ((void*)&test_data, set_completion_complete, set_completion_safe);
 336   char buf[128];
 337   memset(buf, 0xcc, sizeof(buf));
 338   bufferlist bl1;
 339   bl1.append(buf, sizeof(buf));
 340   ASSERT_EQ(0, striper.aio_write("IsSafePP", my_completion, bl1, sizeof(buf), 0));
 341   {
 342     TestAlarm alarm;
 343     // Busy-wait until the AIO completes.
 344     // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
 345     while (true) {
 346       int is_safe = my_completion->is_safe();
 347       if (is_safe)
 348         break;
 349     }
 350   }
 351   bufferlist bl2;
 352   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
 353     ((void*)&test_data, set_completion_complete, set_completion_safe);
 354   ASSERT_EQ(0, striper.aio_read("IsSafePP", my_completion2, &bl2, sizeof(buf), 0));
 355   {
 356     TestAlarm alarm;
 357     my_completion2->wait_for_complete();
 358   }
 359   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
 360   sem_wait(test_data.m_sem);
 361   sem_wait(test_data.m_sem);
 362   my_completion->release();
 363   my_completion2->release();
 364 }
 365
 366 TEST_F(StriperTest, RoundTripAppend) {
 367   AioTestData test_data;
 368   rados_completion_t my_completion, my_completion2, my_completion3;
 369   ASSERT_EQ(0, rados_aio_create_completion
 370             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
 371   char buf[128];
 372   memset(buf, 0xcc, sizeof(buf));
 373   ASSERT_EQ(0, rados_striper_aio_append(striper, "RoundTripAppend", my_completion, buf, sizeof(buf)));
 374   {
 375     TestAlarm alarm;
 376     rados_aio_wait_for_complete(my_completion);
 377   }
 378   char buf2[128];
 379   memset(buf2, 0xdd, sizeof(buf2));
 380   ASSERT_EQ(0, rados_aio_create_completion
 381             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion2));
 382   ASSERT_EQ(0, rados_striper_aio_append(striper, "RoundTripAppend", my_completion2, buf2, sizeof(buf)));
 383   {
 384     TestAlarm alarm;
 385     rados_aio_wait_for_complete(my_completion2);
 386   }
 387   char buf3[sizeof(buf) + sizeof(buf2)];
 388   memset(buf3, 0, sizeof(buf3));
 389   ASSERT_EQ(0, rados_aio_create_completion
 390             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion3));
 391   ASSERT_EQ(0, rados_striper_aio_read(striper, "RoundTripAppend", my_completion3, buf3, sizeof(buf3), 0));
 392   {
 393     TestAlarm alarm;
 394     rados_aio_wait_for_complete(my_completion3);
 395   }
 396   ASSERT_EQ((int)(sizeof(buf) + sizeof(buf2)), rados_aio_get_return_value(my_completion3));
 397   ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
 398   ASSERT_EQ(0, memcmp(buf3 + sizeof(buf), buf2, sizeof(buf2)));
 399   sem_wait(test_data.m_sem);
 400   sem_wait(test_data.m_sem);
 401   rados_aio_release(my_completion);
 402   rados_aio_release(my_completion2);
 403   rados_aio_release(my_completion3);
 404 }
 405
 406 TEST_F(StriperTestPP, RoundTripAppendPP) {
 407   AioTestData test_data;
 408   AioCompletion *my_completion = librados::Rados::aio_create_completion
 409     ((void*)&test_data, set_completion_complete, set_completion_safe);
 410   char buf[128];
 411   memset(buf, 0xcc, sizeof(buf));
 412   bufferlist bl1;
 413   bl1.append(buf, sizeof(buf));
 414   ASSERT_EQ(0, striper.aio_append("RoundTripAppendPP", my_completion, bl1, sizeof(buf)));
 415   {
 416     TestAlarm alarm;
 417     my_completion->wait_for_complete();
 418   }
 419   char buf2[128];
 420   memset(buf2, 0xdd, sizeof(buf2));
 421   bufferlist bl2;
 422   bl2.append(buf2, sizeof(buf2));
 423   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
 424     ((void*)&test_data, set_completion_complete, set_completion_safe);
 425   ASSERT_EQ(0, striper.aio_append("RoundTripAppendPP", my_completion2, bl2, sizeof(buf2)));
 426   {
 427     TestAlarm alarm;
 428     my_completion2->wait_for_complete();
 429   }
 430   bufferlist bl3;
 431   AioCompletion *my_completion3 = librados::Rados::aio_create_completion
 432     ((void*)&test_data, set_completion_complete, set_completion_safe);
 433   ASSERT_EQ(0, striper.aio_read("RoundTripAppendPP", my_completion3, &bl3, 2 * sizeof(buf), 0));
 434   {
 435     TestAlarm alarm;
 436     my_completion3->wait_for_complete();
 437   }
 438   ASSERT_EQ(sizeof(buf) + sizeof(buf2), (unsigned)my_completion3->get_return_value());
 439   ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
 440   ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf), buf2, sizeof(buf2)));
 441   sem_wait(test_data.m_sem);
 442   sem_wait(test_data.m_sem);
 443   my_completion->release();
 444   my_completion2->release();
 445   my_completion3->release();
 446 }
 447
 448 TEST_F(StriperTest, Flush) {
 449   AioTestData test_data;
 450   rados_completion_t my_completion;
 451   ASSERT_EQ(0, rados_aio_create_completion
 452             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
 453   char buf[128];
 454   memset(buf, 0xee, sizeof(buf));
 455   ASSERT_EQ(0, rados_striper_aio_write(striper, "Flush", my_completion, buf, sizeof(buf), 0));
 456   rados_striper_aio_flush(striper);
 457   char buf2[128];
 458   memset(buf2, 0, sizeof(buf2));
 459   rados_completion_t my_completion2;
 460   ASSERT_EQ(0, rados_aio_create_completion
 461             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion2));
 462   ASSERT_EQ(0, rados_striper_aio_read(striper, "Flush", my_completion2, buf2, sizeof(buf2), 0));
 463   {
 464     TestAlarm alarm;
 465     rados_aio_wait_for_complete(my_completion2);
 466   }
 467   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
 468   sem_wait(test_data.m_sem);
 469   sem_wait(test_data.m_sem);
 470   rados_aio_release(my_completion);
 471   rados_aio_release(my_completion2);
 472 }
 473
 474 TEST_F(StriperTestPP, FlushPP) {
 475   AioTestData test_data;
 476   AioCompletion *my_completion = librados::Rados::aio_create_completion
 477     ((void*)&test_data, set_completion_complete, set_completion_safe);
 478   char buf[128];
 479   memset(buf, 0xee, sizeof(buf));
 480   bufferlist bl1;
 481   bl1.append(buf, sizeof(buf));
 482   ASSERT_EQ(0, striper.aio_write("FlushPP", my_completion, bl1, sizeof(buf), 0));
 483   striper.aio_flush();
 484   bufferlist bl2;
 485   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
 486     ((void*)&test_data, set_completion_complete, set_completion_safe);
 487   ASSERT_EQ(0, striper.aio_read("FlushPP", my_completion2, &bl2, sizeof(buf), 0));
 488   {
 489     TestAlarm alarm;
 490     my_completion2->wait_for_complete();
 491   }
 492   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
 493   sem_wait(test_data.m_sem);
 494   sem_wait(test_data.m_sem);
 495   my_completion->release();
 496   my_completion2->release();
 497 }
 498
 499 TEST_F(StriperTest, RoundTripWriteFull) {
 500   AioTestData test_data;
 501   rados_completion_t my_completion, my_completion2, my_completion3;
 502   ASSERT_EQ(0, rados_aio_create_completion
 503             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
 504   char buf[128];
 505   memset(buf, 0xcc, sizeof(buf));
 506   ASSERT_EQ(0, rados_striper_aio_write(striper, "RoundTripWriteFull", my_completion, buf, sizeof(buf), 0));
 507   {
 508     TestAlarm alarm;
 509     rados_aio_wait_for_complete(my_completion);
 510   }
 511   char buf2[64];
 512   memset(buf2, 0xdd, sizeof(buf2));
 513   ASSERT_EQ(0, rados_aio_create_completion
 514             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion2));
 515   ASSERT_EQ(0, rados_striper_aio_write_full(striper, "RoundTripWriteFull", my_completion2, buf2, sizeof(buf2)));
 516   {
 517     TestAlarm alarm;
 518     rados_aio_wait_for_complete(my_completion2);
 519   }
 520   char buf3[sizeof(buf) + sizeof(buf2)];
 521   memset(buf3, 0, sizeof(buf3));
 522   ASSERT_EQ(0, rados_aio_create_completion
 523             ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion3));
 524   ASSERT_EQ(0, rados_striper_aio_read(striper, "RoundTripWriteFull", my_completion3, buf3, sizeof(buf3), 0));
 525   {
 526     TestAlarm alarm;
 527     rados_aio_wait_for_complete(my_completion3);
 528   }
 529   ASSERT_EQ(sizeof(buf2), (unsigned)rados_aio_get_return_value(my_completion3));
 530   ASSERT_EQ(0, memcmp(buf3, buf2, sizeof(buf2)));
 531   sem_wait(test_data.m_sem);
 532   sem_wait(test_data.m_sem);
 533   rados_aio_release(my_completion);
 534   rados_aio_release(my_completion2);
 535   rados_aio_release(my_completion3);
 536 }
 537
 538 TEST_F(StriperTestPP, RoundTripWriteFullPP) {
 539   AioTestData test_data;
 540   AioCompletion *my_completion = librados::Rados::aio_create_completion
 541     ((void*)&test_data, set_completion_complete, set_completion_safe);
 542   char buf[128];
 543   memset(buf, 0xcc, sizeof(buf));
 544   bufferlist bl1;
 545   bl1.append(buf, sizeof(buf));
 546   ASSERT_EQ(0, striper.aio_write("RoundTripWriteFullPP", my_completion, bl1, sizeof(buf), 0));
 547   {
 548     TestAlarm alarm;
 549     my_completion->wait_for_complete();
 550   }
 551   char buf2[64];
 552   memset(buf2, 0xdd, sizeof(buf2));
 553   bufferlist bl2;
 554   bl2.append(buf2, sizeof(buf2));
 555   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
 556     ((void*)&test_data, set_completion_complete, set_completion_safe);
 557   ASSERT_EQ(0, striper.aio_write_full("RoundTripWriteFullPP", my_completion2, bl2));
 558   {
 559     TestAlarm alarm;
 560     my_completion2->wait_for_complete();
 561   }
 562   bufferlist bl3;
 563   AioCompletion *my_completion3 = librados::Rados::aio_create_completion
 564     ((void*)&test_data, set_completion_complete, set_completion_safe);
 565   ASSERT_EQ(0, striper.aio_read("RoundTripWriteFullPP", my_completion3, &bl3, sizeof(buf), 0));
 566   {
 567     TestAlarm alarm;
 568     my_completion3->wait_for_complete();
 569   }
 570   ASSERT_EQ(sizeof(buf2), (unsigned)my_completion3->get_return_value());
 571   ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
 572   sem_wait(test_data.m_sem);
 573   sem_wait(test_data.m_sem);
 574   my_completion->release();
 575   my_completion2->release();
 576   my_completion3->release();
 577 }
 578
 579 TEST_F(StriperTest, RemoveTest) {
 580   char buf[128];
 581   char buf2[sizeof(buf)];
 582   // create oabject
 583   memset(buf, 0xaa, sizeof(buf));
 584   ASSERT_EQ(0, rados_striper_write(striper, "RemoveTest", buf, sizeof(buf), 0));
 585   // async remove it
 586   AioTestData test_data;
 587   rados_completion_t my_completion;
 588   ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
 589               set_completion_complete, set_completion_safe, &my_completion));
 590   ASSERT_EQ(0, rados_striper_aio_remove(striper, "RemoveTest", my_completion));
 591   {
 592     TestAlarm alarm;
 593     ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
 594   }
 595   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
 596   rados_aio_release(my_completion);
 597   // check we get ENOENT on reading
 598   ASSERT_EQ(-ENOENT, rados_striper_read(striper, "RemoveTest", buf2, sizeof(buf2), 0));
 599 }
 600
 601 TEST_F(StriperTestPP, RemoveTestPP) {
 602   char buf[128];
 603   memset(buf, 0xaa, sizeof(buf));
 604   bufferlist bl;
 605   bl.append(buf, sizeof(buf));
 606   ASSERT_EQ(0, striper.write("RemoveTestPP", bl, sizeof(buf), 0));
 607   AioCompletion *my_completion = cluster.aio_create_completion(0, 0, 0);
 608   ASSERT_EQ(0, striper.aio_remove("RemoveTestPP", my_completion));
 609   {
 610     TestAlarm alarm;
 611     ASSERT_EQ(0, my_completion->wait_for_complete());
 612   }
 613   ASSERT_EQ(0, my_completion->get_return_value());
 614   bufferlist bl2;
 615   ASSERT_EQ(-ENOENT, striper.read("RemoveTestPP", &bl2, sizeof(buf), 0));
 616   my_completion->release();
 617 }