63dcd53795b1256280cdb4352353245ca1b636d7
[nivanova/samba-autobuild/.git] / 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 static 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 static bool parse_ip(const char *addr, const char *ifaces, unsigned port,
165                      ctdb_sock_addr *saddr)
166 {
167         char *p;
168         bool ret;
169
170         ZERO_STRUCTP(saddr); /* valgrind :-) */
171
172         /* IPv4 or IPv6 address?
173          *
174          * Use rindex() because we need the right-most ':' below for
175          * IPv4-mapped IPv6 addresses anyway...
176          */
177         p = rindex(addr, ':');
178         if (p == NULL) {
179                 ret = parse_ipv4(addr, port, &saddr->ip);
180         } else {
181                 uint8_t ipv4_mapped_prefix[12] = {
182                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff
183                 };
184
185                 ret = parse_ipv6(addr, ifaces, port, saddr);
186                 if (! ret) {
187                         return ret;
188                 }
189
190                 /*
191                  * Check for IPv4-mapped IPv6 address
192                  * (e.g. ::ffff:192.0.2.128) - reparse as IPv4 if
193                  * necessary
194                  */
195                 if (memcmp(&saddr->ip6.sin6_addr.s6_addr[0],
196                            ipv4_mapped_prefix,
197                            sizeof(ipv4_mapped_prefix)) == 0) {
198                         /* Reparse as IPv4 */
199                         ret = parse_ipv4(p+1, port, &saddr->ip);
200                 }
201         }
202
203         return ret;
204 }
205
206 /*
207   parse a ip/mask pair
208  */
209 bool parse_ip_mask(const char *str, const char *ifaces, ctdb_sock_addr *addr, unsigned *mask)
210 {
211         char *p;
212         char s[64]; /* Much longer than INET6_ADDRSTRLEN */
213         char *endp = NULL;
214         ssize_t len;
215         bool ret;
216
217         ZERO_STRUCT(*addr);
218
219         len = strlen(str);
220         if (len >= sizeof(s)) {
221                 DEBUG(DEBUG_ERR, ("Address %s is unreasonably long\n", str));
222                 return false;
223         }
224
225         strncpy(s, str, len+1);
226
227         p = rindex(s, '/');
228         if (p == NULL) {
229                 DEBUG(DEBUG_ERR, (__location__ " This addr: %s does not contain a mask\n", s));
230                 return false;
231         }
232
233         *mask = strtoul(p+1, &endp, 10);
234         if (endp == NULL || *endp != 0) {
235                 /* trailing garbage */
236                 DEBUG(DEBUG_ERR, (__location__ " Trailing garbage after the mask in %s\n", s));
237                 return false;
238         }
239         *p = 0;
240
241
242         /* now is this a ipv4 or ipv6 address ?*/
243         ret = parse_ip(s, ifaces, 0, addr);
244
245         return ret;
246 }
247
248 /* we don't lock future pages here; it would increase the chance that
249  * we'd fail to mmap later on. */
250 void lockdown_memory(bool valgrinding)
251 {
252 #if defined(HAVE_MLOCKALL) && !defined(_AIX_)
253         /* Extra stack, please! */
254         char dummy[10000];
255         memset(dummy, 0, sizeof(dummy));
256
257         if (valgrinding) {
258                 return;
259         }
260
261         /* Ignore when running in local daemons mode */
262         if (getuid() != 0) {
263                 return;
264         }
265
266         /* Avoid compiler optimizing out dummy. */
267         mlock(dummy, sizeof(dummy));
268         if (mlockall(MCL_CURRENT) != 0) {
269                 DEBUG(DEBUG_WARNING,("Failed to lockdown memory: %s'\n",
270                                      strerror(errno)));
271         }
272 #endif
273 }
274
275 int mkdir_p(const char *dir, int mode)
276 {
277         char t[PATH_MAX];
278         ssize_t len;
279         int ret;
280
281         if (strcmp(dir, "/") == 0) {
282                 return 0;
283         }
284
285         if (strcmp(dir, ".") == 0) {
286                 return 0;
287         }
288
289         /* Try to create directory */
290         ret = mkdir(dir, mode);
291         /* Succeed if that worked or if it already existed */
292         if (ret == 0 || errno == EEXIST) {
293                 return 0;
294         }
295         /* Fail on anything else except ENOENT */
296         if (errno != ENOENT) {
297                 return ret;
298         }
299
300         /* Create ancestors */
301         len = strlen(dir);
302         if (len >= PATH_MAX) {
303                 errno = ENAMETOOLONG;
304                 return -1;
305         }
306         strncpy(t, dir, len+1);
307
308         ret = mkdir_p(dirname(t), mode);
309         if (ret != 0) {
310                 return ret;
311         }
312
313         /* Create directory */
314         ret = mkdir(dir, mode);
315         if ((ret == -1) && (errno == EEXIST)) {
316                 ret = 0;
317         }
318
319         return ret;
320 }
321
322 void mkdir_p_or_die(const char *dir, int mode)
323 {
324         int ret;
325
326         ret = mkdir_p(dir, mode);
327         if (ret != 0) {
328                 DEBUG(DEBUG_ALERT,
329                       ("ctdb exiting with error: "
330                        "failed to create directory \"%s\" (%s)\n",
331                        dir, strerror(errno)));
332                 exit(1);
333         }
334 }
335
336 void ctdb_wait_for_process_to_exit(pid_t pid)
337 {
338         while (kill(pid, 0) == 0 || errno != ESRCH) {
339                 sleep(5);
340         }
341 }