ctdb-daemon: Rename struct ctdb_req_control to ctdb_req_control_old

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>

diff --git a/ctdb/client/ctdb_client.c b/ctdb/client/ctdb_client.c
index e1e62c7c9f10604c6ecd91f4b746bebb38c4b0c9..684bb17788051694eed8c0f93c84e8447f7ff62e 100644 (file)
--- a/ctdb/client/ctdb_client.c
+++ b/ctdb/client/ctdb_client.c
@@ -1073,7 +1073,7 @@ struct ctdb_client_control_state *ctdb_control_send(struct ctdb_context *ctdb,
 {
        struct ctdb_client_control_state *state;
        size_t len;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        int ret;
 
        if (errormsg) {
@@ -1095,9 +1095,9 @@ struct ctdb_client_control_state *ctdb_control_send(struct ctdb_context *ctdb,
 
        talloc_set_destructor(state, ctdb_client_control_destructor);
 
-       len = offsetof(struct ctdb_req_control, data) + data.dsize;
+       len = offsetof(struct ctdb_req_control_old, data) + data.dsize;
        c = ctdbd_allocate_pkt(ctdb, state, CTDB_REQ_CONTROL, 
-                              len, struct ctdb_req_control);
+                              len, struct ctdb_req_control_old);
        state->c            = c;        
        CTDB_NO_MEMORY_NULL(ctdb, c);
        c->hdr.reqid        = state->reqid;

diff --git a/ctdb/common/ctdb_io.c b/ctdb/common/ctdb_io.c
index 8b649a2d43a2ede0090c41d1ec76113f8b5bd921..632574ed7160cb091ec75ad1c67d2825f570b879 100644 (file)
--- a/ctdb/common/ctdb_io.c
+++ b/ctdb/common/ctdb_io.c
@@ -359,7 +359,7 @@ int ctdb_queue_send(struct ctdb_queue *queue, uint8_t *data, uint32_t length)
        if (queue->ctdb->tunable.verbose_memory_names != 0) {
                switch (hdr->operation) {
                case CTDB_REQ_CONTROL: {
-                       struct ctdb_req_control *c = (struct ctdb_req_control *)hdr;
+                       struct ctdb_req_control_old *c = (struct ctdb_req_control_old *)hdr;
                        talloc_set_name(pkt, "ctdb_queue_pkt: %s control opcode=%u srvid=%llu datalen=%u",
                                        queue->name, (unsigned)c->opcode, (unsigned long long)c->srvid, (unsigned)c->datalen);
                        break;

diff --git a/ctdb/include/ctdb_client.h b/ctdb/include/ctdb_client.h
index aed9d53ce16d6f75909c9ec0473f803eb3b31f69..77347eaafc894185061ffde236299dde267dea22 100644 (file)
--- a/ctdb/include/ctdb_client.h
+++ b/ctdb/include/ctdb_client.h
@@ -37,7 +37,7 @@ struct ctdb_client_control_state {
        TDB_DATA outdata;
        enum control_state state;
        char *errormsg;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
 
        /* if we have a callback registered for the completion (or failure) of
           this control

diff --git a/ctdb/include/ctdb_private.h b/ctdb/include/ctdb_private.h
index ece8f2d02c16edff76f79259a796db956a57a645..4c72a513301cdf2b97728ff884808e15c14ffb46 100644 (file)
--- a/ctdb/include/ctdb_private.h
+++ b/ctdb/include/ctdb_private.h
@@ -583,7 +583,7 @@ int ctdb_add_revoke_deferred_call(struct ctdb_context *ctdb,
 int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata);
 
 void ctdb_request_control_reply(struct ctdb_context *ctdb,
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                TDB_DATA *outdata, int32_t status,
                                const char *errormsg);
 
@@ -647,12 +647,12 @@ void ctdb_shutdown_sequence(struct ctdb_context *ctdb, int exit_code);
 /* from server/ctdb_freeze.c */
 
 int32_t ctdb_control_db_freeze(struct ctdb_context *ctdb,
-                              struct ctdb_req_control *c,
+                              struct ctdb_req_control_old *c,
                               uint32_t db_id, bool *async_reply);
 int32_t ctdb_control_db_thaw(struct ctdb_context *ctdb, uint32_t db_id);
 
 int32_t ctdb_control_freeze(struct ctdb_context *ctdb,
-                           struct ctdb_req_control *c, bool *async_reply);
+                           struct ctdb_req_control_old *c, bool *async_reply);
 int32_t ctdb_control_thaw(struct ctdb_context *ctdb, uint32_t priority,
                          bool check_recmode);
 
@@ -789,7 +789,7 @@ int ctdb_process_deferred_attach(struct ctdb_context *ctdb);
 int32_t ctdb_control_db_attach(struct ctdb_context *ctdb, TDB_DATA indata,
                               TDB_DATA *outdata, uint64_t tdb_flags,
                               bool persistent, uint32_t client_id,
-                              struct ctdb_req_control *c,
+                              struct ctdb_req_control_old *c,
                               bool *async_reply);
 int32_t ctdb_control_db_detach(struct ctdb_context *ctdb, TDB_DATA indata,
                               uint32_t client_id);
@@ -832,14 +832,14 @@ bool ctdb_stopped_monitoring(struct ctdb_context *ctdb);
 void ctdb_persistent_finish_trans3_commits(struct ctdb_context *ctdb);
 
 int32_t ctdb_control_trans3_commit(struct ctdb_context *ctdb,
-                                  struct ctdb_req_control *c,
+                                  struct ctdb_req_control_old *c,
                                   TDB_DATA recdata, bool *async_reply);
 
 int32_t ctdb_control_start_persistent_update(struct ctdb_context *ctdb,
-                                            struct ctdb_req_control *c,
+                                            struct ctdb_req_control_old *c,
                                             TDB_DATA recdata);
 int32_t ctdb_control_cancel_persistent_update(struct ctdb_context *ctdb,
-                                             struct ctdb_req_control *c,
+                                             struct ctdb_req_control_old *c,
                                              TDB_DATA recdata);
 
 int32_t ctdb_control_get_db_seqnum(struct ctdb_context *ctdb,
@@ -866,7 +866,7 @@ int32_t ctdb_control_push_db(struct ctdb_context *ctdb, TDB_DATA indata);
 int ctdb_deferred_drop_all_ips(struct ctdb_context *ctdb);
 
 int32_t ctdb_control_set_recmode(struct ctdb_context *ctdb,
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 TDB_DATA indata, bool *async_reply,
                                 const char **errormsg);
 
@@ -875,10 +875,10 @@ bool ctdb_recovery_lock(struct ctdb_context *ctdb);
 void ctdb_recovery_unlock(struct ctdb_context *ctdb);
 
 int32_t ctdb_control_end_recovery(struct ctdb_context *ctdb,
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 bool *async_reply);
 int32_t ctdb_control_start_recovery(struct ctdb_context *ctdb,
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 bool *async_reply);
 
 int32_t ctdb_control_try_delete_records(struct ctdb_context *ctdb,
@@ -940,21 +940,21 @@ int32_t ctdb_control_get_server_id_list(struct ctdb_context *ctdb,
 int ctdb_statistics_init(struct ctdb_context *ctdb);
 
 int32_t ctdb_control_get_stat_history(struct ctdb_context *ctdb,
-                                     struct ctdb_req_control *c,
+                                     struct ctdb_req_control_old *c,
                                      TDB_DATA *outdata);
 
 /* from ctdb_takeover.c */
 
 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 TDB_DATA indata,
                                 bool *async_reply);
 int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 TDB_DATA indata,
                                 bool *async_reply);
 int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 bool *async_reply);
 
 int ctdb_set_public_addresses(struct ctdb_context *ctdb, bool check_addresses);
@@ -977,17 +977,17 @@ void ctdb_takeover_client_destructor_hook(struct ctdb_client *client);
 void ctdb_release_all_ips(struct ctdb_context *ctdb);
 
 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
-                                   struct ctdb_req_control *c,
+                                   struct ctdb_req_control_old *c,
                                    TDB_DATA *outdata);
 int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
-                                       struct ctdb_req_control *c,
+                                       struct ctdb_req_control_old *c,
                                        TDB_DATA indata, TDB_DATA *outdata);
 
 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                TDB_DATA *outdata);
 int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
-                                   struct ctdb_req_control *c,
+                                   struct ctdb_req_control_old *c,
                                    TDB_DATA indata);
 
 int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata);
@@ -1004,7 +1004,7 @@ int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb,
 int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb,
                                        TDB_DATA indata);
 int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
