hang the ctdb_req_control structure off the ctdb_client_control_state

struct  so that if we timeout a control we can print debug info such as
what opcode failed and to which node

we dont need the *status parameter to ctdb_client_control_state

create async versions of the getrecmaster control

pass a memory context to getrecmaster

(This used to be ctdb commit 558b680c82f830fba82c283c78c2de8a0b150b75)

diff --git a/ctdb/client/ctdb_client.c b/ctdb/client/ctdb_client.c
index a18c567ff29b9bbd67bd64a1ed0d765abfb46ae4..22fb0e319ce3198fa67c27de23625097a9914f87 100644 (file)
--- a/ctdb/client/ctdb_client.c
+++ b/ctdb/client/ctdb_client.c
@@ -674,6 +674,7 @@ struct ctdb_client_control_state {
        TDB_DATA outdata;
        enum control_state state;
        char *errormsg;
+       struct ctdb_req_control *c;
 };
 
 /*
@@ -731,6 +732,8 @@ static void control_timeout_func(struct event_context *ev, struct timed_event *t
 {
        struct ctdb_client_control_state *state = talloc_get_type(private_data, struct ctdb_client_control_state);
 
+       DEBUG(0,("control timed out. reqid:%d opcode:%d dstnode:%d\n", state->reqid, state->c->opcode, state->c->hdr.destnode));
+
        state->state = CTDB_CONTROL_TIMEOUT;
 }
 
@@ -738,14 +741,14 @@ static void control_timeout_func(struct event_context *ev, struct timed_event *t
 struct ctdb_client_control_state *ctdb_control_send(struct ctdb_context *ctdb, 
                uint32_t destnode, uint64_t srvid, 
                uint32_t opcode, uint32_t flags, TDB_DATA data, 
-               TALLOC_CTX *mem_ctx, TDB_DATA *outdata, int32_t *status,
+               TALLOC_CTX *mem_ctx, TDB_DATA *outdata,
                struct timeval *timeout,
                char **errormsg)
 
 {
        struct ctdb_client_control_state *state;
-       struct ctdb_req_control *c;
        size_t len;
+       struct ctdb_req_control *c;
        int ret;
 
        if (errormsg) {
@@ -770,8 +773,8 @@ struct ctdb_client_control_state *ctdb_control_send(struct ctdb_context *ctdb,
        len = offsetof(struct ctdb_req_control, data) + data.dsize;
        c = ctdbd_allocate_pkt(ctdb, state, CTDB_REQ_CONTROL, 
                               len, struct ctdb_req_control);
+       state->c            = c;        
        CTDB_NO_MEMORY_NULL(ctdb, c);
-       
        c->hdr.reqid        = state->reqid;
        c->hdr.destnode     = destnode;
        c->hdr.reqid        = state->reqid;
@@ -866,7 +869,7 @@ int ctdb_control(struct ctdb_context *ctdb, uint32_t destnode, uint64_t srvid,
        struct ctdb_client_control_state *state;
 
        state = ctdb_control_send(ctdb, destnode, srvid, opcode, 
-                       flags, data, mem_ctx, outdata, status,
+                       flags, data, mem_ctx, outdata,
                        timeout, errormsg);
        return ctdb_control_recv(ctdb, state, mem_ctx, outdata, status, 
                        errormsg);
@@ -984,27 +987,47 @@ int ctdb_ctrl_getvnnmap(struct ctdb_context *ctdb, struct timeval timeout, uint3
        return 0;
 }
 
-/*
-  get the recovery mode of a remote node
- */
-int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *recmode)
+
+struct ctdb_client_control_state *
+ctdb_ctrl_getrecmode_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode)
+{
+       return ctdb_control_send(ctdb, destnode, 0, 
+                          CTDB_CONTROL_GET_RECMODE, 0, tdb_null, 
+                          mem_ctx, NULL, &timeout, NULL);
+}
+
+int ctdb_ctrl_getrecmode_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmode)
 {
        int ret;
        int32_t res;
 
-       ret = ctdb_control(ctdb, destnode, 0, 
-                          CTDB_CONTROL_GET_RECMODE, 0, tdb_null, 
-                          NULL, NULL, &res, &timeout, NULL);
+       ret = ctdb_control_recv(ctdb, state, mem_ctx, NULL, &res, NULL);
        if (ret != 0) {
-               DEBUG(0,(__location__ " ctdb_control for getrecmode failed\n"));
+               DEBUG(0,(__location__ " ctdb_ctrl_getrecmode_recv failed\n"));
                return -1;
        }
 
-       *recmode = res;
+       if (recmode) {
+               *recmode = (uint32_t)res;
+       }
 
        return 0;
 }
 
+/*
+  get the recovery mode of a remote node
+ */
+int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, uint32_t *recmode)
+{
+       struct ctdb_client_control_state *state;
+
+       state = ctdb_ctrl_getrecmode_send(ctdb, mem_ctx, timeout, destnode);
+       return ctdb_ctrl_getrecmode_recv(ctdb, mem_ctx, state, recmode);
+}
+
+
+
+
 /*
   set the recovery mode of a remote node
  */

