rados: aio, reorder callback completion handler creation

diff --git a/src/include/librados.h b/src/include/librados.h
index ade9cbac1034143f7b345324e02c3984e2d67221..761703ddd3ee6f24c086a3c155c53997e3446b24 100644 (file)
--- a/src/include/librados.h
+++ b/src/include/librados.h
@@ -77,6 +77,7 @@ int rados_exec(rados_pool_t pool, const char *oid, const char *cls, const char *
 typedef void *rados_completion_t;
 typedef void (*rados_callback_t)(rados_completion_t cb, void *arg);
 
+int rados_aio_create_completion(rados_callback_t, void *arg, rados_completion_t *pc);
 int rados_aio_set_callback(rados_completion_t c, rados_callback_t, void *arg);
 int rados_aio_wait_for_complete(rados_completion_t c);
 int rados_aio_wait_for_safe(rados_completion_t c);
@@ -86,10 +87,10 @@ int rados_aio_get_return_value(rados_completion_t c);
 void rados_aio_release(rados_completion_t c);
 int rados_aio_write(rados_pool_t pool, const char *oid,
                    off_t off, const char *buf, size_t len,
-                   rados_completion_t *completion);
+                   rados_completion_t completion);
 int rados_aio_read(rados_pool_t pool, const char *oid,
                   off_t off, char *buf, size_t len,
-                  rados_completion_t *completion);
+                  rados_completion_t completion);
 
 #ifdef __cplusplus
 }

diff --git a/src/include/librados.hpp b/src/include/librados.hpp
index 06ba0931661ad978c81d3c39e7779726cbf287f1..d2d5e3caca21e162d791b83677f0f8e5d3b3a9a8 100644 (file)
--- a/src/include/librados.hpp
+++ b/src/include/librados.hpp
@@ -108,10 +108,10 @@ public:
   };
 
   int aio_read(pool_t pool, const std::string& oid, off_t off, bufferlist *pbl, size_t len,
-              AioCompletion **pc);
+              AioCompletion *c);
   int aio_write(pool_t pool, const std::string& oid, off_t off, const bufferlist& bl, size_t len,
-               AioCompletion **pc);
-
+               AioCompletion *c);
+  int create_completion(callback_t cb, void *cba, AioCompletion **pc);
 };
 
 }

diff --git a/src/librados.cc b/src/librados.cc
index ca85cb2a468a4baf76b8854c0245fda926d9f7ed..9c8bca75ac737dbe1b7623b6bc62f23be39e4b2a 100644 (file)
--- a/src/librados.cc
+++ b/src/librados.cc
@@ -282,13 +282,20 @@ public:
   };
 
   int aio_read(PoolCtx& pool, object_t oid, off_t off, bufferlist *pbl, size_t len,
-              AioCompletion **pc);
+              AioCompletion *c);
   int aio_read(PoolCtx& pool, object_t oid, off_t off, char *buf, size_t len,
-              AioCompletion **pc);
+              AioCompletion *c);
 
   int aio_write(PoolCtx& pool, object_t oid, off_t off, const bufferlist& bl, size_t len,
-               AioCompletion **pc);
+               AioCompletion *c);
 
+  int create_completion(rados_callback_t cb, void *cba, AioCompletion **pc) {
+    *pc = new AioCompletion;
+    if (!pc)
+      return -ENOMEM;
+    (*pc)->set_callback(cb, cba);
+    return 0;
+  }
 };
 
 bool RadosClient::init()
