goto done;
}
if (cnt != hdr->length) {
- ctdb_set_error(ctdb, "Bad header length %d expected %d in client\n",
- hdr->length, cnt);
+ ctdb_set_error(ctdb, "Bad header length %u expected %u in client\n",
+ (unsigned)hdr->length, (unsigned)cnt);
goto done;
}
}
len = offsetof(struct ctdb_req_call, data) + call->key.dsize + call->call_data.dsize;
- c = ctdbd_allocate_pkt(state, len);
+ c = ctdbd_allocate_pkt(ctdb, state, CTDB_REQ_CALL, len, struct ctdb_req_call);
if (c == NULL) {
DEBUG(0, (__location__ " failed to allocate packet\n"));
return NULL;
}
- talloc_set_name_const(c, "ctdb client req_call packet");
- memset(c, 0, offsetof(struct ctdb_req_call, data));
- c->hdr.length = len;
- c->hdr.ctdb_magic = CTDB_MAGIC;
- c->hdr.ctdb_version = CTDB_VERSION;
- c->hdr.operation = CTDB_REQ_CALL;
/* this limits us to 16k outstanding messages - not unreasonable */
c->hdr.reqid = ctdb_reqid_new(ctdb, state);
c->flags = call->flags;
tell the daemon what messaging srvid we will use, and register the message
handler function in the client
*/
-int ctdb_set_message_handler(struct ctdb_context *ctdb, uint32_t srvid,
+int ctdb_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid,
ctdb_message_fn_t handler,
void *private_data)
{
- struct ctdb_req_register c;
+ struct ctdb_req_register *c;
int res;
/* if the domain socket is not yet open, open it */
ctdb_socket_connect(ctdb);
}
- ZERO_STRUCT(c);
-
- c.hdr.length = sizeof(c);
- c.hdr.ctdb_magic = CTDB_MAGIC;
- c.hdr.ctdb_version = CTDB_VERSION;
- c.hdr.operation = CTDB_REQ_REGISTER;
- c.srvid = srvid;
+ c = ctdbd_allocate_pkt(ctdb, ctdb, CTDB_REQ_REGISTER, sizeof(*c),
+ struct ctdb_req_register);
+ CTDB_NO_MEMORY(ctdb, c);
+ c->srvid = srvid;
- res = ctdb_client_queue_pkt(ctdb, &c.hdr);
+ res = ctdb_client_queue_pkt(ctdb, &c->hdr);
+ talloc_free(c);
if (res != 0) {
return res;
}
send a message - from client context
*/
int ctdb_send_message(struct ctdb_context *ctdb, uint32_t vnn,
- uint32_t srvid, TDB_DATA data)
+ uint64_t srvid, TDB_DATA data)
{
struct ctdb_req_message *r;
int len, res;
len = offsetof(struct ctdb_req_message, data) + data.dsize;
- r = ctdbd_allocate_pkt(ctdb, len);
+ r = ctdbd_allocate_pkt(ctdb, ctdb, CTDB_REQ_MESSAGE,
+ len, struct ctdb_req_message);
CTDB_NO_MEMORY(ctdb, r);
- talloc_set_name_const(r, "req_message packet");
- r->hdr.length = len;
- r->hdr.ctdb_magic = CTDB_MAGIC;
- r->hdr.ctdb_version = CTDB_VERSION;
- r->hdr.operation = CTDB_REQ_MESSAGE;
r->hdr.destnode = vnn;
r->hdr.srcnode = ctdb->vnn;
- r->hdr.reqid = 0;
r->srvid = srvid;
r->datalen = data.dsize;
memcpy(&r->data[0], data.dptr, data.dsize);
*/
void ctdb_connect_wait(struct ctdb_context *ctdb)
{
- struct ctdb_req_connect_wait r;
+ struct ctdb_req_connect_wait *r;
int res;
- 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_CONNECT_WAIT;
+ r = ctdbd_allocate_pkt(ctdb, ctdb, CTDB_REQ_CONNECT_WAIT, sizeof(*r),
+ struct ctdb_req_connect_wait);
+ CTDB_NO_MEMORY_VOID(ctdb, r);
DEBUG(3,("ctdb_connect_wait: sending to ctdbd\n"));
ctdb_socket_connect(ctdb);
}
- res = ctdb_queue_send(ctdb->daemon.queue, (uint8_t *)&r.hdr, r.hdr.length);
+ res = ctdb_queue_send(ctdb->daemon.queue, (uint8_t *)&r->hdr, r->hdr.length);
+ talloc_free(r);
if (res != 0) {
DEBUG(0,(__location__ " Failed to queue a connect wait request\n"));
return;
*/
void ctdb_shutdown(struct ctdb_context *ctdb)
{
- struct ctdb_req_shutdown r;
- int len;
+ struct ctdb_req_shutdown *r;
/* if the domain socket is not yet open, open it */
if (ctdb->daemon.sd==-1) {
ctdb_socket_connect(ctdb);
}
- len = sizeof(struct ctdb_req_shutdown);
- ZERO_STRUCT(r);
- r.hdr.length = len;
- r.hdr.ctdb_magic = CTDB_MAGIC;
- r.hdr.ctdb_version = CTDB_VERSION;
- r.hdr.operation = CTDB_REQ_SHUTDOWN;
- r.hdr.reqid = 0;
+ r = ctdbd_allocate_pkt(ctdb, ctdb, CTDB_REQ_SHUTDOWN, sizeof(*r),
+ struct ctdb_req_shutdown);
+ CTDB_NO_MEMORY_VOID(ctdb, r);
+
+ ctdb_client_queue_pkt(ctdb, &(r->hdr));
- ctdb_client_queue_pkt(ctdb, &(r.hdr));
+ talloc_free(r);
/* this event loop will terminate once we receive the reply */
while (1) {
/*
send a ctdb control message
*/
-int ctdb_control(struct ctdb_context *ctdb, uint32_t destnode, uint32_t srvid,
+int ctdb_control(struct ctdb_context *ctdb, uint32_t destnode, uint64_t srvid,
uint32_t opcode, TDB_DATA data,
TALLOC_CTX *mem_ctx, TDB_DATA *outdata, int32_t *status)
{
state->state = CTDB_CALL_WAIT;
len = offsetof(struct ctdb_req_control, data) + data.dsize;
- c = ctdbd_allocate_pkt(state, len);
+ c = ctdbd_allocate_pkt(ctdb, state, CTDB_REQ_CONTROL,
+ len, struct ctdb_req_control);
+ CTDB_NO_MEMORY(ctdb, c);
- memset(c, 0, len);
- c->hdr.length = len;
- c->hdr.ctdb_magic = CTDB_MAGIC;
- c->hdr.ctdb_version = CTDB_VERSION;
- c->hdr.operation = CTDB_REQ_CONTROL;
c->hdr.reqid = state->reqid;
c->hdr.destnode = destnode;
c->hdr.srcnode = ctdb->vnn;
int ctdb_status(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_status *status)
{
int ret;
- TDB_DATA data, outdata;
+ TDB_DATA data;
int32_t res;
ZERO_STRUCT(data);
ret = ctdb_control(ctdb, destnode, 0,
CTDB_CONTROL_STATUS, data,
- ctdb, &outdata, &res);
+ ctdb, &data, &res);
if (ret != 0 || res != 0) {
DEBUG(0,(__location__ " ctdb_control for status failed\n"));
return -1;
}
- if (outdata.dsize != sizeof(struct ctdb_status)) {
+ if (data.dsize != sizeof(struct ctdb_status)) {
DEBUG(0,(__location__ " Wrong status size %u - expected %u\n",
- outdata.dsize, sizeof(struct ctdb_status)));
+ data.dsize, sizeof(struct ctdb_status)));
return -1;
}
- *status = *(struct ctdb_status *)outdata.dptr;
+ *status = *(struct ctdb_status *)data.dptr;
+ talloc_free(data.dptr);
return 0;
}
}
c = *(struct ctdb_context *)data.dptr;
+ talloc_free(data.dptr);
ctdb->num_nodes = c.num_nodes;
ctdb->num_connected = c.num_connected;
talloc_free(data.dptr);
return 0;
-
+}
+
+/*
+ get debug level on a node
+ */
+int ctdb_get_debuglevel(struct ctdb_context *ctdb, uint32_t destnode, uint32_t *level)
+{
+ int ret;
+ int32_t res;
+ TDB_DATA data;
+
+ ZERO_STRUCT(data);
+ ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_GET_DEBUG, data,
+ ctdb, &data, &res);
+ if (ret != 0 || res != 0) {
+ return -1;
+ }
+ if (data.dsize != sizeof(uint32_t)) {
+ DEBUG(0,("Bad control reply size in ctdb_get_debuglevel (got %u)\n",
+ data.dsize));
+ return -1;
+ }
+ *level = *(uint32_t *)data.dptr;
+ talloc_free(data.dptr);
+ return 0;
+}
+
+/*
+ set debug level on a node
+ */
+int ctdb_set_debuglevel(struct ctdb_context *ctdb, uint32_t destnode, uint32_t level)
+{
+ int ret;
+ int32_t res;
+ TDB_DATA data;
+
+ data.dptr = (uint8_t *)&level;
+ data.dsize = sizeof(level);
+
+ ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_SET_DEBUG, data,
+ NULL, NULL, &res);
+ if (ret != 0 || res != 0) {
+ return -1;
+ }
+ return 0;
}
git.samba.org / metze / ctdb / wip.git / blobdiff