ctdb-daemon: Add implementation of tunnel controls
[Samba.git] / ctdb / server / ipalloc_common.c
blob24308cf45e2196cb2950e6d33c319ce75dfd7710
1 /*
2 ctdb ip takeover code
4 Copyright (C) Ronnie Sahlberg 2007
5 Copyright (C) Andrew Tridgell 2007
6 Copyright (C) Martin Schwenke 2011
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, see <http://www.gnu.org/licenses/>.
22 #include "replace.h"
23 #include "system/network.h"
25 #include "ctdb_private.h"
27 #include "lib/util/time.h"
29 #include "lib/util/debug.h"
30 #include "common/logging.h"
32 #include "common/common.h"
33 #include "common/rb_tree.h"
35 #include "protocol/protocol_util.h"
37 #include "server/ipalloc_private.h"
39 #define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
41 /* Given a physical node, return the number of
42 public addresses that is currently assigned to this node.
44 int node_ip_coverage(int32_t pnn, struct public_ip_list *ips)
46 int num=0;
48 for (;ips;ips=ips->next) {
49 if (ips->pnn == pnn) {
50 num++;
53 return num;
57 /* Can the given node host the given IP: is the public IP known to the
58 * node and is NOIPHOST unset?
60 static bool can_node_host_ip(struct ipalloc_state *ipalloc_state,
61 int32_t pnn,
62 struct public_ip_list *ip)
64 if (bitmap_query(ipalloc_state->noiphost, pnn)) {
65 return false;
68 return bitmap_query(ip->available_on, pnn);
71 bool can_node_takeover_ip(struct ipalloc_state *ipalloc_state,
72 int32_t pnn,
73 struct public_ip_list *ip)
75 if (ipalloc_state->no_ip_takeover) {
76 return false;
79 return can_node_host_ip(ipalloc_state, pnn, ip);
82 /* search the node lists list for a node to takeover this ip.
83 pick the node that currently are serving the least number of ips
84 so that the ips get spread out evenly.
86 int find_takeover_node(struct ipalloc_state *ipalloc_state,
87 struct public_ip_list *ip)
89 int pnn, min=0, num;
90 int i, numnodes;
92 numnodes = ipalloc_state->num;
93 pnn = -1;
94 for (i=0; i<numnodes; i++) {
95 /* verify that this node can serve this ip */
96 if (!can_node_takeover_ip(ipalloc_state, i, ip)) {
97 /* no it couldnt so skip to the next node */
98 continue;
101 num = node_ip_coverage(i, ipalloc_state->all_ips);
102 /* was this the first node we checked ? */
103 if (pnn == -1) {
104 pnn = i;
105 min = num;
106 } else {
107 if (num < min) {
108 pnn = i;
109 min = num;
113 if (pnn == -1) {
114 DEBUG(DEBUG_WARNING,(__location__ " Could not find node to take over public address '%s'\n",
115 ctdb_sock_addr_to_string(ipalloc_state,
116 &ip->addr,
117 false)));
119 return -1;
122 ip->pnn = pnn;
123 return 0;
126 uint32_t *ip_key(ctdb_sock_addr *ip)
128 static uint32_t key[IP_KEYLEN];
130 bzero(key, sizeof(key));
132 switch (ip->sa.sa_family) {
133 case AF_INET:
134 key[3] = htonl(ip->ip.sin_addr.s_addr);
135 break;
136 case AF_INET6: {
137 uint32_t *s6_a32 = (uint32_t *)&(ip->ip6.sin6_addr.s6_addr);
138 key[0] = htonl(s6_a32[0]);
139 key[1] = htonl(s6_a32[1]);
140 key[2] = htonl(s6_a32[2]);
141 key[3] = htonl(s6_a32[3]);
142 break;
144 default:
145 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", ip->sa.sa_family));
146 return key;
149 return key;
152 /* Allocate any unassigned IPs just by looping through the IPs and
153 * finding the best node for each.
155 void basic_allocate_unassigned(struct ipalloc_state *ipalloc_state)
157 struct public_ip_list *t;
159 /* loop over all ip's and find a physical node to cover for
160 each unassigned ip.
162 for (t = ipalloc_state->all_ips; t != NULL; t = t->next) {
163 if (t->pnn == -1) {
164 if (find_takeover_node(ipalloc_state, t)) {
165 DEBUG(DEBUG_WARNING,
166 ("Failed to find node to cover ip %s\n",
167 ctdb_sock_addr_to_string(ipalloc_state,
168 &t->addr,
169 false)));
175 void unassign_unsuitable_ips(struct ipalloc_state *ipalloc_state)
177 struct public_ip_list *t;
179 /* verify that the assigned nodes can serve that public ip
180 and set it to -1 if not
182 for (t = ipalloc_state->all_ips; t != NULL; t = t->next) {
183 if (t->pnn == -1) {
184 continue;
186 if (!can_node_host_ip(ipalloc_state, t->pnn, t) != 0) {
187 /* this node can not serve this ip. */
188 DEBUG(DEBUG_DEBUG,("Unassign IP: %s from %d\n",
189 ctdb_sock_addr_to_string(
190 ipalloc_state,
191 &t->addr, false),
192 t->pnn));
193 t->pnn = -1;