test: s/rados_aio_create_completion/rados_aio_create_completion2/

the former is deprecated and replaced with the latter

Signed-off-by: Kefu Chai <kchai@redhat.com>

diff --git a/examples/librados/hello_world_c.c b/examples/librados/hello_world_c.c
index 88a45485e2279c447fbf96943accb99bf31cfd5f..2f91828dee889d270c052be584226ef37d6505a8 100644 (file)
--- a/examples/librados/hello_world_c.c
+++ b/examples/librados/hello_world_c.c
@@ -146,7 +146,7 @@ int main(int argc, const char **argv)
     }
     // allocate the completion from librados
     rados_completion_t read_completion;
-    ret = rados_aio_create_completion(NULL, NULL, NULL, &read_completion);
+    ret = rados_aio_create_completion2(NULL, NULL, &read_completion);
     if (ret < 0) {
       printf("couldn't create completion! error %d\n", ret);
       ret = EXIT_FAILURE;

diff --git a/src/test/librados/aio.cc b/src/test/librados/aio.cc
index a8ca47b8b8fcc87a2e5838b0cdd325700f608fb5..2ffff1c342db2be48d20f9a244b94d9dd5cc53f5 100644 (file)
--- a/src/test/librados/aio.cc
+++ b/src/test/librados/aio.cc
@@ -68,8 +68,8 @@ TEST(LibRadosAio, TooBig) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(-E2BIG, rados_aio_write(test_data.m_ioctx, "foo",
@@ -85,8 +85,8 @@ TEST(LibRadosAio, SimpleWrite) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   auto sg = make_scope_guard([&] { rados_aio_release(my_completion); });
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
@@ -100,8 +100,8 @@ TEST(LibRadosAio, SimpleWrite) {
 
   rados_ioctx_set_namespace(test_data.m_ioctx, "nspace");
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   auto sg2 = make_scope_guard([&] { rados_aio_release(my_completion2); });
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion2, buf, sizeof(buf), 0));
@@ -116,14 +116,14 @@ TEST(LibRadosAio, WaitForSafe) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion, buf, sizeof(buf), 0));
   TestAlarm alarm;
-  ASSERT_EQ(0, rados_aio_wait_for_safe(my_completion));
+  ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   rados_aio_release(my_completion);
 }
