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 bool ipalloc_set_public_ips(struct ipalloc_state *ipalloc_state,
 165                             struct ctdb_public_ip_list *known_ips,
 166                             struct ctdb_public_ip_list *available_ips)
 167 {
 168         ipalloc_state->available_public_ips = available_ips;
 169
 170         ipalloc_state->all_ips = create_merged_ip_list(ipalloc_state,
 171                                                        known_ips);
 172
 173         return (ipalloc_state->all_ips != NULL);
 174 }
 175
 176 /* This can only return false if there are no available IPs *and*
 177  * there are no IP addresses currently allocated.  If the latter is
 178  * true then the cluster can clearly host IPs... just not necessarily
 179  * right now... */
 180 bool ipalloc_can_host_ips(struct ipalloc_state *ipalloc_state)
 181 {
 182         int i;
 183         struct public_ip_list *ip_list;
 184
 185
 186         for (ip_list = ipalloc_state->all_ips;
 187              ip_list != NULL;
 188              ip_list = ip_list->next) {
 189                 if (ip_list->pnn != -1) {
 190                         return true;
 191                 }
 192         }
 193
 194         for (i=0; i < ipalloc_state->num; i++) {
 195                 if (ipalloc_state->available_public_ips[i].num != 0) {
 196                         return true;
 197                 }
 198         }
 199
 200         return false;
 201 }
 202
 203 /* The calculation part of the IP allocation algorithm. */
 204 bool ipalloc(struct ipalloc_state *ipalloc_state)
 205 {
 206         bool ret = false;
 207
 208         switch (ipalloc_state->algorithm) {
 209         case IPALLOC_LCP2:
 210                 ret = ipalloc_lcp2(ipalloc_state);
 211                 break;
 212         case IPALLOC_DETERMINISTIC:
 213                 ret = ipalloc_deterministic(ipalloc_state);
 214                 break;
 215         case IPALLOC_NONDETERMINISTIC:
 216                 ret = ipalloc_nondeterministic(ipalloc_state);
 217                break;
 218         }
 219
 220         /* at this point ->pnn is the node which will own each IP
 221            or -1 if there is no node that can cover this ip
 222         */
 223
 224         return ret;
 225 }