libctdb: add ctdb arg to more functions.

This is going to help for logging, since we want it there.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

diff --git a/include/ctdb.h b/include/ctdb.h
index fa3f30dc3fd3ce1e707ea97c0283de7927428212..5ad8736a7eee89a7516eb624b2ad6ec3c1dafadd 100644 (file)
--- a/include/ctdb.h
+++ b/include/ctdb.h
@@ -44,7 +44,7 @@ int ctdb_service(struct ctdb_connection *ctdb, int revents);
 
 struct ctdb_request;
 
-void ctdb_request_free(struct ctdb_request *req);
+void ctdb_request_free(struct ctdb_connection *ctdb, struct ctdb_request *req);
 
 /*
  * Callback for completed requests: it would normally unpack the request
@@ -83,7 +83,8 @@ ctdb_attachdb_send(struct ctdb_connection *ctdb,
                   const char *name, int persistent, uint32_t tdb_flags,
                   ctdb_callback_t callback, void *private_data);
 
-struct ctdb_db *ctdb_attachdb_recv(struct ctdb_request *req);
+struct ctdb_db *ctdb_attachdb_recv(struct ctdb_connection *ctdb,
+                                  struct ctdb_request *req);
 
 struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb,
                              const char *name, int persistent,
@@ -177,7 +178,8 @@ ctdb_getpnn_send(struct ctdb_connection *ctdb,
                 uint32_t destnode,
                 ctdb_callback_t callback,
                 void *private_data);
-int ctdb_getpnn_recv(struct ctdb_request *req, uint32_t *pnn);
+int ctdb_getpnn_recv(struct ctdb_connection *ctdb,
+                    struct ctdb_request *req, uint32_t *pnn);
 
 int ctdb_getpnn(struct ctdb_connection *ctdb,
                uint32_t destnode,
@@ -194,7 +196,8 @@ ctdb_getrecmaster_send(struct ctdb_connection *ctdb,
                        uint32_t destnode,
                        ctdb_callback_t callback,
                        void *private_data);
-int ctdb_getrecmaster_recv(struct ctdb_request *handle,
+int ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
+                          struct ctdb_request *handle,
                           uint32_t *recmaster);
 int ctdb_getrecmaster(struct ctdb_connection *ctdb,
                        uint32_t destnode,
@@ -206,7 +209,7 @@ int ctdb_getrecmaster(struct ctdb_connection *ctdb,
 /*
  * cancel a request
  */
-int ctdb_cancel(struct ctdb_request *);
+int ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req);
 
 
 /* These ugly macro wrappers make the callbacks typesafe. */

diff --git a/libctdb/control.c b/libctdb/control.c
index 928729050323d1dea66471c134cdc88a6d4d3d7f..609466c3380dfe61f4d51998b7fe4ea76e7cac30 100644 (file)
--- a/libctdb/control.c
+++ b/libctdb/control.c
@@ -24,11 +24,12 @@
 #undef ctdb_getrecmaster_send
 #undef ctdb_getpnn_send
 
-int ctdb_getrecmaster_recv(struct ctdb_request *req, uint32_t *recmaster)
+int ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
+                          struct ctdb_request *req, uint32_t *recmaster)
 {
        struct ctdb_reply_control *reply;
 
-       reply = unpack_reply_control(req, CTDB_CONTROL_GET_RECMASTER);
+       reply = unpack_reply_control(ctdb, req, CTDB_CONTROL_GET_RECMASTER);
        if (!reply || reply->status == -1)
                return -1;
        *recmaster = reply->status;
@@ -45,11 +46,12 @@ struct ctdb_request *ctdb_getrecmaster_send(struct ctdb_connection *ctdb,
                                        callback, private_data);
 }
 
