struct cluster_wait_state {
struct tevent_context *ev;
struct ctdb_client_context *client;
- int num_nodes;
+ uint32_t num_nodes;
bool *ready;
bool join_done;
};
struct tevent_req *cluster_wait_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct ctdb_client_context *client,
- int num_nodes)
+ uint32_t num_nodes)
{
struct tevent_req *req, *subreq;
struct cluster_wait_state *state;
req, struct cluster_wait_state);
struct tevent_req *subreq;
uint32_t pnn;
- int i;
+ uint32_t i;
if (srvid != MSG_ID_JOIN) {
return;
struct tevent_req *cluster_wait_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct ctdb_client_context *client,
- int num_nodes);
+ uint32_t num_nodes);
bool cluster_wait_recv(struct tevent_req *req, int *perr);
struct comm_context *comm;
uint8_t *buf;
size_t *pkt_size;
- int count, id;
+ size_t count, id;
};
static void writer_done(struct tevent_req *subreq);
static struct tevent_req *writer_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int fd, size_t *pkt_size,
- int count)
+ size_t count)
{
struct tevent_req *req, *subreq;
struct writer_state *state;
size_t max_size = 0, buflen;
- int i, ret;
+ size_t i;
+ int ret;
for (i=0; i<count; i++) {
if (pkt_size[i] > max_size) {
static struct tevent_req *test3_writer_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct comm_context *comm,
- size_t *pkt_size, int count)
+ size_t *pkt_size, size_t count)
{
struct tevent_req *req, *subreq;
struct test3_writer_state *state;
size_t max_size = 0, buflen;
- int i;
+ size_t i;
for (i=0; i<count; i++) {
if (pkt_size[i] > max_size) {
*perr = 0;
}
-static void test3_writer(int fd, size_t *pkt_size, int count)
+static void test3_writer(int fd, size_t *pkt_size, size_t count)
{
TALLOC_CTX *mem_ctx;
struct tevent_context *ev;
static TDB_DATA strace_parser(char *buf, TALLOC_CTX *mem_ctx)
{
TDB_DATA data;
- int i = 0, j = 0;
+ size_t i = 0, j = 0;
data.dptr = talloc_size(mem_ctx, strlen(buf));
if (data.dptr == NULL) {
static void dump(void)
{
- int i;
+ size_t i;
for (i=0; i<ARRAY_SIZE(err_codes); i++) {
printf("%s %d\n", err_codes[i].label, err_codes[i].code);
static void match_label(const char *str)
{
int code = -1;
- int i;
+ size_t i;
for (i=0; i<ARRAY_SIZE(err_codes); i++) {
if (strcasecmp(err_codes[i].label, str) == 0) {
static void match_code(int code)
{
const char *label = "UNKNOWN";
- int i;
+ size_t i;
for (i=0; i<ARRAY_SIZE(err_codes); i++) {
if (err_codes[i].code == code) {
static void do_list(TALLOC_CTX *mem_ctx, int argc, const char **argv)
{
struct event_script_list *script_list = NULL;
- int ret, i;
+ unsigned int i;
+ int ret;
if (argc != 3) {
usage(argv[0]);
static bool ctdbd_verify(struct ctdbd_context *ctdb)
{
struct node *node;
- int i;
+ unsigned int i;
if (ctdb->node_map->num_nodes == 0) {
return true;
struct ctdbd_context *ctdb = state->ctdb;
struct tevent_req *subreq;
bool recovery_disabled;
- int i;
+ unsigned int i;
recovery_disabled = false;
for (i=0; i<ctdb->node_map->num_nodes; i++) {
struct ctdb_reply_control reply;
struct ctdb_dbid_map *dbmap;
struct database *db;
- int i;
+ unsigned int i;
reply.rdata.opcode = request->opcode;
struct ctdb_reply_control reply;
struct ctdb_node_map *nodemap;
struct node_map *node_map = ctdb->node_map;
- int i;
+ unsigned int i;
reply.rdata.opcode = request->opcode;
struct ctdb_reply_control reply;
struct ctdb_public_ip_list *ips = NULL;
struct ctdb_public_ip *t = NULL;
- int i;
+ unsigned int i;
reply.rdata.opcode = request->opcode;
struct ctdb_reply_control reply;
struct ctdb_public_ip_list *ips = NULL;
struct ctdb_public_ip *t = NULL;
- int i;
+ unsigned int i;
reply.rdata.opcode = request->opcode;
struct ctdb_reply_control reply;
struct ctdb_node_map *nodemap;
struct node *node;
- int i;
+ unsigned int i;
reply.rdata.opcode = request->opcode;
{
struct ctdb_iface_list *iface_list;
struct interface *iface;
- int i;
+ unsigned int i;
iface_list = talloc_zero(mem_ctx, struct ctdb_iface_list);
if (iface_list == NULL) {
struct ctdbd_context *ctdb = state->ctdb;
struct ctdb_req_header header;
size_t np;
- int ret, i;
+ unsigned int i;
+ int ret;
ret = ctdb_req_header_pull(buf, buflen, &header, &np);
if (ret != 0) {
#define MSG_ID_FETCH 0
-static uint32_t next_node(struct ctdb_client_context *client, int num_nodes)
+static uint32_t next_node(struct ctdb_client_context *client, uint32_t num_nodes)
{
return (ctdb_client_pnn(client) + 1) % num_nodes;
}
struct tevent_context *ev;
struct ctdb_client_context *client;
struct ctdb_db_context *ctdb_db;
- int num_nodes;
+ uint32_t num_nodes;
int timelimit;
int interactive;
TDB_DATA key;
struct tevent_context *ev,
struct ctdb_client_context *client,
struct ctdb_db_context *ctdb_db,
- int num_nodes, int timelimit,
+ uint32_t num_nodes, int timelimit,
int interactive)
{
struct tevent_req *req, *subreq;
size_t len = rand_int(1000) + 1;
char p1[len], p2[len];
size_t buflen, np = 0;
- int i, ret;
+ size_t i;
+ int ret;
for (i=0; i<len-1; i++) {
p1[i] = 'A' + rand_int(26);
void fill_ctdb_vnn_map(TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *p)
{
- int i;
+ unsigned int i;
p->generation = rand32();
p->size = rand_int(20);
void verify_ctdb_vnn_map(struct ctdb_vnn_map *p1, struct ctdb_vnn_map *p2)
{
- int i;
+ unsigned int i;
assert(p1->generation == p2->generation);
assert(p1->size == p2->size);
void fill_ctdb_dbid_map(TALLOC_CTX *mem_ctx, struct ctdb_dbid_map *p)
{
- int i;
+ unsigned int i;
p->num = rand_int(40);
if (p->num > 0) {
void verify_ctdb_dbid_map(struct ctdb_dbid_map *p1, struct ctdb_dbid_map *p2)
{
- int i;
+ unsigned int i;
assert(p1->num == p2->num);
for (i=0; i<p1->num; i++) {
void fill_ctdb_tickle_list(TALLOC_CTX *mem_ctx, struct ctdb_tickle_list *p)
{
- int i;
+ unsigned int i;
fill_ctdb_sock_addr(mem_ctx, &p->addr);
p->num = rand_int(1000);
void verify_ctdb_tickle_list(struct ctdb_tickle_list *p1,
struct ctdb_tickle_list *p2)
{
- int i;
+ unsigned int i;
verify_ctdb_sock_addr(&p1->addr, &p2->addr);
assert(p1->num == p2->num);
void fill_ctdb_public_ip_list(TALLOC_CTX *mem_ctx,
struct ctdb_public_ip_list *p)
{
- int i;
+ unsigned int i;
p->num = rand_int(32);
if (p->num > 0) {
void verify_ctdb_public_ip_list(struct ctdb_public_ip_list *p1,
struct ctdb_public_ip_list *p2)
{
- int i;
+ unsigned int i;
assert(p1->num == p2->num);
for (i=0; i<p1->num; i++) {
void fill_ctdb_node_map(TALLOC_CTX *mem_ctx, struct ctdb_node_map *p)
{
- int i;
+ unsigned int i;
p->num = rand_int(32);
if (p->num > 0) {
void verify_ctdb_node_map(struct ctdb_node_map *p1, struct ctdb_node_map *p2)
{
- int i;
+ unsigned int i;
assert(p1->num == p2->num);
for (i=0; i<p1->num; i++) {
void fill_ctdb_script_list(TALLOC_CTX *mem_ctx, struct ctdb_script_list *p)
{
- int i;
+ unsigned int i;
p->num_scripts = rand_int(32);
if (p->num_scripts > 0) {
void verify_ctdb_script_list(struct ctdb_script_list *p1,
struct ctdb_script_list *p2)
{
- int i;
+ unsigned int i;
assert(p1->num_scripts == p2->num_scripts);
for (i=0; i<p1->num_scripts; i++) {
void fill_ctdb_iface_list(TALLOC_CTX *mem_ctx, struct ctdb_iface_list *p)
{
- int i;
+ unsigned int i;
p->num = rand_int(32);
if (p->num > 0) {
void verify_ctdb_iface_list(struct ctdb_iface_list *p1,
struct ctdb_iface_list *p2)
{
- int i;
+ unsigned int i;
assert(p1->num == p2->num);
for (i=0; i<p1->num; i++) {
void fill_ctdb_db_statistics(TALLOC_CTX *mem_ctx,
struct ctdb_db_statistics *p)
{
- int i;
+ unsigned int i;
p->locks.num_calls = rand32();
p->locks.num_current = rand32();
void verify_ctdb_db_statistics(struct ctdb_db_statistics *p1,
struct ctdb_db_statistics *p2)
{
- int i;
+ unsigned int i;
assert(p1->locks.num_calls == p2->locks.num_calls);
assert(p1->locks.num_current == p2->locks.num_current);
void fill_ctdb_g_lock_list(TALLOC_CTX *mem_ctx, struct ctdb_g_lock_list *p)
{
- int i;
+ unsigned int i;
p->num = rand_int(20) + 1;
p->lock = talloc_zero_array(mem_ctx, struct ctdb_g_lock, p->num);
void verify_ctdb_g_lock_list(struct ctdb_g_lock_list *p1,
struct ctdb_g_lock_list *p2)
{
- int i;
+ unsigned int i;
assert(p1->num == p2->num);
for (i=0; i<p1->num; i++) {
void fill_buffer(void *p, size_t len)
{
- int i;
+ size_t i;
uint8_t *ptr = p;
for (i=0; i<len; i++) {
void fill_string(char *p, size_t len)
{
- int i;
+ size_t i;
for (i=0; i<len-1; i++) {
p[i] = 'A' + rand_int(26);
CTDB_SRVID_DISABLE_RECOVERIES,
CTDB_SRVID_DISABLE_IP_CHECK,
};
- int i;
+ unsigned int i;
if (argc == 2) {
int seed = atoi(argv[1]);
CTDB_SRVID_DISABLE_RECOVERIES,
CTDB_SRVID_DISABLE_IP_CHECK,
};
- int i;
+ size_t i;
if (argc == 2) {
int seed = atoi(argv[1]);
struct ctdb_tickle_list_wire *wire =
(struct ctdb_tickle_list_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
memcpy(&wire->addr, &in->addr, sizeof(ctdb_sock_addr));
wire->num = in->num;
struct ctdb_tickle_list_wire *wire =
(struct ctdb_tickle_list_wire *)buf;
size_t offset;
- int i, ret;
+ unsigned int i;
+ int ret;
if (buflen < offsetof(struct ctdb_tickle_list_wire, conn)) {
return EMSGSIZE;
static size_t ctdb_public_ip_list_len_old(struct ctdb_public_ip_list *in)
{
- int i;
+ unsigned int i;
size_t len;
len = sizeof(uint32_t);
struct ctdb_public_ip_list_wire *wire =
(struct ctdb_public_ip_list_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
wire->num = in->num;
struct ctdb_public_ip_list_wire *wire =
(struct ctdb_public_ip_list_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
bool ret;
if (buflen < sizeof(uint32_t)) {
{
struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
wire->num = in->num;
struct ctdb_node_map *val;
struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
bool ret;
if (buflen < sizeof(uint32_t)) {
static size_t ctdb_script_list_len_old(struct ctdb_script_list *in)
{
- int i;
+ unsigned int i;
size_t len;
if (in == NULL) {
struct ctdb_script_list_wire *wire =
(struct ctdb_script_list_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
if (in == NULL) {
return;
struct ctdb_script_list_wire *wire =
(struct ctdb_script_list_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
bool ret;
/* If event scripts have never been run, the result will be NULL */
struct ctdb_db_statistics_wire *wire =
(struct ctdb_db_statistics_wire *)buf;
size_t offset;
- int i;
+ unsigned int i;
if (buflen < sizeof(struct ctdb_db_statistics)) {
return EMSGSIZE;
uint8_t *buf)
{
size_t offset = 0;
- int i;
+ unsigned int i;
for (i=0; i<in->num; i++) {
ctdb_g_lock_push_old(&in->lock[i], &buf[offset]);
struct ctdb_g_lock_list *val;
unsigned count;
size_t offset;
- int ret, i;
+ unsigned int i;
+ int ret;
val = talloc_zero(mem_ctx, struct ctdb_g_lock_list);
if (val == NULL) {
struct timeval timeout;
struct run_event_script_list *script_list = NULL;
char *arg_str;
- int ret, t, i;
+ unsigned int i;
+ int ret, t;
bool status;
if (argc < 5) {
int argc, const char **argv)
{
struct run_event_script_list *script_list = NULL;
- int ret, i;
+ unsigned int i;
+ int ret;
ret = run_event_list(run_ctx, mem_ctx, &script_list);
if (ret != 0) {
static void dump(void)
{
- int i;
+ size_t i;
for (i=0; i<ARRAY_SIZE(sig_codes); i++) {
printf("%s %d\n", sig_codes[i].label, sig_codes[i].code);
static void match_label(const char *str)
{
int code = -1;
- int i;
+ size_t i;
for (i=0; i<ARRAY_SIZE(sig_codes); i++) {
if (strcasecmp(sig_codes[i].label, str) == 0) {
static void match_code(int code)
{
const char *label = "UNKNOWN";
- int i;
+ size_t i;
for (i=0; i<ARRAY_SIZE(sig_codes); i++) {
if (sig_codes[i].code == code) {