- added counters for controls in ctdb_control status

(This used to be ctdb commit 858061372fc9902837a1a5b8bcfc0ada58eec193)

diff --git a/ctdb/common/ctdb.c b/ctdb/common/ctdb.c
index cb51af621980d9e4c066484195826390d02de0d1..7894fcc32069d22cabed29ae8677bac90a3fbdd8 100644 (file)
--- a/ctdb/common/ctdb.c
+++ b/ctdb/common/ctdb.c
@@ -267,17 +267,17 @@ void ctdb_recv_pkt(struct ctdb_context *ctdb, uint8_t *data, uint32_t length)
                        break;
                }
 
-               ctdb->status.count.req_call++;
+               ctdb->status.node.req_call++;
                ctdb_request_call(ctdb, hdr);
                break;
 
        case CTDB_REPLY_CALL:
-               ctdb->status.count.reply_call++;
+               ctdb->status.node.reply_call++;
                ctdb_reply_call(ctdb, hdr);
                break;
 
        case CTDB_REPLY_ERROR:
-               ctdb->status.count.reply_error++;
+               ctdb->status.node.reply_error++;
                ctdb_reply_error(ctdb, hdr);
                break;
 
@@ -308,7 +308,7 @@ void ctdb_recv_pkt(struct ctdb_context *ctdb, uint8_t *data, uint32_t length)
                        break;
                }
 
-               ctdb->status.count.req_dmaster++;
+               ctdb->status.node.req_dmaster++;
                ctdb_request_dmaster(ctdb, hdr);
                break;
 
@@ -339,27 +339,27 @@ void ctdb_recv_pkt(struct ctdb_context *ctdb, uint8_t *data, uint32_t length)
                        break;
                }
 
-               ctdb->status.count.reply_dmaster++;
+               ctdb->status.node.reply_dmaster++;
                ctdb_reply_dmaster(ctdb, hdr);
                break;
 
        case CTDB_REQ_MESSAGE:
-               ctdb->status.count.req_message++;
+               ctdb->status.node.req_message++;
                ctdb_request_message(ctdb, hdr);
                break;
 
        case CTDB_REQ_FINISHED:
-               ctdb->status.count.req_finished++;
+               ctdb->status.node.req_finished++;
                ctdb_request_finished(ctdb, hdr);
                break;
 
        case CTDB_REQ_CONTROL:
-               ctdb->status.count.req_control++;
+               ctdb->status.node.req_control++;
                ctdb_request_control(ctdb, hdr);
                break;
 
        case CTDB_REPLY_CONTROL:
-               ctdb->status.count.reply_control++;
+               ctdb->status.node.reply_control++;
                ctdb_reply_control(ctdb, hdr);
                break;
 

diff --git a/ctdb/common/ctdb_control.c b/ctdb/common/ctdb_control.c
index 0ee4d6138a12d0770512647f1d893c8ab1b490f2..837f8ccc88e3104aa9767b5f2eac26e9d249c952 100644 (file)
--- a/ctdb/common/ctdb_control.c
+++ b/ctdb/common/ctdb_control.c
@@ -137,14 +137,9 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
 {
        switch (opcode) {
        case CTDB_CONTROL_PROCESS_EXISTS: {
-               pid_t pid;
-               int32_t ret;
-               CHECK_CONTROL_DATA_SIZE(sizeof(pid));
-               pid = *(pid_t *)indata.dptr;
-               ret = kill(pid, 0);
-               DEBUG(5,("process_exists on %u:%u gave %d\n", 
-                        ctdb->vnn, pid, ret));
-               return ret;
+               CHECK_CONTROL_DATA_SIZE(sizeof(pid_t));
+               ctdb->status.controls.process_exists++;
+               return kill(*(pid_t *)indata.dptr, 0);
        }
 
        case CTDB_CONTROL_SET_DEBUG: {
@@ -162,6 +157,7 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
 
        case CTDB_CONTROL_STATUS: {
                CHECK_CONTROL_DATA_SIZE(0);
+               ctdb->status.controls.status++;
                outdata->dptr = (uint8_t *)&ctdb->status;
                outdata->dsize = sizeof(ctdb->status);
                return 0;
@@ -347,6 +343,7 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
 
        case CTDB_CONTROL_CONFIG: {
                CHECK_CONTROL_DATA_SIZE(0);
+               ctdb->status.controls.get_config++;
                outdata->dptr = (uint8_t *)ctdb;
                outdata->dsize = sizeof(*ctdb);
                return 0;
@@ -354,6 +351,7 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
 
        case CTDB_CONTROL_PING:
                CHECK_CONTROL_DATA_SIZE(0);
+               ctdb->status.controls.ping++;
                return ctdb->num_clients;
 
        case CTDB_CONTROL_GET_DBNAME: {
@@ -383,40 +381,50 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
        }
 
        case CTDB_CONTROL_DB_ATTACH:
+               ctdb->status.controls.attach++;
                return ctdb_control_db_attach(ctdb, indata, outdata);
 
        case CTDB_CONTROL_SET_CALL: {
                struct ctdb_control_set_call *sc = 
                        (struct ctdb_control_set_call *)indata.dptr;
+               ctdb->status.controls.set_call++;
                CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_control_set_call));
                return ctdb_daemon_set_call(ctdb, sc->db_id, sc->fn, sc->id);
        }
 
        case CTDB_CONTROL_TRAVERSE_START:
                CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_traverse_start));
+               ctdb->status.controls.traverse_start++;
                return ctdb_control_traverse_start(ctdb, indata, outdata, srcnode);
 
        case CTDB_CONTROL_TRAVERSE_ALL:
+               ctdb->status.controls.traverse_all++;
                return ctdb_control_traverse_all(ctdb, indata, outdata);
 
        case CTDB_CONTROL_TRAVERSE_DATA:
+               ctdb->status.controls.traverse_data++;
                return ctdb_control_traverse_data(ctdb, indata, outdata);
 
        case CTDB_CONTROL_REGISTER_SRVID:
+               ctdb->status.controls.register_srvid++;
                return daemon_register_message_handler(ctdb, client_id, srvid);
 
        case CTDB_CONTROL_DEREGISTER_SRVID:
+               ctdb->status.controls.deregister_srvid++;
                return daemon_deregister_message_handler(ctdb, client_id, srvid);
 
        case CTDB_CONTROL_ENABLE_SEQNUM:
+               ctdb->status.controls.enable_seqnum++;
                CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));
                return ctdb_ltdb_enable_seqnum(ctdb, *(uint32_t *)indata.dptr);
 
        case CTDB_CONTROL_UPDATE_SEQNUM:
