ctdb/server/ipalloc.c

   1 /*
   2    ctdb ip takeover code
   3
   4    Copyright (C) Ronnie Sahlberg  2007
   5    Copyright (C) Andrew Tridgell  2007
   6    Copyright (C) Martin Schwenke  2011
   7
   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.
  12
  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.
  17
  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/>.
  20 */
  21
  22 #include <talloc.h>
  23
  24 #include "replace.h"
  25 #include "system/network.h"
  26
  27 #include "lib/util/debug.h"
  28
  29 #include "common/logging.h"
  30 #include "common/rb_tree.h"
  31
  32 #include "server/ipalloc_private.h"
  33
  34 /* Initialise main ipalloc state and sub-structures */
  35 struct ipalloc_state *
  36 ipalloc_state_init(TALLOC_CTX *mem_ctx,
  37                    uint32_t num_nodes,
  38                    enum ipalloc_algorithm algorithm,
  39                    bool no_ip_failback,
  40                    uint32_t *force_rebalance_nodes)
  41 {
  42         struct ipalloc_state *ipalloc_state =
  43                 talloc_zero(mem_ctx, struct ipalloc_state);
  44         if (ipalloc_state == NULL) {
  45                 DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
  46                 return NULL;
  47         }
  48
  49         ipalloc_state->num = num_nodes;
  50
  51         ipalloc_state->noiptakeover =
  52                 talloc_zero_array(ipalloc_state,
  53                                   bool,
  54                                   ipalloc_state->num);
  55         if (ipalloc_state->noiptakeover == NULL) {
  56                 DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
  57                 goto fail;
  58         }
  59         ipalloc_state->noiphost =
  60                 talloc_zero_array(ipalloc_state,
  61                                   bool,
  62                                   ipalloc_state->num);
  63         if (ipalloc_state->noiphost == NULL) {
  64                 DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
  65                 goto fail;
  66         }
  67
  68         ipalloc_state->algorithm = algorithm;
  69         ipalloc_state->no_ip_failback = no_ip_failback;
  70         ipalloc_state->force_rebalance_nodes = force_rebalance_nodes;
  71
  72         return ipalloc_state;
  73 fail:
  74         talloc_free(ipalloc_state);
  75         return NULL;
  76 }
  77
  78 static void *add_ip_callback(void *parm, void *data)
  79 {
  80         struct public_ip_list *this_ip = parm;
  81         struct public_ip_list *prev_ip = data;
  82
  83         if (prev_ip == NULL) {
  84                 return parm;
  85         }
  86         if (this_ip->pnn == -1) {
  87                 this_ip->pnn = prev_ip->pnn;
  88         }
  89
  90         return parm;
  91 }
  92
  93 static int getips_count_callback(void *param, void *data)
  94 {
  95         struct public_ip_list **ip_list = (struct public_ip_list **)param;
  96         struct public_ip_list *new_ip = (struct public_ip_list *)data;
  97
  98         new_ip->next = *ip_list;
  99         *ip_list     = new_ip;
 100         return 0;
 101 }
 102
 103 /* Nodes only know about those public addresses that they are
 104  * configured to serve and no individual node has a full list of all
 105  * public addresses configured across the cluster.  Therefore, a
 106  * merged list of all public addresses needs to be built so that IP
 107  * allocation can be done. */
 108 static struct public_ip_list *
 109 create_merged_ip_list(struct ipalloc_state *ipalloc_state,
 110                       struct ctdb_public_ip_list *known_ips)
 111 {
 112         int i, j;
 113         struct public_ip_list *ip_list;
 114         struct ctdb_public_ip_list *public_ips;
 115         struct trbt_tree *ip_tree;
 116
 117         ip_tree = trbt_create(ipalloc_state, 0);
 118
 119         if (known_ips == NULL) {
 120                 DEBUG(DEBUG_ERR, ("Known public IPs not set\n"));
 121                 return NULL;
 122         }
 123
 124         for (i=0; i < ipalloc_state->num; i++) {
 125
 126                 public_ips = &known_ips[i];
 127
 128                 for (j=0; j < public_ips->num; j++) {
 129                         struct public_ip_list *tmp_ip;
 130
 131                         /* This is returned as part of ip_list */
 132                         tmp_ip = talloc_zero(ipalloc_state, struct public_ip_list);
 133                         if (tmp_ip == NULL) {
 134                                 DEBUG(DEBUG_ERR,
 135                                       (__location__ " out of memory\n"));
 136                                 talloc_free(ip_tree);
 137                                 return NULL;
 138                         }
 139
 140                         /* Do not use information about IP addresses hosted
 141                          * on other nodes, it may not be accurate */
 142                         if (public_ips->ip[j].pnn == i) {
 143                                 tmp_ip->pnn = public_ips->ip[j].pnn;
 144                         } else {
 145                                 tmp_ip->pnn = -1;
 146                         }
 147                         tmp_ip->addr = public_ips->ip[j].addr;
 148                         tmp_ip->next = NULL;
 149
 150                         trbt_insertarray32_callback(ip_tree,
 151                                 IP_KEYLEN, ip_key(&public_ips->ip[j].addr),
 152                                 add_ip_callback,
 153                                 tmp_ip);
 154                 }
 155         }
 156
 157         ip_list = NULL;
 158         trbt_traversearray32(ip_tree, IP_KEYLEN, getips_count_callback, &ip_list);
 159         talloc_free(ip_tree);
 160
 161         return ip_list;
 162 }
 163
 164 static bool all_nodes_are_disabled(struct ctdb_node_map *nodemap)
 165 {
 166         int i;
 167
 168         for (i=0;i<nodemap->num;i++) {
 169                 if (!(nodemap->node[i].flags &
 170                       (NODE_FLAGS_INACTIVE|NODE_FLAGS_DISABLED))) {
 171                         /* Found one completely healthy node */
 172                         return false;
 173                 }
 174         }
 175
 176         return true;
 177 }
 178
 179 /* Set internal flags for IP allocation:
 180  *   Clear ip flags
 181  *   Set NOIPTAKOVER ip flags from per-node NoIPTakeover tunable
 182  *   Set NOIPHOST ip flag for each INACTIVE node
 183  *   if all nodes are disabled:
 184  *     Set NOIPHOST ip flags from per-node NoIPHostOnAllDisabled tunable
 185  *   else
 186  *     Set NOIPHOST ip flags for disabled nodes
 187  */
 188 void ipalloc_set_node_flags(struct ipalloc_state *ipalloc_state,
 189                             struct ctdb_node_map *nodemap,
 190                             uint32_t *tval_noiptakeover,
 191                             uint32_t *tval_noiphostonalldisabled)
 192 {
 193         int i;
 194
 195         for (i=0;i<nodemap->num;i++) {
 196                 /* Can not take IPs on node with NoIPTakeover set */
 197                 if (tval_noiptakeover[i] != 0) {
 198                         ipalloc_state->noiptakeover[i] = true;
 199                 }
 200
 201                 /* Can not host IPs on INACTIVE node */
 202                 if (nodemap->node[i].flags & NODE_FLAGS_INACTIVE) {
 203                         ipalloc_state->noiphost[i] = true;
 204                 }
 205         }
 206
 207         if (all_nodes_are_disabled(nodemap)) {
 208                 /* If all nodes are disabled, can not host IPs on node
 209                  * with NoIPHostOnAllDisabled set
 210                  */
 211                 for (i=0;i<nodemap->num;i++) {
 212                         if (tval_noiphostonalldisabled[i] != 0) {
 213                                 ipalloc_state->noiphost[i] = true;
 214                         }
 215                 }
 216         } else {
 217                 /* If some nodes are not disabled, then can not host
 218                  * IPs on DISABLED node
 219                  */
 220                 for (i=0;i<nodemap->num;i++) {
 221                         if (nodemap->node[i].flags & NODE_FLAGS_DISABLED) {
 222                                 ipalloc_state->noiphost[i] = true;
 223                         }
 224                 }
 225         }
 226 }
 227
 228 bool ipalloc_set_public_ips(struct ipalloc_state *ipalloc_state,
 229                             struct ctdb_public_ip_list *known_ips,
 230                             struct ctdb_public_ip_list *available_ips)
 231 {
 232         ipalloc_state->available_public_ips = available_ips;
 233
 234         ipalloc_state->all_ips = create_merged_ip_list(ipalloc_state,
 235                                                        known_ips);
 236
 237         return (ipalloc_state->all_ips != NULL);
 238 }
 239
 240 /* This can only return false if there are no available IPs *and*
 241  * there are no IP addresses currently allocated.  If the latter is
 242  * true then the cluster can clearly host IPs... just not necessarily
 243  * right now... */
 244 bool ipalloc_can_host_ips(struct ipalloc_state *ipalloc_state)
 245 {
 246         int i;
 247         struct public_ip_list *ip_list;
 248
 249
 250         for (ip_list = ipalloc_state->all_ips;
 251              ip_list != NULL;
 252              ip_list = ip_list->next) {
 253                 if (ip_list->pnn != -1) {
 254                         return true;
 255                 }
 256         }
 257
 258         for (i=0; i < ipalloc_state->num; i++) {
 259                 if (ipalloc_state->available_public_ips[i].num != 0) {
 260                         return true;
 261                 }
 262         }
 263
 264         return false;
 265 }
 266
 267 /* The calculation part of the IP allocation algorithm. */
 268 struct public_ip_list *ipalloc(struct ipalloc_state *ipalloc_state)
 269 {
 270         bool ret = false;
 271
 272         switch (ipalloc_state->algorithm) {
 273         case IPALLOC_LCP2:
 274                 ret = ipalloc_lcp2(ipalloc_state);
 275                 break;
 276         case IPALLOC_DETERMINISTIC:
 277                 ret = ipalloc_deterministic(ipalloc_state);
 278                 break;
 279         case IPALLOC_NONDETERMINISTIC:
 280                 ret = ipalloc_nondeterministic(ipalloc_state);
 281                break;
 282         }
 283
 284         /* at this point ->pnn is the node which will own each IP
 285            or -1 if there is no node that can cover this ip
 286         */
 287
 288         return (ret ? ipalloc_state->all_ips : NULL);
 289 }