ctdb/server/ipalloc_common.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 "replace.h"
  23 #include "system/network.h"
  24
  25 #include "ctdb_private.h"
  26
  27 #include "lib/util/time.h"
  28
  29 #include "lib/util/debug.h"
  30 #include "common/logging.h"
  31
  32 #include "common/common.h"
  33 #include "common/rb_tree.h"
  34
  35 #include "protocol/protocol_util.h"
  36
  37 #include "server/ipalloc_private.h"
  38
  39 #define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
  40
  41 /* Given a physical node, return the number of
  42    public addresses that is currently assigned to this node.
  43 */
  44 int node_ip_coverage(int32_t pnn, struct public_ip_list *ips)
  45 {
  46         int num=0;
  47
  48         for (;ips;ips=ips->next) {
  49                 if (ips->pnn == pnn) {
  50                         num++;
  51                 }
  52         }
  53         return num;
  54 }
  55
  56
  57 /* Can the given node host the given IP: is the public IP known to the
  58  * node and is NOIPHOST unset?
  59 */
  60 static bool can_node_host_ip(struct ipalloc_state *ipalloc_state,
  61                              int32_t pnn,
  62                              struct public_ip_list *ip)
  63 {
  64         if (bitmap_query(ipalloc_state->noiphost, pnn)) {
  65                 return false;
  66         }
  67
  68         return bitmap_query(ip->available_on, pnn);
  69 }
  70
  71 bool can_node_takeover_ip(struct ipalloc_state *ipalloc_state,
  72                           int32_t pnn,
  73                           struct public_ip_list *ip)
  74 {
  75         if (ipalloc_state->no_ip_takeover) {
  76                 return false;
  77         }
  78
  79         return can_node_host_ip(ipalloc_state, pnn, ip);
  80 }
  81
  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.
  85 */
  86 int find_takeover_node(struct ipalloc_state *ipalloc_state,
  87                        struct public_ip_list *ip)
  88 {
  89         int pnn, min=0, num;
  90         int i, numnodes;
  91
  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;
  99                 }
 100
 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;
 110                         }
 111                 }
 112         }
 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)));
 118
 119                 return -1;
 120         }
 121
 122         ip->pnn = pnn;
 123         return 0;
 124 }
 125
 126 uint32_t *ip_key(ctdb_sock_addr *ip)
 127 {
 128         static uint32_t key[IP_KEYLEN];
 129
 130         bzero(key, sizeof(key));
 131
 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;
 143         }
 144         default:
 145                 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", ip->sa.sa_family));
 146                 return key;
 147         }
 148
 149         return key;
 150 }
 151
 152 /* Allocate any unassigned IPs just by looping through the IPs and
 153  * finding the best node for each.
 154  */
 155 void basic_allocate_unassigned(struct ipalloc_state *ipalloc_state)
 156 {
 157         struct public_ip_list *t;
 158
 159         /* loop over all ip's and find a physical node to cover for
 160            each unassigned ip.
 161         */
 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)));
 170                         }
 171                 }
 172         }
 173 }
 174
 175 void unassign_unsuitable_ips(struct ipalloc_state *ipalloc_state)
 176 {
 177         struct public_ip_list *t;
 178
 179         /* verify that the assigned nodes can serve that public ip
 180            and set it to -1 if not
 181         */
 182         for (t = ipalloc_state->all_ips; t != NULL; t = t->next) {
 183                 if (t->pnn == -1) {
 184                         continue;
 185                 }
 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;
 194                 }
 195         }
 196 }