+               ctdb->status.controls.update_seqnum++;
                CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));              
                return ctdb_ltdb_update_seqnum(ctdb, *(uint32_t *)indata.dptr, srcnode);
 
        case CTDB_CONTROL_SET_SEQNUM_FREQUENCY:
+               ctdb->status.controls.set_seqnum_frequency++;
                CHECK_CONTROL_DATA_SIZE(sizeof(uint32_t));              
                return ctdb_ltdb_set_seqnum_frequency(ctdb, *(uint32_t *)indata.dptr);
 

diff --git a/ctdb/include/ctdb_private.h b/ctdb/include/ctdb_private.h
index a9bef8852e70c45d91626cd2079274791cc39bd2..5bdca6a3ac96c1fb6b24b18c4078f0b78ad9e267 100644 (file)
--- a/ctdb/include/ctdb_private.h
+++ b/ctdb/include/ctdb_private.h
@@ -145,7 +145,7 @@ struct ctdb_status {
                uint32_t req_finished;
                uint32_t req_control;
                uint32_t reply_control;
-       } count;
+       } node;
        struct {
                uint32_t req_call;
                uint32_t req_message;
@@ -154,6 +154,22 @@ struct ctdb_status {
                uint32_t req_shutdown;
                uint32_t req_control;
        } client;
+       struct {
+               uint32_t status;
+               uint32_t get_config;
+               uint32_t ping;
+               uint32_t attach;
+               uint32_t set_call;
+               uint32_t process_exists;
+               uint32_t traverse_start;
+               uint32_t traverse_all;
+               uint32_t traverse_data;
+               uint32_t update_seqnum;
+               uint32_t enable_seqnum;
+               uint32_t set_seqnum_frequency;
+               uint32_t register_srvid;
+               uint32_t deregister_srvid;
+       } controls;
        uint32_t total_calls;
        uint32_t pending_calls;
        uint32_t lockwait_calls;

diff --git a/ctdb/tools/ctdb_control.c b/ctdb/tools/ctdb_control.c
index 5e7c02a86c8f0e28124ff582e625511a3cbff9ab..2e2c8efa3c7efbad27bf0321e77f6a0fdf10e173 100644 (file)
--- a/ctdb/tools/ctdb_control.c
+++ b/ctdb/tools/ctdb_control.c
@@ -88,32 +88,75 @@ static int control_process_exists(struct ctdb_context *ctdb, int argc, const cha
  */
 static void show_status(struct ctdb_status *s)
 {
+       TALLOC_CTX *tmp_ctx = talloc_new(NULL);
+       int i;
+       const char *prefix=NULL;
+       size_t preflen=0;
+       const struct {
+               const char *name;
+               uint32_t offset;
+       } fields[] = {
+#define STATUS_FIELD(n) { #n, offsetof(struct ctdb_status, n) }
+               STATUS_FIELD(client_packets_sent),
+               STATUS_FIELD(client_packets_recv),
+               STATUS_FIELD(node_packets_sent),
+               STATUS_FIELD(node_packets_recv),
+               STATUS_FIELD(node.req_call),
+               STATUS_FIELD(node.reply_call),
+               STATUS_FIELD(node.req_dmaster),
+               STATUS_FIELD(node.reply_dmaster),
+               STATUS_FIELD(node.reply_error),
+               STATUS_FIELD(node.req_message),
+               STATUS_FIELD(node.req_finished),
+               STATUS_FIELD(node.req_control),
+               STATUS_FIELD(node.reply_control),
+               STATUS_FIELD(client.req_call),
+               STATUS_FIELD(client.req_message),
+               STATUS_FIELD(client.req_finished),
+               STATUS_FIELD(client.req_connect_wait),
+               STATUS_FIELD(client.req_shutdown),
+               STATUS_FIELD(client.req_control),
+               STATUS_FIELD(controls.status),
+               STATUS_FIELD(controls.get_config),
+               STATUS_FIELD(controls.ping),
+               STATUS_FIELD(controls.attach),
+               STATUS_FIELD(controls.set_call),
+               STATUS_FIELD(controls.process_exists),
+               STATUS_FIELD(controls.traverse_start),
+               STATUS_FIELD(controls.traverse_all),
+               STATUS_FIELD(controls.traverse_data),
+               STATUS_FIELD(controls.update_seqnum),
+               STATUS_FIELD(controls.enable_seqnum),
+               STATUS_FIELD(controls.set_seqnum_frequency),
+               STATUS_FIELD(controls.register_srvid),
+               STATUS_FIELD(controls.deregister_srvid),
+               STATUS_FIELD(total_calls),
+               STATUS_FIELD(pending_calls),
+               STATUS_FIELD(lockwait_calls),
+               STATUS_FIELD(traverse_calls),
+               STATUS_FIELD(pending_lockwait_calls),
+               STATUS_FIELD(max_hop_count),
+       };
        printf("CTDB version %u\n", CTDB_VERSION);
-       printf(" client_packets_sent     %u\n", s->client_packets_sent);
-       printf(" client_packets_recv     %u\n", s->client_packets_recv);
-       printf("   req_call              %u\n", s->client.req_call);
-       printf("   req_message           %u\n", s->client.req_message);
-       printf("   req_finished          %u\n", s->client.req_finished);
-       printf("   req_connect_wait      %u\n", s->client.req_connect_wait);
-       printf("   req_shutdown          %u\n", s->client.req_shutdown);
-       printf("   req_control           %u\n", s->client.req_control);
-       printf(" node_packets_sent       %u\n", s->node_packets_sent);
-       printf(" node_packets_recv       %u\n", s->node_packets_recv);
-       printf("   req_call              %u\n", s->count.req_call);
-       printf("   reply_call            %u\n", s->count.reply_call);
-       printf("   req_dmaster           %u\n", s->count.req_dmaster);
-       printf("   reply_dmaster         %u\n", s->count.reply_dmaster);
-       printf("   reply_error           %u\n", s->count.reply_error);
-       printf("   req_message           %u\n", s->count.req_message);
-       printf("   req_finished          %u\n", s->count.req_finished);
-       printf(" total_calls             %u\n", s->total_calls);
-       printf(" pending_calls           %u\n", s->pending_calls);
-       printf(" lockwait_calls          %u\n", s->lockwait_calls);
-       printf(" traverse_calls          %u\n", s->traverse_calls);
-       printf(" pending_lockwait_calls  %u\n", s->pending_lockwait_calls);
-       printf(" max_hop_count           %u\n", s->max_hop_count);
-       printf(" max_call_latency        %.6f sec\n", s->max_call_latency);
-       printf(" max_lockwait_latency    %.6f sec\n", s->max_lockwait_latency);
+       for (i=0;i<ARRAY_SIZE(fields);i++) {
+               if (strchr(fields[i].name, '.')) {
+                       preflen = strcspn(fields[i].name, ".")+1;
+                       if (!prefix || strncmp(prefix, fields[i].name, preflen) != 0) {
+                               prefix = fields[i].name;
+                               printf(" %*.*s\n", preflen-1, preflen-1, fields[i].name);
+                       }
+               } else {
+                       preflen = 0;
+               }
+               printf(" %*s%-22s%*s%10u\n", 
+                      preflen?4:0, "",
+                      fields[i].name+preflen, 
+                      preflen?0:4, "",
+                      *(uint32_t *)(fields[i].offset+(uint8_t *)s));
+       }
+       printf(" %-30s     %.6f sec\n", "max_call_latency", s->max_call_latency);
+       printf(" %-30s     %.6f sec\n", "max_lockwait_latency", s->max_lockwait_latency);
+       talloc_free(tmp_ctx);
 }
 
 /*