-int ctdb_getpnn_recv(struct ctdb_request *req, uint32_t *pnn)
+int ctdb_getpnn_recv(struct ctdb_connection *ctdb,
+                    struct ctdb_request *req, uint32_t *pnn)
 {
        struct ctdb_reply_control *reply;
 
-       reply = unpack_reply_control(req, CTDB_CONTROL_GET_PNN);
+       reply = unpack_reply_control(ctdb, req, CTDB_CONTROL_GET_PNN);
        if (!reply || reply->status == -1)
                return -1;
        *pnn = reply->status;

diff --git a/libctdb/ctdb.c b/libctdb/ctdb.c
index 52cd38e4a192b6b173554ee3e23db395c2c9c009..771afec6cdde915e054d18bbaa32eef3f1ef9dff 100644 (file)
--- a/libctdb/ctdb.c
+++ b/libctdb/ctdb.c
@@ -71,11 +71,11 @@ static void set_pnn(struct ctdb_connection *ctdb,
                    struct ctdb_request *req,
                    void *unused)
 {
-       if (ctdb_getpnn_recv(req, &ctdb->pnn) != 0) {
+       if (ctdb_getpnn_recv(ctdb, req, &ctdb->pnn) != 0) {
                /* FIXME: Report error. */
                ctdb->broken = true;
        }
-       ctdb_request_free(req);
+       ctdb_request_free(ctdb, req);
 }
 
 struct ctdb_connection *ctdb_connect(const char *addr)
@@ -156,10 +156,10 @@ struct ctdb_request *new_ctdb_request(size_t len,
        return req;
 }
 
-void ctdb_request_free(struct ctdb_request *req)
+void ctdb_request_free(struct ctdb_connection *ctdb, struct ctdb_request *req)
 {
        if (req->extra_destructor) {
-               req->extra_destructor(req);
+               req->extra_destructor(ctdb, req);
        }
        if (req->reply) {
                free_io_elem(req->reply);
@@ -170,7 +170,8 @@ void ctdb_request_free(struct ctdb_request *req)
 
 /* Sanity-checking wrapper for reply.
  * FIXME: logging! */
-static struct ctdb_reply_call *unpack_reply_call(struct ctdb_request *req,
+static struct ctdb_reply_call *unpack_reply_call(struct ctdb_connection *ctdb,
+                                                struct ctdb_request *req,
                                                 uint32_t callid)
 {
        size_t len;
@@ -194,7 +195,8 @@ static struct ctdb_reply_call *unpack_reply_call(struct ctdb_request *req,
 
 /* Sanity-checking wrapper for reply.
  * FIXME: logging! */
-struct ctdb_reply_control *unpack_reply_control(struct ctdb_request *req,
+struct ctdb_reply_control *unpack_reply_control(struct ctdb_connection *ctdb,
+                                               struct ctdb_request *req,
                                                enum ctdb_controls control)
 {
        size_t len;
@@ -369,10 +371,10 @@ void ctdb_cancel_callback(struct ctdb_connection *ctdb,
                          struct ctdb_request *req,
                          void *unused)
 {
-       ctdb_request_free(req);
+       ctdb_request_free(ctdb, req);
 }
 
-int ctdb_cancel(struct ctdb_request *req)
+int ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req)
 {
        /* FIXME: If it's not sent, we could just free it right now. */
        req->callback = ctdb_cancel_callback;
@@ -400,7 +402,8 @@ static void attachdb_getdbpath_done(struct ctdb_connection *ctdb,
        db->callback(ctdb, req->extra, db->private_data);
 }
 
-struct ctdb_db *ctdb_attachdb_recv(struct ctdb_request *req)
+struct ctdb_db *ctdb_attachdb_recv(struct ctdb_connection *ctdb,
+                                  struct ctdb_request *req)
 {
        struct ctdb_request *dbpath_req = req->extra;
        struct ctdb_reply_control *reply;
@@ -414,7 +417,7 @@ struct ctdb_db *ctdb_attachdb_recv(struct ctdb_request *req)
                return NULL;
        }
 
-       reply = unpack_reply_control(dbpath_req, CTDB_CONTROL_GETDBPATH);
+       reply = unpack_reply_control(ctdb, dbpath_req, CTDB_CONTROL_GETDBPATH);
        if (!reply || reply->status != 0) {
                return NULL;
        }
@@ -445,7 +448,7 @@ static void attachdb_done(struct ctdb_connection *ctdb,
                control = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
        }
 
-       reply = unpack_reply_control(req, control);
+       reply = unpack_reply_control(ctdb, req, control);
        if (!reply || reply->status != 0) {
                /* We failed.  Hand request to user and have them discover it
                 * via ctdb_attachdb_recv. */
@@ -467,13 +470,14 @@ static void attachdb_done(struct ctdb_connection *ctdb,
        req2->extra = req;
 }
 
-static void destroy_req_db(struct ctdb_request *req)
+static void destroy_req_db(struct ctdb_connection *ctdb,
+                          struct ctdb_request *req)
 {
        /* Incomplete db is in priv_data. */
        free(req->priv_data);
        /* second request is chained off this one. */
        if (req->extra) {
-               ctdb_request_free(req->extra);
+               ctdb_request_free(ctdb, req->extra);
        }
 }
 
@@ -573,7 +577,8 @@ static bool try_readrecordlock(struct ctdb_lock *lock, TDB_DATA *data)
 }
 
 /* If they shutdown before we hand them the lock, we free it here. */
-static void destroy_lock(struct ctdb_request *req)
+static void destroy_lock(struct ctdb_connection *ctdb,
+                        struct ctdb_request *req)
 {
        ctdb_release_lock(req->extra);
        ctdb_free_lock(req->extra);
@@ -587,10 +592,10 @@ static void readrecordlock_retry(struct ctdb_connection *ctdb,
        TDB_DATA data;
 
        /* OK, we've received reply to noop migration */
-       reply = unpack_reply_call(req, CTDB_NULL_FUNC);
+       reply = unpack_reply_call(ctdb, req, CTDB_NULL_FUNC);
        if (!reply || reply->status != 0) {
                lock->callback(lock->ctdb_db, NULL, tdb_null, private);
-               ctdb_request_free(req); /* Also frees lock. */
+               ctdb_request_free(ctdb, req); /* Also frees lock. */
                ctdb_free_lock(lock);
                return;
        }

diff --git a/libctdb/libctdb_private.h b/libctdb/libctdb_private.h
index ba5ee44883a6fdf8e4c711371da800dd3422ae36..b3486d2070f90eec161b526570e394a0051fcd87 100644 (file)
--- a/libctdb/libctdb_private.h
+++ b/libctdb/libctdb_private.h
@@ -33,7 +33,8 @@ struct ctdb_request {
        void *priv_data;
 
        /* Extra per-request info. */
-       void (*extra_destructor)(struct ctdb_request *);
+       void (*extra_destructor)(struct ctdb_connection *,
+                                struct ctdb_request *);
        void *extra;
 };
 
@@ -66,7 +67,8 @@ struct ctdb_request *new_ctdb_control_request(struct ctdb_connection *ctdb,
                                              ctdb_callback_t, void *);
 uint32_t new_reqid(struct ctdb_connection *ctdb);
 
-struct ctdb_reply_control *unpack_reply_control(struct ctdb_request *req,
+struct ctdb_reply_control *unpack_reply_control(struct ctdb_connection *ctdb,
+                                               struct ctdb_request *req,
                                                enum ctdb_controls control);
 void ctdb_cancel_callback(struct ctdb_connection *ctdb,
                          struct ctdb_request *req,

diff --git a/libctdb/messages.c b/libctdb/messages.c
index aa997bc9f9f4ee2b519b47920f5cea1e520c5012..a3a28a68c546beeda5f0bfb40a46003e3a70e066 100644 (file)
--- a/libctdb/messages.c
+++ b/libctdb/messages.c
@@ -43,7 +43,7 @@ int ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
        struct message_handler_info *info = req->extra;
        struct ctdb_reply_control *reply;
 
-       reply = unpack_reply_control(req, CTDB_CONTROL_REGISTER_SRVID);
+       reply = unpack_reply_control(ctdb, req, CTDB_CONTROL_REGISTER_SRVID);
        if (!reply || reply->status != 0) {
                return -1;
        }
@@ -55,7 +55,7 @@ int ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
        return 0;
 }
 
-static void free_info(struct ctdb_request *req)
+static void free_info(struct ctdb_connection *ctdb, struct ctdb_request *req)
 {
        free(req->extra);
 }

diff --git a/libctdb/sync.c b/libctdb/sync.c
index df8655279da10ea322f52c5e2f26fb1ba8110e13..ece5408d1640a7598e84486ad95ccade9aade734 100644 (file)
--- a/libctdb/sync.c
+++ b/libctdb/sync.c
@@ -21,11 +21,12 @@
 #include <poll.h>
 #include <errno.h>
 #include <stdlib.h>
+#include "libctdb_private.h"
 
 /* On failure, frees req and returns NULL. */
-static struct ctdb_request *wait_for(struct ctdb_connection *ctdb,
-                                    struct ctdb_request *req,
-                                    bool *done)
+static struct ctdb_request *synchronous(struct ctdb_connection *ctdb,
+                                       struct ctdb_request *req,
+                                       bool *done)
 {
        struct pollfd fds;
 
@@ -40,11 +41,11 @@ static struct ctdb_request *wait_for(struct ctdb_connection *ctdb,
                        /* Signalled is OK, other error is bad. */
                        if (errno == EINTR)
                                continue;
-                       ctdb_request_free(req);
+                       ctdb_request_free(ctdb, req);
                        return NULL;
                }
                if (ctdb_service(ctdb, fds.revents) < 0) {
-                       ctdb_request_free(req);
+                       ctdb_request_free(ctdb, req);
                        return NULL;
                }
        }
@@ -64,12 +65,12 @@ int ctdb_getrecmaster(struct ctdb_connection *ctdb,
        bool done = false;
        int ret = -1;
 
-       req = wait_for(ctdb,
-                      ctdb_getrecmaster_send(ctdb, destnode, set, &done),
-                      &done);
+       req = synchronous(ctdb,
+                         ctdb_getrecmaster_send(ctdb, destnode, set, &done),
+                         &done);
        if (req != NULL) {
-               ret = ctdb_getrecmaster_recv(req, recmaster);
-               ctdb_request_free(req);
+               ret = ctdb_getrecmaster_recv(ctdb, req, recmaster);
+               ctdb_request_free(ctdb, req);
        }
        return ret;
 }
@@ -82,13 +83,13 @@ struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb,
        bool done = false;
        struct ctdb_db *ret = NULL;
 
-       req = wait_for(ctdb,
-                      ctdb_attachdb_send(ctdb, name, persistent, tdb_flags,
-                                         set, &done),
-                      &done);
+       req = synchronous(ctdb,
+                         ctdb_attachdb_send(ctdb, name, persistent, tdb_flags,
+                                            set, &done),
+                         &done);
        if (req != NULL) {
-               ret = ctdb_attachdb_recv(req);
-               ctdb_request_free(req);
+               ret = ctdb_attachdb_recv(ctdb, req);
+               ctdb_request_free(ctdb, req);
        }
        return ret;
 }
@@ -100,12 +101,12 @@ int ctdb_getpnn(struct ctdb_connection *ctdb,
        bool done = false;
        int ret = -1;
 
-       req = wait_for(ctdb,
-                      ctdb_getpnn_send(ctdb, destnode, set, &done),
-                      &done);
+       req = synchronous(ctdb,
+                         ctdb_getpnn_send(ctdb, destnode, set, &done),
+                         &done);
        if (req != NULL) {
-               ret = ctdb_getpnn_recv(req, pnn);
-               ctdb_request_free(req);
+               ret = ctdb_getpnn_recv(ctdb, req, pnn);
+               ctdb_request_free(ctdb, req);
        }
        return ret;
 }

diff --git a/libctdb/tst.c b/libctdb/tst.c
index f1a8e3d41b47afd1ba53fef8987e0df66cd1b822..461c81367a1c92bac18a08be405f92a37000d7bb 100644 (file)
--- a/libctdb/tst.c
+++ b/libctdb/tst.c
@@ -49,8 +49,8 @@ static void pnn_cb(struct ctdb_connection *ctdb,
        int status;
        uint32_t pnn;
 
-       status = ctdb_getpnn_recv(req, &pnn);
-       ctdb_request_free(req);
+       status = ctdb_getpnn_recv(ctdb, req, &pnn);
+       ctdb_request_free(ctdb, req);
        if (status != 0) {
                printf("Error reading PNN\n");
                return;
@@ -64,8 +64,8 @@ static void rm_cb(struct ctdb_connection *ctdb,
        int status;
        uint32_t rm;
 
-       status = ctdb_getrecmaster_recv(req, &rm);
-       ctdb_request_free(req);
+       status = ctdb_getrecmaster_recv(ctdb, req, &rm);
+       ctdb_request_free(ctdb, req);
        if (status != 0) {
                printf("Error reading RECMASTER\n");
                return;
@@ -120,7 +120,7 @@ void message_handler_cb(struct ctdb_connection *ctdb,
        if (ctdb_set_message_handler_recv(ctdb, req) != 0) {
                err(1, "registering message");
        }
-       ctdb_request_free(req);
+       ctdb_request_free(ctdb, req);
        printf("Message handler registered\n");
        registered = true;
 }