sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-20 22:50:26 +03:00
Code

merge from ronnie

Browse Source 
(This used to be ctdb commit c2ad6820f4526c230178e7d1b66b82103bfed904)
This commit is contained in:
Andrew Tridgell 2007-04-27 14:45:45 +02:00
commit 5b8bb39b8a
5 changed files with 172 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
ctdb/common/ctdb_client.c
View File

@ -781,6 +781,70 @@ int ctdb_status(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_status
return 0;
}
/*
get vnn map from a remote node
*/
int ctdb_getvnnmap(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_vnn_map *vnnmap)
{
int ret;
TDB_DATA data, outdata;
int32_t i, res;
ZERO_STRUCT(data);
ret = ctdb_control(ctdb, destnode, 0,
CTDB_CONTROL_GETVNNMAP, data,
ctdb, &outdata, &res);
if (ret != 0 || res != 0) {
DEBUG(0,(__location__ " ctdb_control for getvnnmap failed\n"));
return -1;
}
vnnmap->generation = ((uint32_t *)outdata.dptr)[0];
vnnmap->size = ((uint32_t *)outdata.dptr)[1];
if (vnnmap->map) {
talloc_free(vnnmap->map);
vnnmap->map = NULL;
}
vnnmap->map = talloc_array(vnnmap, uint32_t, vnnmap->size);
for (i=0;i<vnnmap->size;i++) {
vnnmap->map[i] = ((uint32_t *)outdata.dptr)[i+2];
}
return 0;
}
/*
set vnn map on a node
*/
int ctdb_setvnnmap(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_vnn_map *vnnmap)
{
int ret;
TDB_DATA *data, outdata;
int32_t i, res;
data = talloc_zero(ctdb, TDB_DATA);
data->dsize = (vnnmap->size+2)*sizeof(uint32_t);
data->dptr = (unsigned char *)talloc_array(data, uint32_t, vnnmap->size+2);
((uint32_t *)&data->dptr[0])[0] = vnnmap->generation;
((uint32_t *)&data->dptr[0])[1] = vnnmap->size;
for (i=0;i<vnnmap->size;i++) {
((uint32_t *)&data->dptr[0])[i+2] = vnnmap->map[i];
}
ret = ctdb_control(ctdb, destnode, 0,
CTDB_CONTROL_SETVNNMAP, *data,
ctdb, &outdata, &res);
if (ret != 0 || res != 0) {
DEBUG(0,(__location__ " ctdb_control for setvnnmap failed\n"));
return -1;
}
talloc_free(data);
return 0;
}
/*
ping a node
*/

51
ctdb/common/ctdb_control.c
View File