@@ -132,8 +132,8 @@ TEST(LibRadosAio, RoundTrip) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -146,8 +146,8 @@ TEST(LibRadosAio, RoundTrip) {
   char buf2[256];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -164,8 +164,8 @@ TEST(LibRadosAio, RoundTrip2) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -178,8 +178,8 @@ TEST(LibRadosAio, RoundTrip2) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -196,8 +196,8 @@ TEST(LibRadosAio, RoundTrip3) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
 
@@ -219,8 +219,8 @@ TEST(LibRadosAio, RoundTrip3) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
 
   rados_read_op_t op2 = rados_create_read_op();
   rados_read_op_read(op2, 0, sizeof(buf2), buf2, NULL, NULL);
@@ -255,8 +255,8 @@ TEST(LibRadosAio, RoundTripAppend) {
   AioTestData test_data;
   rados_completion_t my_completion, my_completion2, my_completion3;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
@@ -268,8 +268,8 @@ TEST(LibRadosAio, RoundTripAppend) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   char buf2[128];
   memset(buf2, 0xdd, sizeof(buf2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
                               my_completion2, buf2, sizeof(buf2)));
   {
@@ -279,8 +279,8 @@ TEST(LibRadosAio, RoundTripAppend) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
   char buf3[sizeof(buf) + sizeof(buf2)];
   memset(buf3, 0, sizeof(buf3));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion3, buf3, sizeof(buf3), 0));
   {
@@ -301,8 +301,8 @@ TEST(LibRadosAio, RemoveTest) {
   rados_completion_t my_completion;
   AioTestData test_data;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   memset(buf, 0xaa, sizeof(buf));
   ASSERT_EQ(0, rados_append(test_data.m_ioctx, "foo", buf, sizeof(buf)));
   ASSERT_EQ(0, rados_aio_remove(test_data.m_ioctx, "foo", my_completion));
@@ -327,8 +327,8 @@ TEST(LibRadosAio, XattrsRoundTrip) {
   ASSERT_EQ(0, rados_append(test_data.m_ioctx, "foo", buf, sizeof(buf)));
   // async getxattr
   rados_completion_t my_completion;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   ASSERT_EQ(0, rados_aio_getxattr(test_data.m_ioctx, "foo", my_completion, attr1, buf, sizeof(buf)));
   {
     TestAlarm alarm;
@@ -338,8 +338,8 @@ TEST(LibRadosAio, XattrsRoundTrip) {
   rados_aio_release(my_completion);
   // async setxattr
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_setxattr(test_data.m_ioctx, "foo", my_completion2, attr1, attr1_buf, sizeof(attr1_buf)));
   {
     TestAlarm alarm;
@@ -349,8 +349,8 @@ TEST(LibRadosAio, XattrsRoundTrip) {
   rados_aio_release(my_completion2);
   // async getxattr
   rados_completion_t my_completion3;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_getxattr(test_data.m_ioctx, "foo", my_completion3, attr1, buf, sizeof(buf)));
   {
     TestAlarm alarm;
@@ -373,8 +373,8 @@ TEST(LibRadosAio, RmXattr) {
   ASSERT_EQ(0, rados_append(test_data.m_ioctx, "foo", buf, sizeof(buf)));  
   // async setxattr
   rados_completion_t my_completion;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   ASSERT_EQ(0, rados_aio_setxattr(test_data.m_ioctx, "foo", my_completion, attr1, attr1_buf, sizeof(attr1_buf)));
   {
     TestAlarm alarm;
@@ -384,8 +384,8 @@ TEST(LibRadosAio, RmXattr) {
   rados_aio_release(my_completion);
   // async rmxattr
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-            nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+            nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_rmxattr(test_data.m_ioctx, "foo", my_completion2, attr1));
   {
     TestAlarm alarm;
@@ -395,8 +395,8 @@ TEST(LibRadosAio, RmXattr) {
   rados_aio_release(my_completion2);
   // async getxattr after deletion
   rados_completion_t my_completion3;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-            nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+            nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_getxattr(test_data.m_ioctx, "foo", my_completion3, attr1, buf, sizeof(buf)));
   {
     TestAlarm alarm;
@@ -412,8 +412,8 @@ TEST(LibRadosAio, RmXattr) {
   ASSERT_EQ(0, rados_write(test_data.m_ioctx, "foo_rmxattr", buf2, sizeof(buf2), 0));
   // asynx setxattr
   rados_completion_t my_completion4;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-            nullptr, nullptr, &my_completion4));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+            nullptr, &my_completion4));
   ASSERT_EQ(0, rados_aio_setxattr(test_data.m_ioctx, "foo_rmxattr", my_completion4, attr2, attr2_buf, sizeof(attr2_buf)));
   {
     TestAlarm alarm;
@@ -425,8 +425,8 @@ TEST(LibRadosAio, RmXattr) {
   ASSERT_EQ(0, rados_remove(test_data.m_ioctx, "foo_rmxattr"));
   // async rmxattr on non existing object
   rados_completion_t my_completion5;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-            nullptr, nullptr, &my_completion5));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+            nullptr, &my_completion5));
   ASSERT_EQ(0, rados_aio_rmxattr(test_data.m_ioctx, "foo_rmxattr", my_completion5, attr2));
   {
     TestAlarm alarm;
@@ -454,8 +454,8 @@ TEST(LibRadosAio, XattrIter) {
   ASSERT_EQ(0, rados_setxattr(test_data.m_ioctx, "foo", attr2, attr2_buf, sizeof(attr2_buf)));
   // call async version of getxattrs and wait for completion
   rados_completion_t my_completion;
-  ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
-            nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2((void*)&test_data,
+            nullptr, &my_completion));
   rados_xattrs_iter_t iter;
   ASSERT_EQ(0, rados_aio_getxattrs(test_data.m_ioctx, "foo", my_completion, &iter));
   {
@@ -493,8 +493,8 @@ TEST(LibRadosAio, IsComplete) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -507,8 +507,8 @@ TEST(LibRadosAio, IsComplete) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -532,8 +532,8 @@ TEST(LibRadosAio, IsSafe) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -553,8 +553,8 @@ TEST(LibRadosAio, IsSafe) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -571,8 +571,8 @@ TEST(LibRadosAio, ReturnValue) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0, sizeof(buf));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "nonexistent",
@@ -589,8 +589,8 @@ TEST(LibRadosAio, Flush) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xee, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -600,8 +600,8 @@ TEST(LibRadosAio, Flush) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -618,10 +618,10 @@ TEST(LibRadosAio, FlushAsync) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   rados_completion_t flush_completion;
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &flush_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &flush_completion));
   char buf[128];
   memset(buf, 0xee, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -630,18 +630,15 @@ TEST(LibRadosAio, FlushAsync) {
   {
     TestAlarm alarm;
     ASSERT_EQ(0, rados_aio_wait_for_complete(flush_completion));
-    ASSERT_EQ(0, rados_aio_wait_for_safe(flush_completion));
   }
   ASSERT_EQ(1, rados_aio_is_complete(my_completion));
-  ASSERT_EQ(1, rados_aio_is_safe(my_completion));
   ASSERT_EQ(1, rados_aio_is_complete(flush_completion));
-  ASSERT_EQ(1, rados_aio_is_safe(flush_completion));
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -659,8 +656,8 @@ TEST(LibRadosAio, RoundTripWriteFull) {
   AioTestData test_data;
   rados_completion_t my_completion, my_completion2, my_completion3;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -672,8 +669,8 @@ TEST(LibRadosAio, RoundTripWriteFull) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   char buf2[64];
   memset(buf2, 0xdd, sizeof(buf2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_write_full(test_data.m_ioctx, "foo",
                               my_completion2, buf2, sizeof(buf2)));
   {
@@ -683,8 +680,8 @@ TEST(LibRadosAio, RoundTripWriteFull) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
   char buf3[sizeof(buf) + sizeof(buf2)];
   memset(buf3, 0, sizeof(buf3));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion3, buf3, sizeof(buf3), 0));
   {
@@ -702,8 +699,8 @@ TEST(LibRadosAio, RoundTripWriteSame) {
   AioTestData test_data;
   rados_completion_t my_completion, my_completion2, my_completion3;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char full[128];
   memset(full, 0xcc, sizeof(full));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -717,8 +714,8 @@ TEST(LibRadosAio, RoundTripWriteSame) {
   char buf[32];
   size_t ws_write_len = sizeof(full);
   memset(buf, 0xdd, sizeof(buf));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_writesame(test_data.m_ioctx, "foo",
                                   my_completion2, buf, sizeof(buf),
                                   ws_write_len, 0));
@@ -727,8 +724,8 @@ TEST(LibRadosAio, RoundTripWriteSame) {
     ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion2));
   }
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion3, full, sizeof(full), 0));
   {
@@ -748,8 +745,8 @@ TEST(LibRadosAio, SimpleStat) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -762,8 +759,8 @@ TEST(LibRadosAio, SimpleStat) {
   uint64_t psize;
   time_t pmtime;
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion2, &psize, &pmtime));
   {
@@ -780,8 +777,8 @@ TEST(LibRadosAio, SimpleStatNS) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -794,8 +791,8 @@ TEST(LibRadosAio, SimpleStatNS) {
   rados_ioctx_set_namespace(test_data.m_ioctx, "nspace");
   char buf2[64];
   memset(buf2, 0xbb, sizeof(buf2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion, buf2, sizeof(buf2), 0));
   {
@@ -807,8 +804,8 @@ TEST(LibRadosAio, SimpleStatNS) {
   time_t pmtime;
   rados_completion_t my_completion2;
   rados_ioctx_set_namespace(test_data.m_ioctx, "");
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion2, &psize, &pmtime));
   {
@@ -820,8 +817,8 @@ TEST(LibRadosAio, SimpleStatNS) {
 
   rados_ioctx_set_namespace(test_data.m_ioctx, "nspace");
   rados_completion_t my_completion3;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion3, &psize, &pmtime));
   {
@@ -840,8 +837,8 @@ TEST(LibRadosAio, StatRemove) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -854,8 +851,8 @@ TEST(LibRadosAio, StatRemove) {
   uint64_t psize;
   time_t pmtime;
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion2, &psize, &pmtime));
   {
@@ -865,8 +862,8 @@ TEST(LibRadosAio, StatRemove) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
   ASSERT_EQ(sizeof(buf), psize);
   rados_completion_t my_completion3;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_remove(test_data.m_ioctx, "foo", my_completion3));
   {
     TestAlarm alarm;
@@ -876,8 +873,8 @@ TEST(LibRadosAio, StatRemove) {
   uint64_t psize2;
   time_t pmtime2;
   rados_completion_t my_completion4;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion4));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion4));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion4, &psize2, &pmtime2));
   {
@@ -895,8 +892,8 @@ TEST(LibRadosAio, ExecuteClass) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -906,8 +903,8 @@ TEST(LibRadosAio, ExecuteClass) {
     ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   }
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   char out[128];
   ASSERT_EQ(0, rados_aio_exec(test_data.m_ioctx, "foo", my_completion2,
                              "hello", "say_hello", NULL, 0, out, sizeof(out)));
@@ -929,8 +926,8 @@ TEST(LibRadosAio, MultiWrite) {
   AioTestData test_data;
   rados_completion_t my_completion, my_completion2, my_completion3;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -943,8 +940,8 @@ TEST(LibRadosAio, MultiWrite) {
 
   char buf2[64];
   memset(buf2, 0xdd, sizeof(buf2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion2, buf2, sizeof(buf2), sizeof(buf)));
   {
@@ -955,8 +952,8 @@ TEST(LibRadosAio, MultiWrite) {
 
   char buf3[(sizeof(buf) + sizeof(buf2)) * 3];
   memset(buf3, 0, sizeof(buf3));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion3, buf3, sizeof(buf3), 0));
   {
@@ -976,8 +973,8 @@ TEST(LibRadosAio, AioUnlock) {
   ASSERT_EQ("", test_data.init());
   ASSERT_EQ(0, rados_lock_exclusive(test_data.m_ioctx, "foo", "TestLock", "Cookie", "", NULL, 0));
   rados_completion_t my_completion;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-            nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+            nullptr, &my_completion));
   ASSERT_EQ(0, rados_aio_unlock(test_data.m_ioctx, "foo", "TestLock", "Cookie", my_completion));
   {
     TestAlarm alarm;
@@ -1037,8 +1034,8 @@ TEST(LibRadosAioEC, SimpleWrite) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   auto sg = make_scope_guard([&] { rados_aio_release(my_completion); });
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
@@ -1052,8 +1049,8 @@ TEST(LibRadosAioEC, SimpleWrite) {
 
   rados_ioctx_set_namespace(test_data.m_ioctx, "nspace");
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   auto sg2 = make_scope_guard([&] { rados_aio_release(my_completion2); });
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion2, buf, sizeof(buf), 0));
@@ -1064,18 +1061,18 @@ TEST(LibRadosAioEC, SimpleWrite) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
 }
 
-TEST(LibRadosAioEC, WaitForSafe) {
+TEST(LibRadosAioEC, WaitForComplete) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion, buf, sizeof(buf), 0));
   TestAlarm alarm;
-  ASSERT_EQ(0, rados_aio_wait_for_safe(my_completion));
+  ASSERT_EQ(0, rados_aio_wait_for_complete(my_completion));
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   rados_aio_release(my_completion);
 }
@@ -1084,8 +1081,8 @@ TEST(LibRadosAioEC, RoundTrip) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1098,8 +1095,8 @@ TEST(LibRadosAioEC, RoundTrip) {
   char buf2[256];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -1116,8 +1113,8 @@ TEST(LibRadosAioEC, RoundTrip2) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1130,8 +1127,8 @@ TEST(LibRadosAioEC, RoundTrip2) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -1148,8 +1145,8 @@ TEST(LibRadosAioEC, RoundTripAppend) {
   AioTestDataEC test_data;
   rados_completion_t my_completion, my_completion2, my_completion3, my_completion4;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   int requires;
   ASSERT_EQ(0, rados_ioctx_pool_requires_alignment2(test_data.m_ioctx, &requires));
   ASSERT_NE(0, requires);
@@ -1171,8 +1168,8 @@ TEST(LibRadosAioEC, RoundTripAppend) {
   int hbsize = bsize / 2;
   char *buf2 = (char *)new char[hbsize];
   memset(buf2, 0xdd, hbsize);
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
                               my_completion2, buf2, hbsize));
   {
@@ -1181,8 +1178,8 @@ TEST(LibRadosAioEC, RoundTripAppend) {
   }
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
 
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_append(test_data.m_ioctx, "foo",
                               my_completion3, buf2, hbsize));
   {
@@ -1194,8 +1191,8 @@ TEST(LibRadosAioEC, RoundTripAppend) {
   int tbsize = bsize + hbsize;
   char *buf3 = (char *)new char[tbsize];
   memset(buf3, 0, tbsize);
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion4));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion4));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion4, buf3, bsize * 3, 0));
   {
@@ -1218,8 +1215,8 @@ TEST(LibRadosAioEC, IsComplete) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1232,8 +1229,8 @@ TEST(LibRadosAioEC, IsComplete) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -1257,8 +1254,8 @@ TEST(LibRadosAioEC, IsSafe) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1278,8 +1275,8 @@ TEST(LibRadosAioEC, IsSafe) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -1296,8 +1293,8 @@ TEST(LibRadosAioEC, ReturnValue) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0, sizeof(buf));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "nonexistent",
@@ -1314,8 +1311,8 @@ TEST(LibRadosAioEC, Flush) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xee, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1325,8 +1322,8 @@ TEST(LibRadosAioEC, Flush) {
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -1343,10 +1340,10 @@ TEST(LibRadosAioEC, FlushAsync) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   rados_completion_t flush_completion;
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &flush_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &flush_completion));
   char buf[128];
   memset(buf, 0xee, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1355,18 +1352,15 @@ TEST(LibRadosAioEC, FlushAsync) {
   {
     TestAlarm alarm;
     ASSERT_EQ(0, rados_aio_wait_for_complete(flush_completion));
-    ASSERT_EQ(0, rados_aio_wait_for_safe(flush_completion));
   }
   ASSERT_EQ(1, rados_aio_is_complete(my_completion));
-  ASSERT_EQ(1, rados_aio_is_safe(my_completion));
   ASSERT_EQ(1, rados_aio_is_complete(flush_completion));
-  ASSERT_EQ(1, rados_aio_is_safe(flush_completion));
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion2, buf2, sizeof(buf2), 0));
   {
@@ -1384,8 +1378,8 @@ TEST(LibRadosAioEC, RoundTripWriteFull) {
   AioTestDataEC test_data;
   rados_completion_t my_completion, my_completion2, my_completion3;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1397,8 +1391,8 @@ TEST(LibRadosAioEC, RoundTripWriteFull) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   char buf2[64];
   memset(buf2, 0xdd, sizeof(buf2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_write_full(test_data.m_ioctx, "foo",
                               my_completion2, buf2, sizeof(buf2)));
   {
@@ -1408,8 +1402,8 @@ TEST(LibRadosAioEC, RoundTripWriteFull) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
   char buf3[sizeof(buf) + sizeof(buf2)];
   memset(buf3, 0, sizeof(buf3));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion3, buf3, sizeof(buf3), 0));
   {
@@ -1427,8 +1421,8 @@ TEST(LibRadosAioEC, SimpleStat) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1441,8 +1435,8 @@ TEST(LibRadosAioEC, SimpleStat) {
   uint64_t psize;
   time_t pmtime;
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion2, &psize, &pmtime));
   {
@@ -1460,8 +1454,8 @@ TEST(LibRadosAioEC, SimpleStatNS) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1474,8 +1468,8 @@ TEST(LibRadosAioEC, SimpleStatNS) {
   rados_ioctx_set_namespace(test_data.m_ioctx, "nspace");
   char buf2[64];
   memset(buf2, 0xbb, sizeof(buf2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion, buf2, sizeof(buf2), 0));
   {
@@ -1487,8 +1481,8 @@ TEST(LibRadosAioEC, SimpleStatNS) {
   time_t pmtime;
   rados_completion_t my_completion2;
   rados_ioctx_set_namespace(test_data.m_ioctx, "");
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion2, &psize, &pmtime));
   {
@@ -1500,8 +1494,8 @@ TEST(LibRadosAioEC, SimpleStatNS) {
 
   rados_ioctx_set_namespace(test_data.m_ioctx, "nspace");
   rados_completion_t my_completion3;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion3, &psize, &pmtime));
   {
@@ -1520,8 +1514,8 @@ TEST(LibRadosAioEC, StatRemove) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1534,8 +1528,8 @@ TEST(LibRadosAioEC, StatRemove) {
   uint64_t psize;
   time_t pmtime;
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion2, &psize, &pmtime));
   {
@@ -1545,8 +1539,8 @@ TEST(LibRadosAioEC, StatRemove) {
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion2));
   ASSERT_EQ(sizeof(buf), psize);
   rados_completion_t my_completion3;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_remove(test_data.m_ioctx, "foo", my_completion3));
   {
     TestAlarm alarm;
@@ -1556,8 +1550,8 @@ TEST(LibRadosAioEC, StatRemove) {
   uint64_t psize2;
   time_t pmtime2;
   rados_completion_t my_completion4;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion4));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion4));
   ASSERT_EQ(0, rados_aio_stat(test_data.m_ioctx, "foo",
                              my_completion4, &psize2, &pmtime2));
   {
@@ -1575,8 +1569,8 @@ TEST(LibRadosAioEC, ExecuteClass) {
   AioTestDataEC test_data;
   rados_completion_t my_completion;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1587,8 +1581,8 @@ TEST(LibRadosAioEC, ExecuteClass) {
   }
   ASSERT_EQ(0, rados_aio_get_return_value(my_completion));
   rados_completion_t my_completion2;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   char out[128];
   ASSERT_EQ(0, rados_aio_exec(test_data.m_ioctx, "foo", my_completion2,
                              "hello", "say_hello", NULL, 0, out, sizeof(out)));
@@ -1606,8 +1600,8 @@ TEST(LibRadosAioEC, MultiWrite) {
   AioTestDataEC test_data;
   rados_completion_t my_completion, my_completion2, my_completion3;
   ASSERT_EQ("", test_data.init());
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
@@ -1620,8 +1614,8 @@ TEST(LibRadosAioEC, MultiWrite) {
 
   char buf2[64];
   memset(buf2, 0xdd, sizeof(buf2));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion2));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion2));
   ASSERT_EQ(0, rados_aio_write(test_data.m_ioctx, "foo",
                               my_completion2, buf2, sizeof(buf2), sizeof(buf)));
   {
@@ -1632,8 +1626,8 @@ TEST(LibRadosAioEC, MultiWrite) {
 
   char buf3[(sizeof(buf) + sizeof(buf2)) * 3];
   memset(buf3, 0, sizeof(buf3));
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr,
-             nullptr, nullptr, &my_completion3));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr,
+             nullptr, &my_completion3));
   ASSERT_EQ(0, rados_aio_read(test_data.m_ioctx, "foo",
                              my_completion3, buf3, sizeof(buf3), 0));
   {

diff --git a/src/test/librados/misc.cc b/src/test/librados/misc.cc
index 5f7fdd889f5a5accc05c1663129ea83225384ce2..b4dfb371e188ec7f86d1947c506f1ce128932ce4 100644 (file)
--- a/src/test/librados/misc.cc
+++ b/src/test/librados/misc.cc
@@ -119,7 +119,7 @@ TEST(LibRadosMiscPool, PoolCreationRace) {
   while (max--) {
     char buf[100];
     rados_completion_t c;
-    rados_aio_create_completion(0, 0, 0, &c);
+    rados_aio_create_completion2(nullptr, nullptr, &c);
     cls.push_back(c);
     rados_aio_read(a, "PoolCreationRaceObj", c, buf, 100, 0);
     cout << "started " << (void*)c << std::endl;

diff --git a/src/test/librados/snapshots.cc b/src/test/librados/snapshots.cc
index 966ec19add6ce9e0920a60ea22f93e8406ffdf16..ec8e534270b63eabb66a5eeb96f73ac9e50439f0 100644 (file)
--- a/src/test/librados/snapshots.cc
+++ b/src/test/librados/snapshots.cc
@@ -88,7 +88,7 @@ TEST_F(LibRadosSnapshotsSelfManaged, Snap) {
 
   my_snaps.push_back(-2);
   rados_completion_t completion;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
                                            &completion));
   rados_aio_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back(), completion);
   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
@@ -108,7 +108,7 @@ TEST_F(LibRadosSnapshotsSelfManaged, Snap) {
   ASSERT_EQ((int)sizeof(buf3), rados_read(ioctx, "foo", buf3, sizeof(buf3), 0));
   ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
 
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
                                            &completion));
   rados_aio_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back(), completion);
   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