diff --git a/ctdb/include/ctdb.h b/ctdb/include/ctdb.h
index 04339b066631ff53c29352af04498f640dcf1948..2acde41dd52f9e83f025b44054148c139fbed469 100644 (file)
--- a/ctdb/include/ctdb.h
+++ b/ctdb/include/ctdb.h
@@ -302,7 +302,13 @@ int ctdb_ctrl_write_record(struct ctdb_context *ctdb, uint32_t destnode, TALLOC_
 /*
   get the recovery mode of a remote node
  */
-int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *recmode);
+int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, uint32_t *recmode);
+
+struct ctdb_client_control_state *ctdb_ctrl_getrecmode_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
+
+int ctdb_ctrl_getrecmode_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmode);
+
+
 /*
   set the recovery mode of a remote node
  */

diff --git a/ctdb/server/ctdb_recoverd.c b/ctdb/server/ctdb_recoverd.c
index d710cd2a2890b8ed5d4de5d5a8f08ec379f41518..1b1b056cd8461c5bf68b50c7c1e35a0877aaeb32 100644 (file)
--- a/ctdb/server/ctdb_recoverd.c
+++ b/ctdb/server/ctdb_recoverd.c
@@ -1108,7 +1108,7 @@ static void monitor_handler(struct ctdb_context *ctdb, uint64_t srvid,
                                     CTDB_CURRENT_NODE, &ctdb->recovery_master);
 
        if (ret == 0) {
-               ret = ctdb_ctrl_getrecmode(ctdb, CONTROL_TIMEOUT(), 
+               ret = ctdb_ctrl_getrecmode(ctdb, tmp_ctx, CONTROL_TIMEOUT(), 
                                           CTDB_CURRENT_NODE, &ctdb->recovery_mode);
        }
        
@@ -1307,7 +1307,7 @@ again:
                        continue;
                }
 
-               ret = ctdb_ctrl_getrecmode(ctdb, CONTROL_TIMEOUT(), nodemap->nodes[j].vnn, &recmode);
+               ret = ctdb_ctrl_getrecmode(ctdb, mem_ctx, CONTROL_TIMEOUT(), nodemap->nodes[j].vnn, &recmode);
                if (ret != 0) {
                        DEBUG(0, ("Unable to get recmode from node %u\n", vnn));
                        goto again;

diff --git a/ctdb/tests/ctdb_bench.c b/ctdb/tests/ctdb_bench.c
index f1292ee275d9e953f9f3bf2a548ade97988c0594..e020c1b62f27862917b82c6eb1e8fd8cfc1f3e57 100644 (file)
--- a/ctdb/tests/ctdb_bench.c
+++ b/ctdb/tests/ctdb_bench.c
@@ -217,7 +217,7 @@ int main(int argc, const char *argv[])
        printf("Waiting for cluster\n");
        while (1) {
                uint32_t recmode=1;
-               ctdb_ctrl_getrecmode(ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
+               ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
                if (recmode == 0) break;
                event_loop_once(ev);
        }

diff --git a/ctdb/tests/ctdb_fetch.c b/ctdb/tests/ctdb_fetch.c
index f57d05d09931db52391bb41c2b6523390b8d83e4..0a6351f1fdfe1c692d354b419e051907c169216b 100644 (file)
--- a/ctdb/tests/ctdb_fetch.c
+++ b/ctdb/tests/ctdb_fetch.c
@@ -232,7 +232,7 @@ int main(int argc, const char *argv[])
        printf("Waiting for cluster\n");
        while (1) {
                uint32_t recmode=1;
-               ctdb_ctrl_getrecmode(ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
+               ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
                if (recmode == 0) break;
                event_loop_once(ev);
        }

diff --git a/ctdb/tests/ctdb_store.c b/ctdb/tests/ctdb_store.c
index a60e009b91076d52f39da5149c21ac64f23f4053..ea7721a34c26868dc4650c942408fdec64a9adaa 100644 (file)
--- a/ctdb/tests/ctdb_store.c
+++ b/ctdb/tests/ctdb_store.c
@@ -145,7 +145,7 @@ int main(int argc, const char *argv[])
        printf("Waiting for cluster\n");
        while (1) {
                uint32_t recmode=1;
-               ctdb_ctrl_getrecmode(ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
+               ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
                if (recmode == 0) break;
                event_loop_once(ev);
        }

diff --git a/ctdb/tools/ctdb.c b/ctdb/tools/ctdb.c
index 849b638a95321bbd675ef973f05f9de9b7f9b23c..9cfe966db926494b33799a217925db7329b1ec82 100644 (file)
--- a/ctdb/tools/ctdb.c
+++ b/ctdb/tools/ctdb.c
@@ -292,7 +292,7 @@ static int control_status(struct ctdb_context *ctdb, int argc, const char **argv
                printf("hash:%d lmaster:%d\n", i, vnnmap->map[i]);
        }
 
-       ret = ctdb_ctrl_getrecmode(ctdb, TIMELIMIT(), options.vnn, &recmode);
+       ret = ctdb_ctrl_getrecmode(ctdb, ctdb, TIMELIMIT(), options.vnn, &recmode);
        if (ret != 0) {
                DEBUG(0, ("Unable to get recmode from node %u\n", options.vnn));
                return ret;