You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
-#include "includes.h"
-#include "tdb.h"
-#include "lib/util/dlinklist.h"
+#include "replace.h"
#include "system/network.h"
#include "system/filesys.h"
+#include "system/time.h"
#include "system/wait.h"
-#include "../include/ctdb_private.h"
-#include "../common/rb_tree.h"
+
+#include <talloc.h>
+#include <tevent.h>
+
+#include "lib/util/dlinklist.h"
+#include "lib/util/debug.h"
+#include "lib/util/samba_util.h"
+
+#include "ctdb_private.h"
+#include "ctdb_client.h"
+#include "ctdb_logging.h"
+
+#include "common/rb_tree.h"
+#include "common/reqid.h"
+#include "common/system.h"
+#include "common/common.h"
#define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
struct ctdb_ipflags {
bool noiptakeover;
bool noiphost;
+ enum ctdb_runstate runstate;
};
struct ctdb_iface {
CTDB_NO_MEMORY_FATAL(ctdb, i);
i->name = talloc_strdup(i, iface);
CTDB_NO_MEMORY(ctdb, i->name);
- /*
- * If link_up defaults to true then IPs can be allocated to a
- * node during the first recovery. However, then an interface
- * could have its link marked down during the startup event,
- * causing the IP to move almost immediately. If link_up
- * defaults to false then, during normal operation, IPs added
- * to a new interface can't be assigned until a monitor cycle
- * has occurred and marked the new interfaces up. This makes
- * IP allocation unpredictable. The following is a neat
- * compromise: early in startup link_up defaults to false, so
- * IPs can't be assigned, and after startup IPs can be
- * assigned immediately.
- */
- i->link_up = (ctdb->runstate == CTDB_RUNSTATE_RUNNING);
+
+ i->link_up = true;
DLIST_ADD(ctdb->ifaces, i);
/*
send a gratuitous arp
*/
-static void ctdb_control_send_arp(struct event_context *ev, struct timed_event *te,
+static void ctdb_control_send_arp(struct tevent_context *ev,
+ struct tevent_timer *te,
struct timeval t, void *private_data)
{
struct ctdb_takeover_arp *arp = talloc_get_type(private_data,
return;
}
- event_add_timed(arp->ctdb->ev, arp->vnn->takeover_ctx,
- timeval_current_ofs(CTDB_ARP_INTERVAL, 100000),
- ctdb_control_send_arp, arp);
+ tevent_add_timer(arp->ctdb->ev, arp->vnn->takeover_ctx,
+ timeval_current_ofs(CTDB_ARP_INTERVAL, 100000),
+ ctdb_control_send_arp, arp);
}
static int32_t ctdb_announce_vnn_iface(struct ctdb_context *ctdb,
vnn->tcp_update_needed = true;
}
- event_add_timed(arp->ctdb->ev, vnn->takeover_ctx,
- timeval_zero(), ctdb_control_send_arp, arp);
+ tevent_add_timer(arp->ctdb->ev, vnn->takeover_ctx,
+ timeval_zero(), ctdb_control_send_arp, arp);
return 0;
}
struct takeover_callback_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
ctdb_sock_addr *addr;
struct ctdb_vnn *vnn;
};
struct ctdb_do_takeip_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
struct ctdb_vnn *vnn;
};
take over an ip address
*/
static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
struct ctdb_vnn *vnn)
{
int ret;
}
struct ctdb_do_updateip_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
struct ctdb_iface *old;
struct ctdb_vnn *vnn;
};
update (move) an ip address
*/
static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
struct ctdb_vnn *vnn)
{
int ret;
take over an ip address
*/
int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata,
bool *async_reply)
{
return 0;
}
- if (ctdb->do_checkpublicip) {
+ if (ctdb->tunable.disable_ip_failover == 0 && ctdb->do_checkpublicip) {
have_ip = ctdb_sys_have_ip(&pip->addr);
}
best_iface = ctdb_vnn_best_iface(ctdb, vnn);
return 0;
}
-/*
- takeover an ip address old v4 style
- */
-int32_t ctdb_control_takeover_ipv4(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
- TDB_DATA indata,
- bool *async_reply)
-{
- TDB_DATA data;
-
- data.dsize = sizeof(struct ctdb_public_ip);
- data.dptr = (uint8_t *)talloc_zero(c, struct ctdb_public_ip);
- CTDB_NO_MEMORY(ctdb, data.dptr);
-
- memcpy(data.dptr, indata.dptr, indata.dsize);
- return ctdb_control_takeover_ip(ctdb, c, data, async_reply);
-}
-
/*
kill any clients that are registered with a IP that is being released
*/
ctdb_addr_to_str(&ip->addr)));
if (ctdb_same_ip(&tmp_addr, addr)) {
- struct ctdb_client *client = ctdb_reqid_find(ctdb,
- ip->client_id,
- struct ctdb_client);
+ struct ctdb_client *client = reqid_find(ctdb->idr,
+ ip->client_id,
+ struct ctdb_client);
DEBUG(DEBUG_INFO,("matched client %u with IP %s and pid %u\n",
ip->client_id,
ctdb_addr_to_str(&ip->addr),
ctdb_ban_self(ctdb);
}
- if (ctdb->do_checkpublicip && ctdb_sys_have_ip(state->addr)) {
- DEBUG(DEBUG_ERR, ("IP %s still hosted during release IP callback, failing\n",
- ctdb_addr_to_str(state->addr)));
- ctdb_request_control_reply(ctdb, state->c, NULL, -1, NULL);
- talloc_free(state);
- return;
+ if (ctdb->tunable.disable_ip_failover == 0 && ctdb->do_checkpublicip) {
+ if (ctdb_sys_have_ip(state->addr)) {
+ DEBUG(DEBUG_ERR,
+ ("IP %s still hosted during release IP callback, failing\n",
+ ctdb_addr_to_str(state->addr)));
+ ctdb_request_control_reply(ctdb, state->c,
+ NULL, -1, NULL);
+ talloc_free(state);
+ return;
+ }
}
/* send a message to all clients of this node telling them
release an ip address
*/
int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata,
bool *async_reply)
{
* intended new node. The following causes makes ctdbd ignore
* a release for any address it doesn't host.
*/
- if (ctdb->do_checkpublicip) {
+ if (ctdb->tunable.disable_ip_failover == 0 && ctdb->do_checkpublicip) {
if (!ctdb_sys_have_ip(&pip->addr)) {
DEBUG(DEBUG_DEBUG,("Redundant release of IP %s/%u on interface %s (ip not held)\n",
ctdb_addr_to_str(&pip->addr),
return -1;
}
- if (ctdb->do_checkpublicip) {
- iface = ctdb_sys_find_ifname(&pip->addr);
- if (iface == NULL) {
- DEBUG(DEBUG_ERR, ("Could not find which interface the ip address is hosted on. can not release it\n"));
- return 0;
- }
- if (vnn->iface == NULL) {
- DEBUG(DEBUG_WARNING,
- ("Public IP %s is hosted on interface %s but we have no VNN\n",
- ctdb_addr_to_str(&pip->addr),
- iface));
- } else if (strcmp(iface, ctdb_vnn_iface_string(vnn)) != 0) {
- DEBUG(DEBUG_WARNING,
- ("Public IP %s is hosted on inteterface %s but VNN says %s\n",
- ctdb_addr_to_str(&pip->addr),
- iface,
- ctdb_vnn_iface_string(vnn)));
- /* Should we fix vnn->iface? If we do, what
- * happens to reference counts?
- */
- }
- } else {
- iface = strdup(ctdb_vnn_iface_string(vnn));
- }
+ iface = strdup(ctdb_vnn_iface_string(vnn));
DEBUG(DEBUG_NOTICE,("Release of IP %s/%u on interface %s node:%d\n",
ctdb_addr_to_str(&pip->addr),
pip->pnn));
state = talloc(ctdb, struct takeover_callback_state);
- CTDB_NO_MEMORY(ctdb, state);
+ if (state == NULL) {
+ ctdb_set_error(ctdb, "Out of memory at %s:%d",
+ __FILE__, __LINE__);
+ free(iface);
+ return -1;
+ }
state->c = talloc_steal(state, c);
state->addr = talloc(state, ctdb_sock_addr);
- CTDB_NO_MEMORY(ctdb, state->addr);
+ if (state->addr == NULL) {
+ ctdb_set_error(ctdb, "Out of memory at %s:%d",
+ __FILE__, __LINE__);
+ free(iface);
+ talloc_free(state);
+ return -1;
+ }
*state->addr = pip->addr;
state->vnn = vnn;
return 0;
}
-/*
- release an ip address old v4 style
- */
-int32_t ctdb_control_release_ipv4(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
- TDB_DATA indata,
- bool *async_reply)
-{
- TDB_DATA data;
-
- data.dsize = sizeof(struct ctdb_public_ip);
- data.dptr = (uint8_t *)talloc_zero(c, struct ctdb_public_ip);
- CTDB_NO_MEMORY(ctdb, data.dptr);
-
- memcpy(data.dptr, indata.dptr, indata.dsize);
- return ctdb_control_release_ip(ctdb, c, data, async_reply);
-}
-
-
static int ctdb_add_public_address(struct ctdb_context *ctdb,
ctdb_sock_addr *addr,
unsigned mask, const char *ifaces,
return 0;
}
-static void ctdb_check_interfaces_event(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private_data)
-{
- struct ctdb_context *ctdb = talloc_get_type(private_data,
- struct ctdb_context);
- struct ctdb_vnn *vnn;
-
- for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- int i;
-
- for (i=0; vnn->ifaces[i] != NULL; i++) {
- if (!ctdb_sys_check_iface_exists(vnn->ifaces[i])) {
- DEBUG(DEBUG_CRIT,("Interface %s does not exist but is used by public ip %s\n",
- vnn->ifaces[i],
- ctdb_addr_to_str(&vnn->public_address)));
- }
- }
- }
-
- event_add_timed(ctdb->ev, ctdb->check_public_ifaces_ctx,
- timeval_current_ofs(30, 0),
- ctdb_check_interfaces_event, ctdb);
-}
-
-
-int ctdb_start_monitoring_interfaces(struct ctdb_context *ctdb)
-{
- if (ctdb->check_public_ifaces_ctx != NULL) {
- talloc_free(ctdb->check_public_ifaces_ctx);
- ctdb->check_public_ifaces_ctx = NULL;
- }
-
- ctdb->check_public_ifaces_ctx = talloc_new(ctdb);
- if (ctdb->check_public_ifaces_ctx == NULL) {
- ctdb_fatal(ctdb, "failed to allocate context for checking interfaces");
- }
-
- event_add_timed(ctdb->ev, ctdb->check_public_ifaces_ctx,
- timeval_current_ofs(30, 0),
- ctdb_check_interfaces_event, ctdb);
-
- return 0;
-}
-
-
/*
setup the public address lists from a file
*/
return 0;
}
-struct ctdb_public_ip_list {
- struct ctdb_public_ip_list *next;
+struct public_ip_list {
+ struct public_ip_list *next;
uint32_t pnn;
ctdb_sock_addr addr;
};
/* Given a physical node, return the number of
public addresses that is currently assigned to this node.
*/
-static int node_ip_coverage(struct ctdb_context *ctdb,
- int32_t pnn,
- struct ctdb_public_ip_list *ips)
+static int node_ip_coverage(struct ctdb_context *ctdb, int32_t pnn,
+ struct public_ip_list *ips)
{
int num=0;
/* Can the given node host the given IP: is the public IP known to the
* node and is NOIPHOST unset?
*/
-static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
+static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
struct ctdb_ipflags ipflags,
- struct ctdb_public_ip_list *ip)
+ struct public_ip_list *ip)
{
struct ctdb_all_public_ips *public_ips;
int i;
return false;
}
-static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
+static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
struct ctdb_ipflags ipflags,
- struct ctdb_public_ip_list *ip)
+ struct public_ip_list *ip)
{
if (ipflags.noiptakeover) {
return false;
pick the node that currently are serving the least number of ips
so that the ips get spread out evenly.
*/
-static int find_takeover_node(struct ctdb_context *ctdb,
- struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *ip,
- struct ctdb_public_ip_list *all_ips)
+static int find_takeover_node(struct ctdb_context *ctdb,
+ struct ctdb_ipflags *ipflags,
+ struct public_ip_list *ip,
+ struct public_ip_list *all_ips)
{
int pnn, min=0, num;
int i, numnodes;
static void *add_ip_callback(void *parm, void *data)
{
- struct ctdb_public_ip_list *this_ip = parm;
- struct ctdb_public_ip_list *prev_ip = data;
+ struct public_ip_list *this_ip = parm;
+ struct public_ip_list *prev_ip = data;
if (prev_ip == NULL) {
return parm;
static int getips_count_callback(void *param, void *data)
{
- struct ctdb_public_ip_list **ip_list = (struct ctdb_public_ip_list **)param;
- struct ctdb_public_ip_list *new_ip = (struct ctdb_public_ip_list *)data;
+ struct public_ip_list **ip_list = (struct public_ip_list **)param;
+ struct public_ip_list *new_ip = (struct public_ip_list *)data;
new_ip->next = *ip_list;
*ip_list = new_ip;
return 0;
}
-static struct ctdb_public_ip_list *
+static struct public_ip_list *
create_merged_ip_list(struct ctdb_context *ctdb)
{
int i, j;
- struct ctdb_public_ip_list *ip_list;
+ struct public_ip_list *ip_list;
struct ctdb_all_public_ips *public_ips;
if (ctdb->ip_tree != NULL) {
}
for (j=0;j<public_ips->num;j++) {
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
- tmp_ip = talloc_zero(ctdb->ip_tree, struct ctdb_public_ip_list);
+ tmp_ip = talloc_zero(ctdb->ip_tree, struct public_ip_list);
CTDB_NO_MEMORY_NULL(ctdb, tmp_ip);
/* Do not use information about IP addresses hosted
* on other nodes, it may not be accurate */
used in the main part of the algorithm.
*/
static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip,
- struct ctdb_public_ip_list *ips,
+ struct public_ip_list *ips,
int pnn)
{
- struct ctdb_public_ip_list *t;
+ struct public_ip_list *t;
uint32_t d;
uint32_t sum = 0;
/* Return the LCP2 imbalance metric for addresses currently assigned
to the given node.
*/
-static uint32_t lcp2_imbalance(struct ctdb_public_ip_list * all_ips, int pnn)
+static uint32_t lcp2_imbalance(struct public_ip_list * all_ips, int pnn)
{
- struct ctdb_public_ip_list *t;
+ struct public_ip_list *t;
uint32_t imbalance = 0;
*/
static void basic_allocate_unassigned(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
/* loop over all ip's and find a physical node to cover for
each unassigned ip.
*/
static void basic_failback(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
int num_ips)
{
int i, numnodes;
int maxnode, maxnum, minnode, minnum, num, retries;
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
numnodes = talloc_array_length(ipflags);
retries = 0;
*/
if ( (maxnum > minnum+1)
&& (retries < (num_ips + 5)) ){
- struct ctdb_public_ip_list *tmp;
+ struct public_ip_list *tmp;
/* Reassign one of maxnode's VNNs */
for (tmp=all_ips;tmp;tmp=tmp->next) {
static void lcp2_init(struct ctdb_context *tmp_ctx,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *force_rebalance_nodes,
uint32_t **lcp2_imbalances,
bool **rebalance_candidates)
{
int i, numnodes;
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
numnodes = talloc_array_length(ipflags);
*/
static void lcp2_allocate_unassigned(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *lcp2_imbalances)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int dstnode, numnodes;
int minnode;
uint32_t mindsum, dstdsum, dstimbl, minimbl;
- struct ctdb_public_ip_list *minip;
+ struct public_ip_list *minip;
bool should_loop = true;
bool have_unassigned = true;
*/
static bool lcp2_failback_candidate(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
int srcnode,
uint32_t *lcp2_imbalances,
bool *rebalance_candidates)
int dstnode, mindstnode, numnodes;
uint32_t srcimbl, srcdsum, dstimbl, dstdsum;
uint32_t minsrcimbl, mindstimbl;
- struct ctdb_public_ip_list *minip;
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *minip;
+ struct public_ip_list *tmp_ip;
/* Find an IP and destination node that best reduces imbalance. */
srcimbl = 0;
*/
static void lcp2_failback(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *lcp2_imbalances,
bool *rebalance_candidates)
{
static void unassign_unsuitable_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
/* verify that the assigned nodes can serve that public ip
and set it to -1 if not
static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int i, numnodes;
numnodes = talloc_array_length(ipflags);
static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
/* This should be pushed down into basic_failback. */
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int num_ips = 0;
for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
num_ips++;
static void ip_alloc_lcp2(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *force_rebalance_nodes)
{
uint32_t *lcp2_imbalances;
talloc_free(tmp_ctx);
}
-static bool all_nodes_are_disabled(struct ctdb_node_map *nodemap)
+static bool all_nodes_are_disabled(struct ctdb_node_map_old *nodemap)
{
int i;
/* The calculation part of the IP allocation algorithm. */
static void ctdb_takeover_run_core(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list **all_ips_p,
+ struct public_ip_list **all_ips_p,
uint32_t *force_rebalance_nodes)
{
/* since nodes only know about those public addresses that
static uint32_t *get_tunable_from_nodes(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap,
+ struct ctdb_node_map_old *nodemap,
const char *tunable,
uint32_t default_value)
{
static enum ctdb_runstate * get_runstate_from_nodes(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap,
+ struct ctdb_node_map_old *nodemap,
enum ctdb_runstate default_value)
{
uint32_t *nodes;
static struct ctdb_ipflags *
set_ipflags_internal(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap,
+ struct ctdb_node_map_old *nodemap,
uint32_t *tval_noiptakeover,
uint32_t *tval_noiphostonalldisabled,
enum ctdb_runstate *runstate)
if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
ipflags[i].noiphost = true;
}
+ /* Remember the runstate */
+ ipflags[i].runstate = runstate[i];
}
if (all_nodes_are_disabled(nodemap)) {
static struct ctdb_ipflags *set_ipflags(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap)
+ struct ctdb_node_map_old *nodemap)
{
uint32_t *tval_noiptakeover;
uint32_t *tval_noiphostonalldisabled;
int retry_count;
client_async_callback fail_callback;
void *fail_callback_data;
- struct ctdb_node_map *nodemap;
+ struct ctdb_node_map_old *nodemap;
};
static void iprealloc_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
bool *node_failed;
client_async_callback fail_callback;
void *fail_callback_data;
- struct ctdb_node_map *nodemap;
+ struct ctdb_node_map_old *nodemap;
};
static void takeover_run_fail_callback(struct ctdb_context *ctdb,
/*
make any IP alias changes for public addresses that are necessary
*/
-int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap,
+int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodemap,
uint32_t *force_rebalance_nodes,
client_async_callback fail_callback, void *callback_data)
{
int i, j, ret;
struct ctdb_public_ip ip;
- struct ctdb_public_ipv4 ipv4;
uint32_t *nodes;
- struct ctdb_public_ip_list *all_ips, *tmp_ip;
+ struct public_ip_list *all_ips, *tmp_ip;
TDB_DATA data;
struct timeval timeout;
struct client_async_data *async_data;
struct takeover_callback_data *takeover_data;
struct iprealloc_callback_data iprealloc_data;
bool *retry_data;
+ bool can_host_ips;
/*
* ip failover is completely disabled, just send out the
return -1;
}
+ /* Short-circuit IP allocation if no nodes are in the RUNNING
+ * runstate yet, since no nodes will be able to host IPs */
+ can_host_ips = false;
+ for (i=0; i<nodemap->num; i++) {
+ if (ipflags[i].runstate == CTDB_RUNSTATE_RUNNING) {
+ can_host_ips = true;
+ }
+ }
+ if (!can_host_ips) {
+ DEBUG(DEBUG_WARNING,("No nodes available to host public IPs yet\n"));
+ return 0;
+ }
+
/* Do the IP reassignment calculations */
ctdb_takeover_run_core(ctdb, ipflags, &all_ips, force_rebalance_nodes);
*/
continue;
}
- if (tmp_ip->addr.sa.sa_family == AF_INET) {
- ipv4.pnn = tmp_ip->pnn;
- ipv4.sin = tmp_ip->addr.ip;
-
- timeout = TAKEOVER_TIMEOUT();
- data.dsize = sizeof(ipv4);
- data.dptr = (uint8_t *)&ipv4;
- state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
- 0, CTDB_CONTROL_RELEASE_IPv4, 0,
- data, async_data,
- &timeout, NULL);
- } else {
- ip.pnn = tmp_ip->pnn;
- ip.addr = tmp_ip->addr;
-
- timeout = TAKEOVER_TIMEOUT();
- data.dsize = sizeof(ip);
- data.dptr = (uint8_t *)&ip;
- state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
- 0, CTDB_CONTROL_RELEASE_IP, 0,
- data, async_data,
- &timeout, NULL);
- }
+ ip.pnn = tmp_ip->pnn;
+ ip.addr = tmp_ip->addr;
+ timeout = TAKEOVER_TIMEOUT();
+ data.dsize = sizeof(ip);
+ data.dptr = (uint8_t *)&ip;
+ state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
+ 0, CTDB_CONTROL_RELEASE_IP, 0,
+ data, async_data,
+ &timeout, NULL);
if (state == NULL) {
DEBUG(DEBUG_ERR,(__location__ " Failed to call async control CTDB_CONTROL_RELEASE_IP to node %u\n", nodemap->nodes[i].pnn));
talloc_free(tmp_ctx);
return -1;
}
-
+
ctdb_client_async_add(async_data, state);
}
}
continue;
}
- if (tmp_ip->addr.sa.sa_family == AF_INET) {
- ipv4.pnn = tmp_ip->pnn;
- ipv4.sin = tmp_ip->addr.ip;
+ ip.pnn = tmp_ip->pnn;
+ ip.addr = tmp_ip->addr;
- timeout = TAKEOVER_TIMEOUT();
- data.dsize = sizeof(ipv4);
- data.dptr = (uint8_t *)&ipv4;
- state = ctdb_control_send(ctdb, tmp_ip->pnn,
- 0, CTDB_CONTROL_TAKEOVER_IPv4, 0,
- data, async_data,
- &timeout, NULL);
- } else {
- ip.pnn = tmp_ip->pnn;
- ip.addr = tmp_ip->addr;
-
- timeout = TAKEOVER_TIMEOUT();
- data.dsize = sizeof(ip);
- data.dptr = (uint8_t *)&ip;
- state = ctdb_control_send(ctdb, tmp_ip->pnn,
- 0, CTDB_CONTROL_TAKEOVER_IP, 0,
- data, async_data,
- &timeout, NULL);
- }
+ timeout = TAKEOVER_TIMEOUT();
+ data.dsize = sizeof(ip);
+ data.dptr = (uint8_t *)&ip;
+ state = ctdb_control_send(ctdb, tmp_ip->pnn,
+ 0, CTDB_CONTROL_TAKEOVER_IP, 0,
+ data, async_data, &timeout, NULL);
if (state == NULL) {
DEBUG(DEBUG_ERR,(__location__ " Failed to call async control CTDB_CONTROL_TAKEOVER_IP to node %u\n", tmp_ip->pnn));
talloc_free(tmp_ctx);
return -1;
}
-
+
ctdb_client_async_add(async_data, state);
}
if (ctdb_client_async_wait(ctdb, async_data) != 0) {
}
ipreallocated:
- /*
+ /*
* Tell all nodes to run eventscripts to process the
* "ipreallocated" event. This can do a lot of things,
* including restarting services to reconfigure them if public
* IPs have moved. Once upon a time this event only used to
- * update natwg.
+ * update natgw.
*/
retry_data = talloc_zero_array(tmp_ctx, bool, nodemap->num);
CTDB_NO_MEMORY_FATAL(ctdb, retry_data);
/*
called by a client to inform us of a TCP connection that it is managing
that should tickled with an ACK when IP takeover is done
- we handle both the old ipv4 style of packets as well as the new ipv4/6
- pdus.
*/
int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
TDB_DATA indata)
{
- struct ctdb_client *client = ctdb_reqid_find(ctdb, client_id, struct ctdb_client);
- struct ctdb_control_tcp *old_addr = NULL;
- struct ctdb_control_tcp_addr new_addr;
+ struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
struct ctdb_control_tcp_addr *tcp_sock = NULL;
struct ctdb_tcp_list *tcp;
struct ctdb_tcp_connection t;
return 0;
}
- switch (indata.dsize) {
- case sizeof(struct ctdb_control_tcp):
- old_addr = (struct ctdb_control_tcp *)indata.dptr;
- ZERO_STRUCT(new_addr);
- tcp_sock = &new_addr;
- tcp_sock->src.ip = old_addr->src;
- tcp_sock->dest.ip = old_addr->dest;
- break;
- case sizeof(struct ctdb_control_tcp_addr):
- tcp_sock = (struct ctdb_control_tcp_addr *)indata.dptr;
- break;
- default:
- DEBUG(DEBUG_ERR,(__location__ " Invalid data structure passed "
- "to ctdb_control_tcp_client. size was %d but "
- "only allowed sizes are %lu and %lu\n",
- (int)indata.dsize,
- (long unsigned)sizeof(struct ctdb_control_tcp),
- (long unsigned)sizeof(struct ctdb_control_tcp_addr)));
- return -1;
- }
+ tcp_sock = (struct ctdb_control_tcp_addr *)indata.dptr;
addr = tcp_sock->src;
ctdb_canonicalize_ip(&addr, &tcp_sock->src);
}
-/*
- release all IPs on shutdown
- */
void ctdb_release_all_ips(struct ctdb_context *ctdb)
{
struct ctdb_vnn *vnn;
int count = 0;
+ if (ctdb->tunable.disable_ip_failover == 1) {
+ return;
+ }
+
for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
if (!ctdb_sys_have_ip(&vnn->public_address)) {
ctdb_vnn_unassign_iface(ctdb, vnn);
continue;
}
+ /* Don't allow multiple releases at once. Some code,
+ * particularly ctdb_tickle_sentenced_connections() is
+ * not re-entrant */
+ if (vnn->update_in_flight) {
+ DEBUG(DEBUG_WARNING,
+ (__location__
+ " Not releasing IP %s/%u on interface %s, an update is already in progess\n",
+ ctdb_addr_to_str(&vnn->public_address),
+ vnn->public_netmask_bits,
+ ctdb_vnn_iface_string(vnn)));
+ continue;
+ }
+ vnn->update_in_flight = true;
+
DEBUG(DEBUG_INFO,("Release of IP %s/%u on interface %s node:-1\n",
ctdb_addr_to_str(&vnn->public_address),
vnn->public_netmask_bits,
vnn->public_netmask_bits);
release_kill_clients(ctdb, &vnn->public_address);
ctdb_vnn_unassign_iface(ctdb, vnn);
+ vnn->update_in_flight = false;
count++;
}
get list of public IPs
*/
int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
- struct ctdb_req_control *c, TDB_DATA *outdata)
+ struct ctdb_req_control_old *c, TDB_DATA *outdata)
{
int i, num, len;
struct ctdb_all_public_ips *ips;
}
-/*
- get list of public IPs, old ipv4 style. only returns ipv4 addresses
- */
-int32_t ctdb_control_get_public_ipsv4(struct ctdb_context *ctdb,
- struct ctdb_req_control *c, TDB_DATA *outdata)
-{
- int i, num, len;
- struct ctdb_all_public_ipsv4 *ips;
- struct ctdb_vnn *vnn;
-
- /* count how many public ip structures we have */
- num = 0;
- for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- if (vnn->public_address.sa.sa_family != AF_INET) {
- continue;
- }
- num++;
- }
-
- len = offsetof(struct ctdb_all_public_ipsv4, ips) +
- num*sizeof(struct ctdb_public_ipv4);
- ips = talloc_zero_size(outdata, len);
- CTDB_NO_MEMORY(ctdb, ips);
-
- outdata->dsize = len;
- outdata->dptr = (uint8_t *)ips;
-
- ips->num = num;
- i = 0;
- for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- if (vnn->public_address.sa.sa_family != AF_INET) {
- continue;
- }
- ips->ips[i].pnn = vnn->pnn;
- ips->ips[i].sin = vnn->public_address.ip;
- i++;
- }
-
- return 0;
-}
-
int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata,
TDB_DATA *outdata)
{
}
int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA *outdata)
{
int i, num, len;
}
int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata)
{
struct ctdb_control_iface_info *info;
struct ctdb_vnn *vnn;
struct ctdb_context *ctdb;
int capture_fd;
- struct fd_event *fde;
+ struct tevent_fd *fde;
trbt_tree_t *connections;
void *private_data;
};
/*
called when we get a read event on the raw socket
*/
-static void capture_tcp_handler(struct event_context *ev, struct fd_event *fde,
+static void capture_tcp_handler(struct tevent_context *ev,
+ struct tevent_fd *fde,
uint16_t flags, void *private_data)
{
struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
ctdb_sock_addr src, dst;
uint32_t ack_seq, seq;
- if (!(flags & EVENT_FD_READ)) {
+ if (!(flags & TEVENT_FD_READ)) {
return;
}
/*
called every second until all sentenced connections have been reset
*/
-static void ctdb_tickle_sentenced_connections(struct event_context *ev, struct timed_event *te,
+static void ctdb_tickle_sentenced_connections(struct tevent_context *ev,
+ struct tevent_timer *te,
struct timeval t, void *private_data)
{
struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
/* try tickling them again in a seconds time
*/
- event_add_timed(killtcp->ctdb->ev, killtcp, timeval_current_ofs(1, 0),
- ctdb_tickle_sentenced_connections, killtcp);
+ tevent_add_timer(killtcp->ctdb->ev, killtcp,
+ timeval_current_ofs(1, 0),
+ ctdb_tickle_sentenced_connections, killtcp);
}
/*
if (killtcp->fde == NULL) {
- killtcp->fde = event_add_fd(ctdb->ev, killtcp, killtcp->capture_fd,
- EVENT_FD_READ,
- capture_tcp_handler, killtcp);
+ killtcp->fde = tevent_add_fd(ctdb->ev, killtcp,
+ killtcp->capture_fd,
+ TEVENT_FD_READ,
+ capture_tcp_handler, killtcp);
tevent_fd_set_auto_close(killtcp->fde);
/* We also need to set up some events to tickle all these connections
until they are all reset
*/
- event_add_timed(ctdb->ev, killtcp, timeval_current_ofs(1, 0),
- ctdb_tickle_sentenced_connections, killtcp);
+ tevent_add_timer(ctdb->ev, killtcp, timeval_current_ofs(1, 0),
+ ctdb_tickle_sentenced_connections, killtcp);
}
/* tickle him once now */
*/
int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
{
- struct ctdb_control_killtcp *killtcp = (struct ctdb_control_killtcp *)indata.dptr;
+ struct ctdb_tcp_connection *killtcp = (struct ctdb_tcp_connection *)indata.dptr;
return ctdb_killtcp_add_connection(ctdb, &killtcp->src_addr, &killtcp->dst_addr);
}
/*
perform tickle updates if required
*/
-static void ctdb_update_tcp_tickles(struct event_context *ev,
- struct timed_event *te,
- struct timeval t, void *private_data)
+static void ctdb_update_tcp_tickles(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t, void *private_data)
{
struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
int ret;
}
}
- event_add_timed(ctdb->ev, ctdb->tickle_update_context,
- timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
- ctdb_update_tcp_tickles, ctdb);
-}
-
+ tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
+ timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
+ ctdb_update_tcp_tickles, ctdb);
+}
/*
start periodic update of tcp tickles
{
ctdb->tickle_update_context = talloc_new(ctdb);
- event_add_timed(ctdb->ev, ctdb->tickle_update_context,
- timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
- ctdb_update_tcp_tickles, ctdb);
+ tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
+ timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
+ ctdb_update_tcp_tickles, ctdb);
}
/*
send a control_gratuitous arp
*/
-static void send_gratious_arp(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private_data)
+static void send_gratious_arp(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t, void *private_data)
{
int ret;
struct control_gratious_arp *arp = talloc_get_type(private_data,
return;
}
- event_add_timed(arp->ctdb->ev, arp,
- timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
- send_gratious_arp, arp);
+ tevent_add_timer(arp->ctdb->ev, arp,
+ timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
+ send_gratious_arp, arp);
}
arp->iface = talloc_strdup(arp, gratious_arp->iface);
CTDB_NO_MEMORY(ctdb, arp->iface);
arp->count = 0;
-
- event_add_timed(arp->ctdb->ev, arp,
- timeval_zero(), send_gratious_arp, arp);
+
+ tevent_add_timer(arp->ctdb->ev, arp,
+ timeval_zero(), send_gratious_arp, arp);
return 0;
}
}
struct delete_ip_callback_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
};
/*
}
int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata, bool *async_reply)
{
struct ctdb_control_ip_iface *pub = (struct ctdb_control_ip_iface *)indata.dptr;
struct ipreallocated_callback_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
};
static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
/* A control to run the ipreallocated event */
int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
bool *async_reply)
{
int ret;
struct ctdb_all_public_ips *ips,
uint32_t pnn)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int i;
if (ctdb->ip_tree == NULL) {
int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *ip)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
+
+ /* IP tree is never built if DisableIPFailover is set */
+ if (ctdb->tunable.disable_ip_failover != 0) {
+ return 0;
+ }
if (ctdb->ip_tree == NULL) {
DEBUG(DEBUG_ERR,("No ctdb->ip_tree yet. Failed to update ip assignment\n"));
return 0;
}
+void clear_ip_assignment_tree(struct ctdb_context *ctdb)
+{
+ TALLOC_FREE(ctdb->ip_tree);
+}
struct ctdb_reloadips_handle {
struct ctdb_context *ctdb;
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
int status;
int fd[2];
pid_t child;
- struct fd_event *fde;
+ struct tevent_fd *fde;
};
static int ctdb_reloadips_destructor(struct ctdb_reloadips_handle *h)
return 0;
}
-static void ctdb_reloadips_timeout_event(struct event_context *ev,
- struct timed_event *te,
- struct timeval t, void *private_data)
+static void ctdb_reloadips_timeout_event(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t, void *private_data)
{
struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
talloc_free(h);
-}
+}
-static void ctdb_reloadips_child_handler(struct event_context *ev, struct fd_event *fde,
- uint16_t flags, void *private_data)
+static void ctdb_reloadips_child_handler(struct tevent_context *ev,
+ struct tevent_fd *fde,
+ uint16_t flags, void *private_data)
{
struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
and drop any addresses we should nnot longer host, and add new addresses
that we are now able to host
*/
-int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply)
+int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control_old *c, bool *async_reply)
{
struct ctdb_reloadips_handle *h;
pid_t parent = getpid();
talloc_set_destructor(h, ctdb_reloadips_destructor);
- h->fde = event_add_fd(ctdb->ev, h, h->fd[0],
- EVENT_FD_READ, ctdb_reloadips_child_handler,
- (void *)h);
+ h->fde = tevent_add_fd(ctdb->ev, h, h->fd[0], TEVENT_FD_READ,
+ ctdb_reloadips_child_handler, (void *)h);
tevent_fd_set_auto_close(h->fde);
- event_add_timed(ctdb->ev, h,
- timeval_current_ofs(120, 0),
- ctdb_reloadips_timeout_event, h);
+ tevent_add_timer(ctdb->ev, h, timeval_current_ofs(120, 0),
+ ctdb_reloadips_timeout_event, h);
/* we reply later */
*async_reply = true;
git.samba.org / kai / samba-autobuild / .git / blobdiff