remove the timeout parameter to ctdb_control_send() and

have all callers set this explicitely when they need a timeout
for the control

diff --git a/client/ctdb_client.c b/client/ctdb_client.c
index f97d739a3b54ecaf340c96926fa5adaec07c28c0..7b49931142643280b9d9812a976526b17b751ddb 100644 (file)
--- a/client/ctdb_client.c
+++ b/client/ctdb_client.c
@@ -254,7 +254,11 @@ int ctdb_control(struct ctdb_context *ctdb, uint32_t destnode, uint64_t srvid,
 
        state = ctdb_control_send(ctdb, destnode, srvid, opcode, 
                        flags, data, mem_ctx,
-                       timeout, errormsg);
+                       errormsg);
+       if (state != NULL && timeout && !timeval_is_zero(timeout)) {
+               event_add_timed(ctdb->ev, state, *timeout, ctdb_control_timeout_func, state);
+       }
+
        return ctdb_control_recv(ctdb, state, mem_ctx, outdata, status, 
                        errormsg);
 }
@@ -323,11 +327,14 @@ int ctdb_ctrl_shutdown(struct ctdb_context *ctdb, struct timeval timeout, uint32
 
        state = ctdb_control_send(ctdb, destnode, 0, 
                           CTDB_CONTROL_SHUTDOWN, 0, tdb_null, 
-                          NULL, &timeout, NULL);
+                          NULL, NULL);
        if (state == NULL) {
                DEBUG(DEBUG_ERR,(__location__ " ctdb_control for shutdown failed\n"));
                return -1;
        }
+       if (!timeval_is_zero(&timeout)) {
+               event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+       }
 
        return 0;
 }
@@ -377,9 +384,17 @@ int ctdb_ctrl_getvnnmap(struct ctdb_context *ctdb, struct timeval timeout, uint3
 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, 
+       struct ctdb_client_control_state *state;
+
+       state = ctdb_control_send(ctdb, destnode, 0, 
                           CTDB_CONTROL_GET_RECMODE, 0, tdb_null, 
-                          mem_ctx, &timeout, NULL);
+                          mem_ctx, NULL);
+
+       if (state != NULL && !timeval_is_zero(&timeout)) {
+               event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+       }
+
+       return state;
 }
 
 int ctdb_ctrl_getrecmode_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmode)
@@ -443,9 +458,16 @@ struct ctdb_client_control_state *
 ctdb_ctrl_getrecmaster_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, 
                        struct timeval timeout, uint32_t destnode)
 {
-       return ctdb_control_send(ctdb, destnode, 0, 
+       struct ctdb_client_control_state *state;
+
+       state = ctdb_control_send(ctdb, destnode, 0, 
                           CTDB_CONTROL_GET_RECMASTER, 0, tdb_null, 
-                          mem_ctx, &timeout, NULL);
+                          mem_ctx, NULL);
+       if (state != NULL && !timeval_is_zero(&timeout)) {
+               event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+       }
+
+       return state;
 }
 
 int ctdb_ctrl_getrecmaster_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmaster)
@@ -672,7 +694,11 @@ struct ctdb_client_control_state *ctdb_ctrl_pulldb_send(
 
        state = ctdb_control_send(ctdb, destnode, 0, 
                                  CTDB_CONTROL_PULL_DB, 0, indata, 
-                                 mem_ctx, &timeout, NULL);
+                                 mem_ctx, NULL);
+       if (state != NULL && !timeval_is_zero(&timeout)) {
+               event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+       }
+
        talloc_free(pull);
 
        return state;
