ctdb/common/ctdb_util.c

   1 /*
   2    ctdb utility code
   3
   4    Copyright (C) Andrew Tridgell  2006
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "tdb.h"
  22 #include "system/network.h"
  23 #include "system/filesys.h"
  24 #include "system/wait.h"
  25 #include "../include/ctdb_private.h"
  26
  27 /*
  28   return error string for last error
  29 */
  30 const char *ctdb_errstr(struct ctdb_context *ctdb)
  31 {
  32         return ctdb->err_msg;
  33 }
  34
  35
  36 /*
  37   remember an error message
  38 */
  39 void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...)
  40 {
  41         va_list ap;
  42         talloc_free(ctdb->err_msg);
  43         va_start(ap, fmt);
  44         ctdb->err_msg = talloc_vasprintf(ctdb, fmt, ap);
  45         DEBUG(DEBUG_ERR,("ctdb error: %s\n", ctdb->err_msg));
  46         va_end(ap);
  47 }
  48
  49 /*
  50   a fatal internal error occurred - no hope for recovery
  51 */
  52 void ctdb_fatal(struct ctdb_context *ctdb, const char *msg)
  53 {
  54         DEBUG(DEBUG_ALERT,("ctdb fatal error: %s\n", msg));
  55         abort();
  56 }
  57
  58 /*
  59   like ctdb_fatal() but a core/backtrace would not be useful
  60 */
  61 void ctdb_die(struct ctdb_context *ctdb, const char *msg)
  62 {
  63         DEBUG(DEBUG_ALERT,("ctdb exiting with error: %s\n", msg));
  64         exit(1);
  65 }
  66
  67 /* Set the path of a helper program from envvar, falling back to
  68  * dir/file if envvar unset. type is a string to print in log
  69  * messages.  helper is assumed to point to a statically allocated
  70  * array of size bytes, initialised to "".  If file is NULL don't fall
  71  * back if envvar is unset.  If dir is NULL and envvar is unset (but
  72  * file is not NULL) then this is an error.  Returns true if helper is
  73  * set, either previously or this time. */
  74 bool ctdb_set_helper(const char *type, char *helper, size_t size,
  75                      const char *envvar,
  76                      const char *dir, const char *file)
  77 {
  78         const char *t;
  79         struct stat st;
  80
  81         if (helper[0] != '\0') {
  82                 /* Already set */
  83                 return true;
  84         }
  85
  86         t = getenv(envvar);
  87         if (t != NULL) {
  88                 if (strlen(t) >= size) {
  89                         DEBUG(DEBUG_ERR,
  90                               ("Unable to set %s - path too long\n", type));
  91                         return false;
  92                 }
  93
  94                 strncpy(helper, t, size);
  95         } else if (file == NULL) {
  96                 return false;
  97         } else if (dir == NULL) {
  98                         DEBUG(DEBUG_ERR,
  99                               ("Unable to set %s - dir is NULL\n", type));
 100                 return false;
 101         } else {
 102                 if (snprintf(helper, size, "%s/%s", dir, file) >= size) {
 103                         DEBUG(DEBUG_ERR,
 104                               ("Unable to set %s - path too long\n", type));
 105                         return false;
 106                 }
 107         }
 108
 109         if (stat(helper, &st) != 0) {
 110                 DEBUG(DEBUG_ERR,
 111                       ("Unable to set %s \"%s\" - %s\n",
 112                        type, helper, strerror(errno)));
 113                 return false;
 114         }
 115         if (!(st.st_mode & S_IXUSR)) {
 116                 DEBUG(DEBUG_ERR,
 117                       ("Unable to set %s \"%s\" - not executable\n",
 118                        type, helper));
 119                 return false;
 120         }
 121
 122         DEBUG(DEBUG_NOTICE,
 123               ("Set %s to \"%s\"\n", type, helper));
 124         return true;
 125 }
 126
 127 /* Invoke an external program to do some sort of tracing on the CTDB
 128  * process.  This might block for a little while.  The external
 129  * program is specified by the environment variable
 130  * CTDB_EXTERNAL_TRACE.  This program should take one argument: the
 131  * pid of the process to trace.  Commonly, the program would be a
 132  * wrapper script around gcore.
 133  */
 134 void ctdb_external_trace(void)
 135 {
 136         int ret;
 137         const char * t = getenv("CTDB_EXTERNAL_TRACE");
 138         char * cmd;
 139
 140         if (t == NULL) {
 141                 return;
 142         }
 143
 144         cmd = talloc_asprintf(NULL, "%s %lu", t, (unsigned long) getpid());
 145         DEBUG(DEBUG_WARNING,("begin external trace: %s\n", cmd));
 146         ret = system(cmd);
 147         if (ret == -1) {
 148                 DEBUG(DEBUG_ERR,
 149                       ("external trace command \"%s\" failed\n", cmd));
 150         }
 151         DEBUG(DEBUG_WARNING,("end external trace: %s\n", cmd));
 152         talloc_free(cmd);
 153 }
 154
 155 /*
 156   parse a IP:port pair
 157 */
 158 int ctdb_parse_address(struct ctdb_context *ctdb,
 159                        TALLOC_CTX *mem_ctx, const char *str,
 160                        struct ctdb_address *address)
 161 {
 162         struct servent *se;
 163         ctdb_sock_addr addr;
 164
 165         setservent(0);
 166         se = getservbyname("ctdb", "tcp");
 167         endservent();
 168
 169         /* Parse IP address and re-convert to string.  This ensure correct
 170          * string form for IPv6 addresses.
 171          */
 172         if (! parse_ip(str, NULL, 0, &addr)) {
 173                 return -1;
 174         }
 175
 176         address->address = talloc_strdup(mem_ctx, ctdb_addr_to_str(&addr));
 177         CTDB_NO_MEMORY(ctdb, address->address);
 178
 179         if (se == NULL) {
 180                 address->port = CTDB_PORT;
 181         } else {
 182                 address->port = ntohs(se->s_port);
 183         }
 184         return 0;
 185 }
 186
 187
 188 /*
 189   check if two addresses are the same
 190 */
 191 bool ctdb_same_address(struct ctdb_address *a1, struct ctdb_address *a2)
 192 {
 193         return strcmp(a1->address, a2->address) == 0 && a1->port == a2->port;
 194 }
 195
 196
 197 /*
 198   hash function for mapping data to a VNN - taken from tdb
 199 */
 200 uint32_t ctdb_hash(const TDB_DATA *key)
 201 {
 202         return tdb_jenkins_hash(discard_const(key));
 203 }
 204
 205 /*
 206   a type checking varient of idr_find
 207  */
 208 static void *_idr_find_type(struct idr_context *idp, int id, const char *type, const char *location)
 209 {
 210         void *p = idr_find(idp, id);
 211         if (p && talloc_check_name(p, type) == NULL) {
 212                 DEBUG(DEBUG_ERR,("%s idr_find_type expected type %s  but got %s\n",
 213                          location, type, talloc_get_name(p)));
 214                 return NULL;
 215         }
 216         return p;
 217 }
 218
 219 uint32_t ctdb_reqid_new(struct ctdb_context *ctdb, void *state)
 220 {
 221         int id = idr_get_new_above(ctdb->idr, state, ctdb->lastid+1, INT_MAX);
 222         if (id < 0) {
 223                 DEBUG(DEBUG_DEBUG, ("Reqid wrap!\n"));
 224                 id = idr_get_new(ctdb->idr, state, INT_MAX);
 225         }
 226         ctdb->lastid = id;
 227         return id;
 228 }
 229
 230 void *_ctdb_reqid_find(struct ctdb_context *ctdb, uint32_t reqid, const char *type, const char *location)
 231 {
 232         void *p;
 233
 234         p = _idr_find_type(ctdb->idr, reqid, type, location);
 235         if (p == NULL) {
 236                 DEBUG(DEBUG_WARNING, ("Could not find idr:%u\n",reqid));
 237         }
 238
 239         return p;
 240 }
 241
 242
 243 void ctdb_reqid_remove(struct ctdb_context *ctdb, uint32_t reqid)
 244 {
 245         int ret;
 246
 247         ret = idr_remove(ctdb->idr, reqid);
 248         if (ret != 0) {
 249                 DEBUG(DEBUG_ERR, ("Removing idr that does not exist\n"));
 250         }
 251 }
 252
 253
 254 static uint32_t ctdb_marshall_record_size(TDB_DATA key,
 255                                           struct ctdb_ltdb_header *header,
 256                                           TDB_DATA data)
 257 {
 258         return offsetof(struct ctdb_rec_data, data) + key.dsize +
 259                data.dsize + (header ? sizeof(*header) : 0);
 260 }
 261
 262 static void ctdb_marshall_record_copy(struct ctdb_rec_data *rec,
 263                                       uint32_t reqid,
 264                                       TDB_DATA key,
 265                                       struct ctdb_ltdb_header *header,
 266                                       TDB_DATA data,
 267                                       uint32_t length)
 268 {
 269         uint32_t offset;
 270
 271         rec->length = length;
 272         rec->reqid = reqid;
 273         rec->keylen = key.dsize;
 274         memcpy(&rec->data[0], key.dptr, key.dsize);
 275         offset = key.dsize;
 276
 277         if (header) {
 278                 rec->datalen = data.dsize + sizeof(*header);
 279                 memcpy(&rec->data[offset], header, sizeof(*header));
 280                 offset += sizeof(*header);
 281         } else {
 282                 rec->datalen = data.dsize;
 283         }
 284         memcpy(&rec->data[offset], data.dptr, data.dsize);
 285 }
 286
 287 /*
 288   form a ctdb_rec_data record from a key/data pair
 289
 290   note that header may be NULL. If not NULL then it is included in the data portion
 291   of the record
 292  */
 293 struct ctdb_rec_data *ctdb_marshall_record(TALLOC_CTX *mem_ctx, uint32_t reqid,
 294                                            TDB_DATA key,
 295                                            struct ctdb_ltdb_header *header,
 296                                            TDB_DATA data)
 297 {
 298         size_t length;
 299         struct ctdb_rec_data *d;
 300
 301         length = ctdb_marshall_record_size(key, header, data);
 302
 303         d = (struct ctdb_rec_data *)talloc_size(mem_ctx, length);
 304         if (d == NULL) {
 305                 return NULL;
 306         }
 307
 308         ctdb_marshall_record_copy(d, reqid, key, header, data, length);
 309         return d;
 310 }
 311
 312
 313 /* helper function for marshalling multiple records */
 314 struct ctdb_marshall_buffer *ctdb_marshall_add(TALLOC_CTX *mem_ctx,
 315                                                struct ctdb_marshall_buffer *m,
 316                                                uint64_t db_id,
 317                                                uint32_t reqid,
 318                                                TDB_DATA key,
 319                                                struct ctdb_ltdb_header *header,
 320                                                TDB_DATA data)
 321 {
 322         struct ctdb_rec_data *r;
 323         struct ctdb_marshall_buffer *m2;
 324         uint32_t length, offset;
 325
 326         length = ctdb_marshall_record_size(key, header, data);
 327
 328         if (m == NULL) {
 329                 offset = offsetof(struct ctdb_marshall_buffer, data);
 330                 m2 = talloc_zero_size(mem_ctx, offset + length);
 331         } else {
 332                 offset = talloc_get_size(m);
 333                 m2 = talloc_realloc_size(mem_ctx, m, offset + length);
 334         }
 335         if (m2 == NULL) {
 336                 TALLOC_FREE(m);
 337                 return NULL;
 338         }
 339
 340         if (m == NULL) {
 341                 m2->db_id = db_id;
 342         }
 343
 344         r = (struct ctdb_rec_data *)((uint8_t *)m2 + offset);
 345         ctdb_marshall_record_copy(r, reqid, key, header, data, length);
 346         m2->count++;
 347
 348         return m2;
 349 }
 350
 351 /* we've finished marshalling, return a data blob with the marshalled records */
 352 TDB_DATA ctdb_marshall_finish(struct ctdb_marshall_buffer *m)
 353 {
 354         TDB_DATA data;
 355         data.dptr = (uint8_t *)m;
 356         data.dsize = talloc_get_size(m);
 357         return data;
 358 }
 359
 360 /*
 361    loop over a marshalling buffer
 362
 363      - pass r==NULL to start
 364      - loop the number of times indicated by m->count
 365 */
 366 struct ctdb_rec_data *ctdb_marshall_loop_next(struct ctdb_marshall_buffer *m, struct ctdb_rec_data *r,
 367                                               uint32_t *reqid,
 368                                               struct ctdb_ltdb_header *header,
 369                                               TDB_DATA *key, TDB_DATA *data)
 370 {
 371         if (r == NULL) {
 372                 r = (struct ctdb_rec_data *)&m->data[0];
 373         } else {
 374                 r = (struct ctdb_rec_data *)(r->length + (uint8_t *)r);
 375         }
 376
 377         if (reqid != NULL) {
 378                 *reqid = r->reqid;
 379         }
 380
 381         if (key != NULL) {
 382                 key->dptr   = &r->data[0];
 383                 key->dsize  = r->keylen;
 384         }
 385         if (data != NULL) {
 386                 data->dptr  = &r->data[r->keylen];
 387                 data->dsize = r->datalen;
 388                 if (header != NULL) {
 389                         data->dptr += sizeof(*header);
 390                         data->dsize -= sizeof(*header);
 391                 }
 392         }
 393
 394         if (header != NULL) {
 395                 if (r->datalen < sizeof(*header)) {
 396                         return NULL;
 397                 }
 398                 memcpy(header, &r->data[r->keylen], sizeof(*header));
 399         }
 400
 401         return r;
 402 }
 403
 404 /*
 405    This is used to canonicalize a ctdb_sock_addr structure.
 406 */
 407 void ctdb_canonicalize_ip(const ctdb_sock_addr *ip, ctdb_sock_addr *cip)
 408 {
 409         char prefix[12] = { 0,0,0,0,0,0,0,0,0,0,0xff,0xff };
 410
 411         memcpy(cip, ip, sizeof (*cip));
 412
 413         if ( (ip->sa.sa_family == AF_INET6)
 414         && !memcmp(&ip->ip6.sin6_addr, prefix, 12)) {
 415                 memset(cip, 0, sizeof(*cip));
 416 #ifdef HAVE_SOCK_SIN_LEN
 417                 cip->ip.sin_len = sizeof(*cip);
 418 #endif
 419                 cip->ip.sin_family = AF_INET;
 420                 cip->ip.sin_port   = ip->ip6.sin6_port;
 421                 memcpy(&cip->ip.sin_addr, &ip->ip6.sin6_addr.s6_addr[12], 4);
 422         }
 423 }
 424
 425 bool ctdb_same_ip(const ctdb_sock_addr *tip1, const ctdb_sock_addr *tip2)
 426 {
 427         ctdb_sock_addr ip1, ip2;
 428
 429         ctdb_canonicalize_ip(tip1, &ip1);
 430         ctdb_canonicalize_ip(tip2, &ip2);
 431
 432         if (ip1.sa.sa_family != ip2.sa.sa_family) {
 433                 return false;
 434         }
 435
 436         switch (ip1.sa.sa_family) {
 437         case AF_INET:
 438                 return ip1.ip.sin_addr.s_addr == ip2.ip.sin_addr.s_addr;
 439         case AF_INET6:
 440                 return !memcmp(&ip1.ip6.sin6_addr.s6_addr[0],
 441                                 &ip2.ip6.sin6_addr.s6_addr[0],
 442                                 16);
 443         default:
 444                 DEBUG(DEBUG_ERR, (__location__ " CRITICAL Can not compare sockaddr structures of type %u\n", ip1.sa.sa_family));
 445                 return false;
 446         }
 447
 448         return true;
 449 }
 450
 451 /*
 452   compare two ctdb_sock_addr structures
 453  */
 454 bool ctdb_same_sockaddr(const ctdb_sock_addr *ip1, const ctdb_sock_addr *ip2)
 455 {
 456         return ctdb_same_ip(ip1, ip2) && ip1->ip.sin_port == ip2->ip.sin_port;
 457 }
 458
 459 char *ctdb_addr_to_str(ctdb_sock_addr *addr)
 460 {
 461         static char cip[128] = "";
 462
 463         switch (addr->sa.sa_family) {
 464         case AF_INET:
 465                 inet_ntop(addr->ip.sin_family, &addr->ip.sin_addr, cip, sizeof(cip));
 466                 break;
 467         case AF_INET6:
 468                 inet_ntop(addr->ip6.sin6_family, &addr->ip6.sin6_addr, cip, sizeof(cip));
 469                 break;
 470         default:
 471                 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
 472                 ctdb_external_trace();
 473         }
 474
 475         return cip;
 476 }
 477
 478 unsigned ctdb_addr_to_port(ctdb_sock_addr *addr)
 479 {
 480         switch (addr->sa.sa_family) {
 481         case AF_INET:
 482                 return ntohs(addr->ip.sin_port);
 483                 break;
 484         case AF_INET6:
 485                 return ntohs(addr->ip6.sin6_port);
 486                 break;
 487         default:
 488                 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
 489         }
 490
 491         return 0;
 492 }
 493
 494
 495 const char *ctdb_eventscript_call_names[] = {
 496         "init",
 497         "setup",
 498         "startup",
 499         "startrecovery",
 500         "recovered",
 501         "takeip",
 502         "releaseip",
 503         "stopped",
 504         "monitor",
 505         "status",
 506         "shutdown",
 507         "reload",
 508         "updateip",
 509         "ipreallocated"
 510 };
 511
 512 /* Runstate handling */
 513 static struct {
 514         enum ctdb_runstate runstate;
 515         const char * label;
 516 } runstate_map[] = {
 517         { CTDB_RUNSTATE_UNKNOWN, "UNKNOWN" },
 518         { CTDB_RUNSTATE_INIT, "INIT" },
 519         { CTDB_RUNSTATE_SETUP, "SETUP" },
 520         { CTDB_RUNSTATE_FIRST_RECOVERY, "FIRST_RECOVERY" },
 521         { CTDB_RUNSTATE_STARTUP, "STARTUP" },
 522         { CTDB_RUNSTATE_RUNNING, "RUNNING" },
 523         { CTDB_RUNSTATE_SHUTDOWN, "SHUTDOWN" },
 524         { -1, NULL },
 525 };
 526
 527 const char *runstate_to_string(enum ctdb_runstate runstate)
 528 {
 529         int i;
 530         for (i=0; runstate_map[i].label != NULL ; i++) {
 531                 if (runstate_map[i].runstate == runstate) {
 532                         return runstate_map[i].label;
 533                 }
 534         }
 535
 536         return runstate_map[0].label;
 537 }
 538
 539 enum ctdb_runstate runstate_from_string(const char *label)
 540 {
 541         int i;
 542         for (i=0; runstate_map[i].label != NULL; i++) {
 543                 if (strcasecmp(runstate_map[i].label, label) == 0) {
 544                         return runstate_map[i].runstate;
 545                 }
 546         }
 547
 548         return CTDB_RUNSTATE_UNKNOWN;
 549 }
 550
 551 void ctdb_set_runstate(struct ctdb_context *ctdb, enum ctdb_runstate runstate)
 552 {
 553         if (runstate <= ctdb->runstate) {
 554                 ctdb_fatal(ctdb, "runstate must always increase");
 555         }
 556
 557         DEBUG(DEBUG_NOTICE,("Set runstate to %s (%d)\n",
 558                             runstate_to_string(runstate), runstate));
 559         ctdb->runstate = runstate;
 560 }
 561
 562 /* Convert arbitrary data to 4-byte boundary padded uint32 array */
 563 uint32_t *ctdb_key_to_idkey(TALLOC_CTX *mem_ctx, TDB_DATA key)
 564 {
 565         uint32_t idkey_size, *k;
 566
 567         idkey_size = 1 + (key.dsize + sizeof(uint32_t)-1) / sizeof(uint32_t);
 568
 569         k = talloc_zero_array(mem_ctx, uint32_t, idkey_size);
 570         if (k == NULL) {
 571                 return NULL;
 572         }
 573
 574         k[0] = idkey_size;
 575         memcpy(&k[1], key.dptr, key.dsize);
 576
 577         return k;
 578 }