-                                       struct ctdb_req_control *c,
+                                       struct ctdb_req_control_old *c,
                                        TDB_DATA recdata, bool *async_reply);
 
 int verify_remote_ip_allocation(struct ctdb_context *ctdb,
@@ -1015,7 +1015,7 @@ int update_ip_assignment_tree(struct ctdb_context *ctdb,
 void clear_ip_assignment_tree(struct ctdb_context *ctdb);
 
 int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb,
-                                      struct ctdb_req_control *c,
+                                      struct ctdb_req_control_old *c,
                                       bool *async_reply);
 
 /* from ctdb_traverse.c */
@@ -1049,7 +1049,7 @@ int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb,
 /* from ctdb_update_record.c */
 
 int32_t ctdb_control_update_record(struct ctdb_context *ctdb,
-                                  struct ctdb_req_control *c,
+                                  struct ctdb_req_control_old *c,
                                   TDB_DATA recdata, bool *async_reply);
 
 /* from ctdb_uptime.c */
@@ -1093,7 +1093,7 @@ int ctdb_event_script(struct ctdb_context *ctdb,
                      enum ctdb_event call);
 
 int32_t ctdb_run_eventscripts(struct ctdb_context *ctdb,
-                             struct ctdb_req_control *c,
+                             struct ctdb_req_control_old *c,
                              TDB_DATA data, bool *async_reply);
 
 int32_t ctdb_control_enable_script(struct ctdb_context *ctdb, TDB_DATA indata);

diff --git a/ctdb/include/ctdb_protocol.h b/ctdb/include/ctdb_protocol.h
index 11d9f53d67ab2e9665558578897309656c3aa303..e833c2083e08aad1dbb2e05276f6c35e0c8ba1ba 100644 (file)
--- a/ctdb/include/ctdb_protocol.h
+++ b/ctdb/include/ctdb_protocol.h
@@ -480,7 +480,7 @@ struct ctdb_req_message_old {
        uint8_t data[1];
 };
 
-struct ctdb_req_control {
+struct ctdb_req_control_old {
        struct ctdb_req_header hdr;
        uint32_t opcode;
        uint32_t pad;

diff --git a/ctdb/server/ctdb_control.c b/ctdb/server/ctdb_control.c
index 21ace77471d3f60beac0684851933fac9abcabdd..99caba7995c3d495938084f5dc8cf920a3945c08 100644 (file)
--- a/ctdb/server/ctdb_control.c
+++ b/ctdb/server/ctdb_control.c
@@ -91,7 +91,7 @@ static int32_t control_not_implemented(const char *unsupported,
   process a control request
  */
 static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb, 
-                                    struct ctdb_req_control *c,
+                                    struct ctdb_req_control_old *c,
                                     TDB_DATA indata,
                                     TDB_DATA *outdata, uint32_t srcnode,
                                     const char **errormsg,
@@ -724,7 +724,7 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
 /*
   send a reply for a ctdb control
  */
-void ctdb_request_control_reply(struct ctdb_context *ctdb, struct ctdb_req_control *c,
+void ctdb_request_control_reply(struct ctdb_context *ctdb, struct ctdb_req_control_old *c,
                                TDB_DATA *outdata, int32_t status, const char *errormsg)
 {
        struct ctdb_reply_control *r;
@@ -767,7 +767,7 @@ void ctdb_request_control_reply(struct ctdb_context *ctdb, struct ctdb_req_contr
 */
 void ctdb_request_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
 {
-       struct ctdb_req_control *c = (struct ctdb_req_control *)hdr;
+       struct ctdb_req_control_old *c = (struct ctdb_req_control_old *)hdr;
        TDB_DATA data, *outdata;
        int32_t status;
        bool async_reply = false;
@@ -860,7 +860,7 @@ int ctdb_daemon_send_control(struct ctdb_context *ctdb, uint32_t destnode,
                             ctdb_control_callback_fn_t callback,
                             void *private_data)
 {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        struct ctdb_control_state *state;
        size_t len;
 
@@ -901,9 +901,9 @@ int ctdb_daemon_send_control(struct ctdb_context *ctdb, uint32_t destnode,
 
        talloc_set_destructor(state, ctdb_control_destructor);
 
-       len = offsetof(struct ctdb_req_control, data) + data.dsize;
+       len = offsetof(struct ctdb_req_control_old, data) + data.dsize;
        c = ctdb_transport_allocate(ctdb, state, CTDB_REQ_CONTROL, len, 
-                                   struct ctdb_req_control);
+                                   struct ctdb_req_control_old);
        CTDB_NO_MEMORY(ctdb, c);
        talloc_set_name_const(c, "ctdb_req_control packet");
 

diff --git a/ctdb/server/ctdb_daemon.c b/ctdb/server/ctdb_daemon.c
index f885a81f758d00a12cd141d63cc98140bfa5329f..b95741c147974c24beb4d0281f4422a454bcc416 100644 (file)
--- a/ctdb/server/ctdb_daemon.c
+++ b/ctdb/server/ctdb_daemon.c
@@ -811,7 +811,7 @@ static void daemon_request_call_from_client(struct ctdb_client *client,
 
 
 static void daemon_request_control_from_client(struct ctdb_client *client, 
-                                              struct ctdb_req_control *c);
+                                              struct ctdb_req_control_old *c);
 
 /* data contains a packet from the client */
 static void daemon_incoming_packet(void *p, struct ctdb_req_header *hdr)
@@ -850,7 +850,7 @@ static void daemon_incoming_packet(void *p, struct ctdb_req_header *hdr)
 
        case CTDB_REQ_CONTROL:
                CTDB_INCREMENT_STAT(ctdb, client.req_control);
-               daemon_request_control_from_client(client, (struct ctdb_req_control *)hdr);
+               daemon_request_control_from_client(client, (struct ctdb_req_control_old *)hdr);
                break;
 
        default:
@@ -1424,7 +1424,7 @@ struct ctdb_req_header *_ctdb_transport_allocate(struct ctdb_context *ctdb,
 struct daemon_control_state {
        struct daemon_control_state *next, *prev;
        struct ctdb_client *client;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        uint32_t reqid;
        struct ctdb_node *node;
 };
@@ -1498,7 +1498,7 @@ static int daemon_control_destructor(struct daemon_control_state *state)
   from a local client over the unix domain socket
  */
 static void daemon_request_control_from_client(struct ctdb_client *client, 
-                                              struct ctdb_req_control *c)
+                                              struct ctdb_req_control_old *c)
 {
        TDB_DATA data;
        int res;

diff --git a/ctdb/server/ctdb_freeze.c b/ctdb/server/ctdb_freeze.c
index 83a088fea03e3ef7b4ac348a2a886f7767c584d1..94c070077ea73f6d1ef67508059c5bb4eafa0f3f 100644 (file)
--- a/ctdb/server/ctdb_freeze.c
+++ b/ctdb/server/ctdb_freeze.c
@@ -215,8 +215,8 @@ static void ctdb_start_db_freeze(struct ctdb_db_context *ctdb_db)
 static int ctdb_db_freeze_waiter_destructor(struct ctdb_db_freeze_waiter *w)
 {
        /* 'c' pointer is talloc_memdup(), so cannot use talloc_get_type */
-       struct ctdb_req_control *c =
-               (struct ctdb_req_control *)w->private_data;
+       struct ctdb_req_control_old *c =
+               (struct ctdb_req_control_old *)w->private_data;
 
        ctdb_request_control_reply(w->ctdb, c, NULL, w->status, NULL);
        return 0;
@@ -226,7 +226,7 @@ static int ctdb_db_freeze_waiter_destructor(struct ctdb_db_freeze_waiter *w)
  * freeze a database
  */
 int32_t ctdb_control_db_freeze(struct ctdb_context *ctdb,
-                              struct ctdb_req_control *c,
+                              struct ctdb_req_control_old *c,
                               uint32_t db_id,
                               bool *async_reply)
 {
@@ -288,7 +288,7 @@ int32_t ctdb_control_db_thaw(struct ctdb_context *ctdb, uint32_t db_id)
 struct ctdb_freeze_waiter {
        struct ctdb_freeze_waiter *next, *prev;
        struct ctdb_context *ctdb;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        uint32_t priority;
        int32_t status;
 };
@@ -546,7 +546,7 @@ static int ctdb_freeze_waiter_destructor(struct ctdb_freeze_waiter *w)
 /*
   freeze the databases
  */
-int32_t ctdb_control_freeze(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply)
+int32_t ctdb_control_freeze(struct ctdb_context *ctdb, struct ctdb_req_control_old *c, bool *async_reply)
 {
        struct ctdb_freeze_waiter *w;
        uint32_t priority;

diff --git a/ctdb/server/ctdb_ltdb_server.c b/ctdb/server/ctdb_ltdb_server.c
index 54cf7a0185784d9c2db1fe7a631ff45c6b95b2da..43181dc2afe824d9926ba5041a38cebf00c6d0f3 100644 (file)
--- a/ctdb/server/ctdb_ltdb_server.c
+++ b/ctdb/server/ctdb_ltdb_server.c
@@ -1036,7 +1036,7 @@ again:
 struct ctdb_deferred_attach_context {
        struct ctdb_deferred_attach_context *next, *prev;
        struct ctdb_context *ctdb;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
 };
 
 
@@ -1093,7 +1093,7 @@ int ctdb_process_deferred_attach(struct ctdb_context *ctdb)
 int32_t ctdb_control_db_attach(struct ctdb_context *ctdb, TDB_DATA indata,
                               TDB_DATA *outdata, uint64_t tdb_flags, 
                               bool persistent, uint32_t client_id,
-                              struct ctdb_req_control *c,
+                              struct ctdb_req_control_old *c,
                               bool *async_reply)
 {
        const char *db_name = (const char *)indata.dptr;

diff --git a/ctdb/server/ctdb_persistent.c b/ctdb/server/ctdb_persistent.c
index e5ad2fa7f6dc09d437330f3221f638933d6c5c2e..10e68351042993d1ea428c99174a109532f0ece7 100644 (file)
--- a/ctdb/server/ctdb_persistent.c
+++ b/ctdb/server/ctdb_persistent.c
@@ -41,7 +41,7 @@ struct ctdb_persistent_state {
        struct ctdb_context *ctdb;
        struct ctdb_db_context *ctdb_db; /* used by trans3_commit */
        struct ctdb_client *client; /* used by trans3_commit */
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        const char *errormsg;
        uint32_t num_pending;
        int32_t status;
@@ -173,7 +173,7 @@ static int ctdb_persistent_state_destructor(struct ctdb_persistent_state *state)
  * This is used to roll out a transaction to all nodes.
  */
 int32_t ctdb_control_trans3_commit(struct ctdb_context *ctdb,
-                                  struct ctdb_req_control *c,
+                                  struct ctdb_req_control_old *c,
                                   TDB_DATA recdata, bool *async_reply)
 {
        struct ctdb_client *client;
@@ -287,7 +287,7 @@ int32_t ctdb_control_trans3_commit(struct ctdb_context *ctdb,
   for now we ignore the recdata that the client has passed to us.
  */
 int32_t ctdb_control_start_persistent_update(struct ctdb_context *ctdb, 
-                                     struct ctdb_req_control *c,
+                                     struct ctdb_req_control_old *c,
                                      TDB_DATA recdata)
 {
        struct ctdb_client *client = reqid_find(ctdb->idr, c->client_id, struct ctdb_client);
@@ -308,7 +308,7 @@ int32_t ctdb_control_start_persistent_update(struct ctdb_context *ctdb,
   called to tell ctdbd that it is no longer doing a persistent update 
 */
 int32_t ctdb_control_cancel_persistent_update(struct ctdb_context *ctdb, 
-                                             struct ctdb_req_control *c,
+                                             struct ctdb_req_control_old *c,
                                              TDB_DATA recdata)
 {
        struct ctdb_client *client = reqid_find(ctdb->idr, c->client_id, struct ctdb_client);

diff --git a/ctdb/server/ctdb_recover.c b/ctdb/server/ctdb_recover.c
index c898b95e1ab46e1b289f2b1add3a2c954c9319f2..9d5c7d7f02e017a51c008aa98b1d21fa8721542e 100644 (file)
--- a/ctdb/server/ctdb_recover.c
+++ b/ctdb/server/ctdb_recover.c
@@ -408,7 +408,7 @@ failed:
 
 struct ctdb_set_recmode_state {
        struct ctdb_context *ctdb;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        uint32_t recmode;
        int fd[2];
        struct tevent_timer *te;
@@ -539,7 +539,7 @@ int ctdb_deferred_drop_all_ips(struct ctdb_context *ctdb)
   set the recovery mode
  */
 int32_t ctdb_control_set_recmode(struct ctdb_context *ctdb, 
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 TDB_DATA indata, bool *async_reply,
                                 const char **errormsg)
 {
@@ -858,7 +858,7 @@ static int delete_tdb_record(struct ctdb_context *ctdb, struct ctdb_db_context *
 
 
 struct recovery_callback_state {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
 };
 
 
@@ -893,7 +893,7 @@ static void ctdb_end_recovery_callback(struct ctdb_context *ctdb, int status, vo
   recovery has finished
  */
 int32_t ctdb_control_end_recovery(struct ctdb_context *ctdb, 
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                bool *async_reply)
 {
        int ret;
@@ -948,7 +948,7 @@ static void ctdb_start_recovery_callback(struct ctdb_context *ctdb, int status,
   run the startrecovery eventscript
  */
 int32_t ctdb_control_start_recovery(struct ctdb_context *ctdb, 
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                bool *async_reply)
 {
        int ret;

diff --git a/ctdb/server/ctdb_statistics.c b/ctdb/server/ctdb_statistics.c
index c96858631b02d40596c1658cd3e77e231fef0676..7987a318faced2a0258645c3ed393532f198459d 100644 (file)
--- a/ctdb/server/ctdb_statistics.c
+++ b/ctdb/server/ctdb_statistics.c
@@ -67,7 +67,7 @@ int ctdb_statistics_init(struct ctdb_context *ctdb)
 
 
 int32_t ctdb_control_get_stat_history(struct ctdb_context *ctdb, 
-                                     struct ctdb_req_control *c,
+                                     struct ctdb_req_control_old *c,
                                      TDB_DATA *outdata)
 {
        int len;

diff --git a/ctdb/server/ctdb_takeover.c b/ctdb/server/ctdb_takeover.c
index 61a3a8d5a2ce724d7d32cd2b7606b921a6e946f0..78e9e7852c8bca71bc54cc0c7e5e78b94bf69584 100644 (file)
--- a/ctdb/server/ctdb_takeover.c
+++ b/ctdb/server/ctdb_takeover.c
@@ -404,13 +404,13 @@ static int32_t ctdb_announce_vnn_iface(struct ctdb_context *ctdb,
 }
 
 struct takeover_callback_state {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        ctdb_sock_addr *addr;
        struct ctdb_vnn *vnn;
 };
 
 struct ctdb_do_takeip_state {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        struct ctdb_vnn *vnn;
 };
 
@@ -475,7 +475,7 @@ static int ctdb_takeip_destructor(struct ctdb_do_takeip_state *state)
   take over an ip address
  */
 static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
-                             struct ctdb_req_control *c,
+                             struct ctdb_req_control_old *c,
                              struct ctdb_vnn *vnn)
 {
        int ret;
@@ -534,7 +534,7 @@ static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
 }
 
 struct ctdb_do_updateip_state {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        struct ctdb_iface *old;
        struct ctdb_vnn *vnn;
 };
@@ -598,7 +598,7 @@ static int ctdb_updateip_destructor(struct ctdb_do_updateip_state *state)
   update (move) an ip address
  */
 static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                struct ctdb_vnn *vnn)
 {
        int ret;
@@ -694,7 +694,7 @@ static struct ctdb_vnn *find_public_ip_vnn(struct ctdb_context *ctdb, ctdb_sock_
   take over an ip address
  */
 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
-                                struct ctdb_req_control *c,
+                                struct ctdb_req_control_old *c,
                                 TDB_DATA indata,
                                 bool *async_reply)
 {
@@ -926,7 +926,7 @@ static int ctdb_releaseip_destructor(struct takeover_callback_state *state)
   release an ip address
  */
 int32_t ctdb_control_release_ip(struct ctdb_context *ctdb, 
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                TDB_DATA indata, 
                                bool *async_reply)
 {
@@ -3197,7 +3197,7 @@ void ctdb_release_all_ips(struct ctdb_context *ctdb)
   get list of public IPs
  */
 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb, 
-                                   struct ctdb_req_control *c, TDB_DATA *outdata)
+                                   struct ctdb_req_control_old *c, TDB_DATA *outdata)
 {
        int i, num, len;
        struct ctdb_all_public_ips *ips;
@@ -3240,7 +3240,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
 
 
 int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
-                                       struct ctdb_req_control *c,
+                                       struct ctdb_req_control_old *c,
                                        TDB_DATA indata,
                                        TDB_DATA *outdata)
 {
@@ -3309,7 +3309,7 @@ int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
 }
 
 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                TDB_DATA *outdata)
 {
        int i, num, len;
@@ -3345,7 +3345,7 @@ int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
 }
 
 int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
-                                   struct ctdb_req_control *c,
+                                   struct ctdb_req_control_old *c,
                                    TDB_DATA indata)
 {
        struct ctdb_control_iface_info *info;
@@ -4058,7 +4058,7 @@ int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA inda
 }
 
 struct delete_ip_callback_state {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
 };
 
 /*
@@ -4078,7 +4078,7 @@ static void delete_ip_callback(struct ctdb_context *ctdb,
 }
 
 int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
-                                       struct ctdb_req_control *c,
+                                       struct ctdb_req_control_old *c,
                                        TDB_DATA indata, bool *async_reply)
 {
        struct ctdb_control_ip_iface *pub = (struct ctdb_control_ip_iface *)indata.dptr;
@@ -4167,7 +4167,7 @@ int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
 
 
 struct ipreallocated_callback_state {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
 };
 
 static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
@@ -4191,7 +4191,7 @@ static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
 
 /* A control to run the ipreallocated event */
 int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
-                                  struct ctdb_req_control *c,
+                                  struct ctdb_req_control_old *c,
                                   bool *async_reply)
 {
        int ret;
@@ -4299,7 +4299,7 @@ void clear_ip_assignment_tree(struct ctdb_context *ctdb)
 
 struct ctdb_reloadips_handle {
        struct ctdb_context *ctdb;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        int status;
        int fd[2];
        pid_t child;
@@ -4525,7 +4525,7 @@ failed:
    and drop any addresses we should nnot longer host, and add new addresses
    that we are now able to host
 */
-int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply)
+int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control_old *c, bool *async_reply)
 {
        struct ctdb_reloadips_handle *h;
        pid_t parent = getpid();

diff --git a/ctdb/server/ctdb_update_record.c b/ctdb/server/ctdb_update_record.c
index 17d4df5450ee6de3a25d11a4019361497b56488e..64fda3fa6880b3e1b2a263b07ac42e02c43e03a8 100644 (file)
--- a/ctdb/server/ctdb_update_record.c
+++ b/ctdb/server/ctdb_update_record.c
@@ -39,7 +39,7 @@
 struct ctdb_persistent_write_state {
        struct ctdb_db_context *ctdb_db;
        struct ctdb_marshall_buffer *m;
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
        uint32_t flags;
 };
 
@@ -309,7 +309,7 @@ static struct childwrite_handle *ctdb_childwrite(
    current record
  */
 int32_t ctdb_control_update_record(struct ctdb_context *ctdb,
-                                  struct ctdb_req_control *c, TDB_DATA recdata,
+                                  struct ctdb_req_control_old *c, TDB_DATA recdata,
                                   bool *async_reply)
 {
        struct ctdb_db_context *ctdb_db;

diff --git a/ctdb/server/eventscript.c b/ctdb/server/eventscript.c
index b847e5adf8c305ecf367c31752fa5c85ae36e9c9..41acd0754e2cb96d538907edc7da4506c68a7546 100644 (file)
--- a/ctdb/server/eventscript.c
+++ b/ctdb/server/eventscript.c
@@ -928,7 +928,7 @@ int ctdb_event_script(struct ctdb_context *ctdb, enum ctdb_event call)
 }
 
 struct eventscript_callback_state {
-       struct ctdb_req_control *c;
+       struct ctdb_req_control_old *c;
 };
 
 /*
@@ -985,7 +985,7 @@ static const char *get_call(const char *p, enum ctdb_event *call)
   A control to force running of the eventscripts from the ctdb client tool
 */
 int32_t ctdb_run_eventscripts(struct ctdb_context *ctdb,
-               struct ctdb_req_control *c,
+               struct ctdb_req_control_old *c,
                TDB_DATA indata, bool *async_reply)
 {
        int ret;

diff --git a/ctdb/tests/src/ctdb_test_stubs.c b/ctdb/tests/src/ctdb_test_stubs.c
index 38fe016479e49ae3184a0a056f220ba3967cc2c8..f8bf2221d9063f9ae241c69116b9e4ca87bc6e39 100644 (file)
--- a/ctdb/tests/src/ctdb_test_stubs.c
+++ b/ctdb/tests/src/ctdb_test_stubs.c
@@ -540,7 +540,7 @@ ctdb_ctrl_getpnn_stub(struct ctdb_context *ctdb, struct timeval timeout,
 
 /* From ctdb_takeover.c */
 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
-                               struct ctdb_req_control *c,
+                               struct ctdb_req_control_old *c,
                                TDB_DATA *outdata)
 {
        int i, num, len;

diff --git a/source3/lib/ctdbd_conn.c b/source3/lib/ctdbd_conn.c
index 836d97170fc347d0a4bccd3d812e9b3801aa424d..b9ca94779bd105436e6bac2e8540fad2e1a42070 100644 (file)
--- a/source3/lib/ctdbd_conn.c
+++ b/source3/lib/ctdbd_conn.c
@@ -640,7 +640,7 @@ static int ctdbd_control(struct ctdbd_connection *conn,
                         TALLOC_CTX *mem_ctx, TDB_DATA *outdata,
                         int *cstatus)
 {
-       struct ctdb_req_control req;
+       struct ctdb_req_control_old req;
        struct ctdb_req_header *hdr;
        struct ctdb_reply_control *reply = NULL;
        struct iovec iov[2];
@@ -648,7 +648,7 @@ static int ctdbd_control(struct ctdbd_connection *conn,
        int ret;
 
        ZERO_STRUCT(req);
-       req.hdr.length = offsetof(struct ctdb_req_control, data) + data.dsize;
+       req.hdr.length = offsetof(struct ctdb_req_control_old, data) + data.dsize;
        req.hdr.ctdb_magic   = CTDB_MAGIC;
        req.hdr.ctdb_version = CTDB_PROTOCOL;
        req.hdr.operation    = CTDB_REQ_CONTROL;
@@ -663,7 +663,7 @@ static int ctdbd_control(struct ctdbd_connection *conn,
        ctdb_packet_dump(&req.hdr);
 
        iov[0].iov_base = &req;
-       iov[0].iov_len = offsetof(struct ctdb_req_control, data);
+       iov[0].iov_len = offsetof(struct ctdb_req_control_old, data);
        iov[1].iov_base = data.dptr;
        iov[1].iov_len = data.dsize;
 
@@ -742,7 +742,7 @@ bool ctdb_processes_exist(struct ctdbd_connection *conn,
        }
 
        for (i=0; i<num_pids; i++) {
-               struct ctdb_req_control req;
+               struct ctdb_req_control_old req;
                pid_t pid;
                struct iovec iov[2];
                ssize_t nwritten;
@@ -762,7 +762,7 @@ bool ctdb_processes_exist(struct ctdbd_connection *conn,
                           (int)pids[i].vnn, (int)pid,
                           (int)reqids[i]));
 
-               req.hdr.length = offsetof(struct ctdb_req_control, data);
+               req.hdr.length = offsetof(struct ctdb_req_control_old, data);
                req.hdr.length += sizeof(pid);
                req.hdr.ctdb_magic   = CTDB_MAGIC;
                req.hdr.ctdb_version = CTDB_PROTOCOL;
@@ -778,7 +778,7 @@ bool ctdb_processes_exist(struct ctdbd_connection *conn,
                ctdb_packet_dump(&req.hdr);
 
                iov[0].iov_base = &req;
-               iov[0].iov_len = offsetof(struct ctdb_req_control, data);
+               iov[0].iov_len = offsetof(struct ctdb_req_control_old, data);
                iov[1].iov_base = &pid;
                iov[1].iov_len = sizeof(pid);