@ -57,6 +57,43 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
return 0;
}
case CTDB_CONTROL_GETVNNMAP: {
uint32_t i, len;
len = 2+ctdb->vnn_map->size;
outdata->dsize = 4*len;
outdata->dptr = (unsigned char *)talloc_array(outdata, uint32_t, len);
((uint32_t *)outdata->dptr)[0] = ctdb->vnn_map->generation;
((uint32_t *)outdata->dptr)[1] = ctdb->vnn_map->size;
for (i=0;i<ctdb->vnn_map->size;i++) {
((uint32_t *)outdata->dptr)[i+2] = ctdb->vnn_map->map[i];
}
return 0;
}
case CTDB_CONTROL_SETVNNMAP: {
uint32_t *ptr, i;
ptr = (uint32_t *)(&indata.dptr[0]);
ctdb->vnn_map->generation = ptr[0];
ctdb->vnn_map->size = ptr[1];
if (ctdb->vnn_map->map) {
talloc_free(ctdb->vnn_map->map);
ctdb->vnn_map->map = NULL;
}
ctdb->vnn_map->map = talloc_array(ctdb->vnn_map, uint32_t, ctdb->vnn_map->size);
if (ctdb->vnn_map->map == NULL) {
DEBUG(0,(__location__ " Unable to allocate vnn_map->map structure\n"));
exit(1);
}
for (i=0;i<ctdb->vnn_map->size;i++) {
ctdb->vnn_map->map[i] = ptr[i+2];
}
return 0;
}
case CTDB_CONTROL_CONFIG: {
outdata->dptr = (uint8_t *)ctdb;
outdata->dsize = sizeof(*ctdb);
@ -94,7 +131,7 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
void ctdb_request_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
{
struct ctdb_req_control *c = (struct ctdb_req_control *)hdr;
TDB_DATA data, outdata;
TDB_DATA data, *outdata;
struct ctdb_reply_control *r;
int32_t status;
size_t len;
@ -102,10 +139,10 @@ void ctdb_request_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr
data.dptr = &c->data[0];
data.dsize = c->datalen;
ZERO_STRUCT(outdata);
status = ctdb_control_dispatch(ctdb, c->opcode, data, &outdata);
outdata = talloc_zero(c, TDB_DATA);
status = ctdb_control_dispatch(ctdb, c->opcode, data, outdata);
len = offsetof(struct ctdb_reply_control, data) + outdata.dsize;
len = offsetof(struct ctdb_reply_control, data) + outdata->dsize;
r = ctdb->methods->allocate_pkt(ctdb, len);
CTDB_NO_MEMORY_VOID(ctdb, r);
talloc_set_name_const(r, "ctdb_reply_control packet");
@ -118,9 +155,9 @@ void ctdb_request_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr
r->hdr.srcnode = ctdb->vnn;
r->hdr.reqid = hdr->reqid;
r->status = status;
r->datalen = outdata.dsize;
if (outdata.dsize) {
memcpy(&r->data[0], outdata.dptr, outdata.dsize);
r->datalen = outdata->dsize;
if (outdata->dsize) {
memcpy(&r->data[0], outdata->dptr, outdata->dsize);
}
ctdb_queue_packet(ctdb, &r->hdr);

4
ctdb/include/ctdb.h
View File

@ -215,6 +215,10 @@ struct ctdb_context *ctdb_cmdline_client(struct event_context *ev);
struct ctdb_status;
int ctdb_status(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_status *status);
struct ctdb_vnn_map;
int ctdb_getvnnmap(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_vnn_map *vnnmap);
int ctdb_setvnnmap(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_vnn_map *vnnmap);
int ctdb_getdbpath(struct ctdb_db_context *ctdb_db, TALLOC_CTX *mem_ctx, const char **path);
int ctdb_process_exists(struct ctdb_context *ctdb, uint32_t destnode, pid_t pid);

4
ctdb/include/ctdb_private.h
View File

@ -243,7 +243,9 @@ enum ctdb_controls {CTDB_CONTROL_PROCESS_EXISTS,
CTDB_CONTROL_STATUS,
CTDB_CONTROL_CONFIG,
CTDB_CONTROL_PING,
CTDB_CONTROL_GETDBPATH};
CTDB_CONTROL_GETDBPATH,
CTDB_CONTROL_GETVNNMAP,
CTDB_CONTROL_SETVNNMAP};
enum call_state {CTDB_CALL_WAIT, CTDB_CALL_DONE, CTDB_CALL_ERROR};

57
ctdb/tools/ctdb_control.c
View File

@ -36,6 +36,8 @@ static void usage(void)
printf(" ping\n");
printf(" process-exists <vnn:pid>\n");
printf(" status <vnn>\n");
printf(" getvnnmap <vnn>\n");
printf(" setvnnmap <vnn> <generation> <numslots> <lmaster>*\n");
exit(1);
}
@ -116,6 +118,57 @@ static int control_status(struct ctdb_context *ctdb, int argc, const char **argv
return 0;
}
static int control_getvnnmap(struct ctdb_context *ctdb, int argc, const char **argv)
{
uint32_t vnn;
int i, ret;
struct ctdb_vnn_map *vnnmap;
if (argc < 1) {
usage();
}
vnn = strtoul(argv[0], NULL, 0);
vnnmap = talloc_zero(ctdb, struct ctdb_vnn_map);
ret = ctdb_getvnnmap(ctdb, vnn, vnnmap);
if (ret != 0) {
printf("Unable to get vnnmap from node %u\n", vnn);
return ret;
}
printf("Generation:%d\n",vnnmap->generation);
printf("Size:%d\n",vnnmap->size);
for(i=0;i<vnnmap->size;i++){
printf("hash:%d lmaster:%d\n",i,vnnmap->map[i]);
}
return 0;
}
static int control_setvnnmap(struct ctdb_context *ctdb, int argc, const char **argv)
{
uint32_t vnn;
struct ctdb_vnn_map *vnnmap;
int i, ret;
if (argc < 3) {
usage();
}
vnn = strtoul(argv[0], NULL, 0);
vnnmap = talloc_zero(ctdb, struct ctdb_vnn_map);
vnnmap->generation = strtoul(argv[1], NULL, 0);
vnnmap->size = strtoul(argv[2], NULL, 0);
vnnmap->map = talloc_array(vnnmap, uint32_t, vnnmap->size);
for (i=0;i<vnnmap->size;i++) {
vnnmap->map[i] = strtoul(argv[3+i], NULL, 0);
}
ret = ctdb_setvnnmap(ctdb, vnn, vnnmap);
if (ret != 0) {
printf("Unable to set vnnmap for node %u\n", vnn);
return ret;
}
return 0;
}
static int control_ping(struct ctdb_context *ctdb, int argc, const char **argv)
{
@ -190,6 +243,10 @@ int main(int argc, const char *argv[])
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 if (strcmp(control, "getvnnmap") == 0) {
ret = control_getvnnmap(ctdb, extra_argc-1, extra_argv+1);
} else if (strcmp(control, "setvnnmap") == 0) {
ret = control_setvnnmap(ctdb, extra_argc-1, extra_argv+1);
} else if (strcmp(control, "ping") == 0) {
ret = control_ping(ctdb, extra_argc-1, extra_argv+1);
} else {