@@ -227,7 +227,7 @@ TEST_F(LibRadosSnapshotsSelfManagedEC, Snap) {
 
   my_snaps.push_back(-2);
   rados_completion_t completion;
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
                                            &completion));
   rados_aio_ioctx_selfmanaged_snap_create(ioctx, &my_snaps.back(), completion);
   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));
@@ -247,7 +247,7 @@ TEST_F(LibRadosSnapshotsSelfManagedEC, Snap) {
   ASSERT_EQ(bsize, rados_read(ioctx, "foo", buf3, bsize*2, 0));
   ASSERT_EQ(0, memcmp(buf3, buf, bsize));
 
-  ASSERT_EQ(0, rados_aio_create_completion(nullptr, nullptr, nullptr,
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr,
                                            &completion));
   rados_aio_ioctx_selfmanaged_snap_remove(ioctx, my_snaps.back(), completion);
   ASSERT_EQ(0, rados_aio_wait_for_complete(completion));

diff --git a/src/test/librados/watch_notify.cc b/src/test/librados/watch_notify.cc
index 5e7c69a49b0ff08b7ed8082bbe798a2c549c6276..69dd68f5072de550ea39f912a6ac18857d4dc902 100644 (file)
--- a/src/test/librados/watch_notify.cc
+++ b/src/test/librados/watch_notify.cc
@@ -162,7 +162,7 @@ TEST_F(LibRadosWatchNotify, AioWatchDelete) {
 
   rados_completion_t comp;
   uint64_t handle;
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   rados_aio_watch(ioctx, notify_oid, comp, &handle,
                   watch_notify2_test_cb, watch_notify2_test_errcb, this);
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
@@ -178,7 +178,7 @@ TEST_F(LibRadosWatchNotify, AioWatchDelete) {
   ASSERT_TRUE(left > 0);
   ASSERT_EQ(-ENOTCONN, notify_err);
   ASSERT_EQ(-ENOTCONN, rados_watch_check(ioctx, handle));
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   rados_aio_unwatch(ioctx, handle, comp);
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
   ASSERT_EQ(-ENOENT, rados_aio_get_return_value(comp));
@@ -243,7 +243,7 @@ TEST_F(LibRadosWatchNotify, AioWatchNotify2) {
 
   rados_completion_t comp;
   uint64_t handle;
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   rados_aio_watch(ioctx, notify_oid, comp, &handle,
                   watch_notify2_test_cb, watch_notify2_test_errcb, this);
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
@@ -280,7 +280,7 @@ TEST_F(LibRadosWatchNotify, AioWatchNotify2) {
   ASSERT_EQ((char*)0, reply_buf);
   ASSERT_EQ(0u, reply_buf_len);
 
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   rados_aio_unwatch(ioctx, handle, comp);
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
   ASSERT_EQ(0, rados_aio_get_return_value(comp));
@@ -303,7 +303,7 @@ TEST_F(LibRadosWatchNotify, AioNotify) {
   char *reply_buf = 0;
   size_t reply_buf_len;
   rados_completion_t comp;
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   ASSERT_EQ(0, rados_aio_notify(ioctx, "foo", comp, "notify", 6, 300000,
                                 &reply_buf, &reply_buf_len));
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
@@ -328,7 +328,7 @@ TEST_F(LibRadosWatchNotify, AioNotify) {
 
   // try it on a non-existent object ... our buffer pointers
   // should get zeroed.
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   ASSERT_EQ(0, rados_aio_notify(ioctx, "doesnotexist", comp, "notify", 6,
                                 300000, &reply_buf, &reply_buf_len));
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
@@ -436,7 +436,7 @@ TEST_F(LibRadosWatchNotify, WatchNotify2Timeout) {
   rados_unwatch2(ioctx, handle);
 
   rados_completion_t comp;
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   rados_aio_watch_flush(cluster, comp);
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
   ASSERT_EQ(0, rados_aio_get_return_value(comp));
@@ -559,7 +559,7 @@ TEST_F(LibRadosWatchNotify, AioWatchDelete2) {
 
   rados_completion_t comp;
   uint64_t handle;
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   rados_aio_watch2(ioctx, notify_oid, comp, &handle,
                   watch_notify2_test_cb, watch_notify2_test_errcb, timeout, this);
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
@@ -575,7 +575,7 @@ TEST_F(LibRadosWatchNotify, AioWatchDelete2) {
   ASSERT_TRUE(left > 0);
   ASSERT_EQ(-ENOTCONN, notify_err);
   ASSERT_EQ(-ENOTCONN, rados_watch_check(ioctx, handle));
-  ASSERT_EQ(0, rados_aio_create_completion(NULL, NULL, NULL, &comp));
+  ASSERT_EQ(0, rados_aio_create_completion2(nullptr, nullptr, &comp));
   rados_aio_unwatch(ioctx, handle, comp);
   ASSERT_EQ(0, rados_aio_wait_for_complete(comp));
   ASSERT_EQ(-ENOENT, rados_aio_get_return_value(comp));

diff --git a/src/test/libradosstriper/aio.cc b/src/test/libradosstriper/aio.cc
index ab8c9c535b2fc244b71f609d3627dd69e80a2a8a..a1dca85f969bfa54ca98d93d32964cf807062cc4 100644 (file)
--- a/src/test/libradosstriper/aio.cc
+++ b/src/test/libradosstriper/aio.cc
@@ -17,7 +17,7 @@ using std::pair;
 class AioTestData
 {
 public:
-  AioTestData() : m_complete(false), m_safe(false) {
+  AioTestData() : m_complete(false) {
     m_sem = sem_open("test_libradosstriper_aio_sem", O_CREAT, 0644, 0);
   }
 
@@ -28,7 +28,6 @@ public:
 
   sem_t *m_sem;
   bool m_complete;
-  bool m_safe;
 };
 
 void set_completion_complete(rados_completion_t cb, void *arg)
@@ -38,31 +37,23 @@ void set_completion_complete(rados_completion_t cb, void *arg)
   sem_post(test->m_sem);
 }
 
-void set_completion_safe(rados_completion_t cb, void *arg)
-{
-  AioTestData *test = static_cast<AioTestData*>(arg);
-  test->m_safe = true;
-  sem_post(test->m_sem);
-}
-
 TEST_F(StriperTest, SimpleWrite) {
   AioTestData test_data;
   rados_completion_t my_completion;
   ASSERT_EQ(0, rados_aio_create_completion
-            ((void*)&test_data, set_completion_complete, set_completion_safe, &my_completion));
+            ((void*)&test_data, set_completion_complete, &my_completion));
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   ASSERT_EQ(0, rados_striper_aio_write(striper, "StriperTest", my_completion, buf, sizeof(buf), 0));
   TestAlarm alarm;
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
 }
 
 TEST_F(StriperTestPP, SimpleWritePP) {
   AioTestData test_data;
   AioCompletion *my_completion = librados::Rados::aio_create_completion
-    ((void*)&test_data, set_completion_complete, set_completion_safe);
+    ((void*)&test_data, set_completion_complete);
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
   bufferlist bl1;
@@ -70,7 +61,6 @@ TEST_F(StriperTestPP, SimpleWritePP) {
   ASSERT_EQ(0, striper.aio_write("SimpleWritePP", my_completion, bl1, sizeof(buf), 0));
   TestAlarm alarm;
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
 }
 
@@ -85,7 +75,6 @@ TEST_F(StriperTest, WaitForSafe) {
   TestAlarm alarm;
   rados_aio_wait_for_safe(my_completion);
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
 }
 
@@ -101,7 +90,6 @@ TEST_F(StriperTestPP, WaitForSafePP) {
   TestAlarm alarm;
   my_completion->wait_for_complete();
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
 }
 
@@ -116,7 +104,6 @@ TEST_F(StriperTest, RoundTrip) {
   {
     TestAlarm alarm;
     sem_wait(test_data.m_sem);
-    sem_wait(test_data.m_sem);
   }
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
@@ -130,7 +117,6 @@ TEST_F(StriperTest, RoundTrip) {
   }
   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
   rados_aio_release(my_completion2);
 }
@@ -146,7 +132,6 @@ TEST_F(StriperTest, RoundTrip2) {
   {
     TestAlarm alarm;
     sem_wait(test_data.m_sem);
-    sem_wait(test_data.m_sem);
   }
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
@@ -160,7 +145,6 @@ TEST_F(StriperTest, RoundTrip2) {
   }
   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
   rados_aio_release(my_completion2);
 }
@@ -177,7 +161,6 @@ TEST_F(StriperTestPP, RoundTripPP) {
   {
     TestAlarm alarm;
     sem_wait(test_data.m_sem);
-    sem_wait(test_data.m_sem);
   }
   bufferlist bl2;
   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
@@ -189,7 +172,6 @@ TEST_F(StriperTestPP, RoundTripPP) {
   }
   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
   my_completion2->release();
 }
@@ -206,7 +188,6 @@ TEST_F(StriperTestPP, RoundTripPP2) {
   {
     TestAlarm alarm;
     sem_wait(test_data.m_sem);
-    sem_wait(test_data.m_sem);
   }
   bufferlist bl2;
   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
@@ -218,7 +199,6 @@ TEST_F(StriperTestPP, RoundTripPP2) {
   }
   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
   my_completion2->release();
 }
@@ -234,7 +214,6 @@ TEST_F(StriperTest, IsComplete) {
   {
     TestAlarm alarm;
     sem_wait(test_data.m_sem);
-    sem_wait(test_data.m_sem);
   }
   char buf2[128];
   memset(buf2, 0, sizeof(buf2));
@@ -254,7 +233,6 @@ TEST_F(StriperTest, IsComplete) {
   }
   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
   rados_aio_release(my_completion2);
 }
@@ -271,7 +249,6 @@ TEST_F(StriperTestPP, IsCompletePP) {
   {
     TestAlarm alarm;
     sem_wait(test_data.m_sem);
-    sem_wait(test_data.m_sem);
   }
   bufferlist bl2;
   AioCompletion *my_completion2 = librados::Rados::aio_create_completion
@@ -289,7 +266,6 @@ TEST_F(StriperTestPP, IsCompletePP) {
   }
   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
   my_completion2->release();
 }
@@ -324,7 +300,6 @@ TEST_F(StriperTest, IsSafe) {
   }
   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
   rados_aio_release(my_completion2);
 }
@@ -397,7 +372,6 @@ TEST_F(StriperTest, RoundTripAppend) {
   ASSERT_EQ(0, memcmp(buf3, buf, sizeof(buf)));
   ASSERT_EQ(0, memcmp(buf3 + sizeof(buf), buf2, sizeof(buf2)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
   rados_aio_release(my_completion2);
   rados_aio_release(my_completion3);
@@ -439,7 +413,6 @@ TEST_F(StriperTestPP, RoundTripAppendPP) {
   ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf)));
   ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf), buf2, sizeof(buf2)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
   my_completion2->release();
   my_completion3->release();
@@ -466,7 +439,6 @@ TEST_F(StriperTest, Flush) {
   }
   ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
   rados_aio_release(my_completion2);
 }
@@ -491,7 +463,6 @@ TEST_F(StriperTestPP, FlushPP) {
   }
   ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
   my_completion2->release();
 }
@@ -529,7 +500,6 @@ TEST_F(StriperTest, RoundTripWriteFull) {
   ASSERT_EQ(sizeof(buf2), (unsigned)rados_aio_get_return_value(my_completion3));
   ASSERT_EQ(0, memcmp(buf3, buf2, sizeof(buf2)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   rados_aio_release(my_completion);
   rados_aio_release(my_completion2);
   rados_aio_release(my_completion3);
@@ -570,7 +540,6 @@ TEST_F(StriperTestPP, RoundTripWriteFullPP) {
   ASSERT_EQ(sizeof(buf2), (unsigned)my_completion3->get_return_value());
   ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2)));
   sem_wait(test_data.m_sem);
-  sem_wait(test_data.m_sem);
   my_completion->release();
   my_completion2->release();
   my_completion3->release();
@@ -585,7 +554,7 @@ TEST_F(StriperTest, RemoveTest) {
   // async remove it
   AioTestData test_data;
   rados_completion_t my_completion;
-  ASSERT_EQ(0, rados_aio_create_completion((void*)&test_data,
+  ASSERT_EQ(0, rados_aio_create_completion2((void*)&test_data,
              set_completion_complete, set_completion_safe, &my_completion));
   ASSERT_EQ(0, rados_striper_aio_remove(striper, "RemoveTest", my_completion));
   {