OBJS = @TDBOBJ@ @TALLOCOBJ@ @LIBREPLACEOBJ@ @INFINIBAND_WRAPPER_OBJ@ $(EXTRA_OBJ) $(EVENTS_OBJ) $(CTDB_OBJ)
-BINS = bin/ctdbd bin/ctdbd_test bin/ctdb_test bin/ctdb_bench bin/ctdb_messaging bin/ctdb_fetch bin/ctdb_fetch1 bin/lockwait bin/ctdb_status bin/ctdb_control bin/ctdb_dump @INFINIBAND_BINS@
+BINS = bin/ctdbd bin/ctdbd_test bin/ctdb_test bin/ctdb_bench bin/ctdb_messaging bin/ctdb_fetch bin/ctdb_fetch1 bin/lockwait bin/ctdb_control bin/ctdb_dump @INFINIBAND_BINS@
DIRS = lib bin
@echo Linking $@
@$(CC) $(CFLAGS) -o $@ direct/ctdbd.o $(OBJS) $(LIB_FLAGS)
-bin/ctdb_status: $(OBJS) tools/ctdb_status.o
- @echo Linking $@
- @$(CC) $(CFLAGS) -o $@ tools/ctdb_status.o $(OBJS) $(LIB_FLAGS)
-
bin/ctdb_control: $(OBJS) tools/ctdb_control.o
@echo Linking $@
@$(CC) $(CFLAGS) -o $@ tools/ctdb_control.o $(OBJS) $(LIB_FLAGS)
state->state = CTDB_CALL_DONE;
}
-static void ctdb_reply_status(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
static void ctdb_reply_getdbpath(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
static void ctdb_client_reply_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr);
ctdb_reply_connect_wait(ctdb, hdr);
break;
- case CTDB_REPLY_STATUS:
- ctdb_reply_status(ctdb, hdr);
- break;
-
case CTDB_REPLY_GETDBPATH:
ctdb_reply_getdbpath(ctdb, hdr);
break;
}
}
-enum ctdb_status_states {CTDB_STATUS_WAIT, CTDB_STATUS_DONE};
-
-struct ctdb_status_state {
- uint32_t reqid;
- struct ctdb_status *status;
- enum ctdb_status_states state;
-};
-
-/*
- handle a ctdb_reply_status reply
- */
-static void ctdb_reply_status(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
-{
- struct ctdb_reply_status *r = (struct ctdb_reply_status *)hdr;
- struct ctdb_status_state *state;
-
- state = ctdb_reqid_find(ctdb, hdr->reqid, struct ctdb_status_state);
- if (state == NULL) {
- DEBUG(0,(__location__ " reqid %d not found\n", hdr->reqid));
- return;
- }
-
- if (hdr->reqid != state->reqid) {
- /* we found a record but it was the wrong one */
- DEBUG(0, ("Dropped orphaned reply with reqid:%d\n",hdr->reqid));
- return;
- }
-
- *state->status = r->status;
- state->state = CTDB_STATUS_DONE;
-}
-
-int ctdb_status(struct ctdb_context *ctdb, struct ctdb_status *status)
-{
- struct ctdb_req_status r;
- int ret;
- struct ctdb_status_state *state;
-
- /* if the domain socket is not yet open, open it */
- if (ctdb->daemon.sd==-1) {
- ctdb_socket_connect(ctdb);
- }
-
- state = talloc(ctdb, struct ctdb_status_state);
- CTDB_NO_MEMORY(ctdb, state);
-
- state->reqid = ctdb_reqid_new(ctdb, state);
- state->status = status;
- state->state = CTDB_STATUS_WAIT;
-
- ZERO_STRUCT(r);
- r.hdr.length = sizeof(r);
- r.hdr.ctdb_magic = CTDB_MAGIC;
- r.hdr.ctdb_version = CTDB_VERSION;
- r.hdr.operation = CTDB_REQ_STATUS;
- r.hdr.reqid = state->reqid;
-
- ret = ctdb_client_queue_pkt(ctdb, &(r.hdr));
- if (ret != 0) {
- talloc_free(state);
- return -1;
- }
-
- while (state->state == CTDB_STATUS_WAIT) {
- event_loop_once(ctdb->ev);
- }
-
- talloc_free(state);
-
- return 0;
-}
-
enum ctdb_getdbpath_states {CTDB_GETDBPATH_WAIT, CTDB_GETDBPATH_DONE};
if (outdata) {
*outdata = state->outdata;
- outdata->dptr = talloc_steal(mem_ctx, outdata->dptr);
+ outdata->dptr = talloc_memdup(mem_ctx, outdata->dptr, outdata->dsize);
}
*status = state->status;
CTDB_CONTROL_PROCESS_EXISTS, data,
NULL, NULL, &status);
if (ret != 0) {
- DEBUG(0,(__location__ " ctdb_control failed\n"));
+ DEBUG(0,(__location__ " ctdb_control for process_exists failed\n"));
return -1;
}
return status;
}
+
+/*
+ get remote status
+ */
+int ctdb_status(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_status *status)
+{
+ int ret;
+ TDB_DATA data, outdata;
+ int32_t res;
+
+ ZERO_STRUCT(data);
+ ret = ctdb_control(ctdb, destnode, 0,
+ CTDB_CONTROL_STATUS, data,
+ ctdb, &outdata, &res);
+ if (ret != 0 || res != 0) {
+ DEBUG(0,(__location__ " ctdb_control for status failed\n"));
+ return -1;
+ }
+
+ if (outdata.dsize != sizeof(struct ctdb_status)) {
+ DEBUG(0,(__location__ " Wrong status size %u - expected %u\n",
+ outdata.dsize, sizeof(struct ctdb_status)));
+ return -1;
+ }
+
+ *status = *(struct ctdb_status *)outdata.dptr;
+
+ return 0;
+}
pid = *(pid_t *)indata.dptr;
return kill(pid, 0);
}
+ case CTDB_CONTROL_STATUS: {
+ outdata->dptr = (uint8_t *)&ctdb->status;
+ outdata->dsize = sizeof(ctdb->status);
+ return 0;
+ }
default:
DEBUG(0,(__location__ " Unknown CTDB control opcode %u\n", opcode));
return -1;
r->hdr.srcnode = ctdb->vnn;
r->hdr.reqid = hdr->reqid;
r->status = status;
- c->datalen = outdata.dsize;
+ r->datalen = outdata.dsize;
if (outdata.dsize) {
memcpy(&r->data[0], outdata.dptr, outdata.dsize);
}
data.dptr = &c->data[0];
data.dsize = c->datalen;
+ DEBUG(0,("data.dsize=%u\n", data.dsize));
+
state->callback(ctdb, c->status, data, state->private_data);
talloc_free(state);
}
}
-/*
- called when the daemon gets a status request from a client
- */
-static void daemon_request_status(struct ctdb_client *client,
- struct ctdb_req_status *c)
-{
- struct ctdb_reply_status r;
- int res;
-
- /* now send the reply */
- ZERO_STRUCT(r);
-
- r.hdr.length = sizeof(r);
- r.hdr.ctdb_magic = CTDB_MAGIC;
- r.hdr.ctdb_version = CTDB_VERSION;
- r.hdr.operation = CTDB_REPLY_STATUS;
- r.hdr.reqid = c->hdr.reqid;
- r.status = client->ctdb->status;
-
- res = daemon_queue_send(client, &r.hdr);
- if (res != 0) {
- DEBUG(0,(__location__ " Failed to queue a connect wait response\n"));
- return;
- }
-}
-
/*
called when the daemon gets a getdbpath request from a client
*/
daemon_request_shutdown(client, (struct ctdb_req_shutdown *)hdr);
break;
- case CTDB_REQ_STATUS:
- ctdb->status.client.req_status++;
- daemon_request_status(client, (struct ctdb_req_status *)hdr);
- break;
-
case CTDB_REQ_GETDBPATH:
daemon_request_getdbpath(client, (struct ctdb_req_getdbpath *)hdr);
break;
struct ctdb_reply_control *r;
size_t len;
+ DEBUG(0,("callback: size=%u\n", data.dsize));
+ DEBUG(0,("callback: size=%u\n", data.dsize));
+ DEBUG(0,("callback: size=%u\n", data.dsize));
+ DEBUG(0,("callback: size=%u\n", data.dsize));
+ DEBUG(0,("callback: size=%u\n", data.dsize));
+ DEBUG(0,("callback: size=%u\n", data.dsize));
+
/* construct a message to send to the client containing the data */
len = offsetof(struct ctdb_req_control, data) + data.dsize;
r = ctdbd_allocate_pkt(client, len);
struct ctdb_context *ctdb_cmdline_client(struct event_context *ev);
struct ctdb_status;
-int ctdb_status(struct ctdb_context *ctdb, struct ctdb_status *status);
+int ctdb_status(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_status *status);
int ctdb_getdbpath(struct ctdb_db_context *ctdb_db, TDB_DATA *path);
uint32_t req_register;
uint32_t req_connect_wait;
uint32_t req_shutdown;
- uint32_t req_status;
uint32_t req_control;
} client;
uint32_t total_calls;
uint32_t lacount;
};
-enum {CTDB_CONTROL_PROCESS_EXISTS};
+enum {CTDB_CONTROL_PROCESS_EXISTS, CTDB_CONTROL_STATUS};
enum call_state {CTDB_CALL_WAIT, CTDB_CALL_DONE, CTDB_CALL_ERROR};
CTDB_REQ_CONNECT_WAIT = 1001,
CTDB_REPLY_CONNECT_WAIT = 1002,
CTDB_REQ_SHUTDOWN = 1003,
- CTDB_REQ_STATUS = 1004,
- CTDB_REPLY_STATUS = 1005,
- CTDB_REQ_GETDBPATH = 1006,
- CTDB_REPLY_GETDBPATH = 1007
+ CTDB_REQ_GETDBPATH = 1004,
+ CTDB_REPLY_GETDBPATH = 1005
};
#define CTDB_MAGIC 0x43544442 /* CTDB */
uint8_t data[1];
};
-struct ctdb_req_status {
- struct ctdb_req_header hdr;
-};
-
-struct ctdb_reply_status {
- struct ctdb_req_header hdr;
- struct ctdb_status status;
-};
-
struct ctdb_req_control {
struct ctdb_req_header hdr;
uint32_t opcode;
static void usage(void)
{
printf("Usage: ctdb_control [options] <control>\n");
+ printf("\nControls:\n");
+ printf(" process-exists <vnn:pid>\n");
+ printf(" status <vnn>\n");
exit(1);
}
static int control_process_exists(struct ctdb_context *ctdb, int argc, const char **argv)
{
- uint32_t srvid;
- pid_t pid;
+ uint32_t vnn, pid;
int ret;
- if (argc < 2) {
+ if (argc < 1) {
usage();
}
- srvid = strtoul(argv[0], NULL, 0);
- pid = strtoul(argv[1], NULL, 0);
+ if (sscanf(argv[0], "%u:%u", &vnn, &pid) != 2) {
+ printf("Badly formed vnn:pid\n");
+ return -1;
+ }
- ret = ctdb_process_exists(ctdb, srvid, pid);
+ ret = ctdb_process_exists(ctdb, vnn, pid);
if (ret == 0) {
- printf("%u:%u exists\n", srvid, pid);
+ printf("%u:%u exists\n", vnn, pid);
} else {
- printf("%u:%u does not exist\n", srvid, pid);
+ printf("%u:%u does not exist\n", vnn, pid);
}
return ret;
}
+/*
+ display status structure
+ */
+static void show_status(struct ctdb_status *s)
+{
+ 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_register %u\n", s->client.req_register);
+ 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(" reply_redirect %u\n", s->count.reply_redirect);
+ 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(" reply_redirect %u\n", s->count.reply_redirect);
+ 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(" pending_lockwait_calls %u\n", s->pending_lockwait_calls);
+ printf(" max_redirect_count %u\n", s->max_redirect_count);
+ printf(" max_call_latency %.6f sec\n", s->max_call_latency);
+ printf(" max_lockwait_latency %.6f sec\n", s->max_lockwait_latency);
+}
+
+static int control_status(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ uint32_t vnn;
+ int ret;
+ struct ctdb_status status;
+ if (argc < 1) {
+ usage();
+ }
+
+ vnn = strtoul(argv[0], NULL, 0);
+
+ ret = ctdb_status(ctdb, vnn, &status);
+ if (ret != 0) {
+ printf("Unable to get status from node %u\n", vnn);
+ return ret;
+ }
+ show_status(&status);
+ return 0;
+}
+
/*
main program
*/
if (strcmp(control, "process-exists") == 0) {
ret = control_process_exists(ctdb, extra_argc-1, extra_argv+1);
+ } else if (strcmp(control, "status") == 0) {
+ ret = control_status(ctdb, extra_argc-1, extra_argv+1);
} else {
printf("Unknown control '%s'\n", control);
exit(1);
+++ /dev/null
-/*
- ctdb status tool
-
- Copyright (C) Andrew Tridgell 2007
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "includes.h"
-#include "lib/events/events.h"
-#include "system/filesys.h"
-#include "popt.h"
-#include "cmdline.h"
-#include "../include/ctdb_private.h"
-
-
-/*
- display status structure
- */
-static void show_status(struct ctdb_status *s)
-{
- 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_register %u\n", s->client.req_register);
- printf(" req_connect_wait %u\n", s->client.req_connect_wait);
- printf(" req_shutdown %u\n", s->client.req_shutdown);
- printf(" req_status %u\n", s->client.req_status);
- 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(" reply_redirect %u\n", s->count.reply_redirect);
- 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(" reply_redirect %u\n", s->count.reply_redirect);
- 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(" pending_lockwait_calls %u\n", s->pending_lockwait_calls);
- printf(" max_redirect_count %u\n", s->max_redirect_count);
- printf(" max_call_latency %.6f sec\n", s->max_call_latency);
- printf(" max_lockwait_latency %.6f sec\n", s->max_lockwait_latency);
-}
-
-/*
- show usage message
- */
-static void usage(void)
-{
- printf("Usage: ctdb_status <socketpath>\n");
- exit(1);
-}
-
-/*
- main program
-*/
-int main(int argc, const char *argv[])
-{
- struct ctdb_context *ctdb;
- struct poptOption popt_options[] = {
- POPT_AUTOHELP
- POPT_CTDB_CMDLINE
- POPT_TABLEEND
- };
- int opt;
- const char **extra_argv;
- int extra_argc = 0;
- int ret;
- poptContext pc;
- struct event_context *ev;
- const char *ctdb_socket;
- struct ctdb_status status;
-
- pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
-
- while ((opt = poptGetNextOpt(pc)) != -1) {
- switch (opt) {
- default:
- fprintf(stderr, "Invalid option %s: %s\n",
- poptBadOption(pc, 0), poptStrerror(opt));
- exit(1);
- }
- }
-
- /* setup the remaining options for the main program to use */
- extra_argv = poptGetArgs(pc);
- if (extra_argv) {
- extra_argv++;
- while (extra_argv[extra_argc]) extra_argc++;
- }
-
- if (extra_argc < 1) {
- usage();
- }
-
- ctdb_socket = extra_argv[0];
-
- ev = event_context_init(NULL);
-
- /* initialise ctdb */
- ctdb = ctdb_cmdline_client(ev);
- if (ctdb == NULL) {
- printf("Failed to init ctdb\n");
- exit(1);
- }
-
- ret = ctdb_status(ctdb, &status);
- if (ret != 0) {
- printf("Failed to get ctdb status\n");
- exit(1);
- }
-
- show_status(&status);
-
- return 0;
-}
projects / thirdparty / samba.git / commitdiff
