sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-28 01:58:17 +03:00
Code

ctdb-daemon: Rename struct ctdb_all_public_ips to ctdb_public_ip_list_old

Browse Source 
Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>
This commit is contained in:
Amitay Isaacs 2015-10-28 17:16:24 +11:00 committed by Martin Schwenke
parent 2b76e58032
commit 04eaa077aa
8 changed files with 37 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ctdb/client/ctdb_client.c
View File

@ -2774,7 +2774,7 @@ int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
TALLOC_CTX *mem_ctx,
uint32_t flags,
struct ctdb_all_public_ips **ips)
struct ctdb_public_ip_list_old **ips)
{
int ret;
TDB_DATA outdata;
@ -2790,7 +2790,7 @@ int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
return -1;
}
*ips = (struct ctdb_all_public_ips *)talloc_memdup(mem_ctx, outdata.dptr, outdata.dsize);
*ips = (struct ctdb_public_ip_list_old *)talloc_memdup(mem_ctx, outdata.dptr, outdata.dsize);
talloc_free(outdata.dptr);
return 0;
@ -2799,7 +2799,7 @@ int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
int ctdb_ctrl_get_public_ips(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
TALLOC_CTX *mem_ctx,
struct ctdb_all_public_ips **ips)
struct ctdb_public_ip_list_old **ips)
{
return ctdb_ctrl_get_public_ips_flags(ctdb, timeout,
destnode, mem_ctx,

4
ctdb/include/ctdb_client.h
View File

@ -370,11 +370,11 @@ int ctdb_ctrl_list_tunables(struct ctdb_context *ctdb,
int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
TALLOC_CTX *mem_ctx, uint32_t flags,
struct ctdb_all_public_ips **ips);
struct ctdb_public_ip_list_old **ips);
int ctdb_ctrl_get_public_ips(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
TALLOC_CTX *mem_ctx,
struct ctdb_all_public_ips **ips);
struct ctdb_public_ip_list_old **ips);
int ctdb_ctrl_get_public_ip_info(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
TALLOC_CTX *mem_ctx,

6
ctdb/include/ctdb_private.h
View File

@ -130,8 +130,8 @@ struct ctdb_node {
across the nodes. it needs to know which public ip's can be handled
by each node.
*/
struct ctdb_all_public_ips *known_public_ips;
struct ctdb_all_public_ips *available_public_ips;
struct ctdb_public_ip_list_old *known_public_ips;
struct ctdb_public_ip_list_old *available_public_ips;
/* used by the recovery dameon to track when a node should be banned */
struct ctdb_banning_state *ban_state;
};
@ -1008,7 +1008,7 @@ int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
TDB_DATA recdata, bool *async_reply);
int verify_remote_ip_allocation(struct ctdb_context *ctdb,
struct ctdb_all_public_ips *ips,
struct ctdb_public_ip_list_old *ips,
uint32_t pnn);
int update_ip_assignment_tree(struct ctdb_context *ctdb,
struct ctdb_public_ip *ip);

2
ctdb/include/ctdb_protocol.h
View File

