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)
enum ctdb_runstate runstate;
};
-struct ctdb_iface {
- struct ctdb_iface *prev, *next;
+struct ctdb_interface {
+ struct ctdb_interface *prev, *next;
const char *name;
bool link_up;
uint32_t references;
static int ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
{
- struct ctdb_iface *i;
+ struct ctdb_interface *i;
/* Verify that we dont have an entry for this ip yet */
for (i=ctdb->ifaces;i;i=i->next) {
}
/* create a new structure for this interface */
- i = talloc_zero(ctdb, struct ctdb_iface);
+ i = talloc_zero(ctdb, struct ctdb_interface);
CTDB_NO_MEMORY_FATAL(ctdb, i);
i->name = talloc_strdup(i, iface);
CTDB_NO_MEMORY(ctdb, i->name);
static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
struct ctdb_vnn *vnn)
{
- struct ctdb_iface *i, *next;
+ struct ctdb_interface *i, *next;
/* For each interface, check if there's an IP using it. */
for (i = ctdb->ifaces; i != NULL; i = next) {
}
-static struct ctdb_iface *ctdb_find_iface(struct ctdb_context *ctdb,
- const char *iface)
+static struct ctdb_interface *ctdb_find_iface(struct ctdb_context *ctdb,
+ const char *iface)
{
- struct ctdb_iface *i;
+ struct ctdb_interface *i;
for (i=ctdb->ifaces;i;i=i->next) {
if (strcmp(i->name, iface) == 0) {
return NULL;
}
-static struct ctdb_iface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
- struct ctdb_vnn *vnn)
+static struct ctdb_interface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
+ struct ctdb_vnn *vnn)
{
int i;
- struct ctdb_iface *cur = NULL;
- struct ctdb_iface *best = NULL;
+ struct ctdb_interface *cur = NULL;
+ struct ctdb_interface *best = NULL;
for (i=0; vnn->ifaces[i]; i++) {
static int32_t ctdb_vnn_assign_iface(struct ctdb_context *ctdb,
struct ctdb_vnn *vnn)
{
- struct ctdb_iface *best = NULL;
+ struct ctdb_interface *best = NULL;
if (vnn->iface) {
DEBUG(DEBUG_INFO, (__location__ " public address '%s' "
}
for (i=0; vnn->ifaces[i]; i++) {
- struct ctdb_iface *cur;
+ struct ctdb_interface *cur;
cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
if (cur == NULL) {
/*
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_iface *old;
+ struct ctdb_req_control_old *c;
+ struct ctdb_interface *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;
struct ctdb_do_updateip_state *state;
- struct ctdb_iface *old = vnn->iface;
+ struct ctdb_interface *old = vnn->iface;
const char *new_name;
if (vnn->update_in_flight) {
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)
{
bool have_ip = false;
bool do_updateip = false;
bool do_takeip = false;
- struct ctdb_iface *best_iface = NULL;
+ struct ctdb_interface *best_iface = NULL;
if (pip->pnn != ctdb->pnn) {
DEBUG(DEBUG_ERR,(__location__" takeoverip called for an ip '%s' "
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),
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)
{
const char *ip)
{
struct ctdb_vnn *svnn;
- struct ctdb_iface *cur = NULL;
+ struct ctdb_interface *cur = NULL;
bool ok;
int ret;
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;
+ struct ctdb_public_ip_list_old *public_ips;
int i;
if (ipflags.noiphost) {
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 ctdb_all_public_ips *public_ips;
+ struct public_ip_list *ip_list;
+ struct ctdb_public_ip_list_old *public_ips;
if (ctdb->ip_tree != NULL) {
talloc_free(ctdb->ip_tree);
}
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)
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;
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;
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_addr *tcp_sock = NULL;
+ 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_tcp_connection t;
int ret;
return 0;
}
- tcp_sock = (struct ctdb_control_tcp_addr *)indata.dptr;
+ tcp_sock = (struct ctdb_connection *)indata.dptr;
addr = tcp_sock->src;
ctdb_canonicalize_ip(&addr, &tcp_sock->src);
- addr = tcp_sock->dest;
- ctdb_canonicalize_ip(&addr, &tcp_sock->dest);
+ addr = tcp_sock->dst;
+ ctdb_canonicalize_ip(&addr, &tcp_sock->dst);
ZERO_STRUCT(addr);
- memcpy(&addr, &tcp_sock->dest, sizeof(addr));
+ memcpy(&addr, &tcp_sock->dst, sizeof(addr));
vnn = find_public_ip_vnn(ctdb, &addr);
if (vnn == NULL) {
switch (addr.sa.sa_family) {
CTDB_NO_MEMORY(ctdb, tcp);
tcp->connection.src_addr = tcp_sock->src;
- tcp->connection.dst_addr = tcp_sock->dest;
+ tcp->connection.dst_addr = tcp_sock->dst;
DLIST_ADD(client->tcp_list, tcp);
t.src_addr = tcp_sock->src;
- t.dst_addr = tcp_sock->dest;
+ t.dst_addr = tcp_sock->dst;
data.dptr = (uint8_t *)&t;
data.dsize = sizeof(t);
switch (addr.sa.sa_family) {
case AF_INET:
DEBUG(DEBUG_INFO,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
- (unsigned)ntohs(tcp_sock->dest.ip.sin_port),
+ (unsigned)ntohs(tcp_sock->dst.ip.sin_port),
ctdb_addr_to_str(&tcp_sock->src),
(unsigned)ntohs(tcp_sock->src.ip.sin_port), client_id, client->pid));
break;
case AF_INET6:
DEBUG(DEBUG_INFO,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
- (unsigned)ntohs(tcp_sock->dest.ip6.sin6_port),
+ (unsigned)ntohs(tcp_sock->dst.ip6.sin6_port),
ctdb_addr_to_str(&tcp_sock->src),
(unsigned)ntohs(tcp_sock->src.ip6.sin6_port), client_id, client->pid));
break;
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;
+ struct ctdb_public_ip_list_old *ips;
struct ctdb_vnn *vnn;
bool only_available = false;
num++;
}
- len = offsetof(struct ctdb_all_public_ips, ips) +
+ len = offsetof(struct ctdb_public_ip_list_old, ips) +
num*sizeof(struct ctdb_public_ip);
ips = talloc_zero_size(outdata, len);
CTDB_NO_MEMORY(ctdb, ips);
i++;
}
ips->num = i;
- len = offsetof(struct ctdb_all_public_ips, ips) +
+ len = offsetof(struct ctdb_public_ip_list_old, ips) +
i*sizeof(struct ctdb_public_ip);
outdata->dsize = len;
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)
{
info->active_idx = 0xFFFFFFFF;
for (i=0; vnn->ifaces[i]; i++) {
- struct ctdb_iface *cur;
+ struct ctdb_interface *cur;
cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
if (cur == NULL) {
}
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;
struct ctdb_control_get_ifaces *ifaces;
- struct ctdb_iface *cur;
+ struct ctdb_interface *cur;
/* count how many public ip structures we have */
num = 0;
}
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_iface *iface;
+ struct ctdb_interface *iface;
bool link_up = false;
info = (struct ctdb_control_iface_info *)indata.dptr;
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 */
/*
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;
This is verified against ctdb->ip_tree
*/
int verify_remote_ip_allocation(struct ctdb_context *ctdb,
- struct ctdb_all_public_ips *ips,
+ struct ctdb_public_ip_list_old *ips,
uint32_t pnn)
{
- struct 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) {
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);
static int ctdb_reloadips_child(struct ctdb_context *ctdb)
{
TALLOC_CTX *mem_ctx = talloc_new(NULL);
- struct ctdb_all_public_ips *ips;
+ struct ctdb_public_ip_list_old *ips;
struct ctdb_vnn *vnn;
struct client_async_data *async_data;
struct timeval timeout;
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