#include "lib/util/dlinklist.h"
#include "lib/util/debug.h"
#include "lib/util/samba_util.h"
+#include "lib/util/sys_rw.h"
#include "lib/util/util_process.h"
+#include "protocol/protocol_util.h"
+
#include "ctdb_private.h"
#include "ctdb_client.h"
#include "common/rb_tree.h"
#include "common/reqid.h"
#include "common/system.h"
+#include "common/system_socket.h"
#include "common/common.h"
#include "common/logging.h"
uint32_t references;
};
-static const char *ctdb_vnn_iface_string(const struct ctdb_vnn *vnn)
+struct vnn_interface {
+ struct vnn_interface *prev, *next;
+ struct ctdb_interface *iface;
+};
+
+/* state associated with a public ip address */
+struct ctdb_vnn {
+ struct ctdb_vnn *prev, *next;
+
+ struct ctdb_interface *iface;
+ struct vnn_interface *ifaces;
+ ctdb_sock_addr public_address;
+ uint8_t public_netmask_bits;
+
+ /* the node number that is serving this public address, if any.
+ If no node serves this ip it is set to -1 */
+ int32_t pnn;
+
+ /* List of clients to tickle for this public address */
+ struct ctdb_tcp_array *tcp_array;
+
+ /* whether we need to update the other nodes with changes to our list
+ of connected clients */
+ bool tcp_update_needed;
+
+ /* a context to hang sending gratious arp events off */
+ TALLOC_CTX *takeover_ctx;
+
+ /* Set to true any time an update to this VNN is in flight.
+ This helps to avoid races. */
+ bool update_in_flight;
+
+ /* If CTDB_CONTROL_DEL_PUBLIC_IP is received for this IP
+ * address then this flag is set. It will be deleted in the
+ * release IP callback. */
+ bool delete_pending;
+};
+
+static const char *iface_string(const struct ctdb_interface *iface)
{
- if (vnn->iface) {
- return vnn->iface->name;
- }
+ return (iface != NULL ? iface->name : "__none__");
+}
- return "__none__";
+static const char *ctdb_vnn_iface_string(const struct ctdb_vnn *vnn)
+{
+ return iface_string(vnn->iface);
}
-static int ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
+static struct ctdb_interface *ctdb_find_iface(struct ctdb_context *ctdb,
+ const char *iface);
+
+static struct ctdb_interface *
+ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
{
struct ctdb_interface *i;
+ if (strlen(iface) > CTDB_IFACE_SIZE) {
+ DEBUG(DEBUG_ERR, ("Interface name too long \"%s\"\n", iface));
+ return NULL;
+ }
+
/* Verify that we don't have an entry for this ip yet */
- for (i=ctdb->ifaces;i;i=i->next) {
- if (strcmp(i->name, iface) == 0) {
- return 0;
- }
+ i = ctdb_find_iface(ctdb, iface);
+ if (i != NULL) {
+ return i;
}
/* create a new structure for this interface */
i = talloc_zero(ctdb, struct ctdb_interface);
- CTDB_NO_MEMORY_FATAL(ctdb, i);
+ if (i == NULL) {
+ DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+ return NULL;
+ }
i->name = talloc_strdup(i, iface);
- CTDB_NO_MEMORY(ctdb, i->name);
+ if (i->name == NULL) {
+ DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+ talloc_free(i);
+ return NULL;
+ }
i->link_up = true;
DLIST_ADD(ctdb->ifaces, i);
- return 0;
+ return i;
}
-static bool vnn_has_interface_with_name(struct ctdb_vnn *vnn,
- const char *name)
+static bool vnn_has_interface(struct ctdb_vnn *vnn,
+ const struct ctdb_interface *iface)
{
- int n;
+ struct vnn_interface *i;
- for (n = 0; vnn->ifaces[n] != NULL; n++) {
- if (strcmp(name, vnn->ifaces[n]) == 0) {
+ for (i = vnn->ifaces; i != NULL; i = i->next) {
+ if (iface == i->iface) {
return true;
}
}
* foolproof. One alternative is reference counting, where the logic
* is distributed and can, therefore, be broken in multiple places.
* Another alternative is to build a red-black tree of interfaces that
- * can have addresses (by walking ctdb->vnn and ctdb->single_ip_vnn
- * once) and then walking ctdb->ifaces once and deleting those not in
- * the tree. Let's go to one of those if the naive implementation
- * causes problems... :-)
+ * can have addresses (by walking ctdb->vnn once) and then walking
+ * ctdb->ifaces once and deleting those not in the tree. Let's go to
+ * one of those if the naive implementation causes problems... :-)
*/
static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
struct ctdb_vnn *vnn)
next = i->next;
/* Only consider interfaces named in the given VNN. */
- if (!vnn_has_interface_with_name(vnn, i->name)) {
+ if (!vnn_has_interface(vnn, i)) {
continue;
}
- /* Is the "single IP" on this interface? */
- if ((ctdb->single_ip_vnn != NULL) &&
- (ctdb->single_ip_vnn->ifaces[0] != NULL) &&
- (strcmp(i->name, ctdb->single_ip_vnn->ifaces[0]) == 0)) {
- /* Found, next interface please... */
- continue;
- }
/* Search for a vnn with this interface. */
found = false;
for (tv=ctdb->vnn; tv; tv=tv->next) {
- if (vnn_has_interface_with_name(tv, i->name)) {
+ if (vnn_has_interface(tv, i)) {
found = true;
break;
}
static struct ctdb_interface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
struct ctdb_vnn *vnn)
{
- int i;
+ struct vnn_interface *i;
struct ctdb_interface *cur = NULL;
struct ctdb_interface *best = NULL;
- for (i=0; vnn->ifaces[i]; i++) {
+ for (i = vnn->ifaces; i != NULL; i = i->next) {
- cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
- if (cur == NULL) {
- continue;
- }
+ cur = i->iface;
if (!cur->link_up) {
continue;
static bool ctdb_vnn_available(struct ctdb_context *ctdb,
struct ctdb_vnn *vnn)
{
- int i;
+ uint32_t flags;
+ struct vnn_interface *i;
/* Nodes that are not RUNNING can not host IPs */
if (ctdb->runstate != CTDB_RUNSTATE_RUNNING) {
return false;
}
+ flags = ctdb->nodes[ctdb->pnn]->flags;
+ if ((flags & (NODE_FLAGS_INACTIVE|NODE_FLAGS_DISABLED)) != 0) {
+ return false;
+ }
+
if (vnn->delete_pending) {
return false;
}
return true;
}
- for (i=0; vnn->ifaces[i]; i++) {
- struct ctdb_interface *cur;
-
- cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
- if (cur == NULL) {
- continue;
- }
-
- if (cur->link_up) {
+ for (i = vnn->ifaces; i != NULL; i = i->next) {
+ if (i->iface->link_up) {
return true;
}
}
return 0;
}
-struct takeover_callback_state {
- struct ctdb_req_control_old *c;
- ctdb_sock_addr *addr;
- struct ctdb_vnn *vnn;
-};
-
struct ctdb_do_takeip_state {
struct ctdb_req_control_old *c;
struct ctdb_vnn *vnn;
TDB_DATA data;
if (status != 0) {
- struct ctdb_node *node = ctdb->nodes[ctdb->pnn];
-
- if (status == -ETIME) {
+ if (status == -ETIMEDOUT) {
ctdb_ban_self(ctdb);
}
DEBUG(DEBUG_ERR,(__location__ " Failed to takeover IP %s on interface %s\n",
ctdb_vnn_iface_string(state->vnn)));
ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
- node->flags |= NODE_FLAGS_UNHEALTHY;
talloc_free(state);
return;
}
state = talloc(vnn, struct ctdb_do_takeip_state);
CTDB_NO_MEMORY(ctdb, state);
- state->c = talloc_steal(ctdb, c);
+ state->c = NULL;
state->vnn = vnn;
vnn->update_in_flight = true;
return -1;
}
+ state->c = talloc_steal(ctdb, c);
return 0;
}
{
struct ctdb_do_updateip_state *state =
talloc_get_type(private_data, struct ctdb_do_updateip_state);
- int32_t ret;
if (status != 0) {
- if (status == -ETIME) {
+ if (status == -ETIMEDOUT) {
ctdb_ban_self(ctdb);
}
- DEBUG(DEBUG_ERR,(__location__ " Failed to move IP %s from interface %s to %s\n",
- ctdb_addr_to_str(&state->vnn->public_address),
- state->old->name,
- ctdb_vnn_iface_string(state->vnn)));
+ DEBUG(DEBUG_ERR,
+ ("Failed update of IP %s from interface %s to %s\n",
+ ctdb_addr_to_str(&state->vnn->public_address),
+ iface_string(state->old),
+ ctdb_vnn_iface_string(state->vnn)));
/*
* All we can do is reset the old interface
return;
}
- if (ctdb->do_checkpublicip) {
-
- ret = ctdb_announce_vnn_iface(ctdb, state->vnn);
- if (ret != 0) {
- ctdb_request_control_reply(ctdb, state->c, NULL, -1, NULL);
- talloc_free(state);
- return;
- }
-
- }
-
/* the control succeeded */
ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
talloc_free(state);
int ret;
struct ctdb_do_updateip_state *state;
struct ctdb_interface *old = vnn->iface;
+ const char *old_name = iface_string(old);
const char *new_name;
if (vnn->update_in_flight) {
ctdb_vnn_unassign_iface(ctdb, vnn);
ret = ctdb_vnn_assign_iface(ctdb, vnn);
if (ret != 0) {
- DEBUG(DEBUG_ERR,("update of IP %s/%u failed to "
- "assin a usable interface (old iface '%s')\n",
+ DEBUG(DEBUG_ERR,("Update of IP %s/%u failed to "
+ "assign a usable interface (old iface '%s')\n",
ctdb_addr_to_str(&vnn->public_address),
vnn->public_netmask_bits,
- old->name));
+ old_name));
return -1;
}
- new_name = ctdb_vnn_iface_string(vnn);
- if (old->name != NULL && new_name != NULL && !strcmp(old->name, new_name)) {
+ if (old == vnn->iface) {
/* A benign update from one interface onto itself.
* no need to run the eventscripts in this case, just return
* success.
state = talloc(vnn, struct ctdb_do_updateip_state);
CTDB_NO_MEMORY(ctdb, state);
- state->c = talloc_steal(ctdb, c);
+ state->c = NULL;
state->old = old;
state->vnn = vnn;
vnn->update_in_flight = true;
talloc_set_destructor(state, ctdb_updateip_destructor);
+ new_name = ctdb_vnn_iface_string(vnn);
DEBUG(DEBUG_NOTICE,("Update of IP %s/%u from "
"interface %s to %s\n",
ctdb_addr_to_str(&vnn->public_address),
vnn->public_netmask_bits,
- old->name,
+ old_name,
new_name));
ret = ctdb_event_script_callback(ctdb,
state,
CTDB_EVENT_UPDATE_IP,
"%s %s %s %u",
- state->old->name,
+ old_name,
new_name,
ctdb_addr_to_str(&vnn->public_address),
vnn->public_netmask_bits);
if (ret != 0) {
- DEBUG(DEBUG_ERR,(__location__ " Failed update IP %s from interface %s to %s\n",
- ctdb_addr_to_str(&vnn->public_address),
- old->name, new_name));
+ DEBUG(DEBUG_ERR,
+ ("Failed update IP %s from interface %s to %s\n",
+ ctdb_addr_to_str(&vnn->public_address),
+ old_name, new_name));
talloc_free(state);
return -1;
}
+ state->c = talloc_steal(ctdb, c);
return 0;
}
return -1;
}
- if (vnn->iface == NULL && vnn->pnn == -1 && have_ip && best_iface != NULL) {
- DEBUG(DEBUG_ERR,("Taking over newly created ip\n"));
- have_ip = false;
- }
-
-
- if (vnn->iface == NULL && have_ip) {
- DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
- "but we have no interface assigned, has someone manually configured it? Ignore for now.\n",
- ctdb_addr_to_str(&vnn->public_address)));
- return 0;
- }
-
if (vnn->pnn != ctdb->pnn && have_ip && vnn->pnn != -1) {
DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
"and we have it on iface[%s], but it was assigned to node %d"
}
if (vnn->pnn == -1 && have_ip) {
- vnn->pnn = ctdb->pnn;
- DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
- "and we already have it on iface[%s], update local daemon\n",
- ctdb_addr_to_str(&vnn->public_address),
- ctdb_vnn_iface_string(vnn)));
- return 0;
+ /* This will cause connections to be reset and
+ * reestablished. However, this is a very unusual
+ * situation and doing this will completely repair the
+ * inconsistency in the VNN.
+ */
+ DEBUG(DEBUG_WARNING,
+ (__location__
+ " Doing updateip for IP %s already on an interface\n",
+ ctdb_addr_to_str(&vnn->public_address)));
+ do_updateip = true;
}
if (vnn->iface) {
return 0;
}
-/*
- kill any clients that are registered with a IP that is being released
- */
-static void release_kill_clients(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
-{
- struct ctdb_client_ip *ip;
-
- DEBUG(DEBUG_INFO,("release_kill_clients for ip %s\n",
- ctdb_addr_to_str(addr)));
-
- for (ip=ctdb->client_ip_list; ip; ip=ip->next) {
- ctdb_sock_addr tmp_addr;
-
- tmp_addr = ip->addr;
- DEBUG(DEBUG_INFO,("checking for client %u with IP %s\n",
- ip->client_id,
- ctdb_addr_to_str(&ip->addr)));
-
- if (ctdb_same_ip(&tmp_addr, addr)) {
- 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),
- client->pid));
-
- if (client->pid != 0) {
- DEBUG(DEBUG_INFO,(__location__ " Killing client pid %u for IP %s on client_id %u\n",
- (unsigned)client->pid,
- ctdb_addr_to_str(addr),
- ip->client_id));
- kill(client->pid, SIGKILL);
- }
- }
- }
-}
-
static void do_delete_ip(struct ctdb_context *ctdb, struct ctdb_vnn *vnn)
{
DLIST_REMOVE(ctdb->vnn, vnn);
talloc_free(vnn);
}
+static struct ctdb_vnn *release_ip_post(struct ctdb_context *ctdb,
+ struct ctdb_vnn *vnn,
+ ctdb_sock_addr *addr)
+{
+ TDB_DATA data;
+
+ /* Send a message to all clients of this node telling them
+ * that the cluster has been reconfigured and they should
+ * close any connections on this IP address
+ */
+ data.dptr = (uint8_t *)ctdb_addr_to_str(addr);
+ data.dsize = strlen((char *)data.dptr)+1;
+ DEBUG(DEBUG_INFO, ("Sending RELEASE_IP message for %s\n", data.dptr));
+ ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_RELEASE_IP, data);
+
+ ctdb_vnn_unassign_iface(ctdb, vnn);
+
+ /* Process the IP if it has been marked for deletion */
+ if (vnn->delete_pending) {
+ do_delete_ip(ctdb, vnn);
+ return NULL;
+ }
+
+ return vnn;
+}
+
+struct release_ip_callback_state {
+ struct ctdb_req_control_old *c;
+ ctdb_sock_addr *addr;
+ struct ctdb_vnn *vnn;
+ uint32_t target_pnn;
+};
+
/*
called when releaseip event finishes
*/
-static void release_ip_callback(struct ctdb_context *ctdb, int status,
+static void release_ip_callback(struct ctdb_context *ctdb, int status,
void *private_data)
{
- struct takeover_callback_state *state =
- talloc_get_type(private_data, struct takeover_callback_state);
- TDB_DATA data;
+ struct release_ip_callback_state *state =
+ talloc_get_type(private_data, struct release_ip_callback_state);
- if (status == -ETIME) {
+ if (status == -ETIMEDOUT) {
ctdb_ban_self(ctdb);
}
}
}
- /* send a message to all clients of this node telling them
- that the cluster has been reconfigured and they should
- release any sockets on this IP */
- data.dptr = (uint8_t *)talloc_strdup(state, ctdb_addr_to_str(state->addr));
- CTDB_NO_MEMORY_VOID(ctdb, data.dptr);
- data.dsize = strlen((char *)data.dptr)+1;
-
- DEBUG(DEBUG_INFO,(__location__ " sending RELEASE_IP for '%s'\n", data.dptr));
-
- ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_RELEASE_IP, data);
-
- /* kill clients that have registered with this IP */
- release_kill_clients(ctdb, state->addr);
-
- ctdb_vnn_unassign_iface(ctdb, state->vnn);
-
- /* Process the IP if it has been marked for deletion */
- if (state->vnn->delete_pending) {
- do_delete_ip(ctdb, state->vnn);
- state->vnn = NULL;
- }
+ state->vnn->pnn = state->target_pnn;
+ state->vnn = release_ip_post(ctdb, state->vnn, state->addr);
/* the control succeeded */
ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
talloc_free(state);
}
-static int ctdb_releaseip_destructor(struct takeover_callback_state *state)
+static int ctdb_releaseip_destructor(struct release_ip_callback_state *state)
{
if (state->vnn != NULL) {
state->vnn->update_in_flight = false;
bool *async_reply)
{
int ret;
- struct takeover_callback_state *state;
+ struct release_ip_callback_state *state;
struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
struct ctdb_vnn *vnn;
- char *iface;
+ const char *iface;
/* update our vnn list */
vnn = find_public_ip_vnn(ctdb, &pip->addr);
ctdb_addr_to_str(&pip->addr)));
return 0;
}
- vnn->pnn = pip->pnn;
/* stop any previous arps */
talloc_free(vnn->takeover_ctx);
vnn->takeover_ctx = NULL;
- /* Some ctdb tool commands (e.g. moveip, rebalanceip) send
- * lazy multicast to drop an IP from any node that isn't the
- * intended new node. The following causes makes ctdbd ignore
- * a release for any address it doesn't host.
+ /* RELEASE_IP controls are sent to all nodes that should not
+ * be hosting a particular IP. This serves 2 purposes. The
+ * first is to help resolve any inconsistencies. If a node
+ * does unexpectly host an IP then it will be released. The
+ * 2nd is to use a "redundant release" to tell non-takeover
+ * nodes where an IP is moving to. This is how "ctdb ip" can
+ * report the (likely) location of an IP by only asking the
+ * local node. Redundant releases need to update the PNN but
+ * are otherwise ignored.
*/
if (ctdb->tunable.disable_ip_failover == 0 && ctdb->do_checkpublicip) {
if (!ctdb_sys_have_ip(&pip->addr)) {
ctdb_addr_to_str(&pip->addr),
vnn->public_netmask_bits,
ctdb_vnn_iface_string(vnn)));
+ vnn->pnn = pip->pnn;
ctdb_vnn_unassign_iface(ctdb, vnn);
return 0;
}
DEBUG(DEBUG_DEBUG,("Redundant release of IP %s/%u (ip not held)\n",
ctdb_addr_to_str(&pip->addr),
vnn->public_netmask_bits));
+ vnn->pnn = pip->pnn;
return 0;
}
}
return -1;
}
- iface = strdup(ctdb_vnn_iface_string(vnn));
+ iface = 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),
iface,
pip->pnn));
- state = talloc(ctdb, struct takeover_callback_state);
+ state = talloc(ctdb, struct release_ip_callback_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);
+ state->c = NULL;
+ state->addr = talloc(state, ctdb_sock_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->target_pnn = pip->pnn;
state->vnn = vnn;
vnn->update_in_flight = true;
iface,
ctdb_addr_to_str(&pip->addr),
vnn->public_netmask_bits);
- free(iface);
if (ret != 0) {
DEBUG(DEBUG_ERR,(__location__ " Failed to release IP %s on interface %s\n",
ctdb_addr_to_str(&pip->addr),
/* tell the control that we will be reply asynchronously */
*async_reply = true;
+ state->c = talloc_steal(state, c);
return 0;
}
bool check_address)
{
struct ctdb_vnn *vnn;
- uint32_t num = 0;
char *tmp;
const char *iface;
- int i;
- int ret;
-
- tmp = strdup(ifaces);
- for (iface = strtok(tmp, ","); iface; iface = strtok(NULL, ",")) {
- if (!ctdb_sys_check_iface_exists(iface)) {
- DEBUG(DEBUG_CRIT,("Interface %s does not exist. Can not add public-address : %s\n", iface, ctdb_addr_to_str(addr)));
- free(tmp);
- return -1;
- }
- }
- free(tmp);
- /* Verify that we don't have an entry for this ip yet */
- for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
+ /* Verify that we don't have an entry for this IP yet */
+ for (vnn = ctdb->vnn; vnn != NULL; vnn = vnn->next) {
if (ctdb_same_sockaddr(addr, &vnn->public_address)) {
- DEBUG(DEBUG_CRIT,("Same ip '%s' specified multiple times in the public address list \n",
- ctdb_addr_to_str(addr)));
+ DEBUG(DEBUG_ERR,
+ ("Duplicate public IP address '%s'\n",
+ ctdb_addr_to_str(addr)));
return -1;
- }
+ }
}
- /* create a new vnn structure for this ip address */
+ /* Create a new VNN structure for this IP address */
vnn = talloc_zero(ctdb, struct ctdb_vnn);
- CTDB_NO_MEMORY_FATAL(ctdb, vnn);
- vnn->ifaces = talloc_array(vnn, const char *, num + 2);
+ if (vnn == NULL) {
+ DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+ return -1;
+ }
tmp = talloc_strdup(vnn, ifaces);
- CTDB_NO_MEMORY_FATAL(ctdb, tmp);
- for (iface = strtok(tmp, ","); iface; iface = strtok(NULL, ",")) {
- vnn->ifaces = talloc_realloc(vnn, vnn->ifaces, const char *, num + 2);
- CTDB_NO_MEMORY_FATAL(ctdb, vnn->ifaces);
- vnn->ifaces[num] = talloc_strdup(vnn, iface);
- CTDB_NO_MEMORY_FATAL(ctdb, vnn->ifaces[num]);
- num++;
+ if (tmp == NULL) {
+ DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+ talloc_free(vnn);
+ return -1;
}
- talloc_free(tmp);
- vnn->ifaces[num] = NULL;
- vnn->public_address = *addr;
- vnn->public_netmask_bits = mask;
- vnn->pnn = -1;
- if (check_address) {
- if (ctdb_sys_have_ip(addr)) {
- DEBUG(DEBUG_ERR,("We are already hosting public address '%s'. setting PNN to ourself:%d\n", ctdb_addr_to_str(addr), ctdb->pnn));
- vnn->pnn = ctdb->pnn;
+ for (iface = strtok(tmp, ","); iface; iface = strtok(NULL, ",")) {
+ struct vnn_interface *vnn_iface;
+ struct ctdb_interface *i;
+ if (!ctdb_sys_check_iface_exists(iface)) {
+ DEBUG(DEBUG_ERR,
+ ("Unknown interface %s for public address %s\n",
+ iface, ctdb_addr_to_str(addr)));
+ talloc_free(vnn);
+ return -1;
}
- }
- for (i=0; vnn->ifaces[i]; i++) {
- ret = ctdb_add_local_iface(ctdb, vnn->ifaces[i]);
- if (ret != 0) {
- DEBUG(DEBUG_CRIT, (__location__ " failed to add iface[%s] "
- "for public_address[%s]\n",
- vnn->ifaces[i], ctdb_addr_to_str(addr)));
+ i = ctdb_add_local_iface(ctdb, iface);
+ if (i == NULL) {
+ DEBUG(DEBUG_ERR,
+ ("Failed to add interface '%s' "
+ "for public address %s\n",
+ iface, ctdb_addr_to_str(addr)));
+ talloc_free(vnn);
+ return -1;
+ }
+
+ vnn_iface = talloc_zero(vnn, struct vnn_interface);
+ if (vnn_iface == NULL) {
+ DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
talloc_free(vnn);
return -1;
}
+
+ vnn_iface->iface = i;
+ DLIST_ADD_END(vnn->ifaces, vnn_iface);
}
+ talloc_free(tmp);
+ vnn->public_address = *addr;
+ vnn->public_netmask_bits = mask;
+ vnn->pnn = -1;
DLIST_ADD(ctdb->vnn, vnn);
*/
int ctdb_set_public_addresses(struct ctdb_context *ctdb, bool check_addresses)
{
+ bool ok;
char **lines;
int nlines;
int i;
+ /* If no public addresses file given then try the default */
+ if (ctdb->public_addresses_file == NULL) {
+ const char *b = getenv("CTDB_BASE");
+ if (b == NULL) {
+ DBG_ERR("CTDB_BASE not set\n");
+ return -1;
+ }
+ ctdb->public_addresses_file = talloc_asprintf(
+ ctdb, "%s/%s", b, "public_addresses");
+ if (ctdb->public_addresses_file == NULL) {
+ DBG_ERR("Out of memory\n");
+ return -1;
+ }
+ }
+
+ /* If the file doesn't exist then warn and do nothing */
+ ok = file_exist(ctdb->public_addresses_file);
+ if (!ok) {
+ D_WARNING("Not loading public addresses, no file %s\n",
+ ctdb->public_addresses_file);
+ return 0;
+ }
+
lines = file_lines_load(ctdb->public_addresses_file, &nlines, 0, ctdb);
if (lines == NULL) {
ctdb_set_error(ctdb, "Failed to load public address list '%s'\n", ctdb->public_addresses_file);
const char *addrstr;
const char *ifaces;
char *tok, *line;
+ int ret;
line = lines[i];
while ((*line == ' ') || (*line == '\t')) {
}
tok = strtok(line, " \t");
addrstr = tok;
+
tok = strtok(NULL, " \t");
if (tok == NULL) {
- if (NULL == ctdb->default_public_interface) {
- DEBUG(DEBUG_CRIT,("No default public interface and no interface specified at line %u of public address list\n",
- i+1));
- talloc_free(lines);
- return -1;
- }
- ifaces = ctdb->default_public_interface;
- } else {
- ifaces = tok;
+ D_ERR("No interface specified at line %u "
+ "of public addresses file\n", i+1);
+ talloc_free(lines);
+ return -1;
+ }
+ ifaces = tok;
+
+ if (addrstr == NULL) {
+ D_ERR("Badly formed line %u in public address list\n",
+ i+1);
+ talloc_free(lines);
+ return -1;
}
- if (!addrstr || !parse_ip_mask(addrstr, ifaces, &addr, &mask)) {
- DEBUG(DEBUG_CRIT,("Badly formed line %u in public address list\n", i+1));
+ ret = ctdb_sock_addr_mask_from_string(addrstr, &addr, &mask);
+ if (ret != 0) {
+ D_ERR("Badly formed line %u in public address list\n",
+ i+1);
talloc_free(lines);
return -1;
}
+
if (ctdb_add_public_address(ctdb, &addr, mask, ifaces, check_addresses)) {
DEBUG(DEBUG_CRIT,("Failed to add line %u to the public address list\n", i+1));
talloc_free(lines);
}
+ D_NOTICE("Loaded public addresses from %s\n",
+ ctdb->public_addresses_file);
+
talloc_free(lines);
return 0;
}
-int ctdb_set_single_public_ip(struct ctdb_context *ctdb,
- const char *iface,
- const char *ip)
+/*
+ destroy a ctdb_client_ip structure
+ */
+static int ctdb_client_ip_destructor(struct ctdb_client_ip *ip)
{
- struct ctdb_vnn *svnn;
- struct ctdb_interface *cur = NULL;
- bool ok;
- int ret;
-
- svnn = talloc_zero(ctdb, struct ctdb_vnn);
- CTDB_NO_MEMORY(ctdb, svnn);
-
- svnn->ifaces = talloc_array(svnn, const char *, 2);
- CTDB_NO_MEMORY(ctdb, svnn->ifaces);
- svnn->ifaces[0] = talloc_strdup(svnn->ifaces, iface);
- CTDB_NO_MEMORY(ctdb, svnn->ifaces[0]);
- svnn->ifaces[1] = NULL;
-
- ok = parse_ip(ip, iface, 0, &svnn->public_address);
- if (!ok) {
- talloc_free(svnn);
- return -1;
- }
-
- ret = ctdb_add_local_iface(ctdb, svnn->ifaces[0]);
- if (ret != 0) {
- DEBUG(DEBUG_CRIT, (__location__ " failed to add iface[%s] "
- "for single_ip[%s]\n",
- svnn->ifaces[0],
- ctdb_addr_to_str(&svnn->public_address)));
- talloc_free(svnn);
- return -1;
- }
-
- /* assume the single public ip interface is initially "good" */
- cur = ctdb_find_iface(ctdb, iface);
- if (cur == NULL) {
- DEBUG(DEBUG_CRIT,("Can not find public interface %s used by --single-public-ip", iface));
- return -1;
- }
- cur->link_up = true;
-
- ret = ctdb_vnn_assign_iface(ctdb, svnn);
- if (ret != 0) {
- talloc_free(svnn);
- return -1;
- }
+ DEBUG(DEBUG_DEBUG,("destroying client tcp for %s:%u (client_id %u)\n",
+ ctdb_addr_to_str(&ip->addr),
+ ntohs(ip->addr.ip.sin_port),
+ ip->client_id));
- ctdb->single_ip_vnn = svnn;
+ DLIST_REMOVE(ip->ctdb->client_ip_list, ip);
return 0;
}
-static void *add_ip_callback(void *parm, void *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
+ */
+int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
+ TDB_DATA indata)
{
- struct public_ip_list *this_ip = parm;
- struct public_ip_list *prev_ip = data;
+ struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
+ struct ctdb_connection *tcp_sock = NULL;
+ struct ctdb_tcp_list *tcp;
+ struct ctdb_connection t;
+ int ret;
+ TDB_DATA data;
+ struct ctdb_client_ip *ip;
+ struct ctdb_vnn *vnn;
+ ctdb_sock_addr addr;
- if (prev_ip == NULL) {
- return parm;
- }
- if (this_ip->pnn == -1) {
- this_ip->pnn = prev_ip->pnn;
+ /* If we don't have public IPs, tickles are useless */
+ if (ctdb->vnn == NULL) {
+ return 0;
}
- return parm;
-}
-
-static int getips_count_callback(void *param, void *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;
-}
+ tcp_sock = (struct ctdb_connection *)indata.dptr;
-static int verify_remote_ip_allocation(struct ctdb_context *ctdb,
- struct ctdb_public_ip_list_old *ips,
- uint32_t pnn);
-
-static int ctdb_reload_remote_public_ips(struct ctdb_context *ctdb,
- struct ipalloc_state *ipalloc_state,
- struct ctdb_node_map_old *nodemap)
-{
- int j;
- int ret;
-
- if (ipalloc_state->num != nodemap->num) {
- DEBUG(DEBUG_ERR,
- (__location__
- " ipalloc_state->num (%d) != nodemap->num (%d) invalid param\n",
- ipalloc_state->num, nodemap->num));
- return -1;
- }
-
- for (j=0; j<nodemap->num; j++) {
- if (nodemap->nodes[j].flags & NODE_FLAGS_INACTIVE) {
- continue;
- }
-
- /* Retrieve the list of known public IPs from the node */
- ret = ctdb_ctrl_get_public_ips_flags(ctdb,
- TAKEOVER_TIMEOUT(),
- j,
- ipalloc_state->known_public_ips,
- 0,
- &ipalloc_state->known_public_ips[j]);
- if (ret != 0) {
- DEBUG(DEBUG_ERR,
- ("Failed to read known public IPs from node: %u\n",
- j));
- return -1;
- }
-
- if (ctdb->do_checkpublicip) {
- verify_remote_ip_allocation(ctdb,
- ipalloc_state->known_public_ips[j],
- j);
- }
-
- /* Retrieve the list of available public IPs from the node */
- ret = ctdb_ctrl_get_public_ips_flags(ctdb,
- TAKEOVER_TIMEOUT(),
- j,
- ipalloc_state->available_public_ips,
- CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE,
- &ipalloc_state->available_public_ips[j]);
- if (ret != 0) {
- DEBUG(DEBUG_ERR,
- ("Failed to read available public IPs from node: %u\n",
- j));
- return -1;
- }
- }
-
- return 0;
-}
-
-static struct public_ip_list *
-create_merged_ip_list(struct ctdb_context *ctdb, struct ipalloc_state *ipalloc_state)
-{
- int i, j;
- struct public_ip_list *ip_list;
- struct ctdb_public_ip_list_old *public_ips;
-
- TALLOC_FREE(ctdb->ip_tree);
- ctdb->ip_tree = trbt_create(ctdb, 0);
-
- for (i=0; i < ctdb->num_nodes; i++) {
- public_ips = ipalloc_state->known_public_ips[i];
-
- if (ctdb->nodes[i]->flags & NODE_FLAGS_DELETED) {
- continue;
- }
-
- /* there were no public ips for this node */
- if (public_ips == NULL) {
- continue;
- }
-
- for (j=0; j < public_ips->num; j++) {
- struct public_ip_list *tmp_ip;
-
- 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 */
- if (public_ips->ips[j].pnn == ctdb->nodes[i]->pnn) {
- tmp_ip->pnn = public_ips->ips[j].pnn;
- } else {
- tmp_ip->pnn = -1;
- }
- tmp_ip->addr = public_ips->ips[j].addr;
- tmp_ip->next = NULL;
-
- trbt_insertarray32_callback(ctdb->ip_tree,
- IP_KEYLEN, ip_key(&public_ips->ips[j].addr),
- add_ip_callback,
- tmp_ip);
- }
- }
-
- ip_list = NULL;
- trbt_traversearray32(ctdb->ip_tree, IP_KEYLEN, getips_count_callback, &ip_list);
-
- return ip_list;
-}
-
-static bool all_nodes_are_disabled(struct ctdb_node_map_old *nodemap)
-{
- int i;
-
- for (i=0;i<nodemap->num;i++) {
- if (!(nodemap->nodes[i].flags & (NODE_FLAGS_INACTIVE|NODE_FLAGS_DISABLED))) {
- /* Found one completely healthy node */
- return false;
- }
- }
-
- return true;
-}
-
-struct get_tunable_callback_data {
- const char *tunable;
- uint32_t *out;
- bool fatal;
-};
-
-static void get_tunable_callback(struct ctdb_context *ctdb, uint32_t pnn,
- int32_t res, TDB_DATA outdata,
- void *callback)
-{
- struct get_tunable_callback_data *cd =
- (struct get_tunable_callback_data *)callback;
- int size;
-
- if (res != 0) {
- /* Already handled in fail callback */
- return;
- }
-
- if (outdata.dsize != sizeof(uint32_t)) {
- DEBUG(DEBUG_ERR,("Wrong size of returned data when reading \"%s\" tunable from node %d. Expected %d bytes but received %d bytes\n",
- cd->tunable, pnn, (int)sizeof(uint32_t),
- (int)outdata.dsize));
- cd->fatal = true;
- return;
- }
-
- size = talloc_array_length(cd->out);
- if (pnn >= size) {
- DEBUG(DEBUG_ERR,("Got %s reply from node %d but nodemap only has %d entries\n",
- cd->tunable, pnn, size));
- return;
- }
-
-
- cd->out[pnn] = *(uint32_t *)outdata.dptr;
-}
-
-static void get_tunable_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
- int32_t res, TDB_DATA outdata,
- void *callback)
-{
- struct get_tunable_callback_data *cd =
- (struct get_tunable_callback_data *)callback;
-
- switch (res) {
- case -ETIME:
- DEBUG(DEBUG_ERR,
- ("Timed out getting tunable \"%s\" from node %d\n",
- cd->tunable, pnn));
- cd->fatal = true;
- break;
- case -EINVAL:
- case -1:
- DEBUG(DEBUG_WARNING,
- ("Tunable \"%s\" not implemented on node %d\n",
- cd->tunable, pnn));
- break;
- default:
- DEBUG(DEBUG_ERR,
- ("Unexpected error getting tunable \"%s\" from node %d\n",
- cd->tunable, pnn));
- cd->fatal = true;
- }
-}
-
-static uint32_t *get_tunable_from_nodes(struct ctdb_context *ctdb,
- TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map_old *nodemap,
- const char *tunable,
- uint32_t default_value)
-{
- TDB_DATA data;
- struct ctdb_control_get_tunable *t;
- uint32_t *nodes;
- uint32_t *tvals;
- struct get_tunable_callback_data callback_data;
- int i;
-
- tvals = talloc_array(tmp_ctx, uint32_t, nodemap->num);
- CTDB_NO_MEMORY_NULL(ctdb, tvals);
- for (i=0; i<nodemap->num; i++) {
- tvals[i] = default_value;
- }
-
- callback_data.out = tvals;
- callback_data.tunable = tunable;
- callback_data.fatal = false;
-
- data.dsize = offsetof(struct ctdb_control_get_tunable, name) + strlen(tunable) + 1;
- data.dptr = talloc_size(tmp_ctx, data.dsize);
- t = (struct ctdb_control_get_tunable *)data.dptr;
- t->length = strlen(tunable)+1;
- memcpy(t->name, tunable, t->length);
- nodes = list_of_connected_nodes(ctdb, nodemap, tmp_ctx, true);
- if (ctdb_client_async_control(ctdb, CTDB_CONTROL_GET_TUNABLE,
- nodes, 0, TAKEOVER_TIMEOUT(),
- false, data,
- get_tunable_callback,
- get_tunable_fail_callback,
- &callback_data) != 0) {
- if (callback_data.fatal) {
- talloc_free(tvals);
- tvals = NULL;
- }
- }
- talloc_free(nodes);
- talloc_free(data.dptr);
-
- return tvals;
-}
-
-/* Set internal flags for IP allocation:
- * Clear ip flags
- * Set NOIPTAKOVER ip flags from per-node NoIPTakeover tunable
- * Set NOIPHOST ip flag for each INACTIVE node
- * if all nodes are disabled:
- * Set NOIPHOST ip flags from per-node NoIPHostOnAllDisabled tunable
- * else
- * Set NOIPHOST ip flags for disabled nodes
- */
-static void set_ipflags_internal(struct ipalloc_state *ipalloc_state,
- struct ctdb_node_map_old *nodemap,
- uint32_t *tval_noiptakeover,
- uint32_t *tval_noiphostonalldisabled)
-{
- int i;
-
- for (i=0;i<nodemap->num;i++) {
- /* Can not take IPs on node with NoIPTakeover set */
- if (tval_noiptakeover[i] != 0) {
- ipalloc_state->noiptakeover[i] = true;
- }
-
- /* Can not host IPs on INACTIVE node */
- if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
- ipalloc_state->noiphost[i] = true;
- }
- }
-
- if (all_nodes_are_disabled(nodemap)) {
- /* If all nodes are disabled, can not host IPs on node
- * with NoIPHostOnAllDisabled set
- */
- for (i=0;i<nodemap->num;i++) {
- if (tval_noiphostonalldisabled[i] != 0) {
- ipalloc_state->noiphost[i] = true;
- }
- }
- } else {
- /* If some nodes are not disabled, then can not host
- * IPs on DISABLED node
- */
- for (i=0;i<nodemap->num;i++) {
- if (nodemap->nodes[i].flags & NODE_FLAGS_DISABLED) {
- ipalloc_state->noiphost[i] = true;
- }
- }
- }
-}
-
-static bool set_ipflags(struct ctdb_context *ctdb,
- struct ipalloc_state *ipalloc_state,
- struct ctdb_node_map_old *nodemap)
-{
- uint32_t *tval_noiptakeover;
- uint32_t *tval_noiphostonalldisabled;
-
- tval_noiptakeover = get_tunable_from_nodes(ctdb, ipalloc_state, nodemap,
- "NoIPTakeover", 0);
- if (tval_noiptakeover == NULL) {
- return false;
- }
-
- tval_noiphostonalldisabled =
- get_tunable_from_nodes(ctdb, ipalloc_state, nodemap,
- "NoIPHostOnAllDisabled", 0);
- if (tval_noiphostonalldisabled == NULL) {
- /* Caller frees tmp_ctx */
- return false;
- }
-
- set_ipflags_internal(ipalloc_state, nodemap,
- tval_noiptakeover,
- tval_noiphostonalldisabled);
-
- talloc_free(tval_noiptakeover);
- talloc_free(tval_noiphostonalldisabled);
-
- return true;
-}
-
-static struct ipalloc_state * ipalloc_state_init(struct ctdb_context *ctdb,
- TALLOC_CTX *mem_ctx)
-{
- struct ipalloc_state *ipalloc_state =
- talloc_zero(mem_ctx, struct ipalloc_state);
- if (ipalloc_state == NULL) {
- DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
- return NULL;
- }
-
- ipalloc_state->num = ctdb->num_nodes;
- ipalloc_state->known_public_ips =
- talloc_zero_array(ipalloc_state,
- struct ctdb_public_ip_list_old *,
- ipalloc_state->num);
- if (ipalloc_state->known_public_ips == NULL) {
- DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
- goto fail;
- }
- ipalloc_state->available_public_ips =
- talloc_zero_array(ipalloc_state,
- struct ctdb_public_ip_list_old *,
- ipalloc_state->num);
- if (ipalloc_state->available_public_ips == NULL) {
- DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
- goto fail;
- }
- ipalloc_state->noiptakeover =
- talloc_zero_array(ipalloc_state,
- bool,
- ipalloc_state->num);
- if (ipalloc_state->noiptakeover == NULL) {
- DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
- goto fail;
- }
- ipalloc_state->noiphost =
- talloc_zero_array(ipalloc_state,
- bool,
- ipalloc_state->num);
- if (ipalloc_state->noiphost == NULL) {
- DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
- goto fail;
- }
-
- if (1 == ctdb->tunable.lcp2_public_ip_assignment) {
- ipalloc_state->algorithm = IPALLOC_LCP2;
- } else if (1 == ctdb->tunable.deterministic_public_ips) {
- ipalloc_state->algorithm = IPALLOC_DETERMINISTIC;
- } else {
- ipalloc_state->algorithm = IPALLOC_NONDETERMINISTIC;
- }
-
- ipalloc_state->no_ip_failback = ctdb->tunable.no_ip_failback;
-
- return ipalloc_state;
-fail:
- talloc_free(ipalloc_state);
- return NULL;
-}
-
-struct iprealloc_callback_data {
- bool *retry_nodes;
- int retry_count;
- client_async_callback fail_callback;
- void *fail_callback_data;
- struct ctdb_node_map_old *nodemap;
-};
-
-static void iprealloc_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
- int32_t res, TDB_DATA outdata,
- void *callback)
-{
- int numnodes;
- struct iprealloc_callback_data *cd =
- (struct iprealloc_callback_data *)callback;
-
- numnodes = talloc_array_length(cd->retry_nodes);
- if (pnn > numnodes) {
- DEBUG(DEBUG_ERR,
- ("ipreallocated failure from node %d, "
- "but only %d nodes in nodemap\n",
- pnn, numnodes));
- return;
- }
-
- /* Can't run the "ipreallocated" event on a INACTIVE node */
- if (cd->nodemap->nodes[pnn].flags & NODE_FLAGS_INACTIVE) {
- DEBUG(DEBUG_WARNING,
- ("ipreallocated failed on inactive node %d, ignoring\n",
- pnn));
- return;
- }
-
- switch (res) {
- case -ETIME:
- /* If the control timed out then that's a real error,
- * so call the real fail callback
- */
- if (cd->fail_callback) {
- cd->fail_callback(ctdb, pnn, res, outdata,
- cd->fail_callback_data);
- } else {
- DEBUG(DEBUG_WARNING,
- ("iprealloc timed out but no callback registered\n"));
- }
- break;
- default:
- /* If not a timeout then either the ipreallocated
- * eventscript (or some setup) failed. This might
- * have failed because the IPREALLOCATED control isn't
- * implemented - right now there is no way of knowing
- * because the error codes are all folded down to -1.
- * Consider retrying using EVENTSCRIPT control...
- */
- DEBUG(DEBUG_WARNING,
- ("ipreallocated failure from node %d, flagging retry\n",
- pnn));
- cd->retry_nodes[pnn] = true;
- cd->retry_count++;
- }
-}
-
-struct takeover_callback_data {
- bool *node_failed;
- client_async_callback fail_callback;
- void *fail_callback_data;
- struct ctdb_node_map_old *nodemap;
-};
-
-static void takeover_run_fail_callback(struct ctdb_context *ctdb,
- uint32_t node_pnn, int32_t res,
- TDB_DATA outdata, void *callback_data)
-{
- struct takeover_callback_data *cd =
- talloc_get_type_abort(callback_data,
- struct takeover_callback_data);
- int i;
-
- for (i = 0; i < cd->nodemap->num; i++) {
- if (node_pnn == cd->nodemap->nodes[i].pnn) {
- break;
- }
- }
-
- if (i == cd->nodemap->num) {
- DEBUG(DEBUG_ERR, (__location__ " invalid PNN %u\n", node_pnn));
- return;
- }
-
- if (!cd->node_failed[i]) {
- cd->node_failed[i] = true;
- cd->fail_callback(ctdb, node_pnn, res, outdata,
- cd->fail_callback_data);
- }
-}
-
-/*
- * Recalculate the allocation of public IPs to nodes and have the
- * nodes host their allocated addresses.
- *
- * - Allocate memory for IP allocation state, including per node
- * arrays
- * - Populate IP allocation algorithm in IP allocation state
- * - Populate local value of tunable NoIPFailback in IP allocation
- state - this is really a cluster-wide configuration variable and
- only the value form the master node is used
- * - Retrieve tunables NoIPTakeover and NoIPHostOnAllDisabled from all
- * connected nodes - this is done separately so tunable values can
- * be faked in unit testing
- * - Populate NoIPTakover tunable in IP allocation state
- * - Populate NoIPHost in IP allocation state, derived from node flags
- * and NoIPHostOnAllDisabled tunable
- * - Retrieve and populate known and available IP lists in IP
- * allocation state
- * - If no available IP addresses then early exit
- * - Build list of (known IPs, currently assigned node)
- * - Populate list of nodes to force rebalance - internal structure,
- * currently no way to fetch, only used by LCP2 for nodes that have
- * had new IP addresses added
- * - Run IP allocation algorithm
- * - Send RELEASE_IP to all nodes for IPs they should not host
- * - Send TAKE_IP to all nodes for IPs they should host
- * - Send IPREALLOCATED to all nodes (with backward compatibility hack)
- */
-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;
- uint32_t *nodes;
- struct public_ip_list *all_ips, *tmp_ip;
- TDB_DATA data;
- struct timeval timeout;
- struct client_async_data *async_data;
- struct ctdb_client_control_state *state;
- TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
- struct ipalloc_state *ipalloc_state;
- 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
- * ipreallocated event.
- */
- if (ctdb->tunable.disable_ip_failover != 0) {
- goto ipreallocated;
- }
-
- ipalloc_state = ipalloc_state_init(ctdb, tmp_ctx);
- if (ipalloc_state == NULL) {
- talloc_free(tmp_ctx);
- return -1;
- }
-
- if (!set_ipflags(ctdb, ipalloc_state, nodemap)) {
- DEBUG(DEBUG_ERR,("Failed to set IP flags - aborting takeover run\n"));
- talloc_free(tmp_ctx);
- return -1;
- }
-
- /* Fetch known/available public IPs from each active node */
- ret = ctdb_reload_remote_public_ips(ctdb, ipalloc_state, nodemap);
- if (ret != 0) {
- talloc_free(tmp_ctx);
- return -1;
- }
-
- /* Short-circuit IP allocation if no node has available IPs */
- can_host_ips = false;
- for (i=0; i < ipalloc_state->num; i++) {
- if (ipalloc_state->available_public_ips[i] != NULL) {
- can_host_ips = true;
- }
- }
- if (!can_host_ips) {
- DEBUG(DEBUG_WARNING,("No nodes available to host public IPs yet\n"));
- return 0;
- }
-
- /* since nodes only know about those public addresses that
- can be served by that particular node, no single node has
- a full list of all public addresses that exist in the cluster.
- Walk over all node structures and create a merged list of
- all public addresses that exist in the cluster.
-
- keep the tree of ips around as ctdb->ip_tree
- */
- all_ips = create_merged_ip_list(ctdb, ipalloc_state);
- ipalloc_state->all_ips = all_ips;
-
- ipalloc_state->force_rebalance_nodes = force_rebalance_nodes;
-
- /* Do the IP reassignment calculations */
- ipalloc(ipalloc_state);
-
- /* Now tell all nodes to release any public IPs should not
- * host. This will be a NOOP on nodes that don't currently
- * hold the given IP.
- */
- takeover_data = talloc_zero(tmp_ctx, struct takeover_callback_data);
- CTDB_NO_MEMORY_FATAL(ctdb, takeover_data);
-
- takeover_data->node_failed = talloc_zero_array(tmp_ctx,
- bool, nodemap->num);
- CTDB_NO_MEMORY_FATAL(ctdb, takeover_data->node_failed);
- takeover_data->fail_callback = fail_callback;
- takeover_data->fail_callback_data = callback_data;
- takeover_data->nodemap = nodemap;
-
- async_data = talloc_zero(tmp_ctx, struct client_async_data);
- CTDB_NO_MEMORY_FATAL(ctdb, async_data);
-
- async_data->fail_callback = takeover_run_fail_callback;
- async_data->callback_data = takeover_data;
-
- ZERO_STRUCT(ip); /* Avoid valgrind warnings for union */
-
- /* Send a RELEASE_IP to all nodes that should not be hosting
- * each IP. For each IP, all but one of these will be
- * redundant. However, the redundant ones are used to tell
- * nodes which node should be hosting the IP so that commands
- * like "ctdb ip" can display a particular nodes idea of who
- * is hosting what. */
- for (i=0;i<nodemap->num;i++) {
- /* don't talk to unconnected nodes, but do talk to banned nodes */
- if (nodemap->nodes[i].flags & NODE_FLAGS_DISCONNECTED) {
- continue;
- }
-
- for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
- if (tmp_ip->pnn == nodemap->nodes[i].pnn) {
- /* This node should be serving this
- vnn so don't tell it to release the ip
- */
- continue;
- }
- 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);
- }
- }
- if (ctdb_client_async_wait(ctdb, async_data) != 0) {
- DEBUG(DEBUG_ERR,(__location__ " Async control CTDB_CONTROL_RELEASE_IP failed\n"));
- talloc_free(tmp_ctx);
- return -1;
- }
- talloc_free(async_data);
-
-
- /* For each IP, send a TAKOVER_IP to the node that should be
- * hosting it. Many of these will often be redundant (since
- * the allocation won't have changed) but they can be useful
- * to recover from inconsistencies. */
- async_data = talloc_zero(tmp_ctx, struct client_async_data);
- CTDB_NO_MEMORY_FATAL(ctdb, async_data);
-
- async_data->fail_callback = fail_callback;
- async_data->callback_data = callback_data;
-
- for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
- if (tmp_ip->pnn == -1) {
- /* this IP won't be taken over */
- continue;
- }
-
- 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);
- 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) {
- DEBUG(DEBUG_ERR,(__location__ " Async control CTDB_CONTROL_TAKEOVER_IP failed\n"));
- talloc_free(tmp_ctx);
- return -1;
- }
-
-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 natgw.
- */
- retry_data = talloc_zero_array(tmp_ctx, bool, nodemap->num);
- CTDB_NO_MEMORY_FATAL(ctdb, retry_data);
- iprealloc_data.retry_nodes = retry_data;
- iprealloc_data.retry_count = 0;
- iprealloc_data.fail_callback = fail_callback;
- iprealloc_data.fail_callback_data = callback_data;
- iprealloc_data.nodemap = nodemap;
-
- nodes = list_of_connected_nodes(ctdb, nodemap, tmp_ctx, true);
- ret = ctdb_client_async_control(ctdb, CTDB_CONTROL_IPREALLOCATED,
- nodes, 0, TAKEOVER_TIMEOUT(),
- false, tdb_null,
- NULL, iprealloc_fail_callback,
- &iprealloc_data);
- if (ret != 0) {
- /* If the control failed then we should retry to any
- * nodes flagged by iprealloc_fail_callback using the
- * EVENTSCRIPT control. This is a best-effort at
- * backward compatiblity when running a mixed cluster
- * where some nodes have not yet been upgraded to
- * support the IPREALLOCATED control.
- */
- DEBUG(DEBUG_WARNING,
- ("Retry ipreallocated to some nodes using eventscript control\n"));
-
- nodes = talloc_array(tmp_ctx, uint32_t,
- iprealloc_data.retry_count);
- CTDB_NO_MEMORY_FATAL(ctdb, nodes);
-
- j = 0;
- for (i=0; i<nodemap->num; i++) {
- if (iprealloc_data.retry_nodes[i]) {
- nodes[j] = i;
- j++;
- }
- }
-
- data.dptr = discard_const("ipreallocated");
- data.dsize = strlen((char *)data.dptr) + 1;
- ret = ctdb_client_async_control(ctdb,
- CTDB_CONTROL_RUN_EVENTSCRIPTS,
- nodes, 0, TAKEOVER_TIMEOUT(),
- false, data,
- NULL, fail_callback,
- callback_data);
- if (ret != 0) {
- DEBUG(DEBUG_ERR, (__location__ " failed to send control to run eventscripts with \"ipreallocated\"\n"));
- }
- }
-
- talloc_free(tmp_ctx);
- return ret;
-}
-
-
-/*
- destroy a ctdb_client_ip structure
- */
-static int ctdb_client_ip_destructor(struct ctdb_client_ip *ip)
-{
- DEBUG(DEBUG_DEBUG,("destroying client tcp for %s:%u (client_id %u)\n",
- ctdb_addr_to_str(&ip->addr),
- ntohs(ip->addr.ip.sin_port),
- ip->client_id));
-
- DLIST_REMOVE(ip->ctdb->client_ip_list, ip);
- return 0;
-}
-
-/*
- 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
- */
-int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
- TDB_DATA indata)
-{
- struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
- struct ctdb_connection *tcp_sock = NULL;
- struct ctdb_tcp_list *tcp;
- struct ctdb_connection t;
- int ret;
- TDB_DATA data;
- struct ctdb_client_ip *ip;
- struct ctdb_vnn *vnn;
- ctdb_sock_addr addr;
-
- /* If we don't have public IPs, tickles are useless */
- if (ctdb->vnn == NULL) {
- return 0;
- }
-
- tcp_sock = (struct ctdb_connection *)indata.dptr;
-
- addr = tcp_sock->src;
- ctdb_canonicalize_ip(&addr, &tcp_sock->src);
- addr = tcp_sock->dst;
- ctdb_canonicalize_ip(&addr, &tcp_sock->dst);
+ addr = tcp_sock->src;
+ ctdb_canonicalize_ip(&addr, &tcp_sock->src);
+ addr = tcp_sock->dst;
+ ctdb_canonicalize_ip(&addr, &tcp_sock->dst);
ZERO_STRUCT(addr);
memcpy(&addr, &tcp_sock->dst, sizeof(addr));
and we don't need to do anything
*/
if (vnn->tcp_array == NULL) {
- DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
+ DEBUG(DEBUG_INFO,("Trying to remove tickle that doesn't exist (array is empty) %s:%u\n",
ctdb_addr_to_str(&conn->dst),
ntohs(conn->dst.ip.sin_port)));
return;
*/
tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
if (tcpp == NULL) {
- DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist %s:%u\n",
+ DEBUG(DEBUG_INFO,("Trying to remove tickle that doesn't exist %s:%u\n",
ctdb_addr_to_str(&conn->dst),
ntohs(conn->dst.ip.sin_port)));
return;
}
+static void ctdb_send_set_tcp_tickles_for_all(struct ctdb_context *ctdb,
+ bool force);
+
/*
Called when another daemon starts - causes all tickles for all
public addresses we are serving to be sent to the new node on the
- next check. This actually causes the next scheduled call to
- tdb_update_tcp_tickles() to update all nodes. This is simple and
+ next check. This actually causes the tickles to be sent to the
+ other node immediately. In case there is an error, the periodic
+ timer will send the updates on timer event. This is simple and
doesn't require careful error handling.
*/
int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t pnn)
{
- struct ctdb_vnn *vnn;
-
DEBUG(DEBUG_INFO, ("Received startup control from node %lu\n",
(unsigned long) pnn));
- for (vnn = ctdb->vnn; vnn != NULL; vnn = vnn->next) {
- vnn->tcp_update_needed = true;
- }
-
+ ctdb_send_set_tcp_tickles_for_all(ctdb, true);
return 0;
}
void ctdb_release_all_ips(struct ctdb_context *ctdb)
{
- struct ctdb_vnn *vnn;
+ struct ctdb_vnn *vnn, *next;
int count = 0;
if (ctdb->tunable.disable_ip_failover == 1) {
return;
}
- for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
+ for (vnn = ctdb->vnn; vnn != NULL; vnn = next) {
+ /* vnn can be freed below in release_ip_post() */
+ next = vnn->next;
+
if (!ctdb_sys_have_ip(&vnn->public_address)) {
ctdb_vnn_unassign_iface(ctdb, vnn);
continue;
}
- if (!vnn->iface) {
- continue;
- }
/* Don't allow multiple releases at once. Some code,
* particularly ctdb_tickle_sentenced_connections() is
if (vnn->update_in_flight) {
DEBUG(DEBUG_WARNING,
(__location__
- " Not releasing IP %s/%u on interface %s, an update is already in progess\n",
+ " Not releasing IP %s/%u on interface %s, an update is already in progress\n",
ctdb_addr_to_str(&vnn->public_address),
vnn->public_netmask_bits,
ctdb_vnn_iface_string(vnn)));
vnn->public_netmask_bits,
ctdb_vnn_iface_string(vnn)));
- ctdb_event_script_args(ctdb, CTDB_EVENT_RELEASE_IP, "%s %s %u",
- ctdb_vnn_iface_string(vnn),
- ctdb_addr_to_str(&vnn->public_address),
- vnn->public_netmask_bits);
- release_kill_clients(ctdb, &vnn->public_address);
- ctdb_vnn_unassign_iface(ctdb, vnn);
- vnn->update_in_flight = false;
+ ctdb_event_script_args(ctdb, CTDB_EVENT_RELEASE_IP, "%s %s %u",
+ ctdb_vnn_iface_string(vnn),
+ ctdb_addr_to_str(&vnn->public_address),
+ vnn->public_netmask_bits);
+ /* releaseip timeouts are converted to success, so to
+ * detect failures just check if the IP address is
+ * still there...
+ */
+ if (ctdb_sys_have_ip(&vnn->public_address)) {
+ DEBUG(DEBUG_ERR,
+ (__location__
+ " IP address %s not released\n",
+ ctdb_addr_to_str(&vnn->public_address)));
+ vnn->update_in_flight = false;
+ continue;
+ }
+
+ vnn = release_ip_post(ctdb, vnn, &vnn->public_address);
+ if (vnn != NULL) {
+ vnn->update_in_flight = false;
+ }
count++;
}
ctdb_sock_addr *addr;
struct ctdb_public_ip_info_old *info;
struct ctdb_vnn *vnn;
+ struct vnn_interface *iface;
addr = (ctdb_sock_addr *)indata.dptr;
vnn = find_public_ip_vnn(ctdb, addr);
- if (vnn == NULL) {
- /* if it is not a public ip it could be our 'single ip' */
- if (ctdb->single_ip_vnn) {
- if (ctdb_same_ip(&ctdb->single_ip_vnn->public_address, addr)) {
- vnn = ctdb->single_ip_vnn;
- }
- }
- }
if (vnn == NULL) {
DEBUG(DEBUG_ERR,(__location__ " Could not get public ip info, "
"'%s'not a public address\n",
/* count how many public ip structures we have */
num = 0;
- for (;vnn->ifaces[num];) {
+ for (iface = vnn->ifaces; iface != NULL; iface = iface->next) {
num++;
}
info->ip.pnn = vnn->pnn;
info->active_idx = 0xFFFFFFFF;
- for (i=0; vnn->ifaces[i]; i++) {
+ i = 0;
+ for (iface = vnn->ifaces; iface != NULL; iface = iface->next) {
struct ctdb_interface *cur;
- cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
- if (cur == NULL) {
- DEBUG(DEBUG_CRIT, (__location__ " internal error iface[%s] unknown\n",
- vnn->ifaces[i]));
- return -1;
- }
+ cur = iface->iface;
if (vnn->iface == cur) {
info->active_idx = i;
}
- strncpy(info->ifaces[i].name, cur->name, sizeof(info->ifaces[i].name)-1);
+ strncpy(info->ifaces[i].name, cur->name,
+ sizeof(info->ifaces[i].name));
+ info->ifaces[i].name[sizeof(info->ifaces[i].name)-1] = '\0';
info->ifaces[i].link_state = cur->link_up;
info->ifaces[i].references = cur->references;
+
+ i++;
}
info->num = i;
len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
i = 0;
for (cur=ctdb->ifaces;cur;cur=cur->next) {
- strcpy(ifaces->ifaces[i].name, cur->name);
+ strncpy(ifaces->ifaces[i].name, cur->name,
+ sizeof(ifaces->ifaces[i].name));
+ ifaces->ifaces[i].name[sizeof(ifaces->ifaces[i].name)-1] = '\0';
ifaces->ifaces[i].link_state = cur->link_up;
ifaces->ifaces[i].references = cur->references;
i++;
return 0;
}
- DEBUG(iface->link_up?DEBUG_ERR:DEBUG_NOTICE,
+ DEBUG(DEBUG_ERR,
("iface[%s] has changed it's link status %s => %s\n",
iface->name,
iface->link_up?"up":"down",
}
-/*
- structure containing the listening socket and the list of tcp connections
- that the ctdb daemon is to kill
-*/
-struct ctdb_kill_tcp {
- struct ctdb_vnn *vnn;
- struct ctdb_context *ctdb;
- int capture_fd;
- struct tevent_fd *fde;
- trbt_tree_t *connections;
- void *private_data;
-};
-
-/*
- a tcp connection that is to be killed
- */
-struct ctdb_killtcp_con {
- ctdb_sock_addr src_addr;
- ctdb_sock_addr dst_addr;
- int count;
- struct ctdb_kill_tcp *killtcp;
-};
-
-/* this function is used to create a key to represent this socketpair
- in the killtcp tree.
- this key is used to insert and lookup matching socketpairs that are
- to be tickled and RST
-*/
-#define KILLTCP_KEYLEN 10
-static uint32_t *killtcp_key(ctdb_sock_addr *src, ctdb_sock_addr *dst)
-{
- static uint32_t key[KILLTCP_KEYLEN];
-
- bzero(key, sizeof(key));
-
- if (src->sa.sa_family != dst->sa.sa_family) {
- DEBUG(DEBUG_ERR, (__location__ " ERROR, different families passed :%u vs %u\n", src->sa.sa_family, dst->sa.sa_family));
- return key;
- }
-
- switch (src->sa.sa_family) {
- case AF_INET:
- key[0] = dst->ip.sin_addr.s_addr;
- key[1] = src->ip.sin_addr.s_addr;
- key[2] = dst->ip.sin_port;
- key[3] = src->ip.sin_port;
- break;
- case AF_INET6: {
- uint32_t *dst6_addr32 =
- (uint32_t *)&(dst->ip6.sin6_addr.s6_addr);
- uint32_t *src6_addr32 =
- (uint32_t *)&(src->ip6.sin6_addr.s6_addr);
- key[0] = dst6_addr32[3];
- key[1] = src6_addr32[3];
- key[2] = dst6_addr32[2];
- key[3] = src6_addr32[2];
- key[4] = dst6_addr32[1];
- key[5] = src6_addr32[1];
- key[6] = dst6_addr32[0];
- key[7] = src6_addr32[0];
- key[8] = dst->ip6.sin6_port;
- key[9] = src->ip6.sin6_port;
- break;
- }
- default:
- DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", src->sa.sa_family));
- return key;
- }
-
- return key;
-}
-
-/*
- called when we get a read event on the raw socket
- */
-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);
- struct ctdb_killtcp_con *con;
- ctdb_sock_addr src, dst;
- uint32_t ack_seq, seq;
-
- if (!(flags & TEVENT_FD_READ)) {
- return;
- }
-
- if (ctdb_sys_read_tcp_packet(killtcp->capture_fd,
- killtcp->private_data,
- &src, &dst,
- &ack_seq, &seq) != 0) {
- /* probably a non-tcp ACK packet */
- return;
- }
-
- /* check if we have this guy in our list of connections
- to kill
- */
- con = trbt_lookuparray32(killtcp->connections,
- KILLTCP_KEYLEN, killtcp_key(&src, &dst));
- if (con == NULL) {
- /* no this was some other packet we can just ignore */
- return;
- }
-
- /* This one has been tickled !
- now reset him and remove him from the list.
- */
- DEBUG(DEBUG_INFO, ("sending a tcp reset to kill connection :%d -> %s:%d\n",
- ntohs(con->dst_addr.ip.sin_port),
- ctdb_addr_to_str(&con->src_addr),
- ntohs(con->src_addr.ip.sin_port)));
-
- ctdb_sys_send_tcp(&con->dst_addr, &con->src_addr, ack_seq, seq, 1);
- talloc_free(con);
-}
-
-
-/* when traversing the list of all tcp connections to send tickle acks to
- (so that we can capture the ack coming back and kill the connection
- by a RST)
- this callback is called for each connection we are currently trying to kill
-*/
-static int tickle_connection_traverse(void *param, void *data)
-{
- struct ctdb_killtcp_con *con = talloc_get_type(data, struct ctdb_killtcp_con);
-
- /* have tried too many times, just give up */
- if (con->count >= 5) {
- /* can't delete in traverse: reparent to delete_cons */
- talloc_steal(param, con);
- return 0;
- }
-
- /* othervise, try tickling it again */
- con->count++;
- ctdb_sys_send_tcp(
- (ctdb_sock_addr *)&con->dst_addr,
- (ctdb_sock_addr *)&con->src_addr,
- 0, 0, 0);
- return 0;
-}
-
-
-/*
- called every second until all sentenced connections have been reset
- */
-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);
- void *delete_cons = talloc_new(NULL);
-
- /* loop over all connections sending tickle ACKs */
- trbt_traversearray32(killtcp->connections, KILLTCP_KEYLEN, tickle_connection_traverse, delete_cons);
-
- /* now we've finished traverse, it's safe to do deletion. */
- talloc_free(delete_cons);
-
- /* If there are no more connections to kill we can remove the
- entire killtcp structure
- */
- if ( (killtcp->connections == NULL) ||
- (killtcp->connections->root == NULL) ) {
- talloc_free(killtcp);
- return;
- }
-
- /* try tickling them again in a seconds time
- */
- tevent_add_timer(killtcp->ctdb->ev, killtcp,
- timeval_current_ofs(1, 0),
- ctdb_tickle_sentenced_connections, killtcp);
-}
-
-/*
- destroy the killtcp structure
- */
-static int ctdb_killtcp_destructor(struct ctdb_kill_tcp *killtcp)
-{
- struct ctdb_vnn *tmpvnn;
-
- /* verify that this vnn is still active */
- for (tmpvnn = killtcp->ctdb->vnn; tmpvnn; tmpvnn = tmpvnn->next) {
- if (tmpvnn == killtcp->vnn) {
- break;
- }
- }
-
- if (tmpvnn == NULL) {
- return 0;
- }
-
- if (killtcp->vnn->killtcp != killtcp) {
- return 0;
- }
-
- killtcp->vnn->killtcp = NULL;
-
- return 0;
-}
-
-
-/* nothing fancy here, just unconditionally replace any existing
- connection structure with the new one.
-
- don't even free the old one if it did exist, that one is talloc_stolen
- by the same node in the tree anyway and will be deleted when the new data
- is deleted
-*/
-static void *add_killtcp_callback(void *parm, void *data)
-{
- return parm;
-}
-
-/*
- add a tcp socket to the list of connections we want to RST
- */
-static int ctdb_killtcp_add_connection(struct ctdb_context *ctdb,
- ctdb_sock_addr *s,
- ctdb_sock_addr *d)
-{
- ctdb_sock_addr src, dst;
- struct ctdb_kill_tcp *killtcp;
- struct ctdb_killtcp_con *con;
- struct ctdb_vnn *vnn;
-
- ctdb_canonicalize_ip(s, &src);
- ctdb_canonicalize_ip(d, &dst);
-
- vnn = find_public_ip_vnn(ctdb, &dst);
- if (vnn == NULL) {
- vnn = find_public_ip_vnn(ctdb, &src);
- }
- if (vnn == NULL) {
- /* if it is not a public ip it could be our 'single ip' */
- if (ctdb->single_ip_vnn) {
- if (ctdb_same_ip(&ctdb->single_ip_vnn->public_address, &dst)) {
- vnn = ctdb->single_ip_vnn;
- }
- }
- }
- if (vnn == NULL) {
- DEBUG(DEBUG_ERR,(__location__ " Could not killtcp, not a public address\n"));
- return -1;
- }
-
- killtcp = vnn->killtcp;
-
- /* If this is the first connection to kill we must allocate
- a new structure
- */
- if (killtcp == NULL) {
- killtcp = talloc_zero(vnn, struct ctdb_kill_tcp);
- CTDB_NO_MEMORY(ctdb, killtcp);
-
- killtcp->vnn = vnn;
- killtcp->ctdb = ctdb;
- killtcp->capture_fd = -1;
- killtcp->connections = trbt_create(killtcp, 0);
-
- vnn->killtcp = killtcp;
- talloc_set_destructor(killtcp, ctdb_killtcp_destructor);
- }
-
-
-
- /* create a structure that describes this connection we want to
- RST and store it in killtcp->connections
- */
- con = talloc(killtcp, struct ctdb_killtcp_con);
- CTDB_NO_MEMORY(ctdb, con);
- con->src_addr = src;
- con->dst_addr = dst;
- con->count = 0;
- con->killtcp = killtcp;
-
-
- trbt_insertarray32_callback(killtcp->connections,
- KILLTCP_KEYLEN, killtcp_key(&con->dst_addr, &con->src_addr),
- add_killtcp_callback, con);
-
- /*
- If we don't have a socket to listen on yet we must create it
- */
- if (killtcp->capture_fd == -1) {
- const char *iface = ctdb_vnn_iface_string(vnn);
- killtcp->capture_fd = ctdb_sys_open_capture_socket(iface, &killtcp->private_data);
- if (killtcp->capture_fd == -1) {
- DEBUG(DEBUG_CRIT,(__location__ " Failed to open capturing "
- "socket on iface '%s' for killtcp (%s)\n",
- iface, strerror(errno)));
- goto failed;
- }
- }
-
-
- if (killtcp->fde == NULL) {
- 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
- */
- tevent_add_timer(ctdb->ev, killtcp, timeval_current_ofs(1, 0),
- ctdb_tickle_sentenced_connections, killtcp);
- }
-
- /* tickle him once now */
- ctdb_sys_send_tcp(
- &con->dst_addr,
- &con->src_addr,
- 0, 0, 0);
-
- return 0;
-
-failed:
- talloc_free(vnn->killtcp);
- vnn->killtcp = NULL;
- return -1;
-}
-
-/*
- kill a TCP connection.
- */
-int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
-{
- struct ctdb_connection *killtcp = (struct ctdb_connection *)indata.dptr;
-
- return ctdb_killtcp_add_connection(ctdb, &killtcp->src, &killtcp->dst);
-}
-
/*
called by a daemon to inform us of the entire list of TCP tickles for
a particular public address.
ctdb_sock_addr *addr = (ctdb_sock_addr *)indata.dptr;
struct ctdb_tickle_list_old *list;
struct ctdb_tcp_array *tcparray;
- int num;
+ int num, i;
struct ctdb_vnn *vnn;
+ unsigned port;
vnn = find_public_ip_vnn(ctdb, addr);
if (vnn == NULL) {
- DEBUG(DEBUG_ERR,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
+ DEBUG(DEBUG_ERR,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
ctdb_addr_to_str(addr)));
return 1;
}
+ port = ctdb_addr_to_port(addr);
+
tcparray = vnn->tcp_array;
- if (tcparray) {
- num = tcparray->num;
- } else {
- num = 0;
+ num = 0;
+ if (tcparray != NULL) {
+ if (port == 0) {
+ /* All connections */
+ num = tcparray->num;
+ } else {
+ /* Count connections for port */
+ for (i = 0; i < tcparray->num; i++) {
+ if (port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
+ num++;
+ }
+ }
+ }
}
outdata->dsize = offsetof(struct ctdb_tickle_list_old, connections)
list->addr = *addr;
list->num = num;
- if (num) {
- memcpy(&list->connections[0], tcparray->connections,
- sizeof(struct ctdb_connection) * num);
+
+ if (num == 0) {
+ return 0;
+ }
+
+ num = 0;
+ for (i = 0; i < tcparray->num; i++) {
+ if (port == 0 || \
+ port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
+ list->connections[num] = tcparray->connections[i];
+ num++;
+ }
}
return 0;
return ret;
}
-
-/*
- perform tickle updates if required
- */
-static void ctdb_update_tcp_tickles(struct tevent_context *ev,
- struct tevent_timer *te,
- struct timeval t, void *private_data)
+static void ctdb_send_set_tcp_tickles_for_all(struct ctdb_context *ctdb,
+ bool force)
{
- struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
- int ret;
struct ctdb_vnn *vnn;
+ int ret;
- for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- /* we only send out updates for public addresses that
+ for (vnn = ctdb->vnn; vnn != NULL; vnn = vnn->next) {
+ /* we only send out updates for public addresses that
we have taken over
*/
if (ctdb->pnn != vnn->pnn) {
continue;
}
+
/* We only send out the updates if we need to */
- if (!vnn->tcp_update_needed) {
+ if (!force && !vnn->tcp_update_needed) {
continue;
}
+
ret = ctdb_send_set_tcp_tickles_for_ip(ctdb,
&vnn->public_address,
vnn->tcp_array);
if (ret != 0) {
- DEBUG(DEBUG_ERR,("Failed to send the tickle update for public address %s\n",
- ctdb_addr_to_str(&vnn->public_address)));
+ D_ERR("Failed to send the tickle update for ip %s\n",
+ ctdb_addr_to_str(&vnn->public_address));
+ vnn->tcp_update_needed = true;
} else {
- DEBUG(DEBUG_INFO,
- ("Sent tickle update for public address %s\n",
- ctdb_addr_to_str(&vnn->public_address)));
+ D_INFO("Sent tickle update for ip %s\n",
+ ctdb_addr_to_str(&vnn->public_address));
vnn->tcp_update_needed = false;
}
}
+}
+
+/*
+ perform tickle updates if required
+ */
+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);
+
+ ctdb_send_set_tcp_tickles_for_all(ctdb, false);
+
tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
ctdb_update_tcp_tickles, ctdb);
return 0;
}
-struct delete_ip_callback_state {
- struct ctdb_req_control_old *c;
-};
-
-/*
- called when releaseip event finishes for del_public_address
- */
-static void delete_ip_callback(struct ctdb_context *ctdb,
- int32_t status, TDB_DATA data,
- const char *errormsg,
- void *private_data)
-{
- struct delete_ip_callback_state *state =
- talloc_get_type(private_data, struct delete_ip_callback_state);
-
- /* If release failed then fail. */
- ctdb_request_control_reply(ctdb, state->c, NULL, status, errormsg);
- talloc_free(private_data);
-}
-
-int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
- struct ctdb_req_control_old *c,
- TDB_DATA indata, bool *async_reply)
+int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
{
struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
struct ctdb_vnn *vnn;
for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
if (ctdb_same_ip(&vnn->public_address, &pub->addr)) {
if (vnn->pnn == ctdb->pnn) {
- struct delete_ip_callback_state *state;
- struct ctdb_public_ip *ip;
- TDB_DATA data;
- int ret;
-
+ /* This IP is currently being hosted.
+ * Defer the deletion until the next
+ * takeover run. "ctdb reloadips" will
+ * always cause a takeover run. "ctdb
+ * delip" will now need an explicit
+ * "ctdb ipreallocated" afterwards. */
vnn->delete_pending = true;
-
- state = talloc(ctdb,
- struct delete_ip_callback_state);
- CTDB_NO_MEMORY(ctdb, state);
- state->c = c;
-
- ip = talloc(state, struct ctdb_public_ip);
- if (ip == NULL) {
- DEBUG(DEBUG_ERR,
- (__location__ " Out of memory\n"));
- talloc_free(state);
- return -1;
- }
- ip->pnn = -1;
- ip->addr = pub->addr;
-
- data.dsize = sizeof(struct ctdb_public_ip);
- data.dptr = (unsigned char *)ip;
-
- ret = ctdb_daemon_send_control(ctdb,
- ctdb_get_pnn(ctdb),
- 0,
- CTDB_CONTROL_RELEASE_IP,
- 0, 0,
- data,
- delete_ip_callback,
- state);
- if (ret == -1) {
- DEBUG(DEBUG_ERR,
- (__location__ "Unable to send "
- "CTDB_CONTROL_RELEASE_IP\n"));
- talloc_free(state);
- return -1;
- }
-
- state->c = talloc_steal(state, c);
- *async_reply = true;
} else {
/* This IP is not hosted on the
* current node so just delete it
DEBUG(DEBUG_ERR,
(" \"ipreallocated\" event script failed (status %d)\n",
status));
- if (status == -ETIME) {
+ if (status == -ETIMEDOUT) {
ctdb_ban_self(ctdb);
}
}
}
-/* This function is called from the recovery daemon to verify that a remote
- node has the expected ip allocation.
- This is verified against ctdb->ip_tree
-*/
-static int verify_remote_ip_allocation(struct ctdb_context *ctdb,
- struct ctdb_public_ip_list_old *ips,
- uint32_t pnn)
-{
- struct public_ip_list *tmp_ip;
- int i;
-
- if (ctdb->ip_tree == NULL) {
- /* don't know the expected allocation yet, assume remote node
- is correct. */
- return 0;
- }
-
- if (ips == NULL) {
- return 0;
- }
-
- for (i=0; i<ips->num; i++) {
- tmp_ip = trbt_lookuparray32(ctdb->ip_tree, IP_KEYLEN, ip_key(&ips->ips[i].addr));
- if (tmp_ip == NULL) {
- DEBUG(DEBUG_ERR,("Node %u has new or unknown public IP %s\n", pnn, ctdb_addr_to_str(&ips->ips[i].addr)));
- return -1;
- }
-
- if (tmp_ip->pnn == -1 || ips->ips[i].pnn == -1) {
- continue;
- }
-
- if (tmp_ip->pnn != ips->ips[i].pnn) {
- DEBUG(DEBUG_ERR,
- ("Inconsistent IP allocation - node %u thinks %s is held by node %u while it is assigned to node %u\n",
- pnn,
- ctdb_addr_to_str(&ips->ips[i].addr),
- ips->ips[i].pnn, tmp_ip->pnn));
- return -1;
- }
- }
-
- return 0;
-}
-
-int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *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 -1;
- }
-
- tmp_ip = trbt_lookuparray32(ctdb->ip_tree, IP_KEYLEN, ip_key(&ip->addr));
- if (tmp_ip == NULL) {
- DEBUG(DEBUG_ERR,(__location__ " Could not find record for address %s, update ip\n", ctdb_addr_to_str(&ip->addr)));
- return -1;
- }
-
- DEBUG(DEBUG_NOTICE,("Updated ip assignment tree for ip : %s from node %u to node %u\n", ctdb_addr_to_str(&ip->addr), tmp_ip->pnn, ip->pnn));
- tmp_ip->pnn = ip->pnn;
-
- 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_old *c;
struct ctdb_addr_info_old *pub;
const char *ifaces = NULL;
uint32_t len;
- int iface = 0;
+ struct vnn_interface *iface = NULL;
DEBUG(DEBUG_NOTICE,
("New IP %s configured, adding it\n",
first_add = false;
}
- ifaces = vnn->ifaces[0];
- iface = 1;
- while (vnn->ifaces[iface] != NULL) {
+ ifaces = vnn->ifaces->iface->name;
+ iface = vnn->ifaces->next;
+ while (iface != NULL) {
ifaces = talloc_asprintf(vnn, "%s,%s", ifaces,
- vnn->ifaces[iface]);
- iface++;
+ iface->iface->name);
+ iface = iface->next;
}
len = strlen(ifaces) + 1;
signed char res = 0;
close(h->fd[0]);
- debug_extra = talloc_asprintf(NULL, "reloadips:");
prctl_set_comment("ctdb_reloadips");
- if (switch_from_server_to_client(ctdb, "reloadips-child") != 0) {
+ if (switch_from_server_to_client(ctdb) != 0) {
DEBUG(DEBUG_CRIT,("ERROR: Failed to switch reloadips child into client mode\n"));
res = -1;
} else {
}
sys_write(h->fd[1], &res, 1);
- /* make sure we die when our parent dies */
- while (ctdb_kill(ctdb, parent, 0) == 0 || errno != ESRCH) {
- sleep(5);
- }
+ ctdb_wait_for_process_to_exit(parent);
_exit(0);
}
git.samba.org / samba.git / blobdiff