@ -596,7 +596,7 @@ struct ctdb_public_ip {
ctdb_sock_addr addr;
};
struct ctdb_all_public_ips {
struct ctdb_public_ip_list_old {
uint32_t num;
struct ctdb_public_ip ips[1];
};

2
ctdb/server/ctdb_recoverd.c
View File

@ -3379,7 +3379,7 @@ static int verify_local_ip_allocation(struct ctdb_context *ctdb, struct ctdb_rec
we also request a ip reallocation.
*/
if (ctdb->tunable.disable_ip_failover == 0) {
struct ctdb_all_public_ips *ips = NULL;
struct ctdb_public_ip_list_old *ips = NULL;
/* read the *available* IPs from the local node */
ret = ctdb_ctrl_get_public_ips_flags(ctdb, CONTROL_TIMEOUT(), CTDB_CURRENT_NODE, mem_ctx, CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE, &ips);

14
ctdb/server/ctdb_takeover.c
View File

@ -1258,7 +1258,7 @@ static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
struct ctdb_ipflags ipflags,
struct public_ip_list *ip)
{
struct ctdb_all_public_ips *public_ips;
struct ctdb_public_ip_list_old *public_ips;
int i;
if (ipflags.noiphost) {
@ -1393,7 +1393,7 @@ create_merged_ip_list(struct ctdb_context *ctdb)
{
int i, j;
struct public_ip_list *ip_list;
struct ctdb_all_public_ips *public_ips;
struct ctdb_public_ip_list_old *public_ips;
if (ctdb->ip_tree != NULL) {
talloc_free(ctdb->ip_tree);
@ -3199,7 +3199,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
struct ctdb_req_control_old *c, TDB_DATA *outdata)
{
int i, num, len;
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
struct ctdb_vnn *vnn;
bool only_available = false;
@ -3213,7 +3213,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
num++;
}
len = offsetof(struct ctdb_all_public_ips, ips) +
len = offsetof(struct ctdb_public_ip_list_old, ips) +
num*sizeof(struct ctdb_public_ip);
ips = talloc_zero_size(outdata, len);
CTDB_NO_MEMORY(ctdb, ips);
@ -3228,7 +3228,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
i++;
}
ips->num = i;
len = offsetof(struct ctdb_all_public_ips, ips) +
len = offsetof(struct ctdb_public_ip_list_old, ips) +
i*sizeof(struct ctdb_public_ip);
outdata->dsize = len;
@ -4225,7 +4225,7 @@ int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
This is verified against ctdb->ip_tree
*/
int verify_remote_ip_allocation(struct ctdb_context *ctdb,
struct ctdb_all_public_ips *ips,
struct ctdb_public_ip_list_old *ips,
uint32_t pnn)
{
struct public_ip_list *tmp_ip;
@ -4349,7 +4349,7 @@ static void ctdb_reloadips_child_handler(struct tevent_context *ev,
static int ctdb_reloadips_child(struct ctdb_context *ctdb)
{
TALLOC_CTX *mem_ctx = talloc_new(NULL);
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
struct ctdb_vnn *vnn;
struct client_async_data *async_data;
struct timeval timeout;

19
ctdb/tests/src/ctdb_takeover_tests.c
View File

@ -103,20 +103,21 @@ static bool
read_ctdb_public_ip_info(TALLOC_CTX *ctx,
int numnodes,
struct public_ip_list ** all_ips,
struct ctdb_all_public_ips *** avail)
struct ctdb_public_ip_list_old *** avail)
{
char line[1024];
ctdb_sock_addr addr;
char *t, *tok;
struct public_ip_list * ta;
int pnn, numips, curr, n, i;
struct ctdb_all_public_ips * a;
struct ctdb_public_ip_list_old * a;
struct public_ip_list *last = NULL;
*avail = talloc_array_size(ctx, sizeof(struct ctdb_all_public_ips *), CTDB_TEST_MAX_NODES);
*avail = talloc_array_size(ctx, sizeof(struct ctdb_public_ip_list_old *),
CTDB_TEST_MAX_NODES);
memset(*avail, 0,
sizeof(struct ctdb_all_public_ips *) * CTDB_TEST_MAX_NODES);
sizeof(struct ctdb_public_ip_list_old *) * CTDB_TEST_MAX_NODES);
numips = 0;
*all_ips = NULL;
@ -181,7 +182,7 @@ read_ctdb_public_ip_info(TALLOC_CTX *ctx,
while (t != NULL) {
n = (int) strtol(t, (char **) NULL, 10);
if ((*avail)[n] == NULL) {
(*avail)[n] = talloc_array(ctx, struct ctdb_all_public_ips, CTDB_TEST_MAX_IPS);
(*avail)[n] = talloc_array(ctx, struct ctdb_public_ip_list_old, CTDB_TEST_MAX_IPS);
(*avail)[n]->num = 0;
}
curr = (*avail)[n]->num;
@ -195,7 +196,7 @@ read_ctdb_public_ip_info(TALLOC_CTX *ctx,
}
/* Build list of all allowed IPs */
a = talloc_array(ctx, struct ctdb_all_public_ips, CTDB_TEST_MAX_IPS);
a = talloc_array(ctx, struct ctdb_public_ip_list_old, CTDB_TEST_MAX_IPS);
a->num = numips;
for (ta = *all_ips, i=0; ta != NULL && i < numips ; ta = ta->next, i++) {
a->ips[i].pnn = ta->pnn;
@ -213,7 +214,7 @@ read_ctdb_public_ip_info(TALLOC_CTX *ctx,
}
static void print_ctdb_available_ips(int numnodes,
struct ctdb_all_public_ips **avail)
struct ctdb_public_ip_list_old **avail)
{
int n, i;
@ -234,7 +235,7 @@ static void ctdb_test_read_ctdb_public_ip_info(const char nodestates[])
{
int numnodes;
struct public_ip_list *l;
struct ctdb_all_public_ips **avail;
struct ctdb_public_ip_list_old **avail;
char *tok, *ns;
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
@ -412,7 +413,7 @@ static void ctdb_test_init(const char nodestates[],
struct ctdb_ipflags **ipflags,
bool read_ips_for_multiple_nodes)
{
struct ctdb_all_public_ips **avail;
struct ctdb_public_ip_list_old **avail;
int i, numnodes;
uint32_t nodeflags[CTDB_TEST_MAX_NODES];
char *tok, *ns, *t;

20
ctdb/tools/ctdb.c
View File

@ -1748,7 +1748,7 @@ static int control_get_tickles(struct ctdb_context *ctdb, int argc, const char *
static int move_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr, uint32_t pnn)
{
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
struct ctdb_public_ip ip;
int i, ret;
uint32_t *nodes;
@ -1843,7 +1843,7 @@ static int
find_other_host_for_public_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
{
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
struct ctdb_node_map_old *nodemap=NULL;
int i, j, ret;
int pnn;
@ -2077,7 +2077,7 @@ static int control_rebalanceip(struct ctdb_context *ctdb, int argc, const char *
static int getips_store_callback(void *param, void *data)
{
struct ctdb_public_ip *node_ip = (struct ctdb_public_ip *)data;
struct ctdb_all_public_ips *ips = param;
struct ctdb_public_ip_list_old *ips = param;
int i;
i = ips->num++;
@ -2127,9 +2127,9 @@ static void *add_ip_callback(void *parm, void *data)
}
static int
control_get_all_public_ips(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx, struct ctdb_all_public_ips **ips)
control_get_all_public_ips(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx, struct ctdb_public_ip_list_old **ips)
{
struct ctdb_all_public_ips *tmp_ips;
struct ctdb_public_ip_list_old *tmp_ips;
struct ctdb_node_map_old *nodemap=NULL;
trbt_tree_t *ip_tree;
int i, j, len, ret;
@ -2177,7 +2177,7 @@ control_get_all_public_ips(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx, struc
count = 0;
trbt_traversearray32(ip_tree, IP_KEYLEN, getips_count_callback, &count);
len = offsetof(struct ctdb_all_public_ips, ips) +
len = offsetof(struct ctdb_public_ip_list_old, ips) +
count*sizeof(struct ctdb_public_ip);
tmp_ips = talloc_zero_size(tmp_ctx, len);
trbt_traversearray32(ip_tree, IP_KEYLEN, getips_store_callback, tmp_ips);
@ -2378,7 +2378,7 @@ static int control_addip(struct ctdb_context *ctdb, int argc, const char **argv)
ctdb_sock_addr addr;
struct ctdb_control_ip_iface *pub;
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
if (argc != 2) {
@ -2482,7 +2482,7 @@ static int control_delip_all(struct ctdb_context *ctdb, int argc, const char **a
{
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
struct ctdb_node_map_old *nodemap=NULL;
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
int ret, i, j;
ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, tmp_ctx, &nodemap);
@ -2557,7 +2557,7 @@ static int control_delip(struct ctdb_context *ctdb, int argc, const char **argv)
ctdb_sock_addr addr;
struct ctdb_control_ip_iface pub;
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
if (argc != 1) {
talloc_free(tmp_ctx);
@ -2964,7 +2964,7 @@ static int control_ip(struct ctdb_context *ctdb, int argc, const char **argv)
{
int i, ret;
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
struct ctdb_all_public_ips *ips;
struct ctdb_public_ip_list_old *ips;
if (argc == 1 && strcmp(argv[0], "all") == 0) {
options.pnn = CTDB_BROADCAST_ALL;