@@ -771,10 +778,9 @@ int RadosClient::write_full(PoolCtx& pool, const object_t& oid, bufferlist& bl)
 }
 
 int RadosClient::aio_read(PoolCtx& pool, const object_t oid, off_t off, bufferlist *pbl, size_t len,
-                         AioCompletion **pc)
+                         AioCompletion *c)
 {
  
-  AioCompletion *c = new AioCompletion;
   Context *onack = new C_aio_Ack(c);
 
   c->pbl = pbl;
@@ -785,13 +791,11 @@ int RadosClient::aio_read(PoolCtx& pool, const object_t oid, off_t off, bufferli
                 off, len, pool.snap_seq, &c->bl, 0,
                  onack);
 
-  *pc = c;
   return 0;
 }
 int RadosClient::aio_read(PoolCtx& pool, const object_t oid, off_t off, char *buf, size_t len,
-                         AioCompletion **pc)
+                         AioCompletion *c)
 {
-  AioCompletion *c = new AioCompletion;
   Context *onack = new C_aio_Ack(c);
 
   c->buf = buf;
@@ -803,17 +807,15 @@ int RadosClient::aio_read(PoolCtx& pool, const object_t oid, off_t off, char *bu
                 off, len, pool.snap_seq, &c->bl, 0,
                  onack);
 
-  *pc = c;
   return 0;
 }
 
 int RadosClient::aio_write(PoolCtx& pool, const object_t oid, off_t off, const bufferlist& bl, size_t len,
-                          AioCompletion **pc)
+                          AioCompletion *c)
 {
   SnapContext snapc;
   utime_t ut = g_clock.now();
 
-  AioCompletion *c = new AioCompletion;
   Context *onack = new C_aio_Ack(c);
   Context *onsafe = new C_aio_Safe(c);
 
@@ -823,7 +825,6 @@ int RadosClient::aio_write(PoolCtx& pool, const object_t oid, off_t off, const b
                  off, len, pool.snapc, bl, ut, 0,
                  onack, onsafe);
 
-  *pc = c;
   return 0;
 }
 
@@ -1376,29 +1377,37 @@ int Rados::snap_get_stamp(rados_pool_t pool, snap_t snapid, time_t *t)
 
 // AIO
 int Rados::aio_read(rados_pool_t pool, const string& oid, off_t off, bufferlist *pbl, size_t len,
-                   Rados::AioCompletion **pc)
+                   Rados::AioCompletion *c)
 {
   RadosClient::PoolCtx *ctx = (RadosClient::PoolCtx *)pool;
-  RadosClient::AioCompletion *c;
-  int r = ((RadosClient *)client)->aio_read(*ctx, oid, off, pbl, len, &c);
-  if (r >= 0) {
-    *pc = new AioCompletion((void *)c);
-  }
+  RadosClient::AioCompletion *pc = (RadosClient::AioCompletion *)c->pc;
+  int r = ((RadosClient *)client)->aio_read(*ctx, oid, off, pbl, len, pc);
   return r;
 }
 
 int Rados::aio_write(rados_pool_t pool, const string& oid, off_t off, const bufferlist& bl, size_t len,
-                    AioCompletion **pc)
+                    AioCompletion *c)
 {
   RadosClient::PoolCtx *ctx = (RadosClient::PoolCtx *)pool;
-  RadosClient::AioCompletion *c;
-  int r = ((RadosClient *)client)->aio_write(*ctx, oid, off, bl, len, &c);
-  if (r >= 0) {
-    *pc = new AioCompletion((void *)c);
-  }
+  RadosClient::AioCompletion *pc = (RadosClient::AioCompletion *)c->pc;
+  int r = ((RadosClient *)client)->aio_write(*ctx, oid, off, bl, len, pc);
   return r;
 }
 