@@ -1278,9 +1304,16 @@ int ctdb_ctrl_getpid(struct ctdb_context *ctdb, struct timeval timeout, uint32_t
 struct ctdb_client_control_state *
 ctdb_ctrl_freeze_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, uint32_t priority)
 {
-       return ctdb_control_send(ctdb, destnode, priority, 
+       struct ctdb_client_control_state *state;
+
+       state = ctdb_control_send(ctdb, destnode, priority, 
                           CTDB_CONTROL_FREEZE, 0, tdb_null, 
-                          mem_ctx, &timeout, NULL);
+                          mem_ctx, NULL);
+       if (state != NULL && !timeval_is_zero(&timeout)) {
+               event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+       }
+
+       return state;
 }
 
 /* 
@@ -2243,9 +2276,16 @@ uint32_t ctdb_get_pnn(struct ctdb_context *ctdb)
 struct ctdb_client_control_state *
 ctdb_ctrl_uptime_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode)
 {
-       return ctdb_control_send(ctdb, destnode, 0, 
+       struct ctdb_client_control_state *state;
+
+       state = ctdb_control_send(ctdb, destnode, 0, 
                           CTDB_CONTROL_UPTIME, 0, tdb_null, 
-                          mem_ctx, &timeout, NULL);
+                          mem_ctx, NULL);
+       if (state != NULL && !timeval_is_zero(&timeout)) {
+               event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+       }
+
+       return state;
 }
 
 int ctdb_ctrl_uptime_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, struct ctdb_uptime **uptime)
@@ -2407,12 +2447,15 @@ int ctdb_client_async_control(struct ctdb_context *ctdb,
                uint32_t pnn = nodes[j];
 
                state = ctdb_control_send(ctdb, pnn, srvid, opcode, 
-                                         0, data, async_data, &timeout, NULL);
+                                         0, data, async_data, NULL);
                if (state == NULL) {
                        DEBUG(DEBUG_ERR,(__location__ " Failed to call async control %u\n", (unsigned)opcode));
                        talloc_free(async_data);
                        return -1;
                }
+               if (!timeval_is_zero(&timeout)) {
+                       event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+               }
                
                ctdb_client_async_add(async_data, state);
        }
@@ -2596,9 +2639,16 @@ ctdb_read_pnn_lock(int fd, int32_t pnn)
 struct ctdb_client_control_state *
 ctdb_ctrl_getcapabilities_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode)
 {
-       return ctdb_control_send(ctdb, destnode, 0, 
+       struct ctdb_client_control_state *state;
+
+       state = ctdb_control_send(ctdb, destnode, 0, 
                           CTDB_CONTROL_GET_CAPABILITIES, 0, tdb_null, 
-                          mem_ctx, &timeout, NULL);
+                          mem_ctx, NULL);
+       if (state != NULL && !timeval_is_zero(&timeout)) {
+               event_add_timed(ctdb->ev, state, timeout, ctdb_control_timeout_func, state);
+       }
+
+       return state;
 }
 
 int ctdb_ctrl_getcapabilities_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *capabilities)

diff --git a/include/ctdb_private.h b/include/ctdb_private.h
index 658ba9b7319b56be3ecbc10ef630d79a3a814e68..90d4c13298c83b295f50b3a04badea54a344bb65 100644 (file)
--- a/include/ctdb_private.h
+++ b/include/ctdb_private.h
@@ -1075,7 +1075,6 @@ 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,
-               struct timeval *timeout,
                char **errormsg);
 
 

diff --git a/libctdb/ctdb_client.c b/libctdb/ctdb_client.c
index 92d0455737b2445fcbe746e51534788de8e10cc7..23faa4b5af86c56fd339dea7552009e54455cd8c 100644 (file)
--- a/libctdb/ctdb_client.c
+++ b/libctdb/ctdb_client.c
@@ -441,7 +441,6 @@ 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,
-               struct timeval *timeout,
                char **errormsg)
 {
        struct ctdb_client_control_state *state;
@@ -484,11 +483,6 @@ struct ctdb_client_control_state *ctdb_control_send(struct ctdb_context *ctdb,
                memcpy(&c->data[0], data.dptr, data.dsize);
        }
 
-       /* timeout */
-       if (timeout && !timeval_is_zero(timeout)) {
-               event_add_timed(ctdb->ev, state, *timeout, ctdb_control_timeout_func, state);
-       }
-
        ret = ctdb_client_queue_pkt(ctdb, &(c->hdr));
        if (ret != 0) {
                talloc_free(state);

diff --git a/libctdb/libctdb.c b/libctdb/libctdb.c
index 254be93f45da851f8cf053d72deff43a7148f9fa..638874c7c8903416b7dcd6ed8028001ae511c17e 100644 (file)
--- a/libctdb/libctdb.c
+++ b/libctdb/libctdb.c
@@ -164,7 +164,7 @@ ctdb_getrecmaster_send(struct ctdb_context *ctdb,
 
        state = ctdb_control_send(ctdb, destnode, 0, 
                           CTDB_CONTROL_GET_RECMASTER, 0, tdb_null, 
-                          ctdb, NULL, NULL);
+                          ctdb, NULL);
 
        if (state == NULL) {
                DEBUG(DEBUG_ERR,(__location__ " Failed to send GET_RECMASTER control\n"));
@@ -246,7 +246,7 @@ ctdb_set_message_handler_send(struct ctdb_context *ctdb, uint64_t srvid,
 
        state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, srvid, 
                           CTDB_CONTROL_REGISTER_SRVID, 0, tdb_null, 
-                          ctdb, NULL, NULL);
+                          ctdb, NULL);
 
        if (state == NULL) {
                DEBUG(DEBUG_ERR,(__location__ " Failed to send REGISTER_SRVID control\n"));
@@ -320,7 +320,7 @@ ctdb_remove_message_handler_send(struct ctdb_context *ctdb, uint64_t srvid,
 
        state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, srvid, 
                           CTDB_CONTROL_DEREGISTER_SRVID, 0, tdb_null, 
-                          ctdb, NULL, NULL);
+                          ctdb, NULL);
 
        if (state == NULL) {
                DEBUG(DEBUG_ERR,(__location__ " Failed to send DEREGISTER_SRVID control\n"));

diff --git a/server/ctdb_takeover.c b/server/ctdb_takeover.c
index 6857f371417701e8013c3029d303744cd072d804..596a7ee830b5bc802d58ae8d0f9362a2f21f502f 100644 (file)
--- a/server/ctdb_takeover.c
+++ b/server/ctdb_takeover.c
@@ -1218,7 +1218,6 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap)
        struct ctdb_public_ip_list *all_ips, *tmp_ip;
        int maxnode, maxnum=0, minnode, minnum=0, num;
        TDB_DATA data;
-       struct timeval timeout;
        struct client_async_data *async_data;
        struct ctdb_client_control_state *state;
        TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
@@ -1442,24 +1441,29 @@ finished:
                                ipv4.pnn = tmp_ip->pnn;
                                ipv4.sin = tmp_ip->addr.ip;
 
-                               timeout = TAKEOVER_TIMEOUT();
+                               
                                data.dsize = sizeof(ipv4);
                                data.dptr  = (uint8_t *)&ipv4;
                                state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
                                                0, CTDB_CONTROL_RELEASE_IPv4, 0,
                                                data, async_data,
-                                               &timeout, NULL);
+                                               NULL);
+                               if (state != NULL) {
+                                       event_add_timed(ctdb->ev, state, TAKEOVER_TIMEOUT(), ctdb_control_timeout_func, state);
+                               }
                        } else {
                                ip.pnn  = tmp_ip->pnn;
                                ip.addr = tmp_ip->addr;
 
-                               timeout = TAKEOVER_TIMEOUT();
                                data.dsize = sizeof(ip);
                                data.dptr  = (uint8_t *)&ip;
                                state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
                                                0, CTDB_CONTROL_RELEASE_IP, 0,
                                                data, async_data,
-                                               &timeout, NULL);
+                                               NULL);
+                               if (state != NULL) {
+                                       event_add_timed(ctdb->ev, state, TAKEOVER_TIMEOUT(), ctdb_control_timeout_func, state);
+                               }
                        }
 
                        if (state == NULL) {
@@ -1492,24 +1496,28 @@ finished:
                        ipv4.pnn = tmp_ip->pnn;
                        ipv4.sin = tmp_ip->addr.ip;
 
-                       timeout = TAKEOVER_TIMEOUT();
                        data.dsize = sizeof(ipv4);
                        data.dptr  = (uint8_t *)&ipv4;
                        state = ctdb_control_send(ctdb, tmp_ip->pnn,
                                        0, CTDB_CONTROL_TAKEOVER_IPv4, 0,
                                        data, async_data,
-                                       &timeout, NULL);
+                                       NULL);
+                       if (state != NULL) {
+                               event_add_timed(ctdb->ev, state, TAKEOVER_TIMEOUT(), ctdb_control_timeout_func, state);
+                       }
                } else {
                        ip.pnn  = tmp_ip->pnn;
                        ip.addr = tmp_ip->addr;
 
-                       timeout = TAKEOVER_TIMEOUT();
                        data.dsize = sizeof(ip);
                        data.dptr  = (uint8_t *)&ip;
                        state = ctdb_control_send(ctdb, tmp_ip->pnn,
                                        0, CTDB_CONTROL_TAKEOVER_IP, 0,
                                        data, async_data,
-                                       &timeout, NULL);
+                                       NULL);
+                       if (state != NULL) {
+                               event_add_timed(ctdb->ev, state, TAKEOVER_TIMEOUT(), ctdb_control_timeout_func, state);
+                       }
                }
                if (state == NULL) {
                        DEBUG(DEBUG_ERR,(__location__ " Failed to call async control CTDB_CONTROL_TAKEOVER_IP to node %u\n", tmp_ip->pnn));