ctdb/common/system_util.c

   1 /*
   2    common system utilities
   3
   4    Copyright (C) Amitay Isaacs  2014
   5    Copyright (C) Martin Schwenke  2014
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "replace.h"
  22 #include "system/filesys.h"
  23 #include "system/shmem.h"
  24 #include "system/network.h"
  25
  26 #include <talloc.h>
  27 #include <libgen.h>
  28
  29 #include "lib/util/debug.h"
  30
  31 #include "protocol/protocol.h"
  32
  33 #include "common/logging.h"
  34 #include "common/system.h"
  35
  36 #if HAVE_SCHED_H
  37 #include <sched.h>
  38 #endif
  39
  40 #if HAVE_PROCINFO_H
  41 #include <procinfo.h>
  42 #endif
  43
  44 /*
  45   if possible, make this task real time
  46  */
  47 bool set_scheduler(void)
  48 {
  49 #ifdef _AIX_
  50 #if HAVE_THREAD_SETSCHED
  51         struct thrdentry64 te;
  52         tid64_t ti;
  53
  54         ti = 0ULL;
  55         if (getthrds64(getpid(), &te, sizeof(te), &ti, 1) != 1) {
  56                 DEBUG(DEBUG_ERR, ("Unable to get thread information\n"));
  57                 return false;
  58         }
  59
  60         if (thread_setsched(te.ti_tid, 0, SCHED_RR) == -1) {
  61                 DEBUG(DEBUG_ERR, ("Unable to set scheduler to SCHED_RR (%s)\n",
  62                                   strerror(errno)));
  63                 return false;
  64         } else {
  65                 return true;
  66         }
  67 #endif
  68 #else /* no AIX */
  69 #if HAVE_SCHED_SETSCHEDULER
  70         struct sched_param p;
  71
  72         p.sched_priority = 1;
  73
  74         if (sched_setscheduler(0, SCHED_FIFO, &p) == -1) {
  75                 DEBUG(DEBUG_CRIT,("Unable to set scheduler to SCHED_FIFO (%s)\n",
  76                          strerror(errno)));
  77                 return false;
  78         } else {
  79                 return true;
  80         }
  81 #endif
  82 #endif
  83         DEBUG(DEBUG_CRIT,("No way to set real-time priority.\n"));
  84         return false;
  85 }
  86
  87 /*
  88   reset scheduler from real-time to normal scheduling
  89  */
  90 void reset_scheduler(void)
  91 {
  92 #ifdef _AIX_
  93 #if HAVE_THREAD_SETSCHED
  94         struct thrdentry64 te;
  95         tid64_t ti;
  96
  97         ti = 0ULL;
  98         if (getthrds64(getpid(), &te, sizeof(te), &ti, 1) != 1) {
  99                 DEBUG(DEBUG_ERR, ("Unable to get thread information\n"));
 100         }
 101         if (thread_setsched(te.ti_tid, 0, SCHED_OTHER) == -1) {
 102                 DEBUG(DEBUG_ERR, ("Unable to set scheduler to SCHED_OTHER\n"));
 103         }
 104 #endif
 105 #else /* no AIX */
 106 #if HAVE_SCHED_SETSCHEDULER
 107         struct sched_param p;
 108
 109         p.sched_priority = 0;
 110         if (sched_setscheduler(0, SCHED_OTHER, &p) == -1) {
 111                 DEBUG(DEBUG_ERR, ("Unable to set scheduler to SCHED_OTHER\n"));
 112         }
 113 #endif
 114 #endif
 115 }
 116
 117 bool parse_ipv4(const char *s, unsigned port, struct sockaddr_in *sin)
 118 {
 119         sin->sin_family = AF_INET;
 120         sin->sin_port   = htons(port);
 121
 122         if (inet_pton(AF_INET, s, &sin->sin_addr) != 1) {
 123                 DEBUG(DEBUG_ERR, (__location__ " Failed to translate %s into sin_addr\n", s));
 124                 return false;
 125         }
 126
 127 #ifdef HAVE_SOCK_SIN_LEN
 128         sin->sin_len = sizeof(*sin);
 129 #endif
 130         return true;
 131 }
 132
 133 static bool parse_ipv6(const char *s, const char *ifaces, unsigned port, ctdb_sock_addr *saddr)
 134 {
 135         saddr->ip6.sin6_family   = AF_INET6;
 136         saddr->ip6.sin6_port     = htons(port);
 137         saddr->ip6.sin6_flowinfo = 0;
 138         saddr->ip6.sin6_scope_id = 0;
 139
 140         if (inet_pton(AF_INET6, s, &saddr->ip6.sin6_addr) != 1) {
 141                 DEBUG(DEBUG_ERR, (__location__ " Failed to translate %s into sin6_addr\n", s));
 142                 return false;
 143         }
 144
 145         if (ifaces && IN6_IS_ADDR_LINKLOCAL(&saddr->ip6.sin6_addr)) {
 146                 if (strchr(ifaces, ',')) {
 147                         DEBUG(DEBUG_ERR, (__location__ " Link local address %s "
 148                                           "is specified for multiple ifaces %s\n",
 149                                           s, ifaces));
 150                         return false;
 151                 }
 152                 saddr->ip6.sin6_scope_id = if_nametoindex(ifaces);
 153         }
 154
 155 #ifdef HAVE_SOCK_SIN_LEN
 156         saddr->ip6.sin6_len = sizeof(*saddr);
 157 #endif
 158         return true;
 159 }
 160
 161 /*
 162   parse an ip
 163  */
 164 bool parse_ip(const char *addr, const char *ifaces, unsigned port, ctdb_sock_addr *saddr)
 165 {
 166         char *p;
 167         bool ret;
 168
 169         ZERO_STRUCTP(saddr); /* valgrind :-) */
 170
 171         /* IPv4 or IPv6 address?
 172          *
 173          * Use rindex() because we need the right-most ':' below for
 174          * IPv4-mapped IPv6 addresses anyway...
 175          */
 176         p = rindex(addr, ':');
 177         if (p == NULL) {
 178                 ret = parse_ipv4(addr, port, &saddr->ip);
 179         } else {
 180                 uint8_t ipv4_mapped_prefix[12] = {
 181                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff
 182                 };
 183
 184                 ret = parse_ipv6(addr, ifaces, port, saddr);
 185                 if (! ret) {
 186                         return ret;
 187                 }
 188
 189                 /*
 190                  * Check for IPv4-mapped IPv6 address
 191                  * (e.g. ::ffff:192.0.2.128) - reparse as IPv4 if
 192                  * necessary
 193                  */
 194                 if (memcmp(&saddr->ip6.sin6_addr.s6_addr[0],
 195                            ipv4_mapped_prefix,
 196                            sizeof(ipv4_mapped_prefix)) == 0) {
 197                         /* Reparse as IPv4 */
 198                         ret = parse_ipv4(p+1, port, &saddr->ip);
 199                 }
 200         }
 201
 202         return ret;
 203 }
 204
 205 /*
 206   parse a ip/mask pair
 207  */
 208 bool parse_ip_mask(const char *str, const char *ifaces, ctdb_sock_addr *addr, unsigned *mask)
 209 {
 210         char *p;
 211         char s[64]; /* Much longer than INET6_ADDRSTRLEN */
 212         char *endp = NULL;
 213         ssize_t len;
 214         bool ret;
 215
 216         ZERO_STRUCT(*addr);
 217
 218         len = strlen(str);
 219         if (len >= sizeof(s)) {
 220                 DEBUG(DEBUG_ERR, ("Address %s is unreasonably long\n", str));
 221                 return false;
 222         }
 223
 224         strncpy(s, str, len+1);
 225
 226         p = rindex(s, '/');
 227         if (p == NULL) {
 228                 DEBUG(DEBUG_ERR, (__location__ " This addr: %s does not contain a mask\n", s));
 229                 return false;
 230         }
 231
 232         *mask = strtoul(p+1, &endp, 10);
 233         if (endp == NULL || *endp != 0) {
 234                 /* trailing garbage */
 235                 DEBUG(DEBUG_ERR, (__location__ " Trailing garbage after the mask in %s\n", s));
 236                 return false;
 237         }
 238         *p = 0;
 239
 240
 241         /* now is this a ipv4 or ipv6 address ?*/
 242         ret = parse_ip(s, ifaces, 0, addr);
 243
 244         return ret;
 245 }
 246
 247 /* we don't lock future pages here; it would increase the chance that
 248  * we'd fail to mmap later on. */
 249 void lockdown_memory(bool valgrinding)
 250 {
 251 #if defined(HAVE_MLOCKALL) && !defined(_AIX_)
 252         /* Extra stack, please! */
 253         char dummy[10000];
 254         memset(dummy, 0, sizeof(dummy));
 255
 256         if (valgrinding) {
 257                 return;
 258         }
 259
 260         /* Ignore when running in local daemons mode */
 261         if (getuid() != 0) {
 262                 return;
 263         }
 264
 265         /* Avoid compiler optimizing out dummy. */
 266         mlock(dummy, sizeof(dummy));
 267         if (mlockall(MCL_CURRENT) != 0) {
 268                 DEBUG(DEBUG_WARNING,("Failed to lockdown memory: %s'\n",
 269                                      strerror(errno)));
 270         }
 271 #endif
 272 }
 273
 274 int mkdir_p(const char *dir, int mode)
 275 {
 276         char t[PATH_MAX];
 277         ssize_t len;
 278         int ret;
 279
 280         if (strcmp(dir, "/") == 0) {
 281                 return 0;
 282         }
 283
 284         if (strcmp(dir, ".") == 0) {
 285                 return 0;
 286         }
 287
 288         /* Try to create directory */
 289         ret = mkdir(dir, mode);
 290         /* Succeed if that worked or if it already existed */
 291         if (ret == 0 || errno == EEXIST) {
 292                 return 0;
 293         }
 294         /* Fail on anything else except ENOENT */
 295         if (errno != ENOENT) {
 296                 return ret;
 297         }
 298
 299         /* Create ancestors */
 300         len = strlen(dir);
 301         if (len >= PATH_MAX) {
 302                 errno = ENAMETOOLONG;
 303                 return -1;
 304         }
 305         strncpy(t, dir, len+1);
 306
 307         ret = mkdir_p(dirname(t), mode);
 308         if (ret != 0) {
 309                 return ret;
 310         }
 311
 312         /* Create directory */
 313         ret = mkdir(dir, mode);
 314         if ((ret == -1) && (errno == EEXIST)) {
 315                 ret = 0;
 316         }
 317
 318         return ret;
 319 }
 320
 321 void mkdir_p_or_die(const char *dir, int mode)
 322 {
 323         int ret;
 324
 325         ret = mkdir_p(dir, mode);
 326         if (ret != 0) {
 327                 DEBUG(DEBUG_ALERT,
 328                       ("ctdb exiting with error: "
 329                        "failed to create directory \"%s\" (%s)\n",
 330                        dir, strerror(errno)));
 331                 exit(1);
 332         }
 333 }
 334
 335 void ctdb_wait_for_process_to_exit(pid_t pid)
 336 {
 337         while (kill(pid, 0) == 0 || errno != ESRCH) {
 338                 sleep(5);
 339         }
 340 }