+int Rados::create_completion(callback_t cb, void *cba, AioCompletion **pc)
+{
+  RadosClient::AioCompletion *c;
+  int r = ((RadosClient *)client)->create_completion(cb, cba, &c);
+  if (r < 0)
+    return r;
+
+  *pc = new AioCompletion(c);
+  if (!pc)
+    return -ENOMEM;
+
+  return 0;
+}
+
 int Rados::AioCompletion::set_callback(rados_callback_t cb, void *cba)
 {
   RadosClient::AioCompletion *c = (RadosClient::AioCompletion *)pc;
@@ -1730,9 +1739,9 @@ extern "C" int rados_list_objects_next(rados_list_ctx_t listctx, const char **en
 // -------------------------
 // aio
 
-extern "C" int rados_aio_set_callback(rados_completion_t c, rados_callback_t cb, void *cba)
+extern "C" int rados_aio_create_completion(rados_callback_t cb, void *cba, rados_completion_t *pc)
 {
-  return ((RadosClient::AioCompletion *)c)->set_callback(cb, cba);
+  return radosp->create_completion(cb, cba, (RadosClient::AioCompletion **)pc);
 }
 
 extern "C" int rados_aio_wait_for_complete(rados_completion_t c)
@@ -1767,21 +1776,21 @@ extern "C" void rados_aio_release(rados_completion_t c)
 
 extern "C" int rados_aio_read(rados_pool_t pool, const char *o,
                               off_t off, char *buf, size_t len,
-                              rados_completion_t *completion)
+                              rados_completion_t completion)
 {
   RadosClient::PoolCtx *ctx = (RadosClient::PoolCtx *)pool;
   object_t oid(o);
-  return radosp->aio_read(*ctx, oid, off, buf, len, (RadosClient::AioCompletion**)completion);
+  return radosp->aio_read(*ctx, oid, off, buf, len, (RadosClient::AioCompletion*)completion);
 }
 
 extern "C" int rados_aio_write(rados_pool_t pool, const char *o,
                               off_t off, const char *buf, size_t len,
-                              rados_completion_t *completion)
+                              rados_completion_t completion)
 {
   RadosClient::PoolCtx *ctx = (RadosClient::PoolCtx *)pool;
   object_t oid(o);
   bufferlist bl;
   bl.append(buf, len);
-  return radosp->aio_write(*ctx, oid, off, bl, len, (RadosClient::AioCompletion**)completion);
+  return radosp->aio_write(*ctx, oid, off, bl, len, (RadosClient::AioCompletion*)completion);
 }
 

diff --git a/src/osdc/rados_bencher.h b/src/osdc/rados_bencher.h
index 56e215df8e86bffbc546f143c39f33c3f5db34d3..f855b9d9076f330f67846b23e22a0201a8a68594 100644 (file)
--- a/src/osdc/rados_bencher.h
+++ b/src/osdc/rados_bencher.h
@@ -145,7 +145,7 @@ int write_bench(Rados& rados, rados_pool_t pool,
   dataLock.Unlock();
   for (int i = 0; i<concurrentios; ++i) {
     start_times[i] = g_clock.now();
-    r = rados.aio_write(pool, name[i], 0, *contents[i], data->object_size, &completions[i]);
+    r = rados.aio_write(pool, name[i], 0, *contents[i], data->object_size, completions[i]);
     if (r < 0) { //naughty, doesn't clean up heap
        dataLock.Unlock();
        return -5; //EIO
@@ -196,7 +196,7 @@ int write_bench(Rados& rados, rados_pool_t pool,
     //write new stuff to rados, then delete old stuff
     //and save locations of new stuff for later deletion
     start_times[slot] = g_clock.now();
-    r = rados.aio_write(pool, newName, 0, *newContents, data->object_size, &completions[slot]);
+    r = rados.aio_write(pool, newName, 0, *newContents, data->object_size, completions[slot]);
     if (r < 0) //naughty; doesn't clean up heap space.
       return r;
     dataLock.Lock();
@@ -305,7 +305,7 @@ int seq_read_bench(Rados& rados, rados_pool_t pool, int seconds_to_run,
   //start initial reads
   for (int i = 0; i < concurrentios; ++i) {
     start_times[i] = g_clock.now();
-    r = rados.aio_read(pool, name[i], 0, contents[i], data->object_size, &completions[i]);
+    r = rados.aio_read(pool, name[i], 0, contents[i], data->object_size, completions[i]);
     if (r < 0) { //naughty, doesn't clean up heap -- oh, or handle the print thread!
       cerr << "r = " << r << std::endl;
       dataLock.Unlock();
@@ -352,7 +352,7 @@ int seq_read_bench(Rados& rados, rados_pool_t pool, int seconds_to_run,
     //start new read and check data if requested
     start_times[slot] = g_clock.now();
     contents[slot] = new bufferlist();
-    r = rados.aio_read(pool, newName, 0, contents[slot], data->object_size, &completions[slot]);
+    r = rados.aio_read(pool, newName, 0, contents[slot], data->object_size, completions[slot]);
     if (r < 0)
       return r;
     dataLock.Lock();