File: | xlators/mgmt/glusterd/src/glusterd-geo-rep.c |
Location: | line 65, column 30 |
Description: | Access to field 'rpc_err' results in a dereference of a null pointer (loaded from variable 'req') |
1 | /* | |||||
2 | Copyright (c) 2011-2012 Red Hat, Inc. <http://www.redhat.com> | |||||
3 | This file is part of GlusterFS. | |||||
4 | ||||||
5 | This file is licensed to you under your choice of the GNU Lesser | |||||
6 | General Public License, version 3 or any later version (LGPLv3 or | |||||
7 | later), or the GNU General Public License, version 2 (GPLv2), in all | |||||
8 | cases as published by the Free Software Foundation. | |||||
9 | */ | |||||
10 | #ifndef _CONFIG_H | |||||
11 | #define _CONFIG_H | |||||
12 | #include "config.h" | |||||
13 | #endif | |||||
14 | ||||||
15 | #include "common-utils.h" | |||||
16 | #include "cli1-xdr.h" | |||||
17 | #include "xdr-generic.h" | |||||
18 | #include "glusterd.h" | |||||
19 | #include "glusterd-op-sm.h" | |||||
20 | #include "glusterd-store.h" | |||||
21 | #include "glusterd-utils.h" | |||||
22 | #include "glusterd-volgen.h" | |||||
23 | #include "run.h" | |||||
24 | #include "syscall.h" | |||||
25 | ||||||
26 | #include <signal.h> | |||||
27 | ||||||
28 | static char *gsync_reserved_opts[] = { | |||||
29 | "gluster-command-dir", | |||||
30 | "pid-file", | |||||
31 | "remote-gsyncd" | |||||
32 | "state-file", | |||||
33 | "session-owner", | |||||
34 | "state-socket-unencoded", | |||||
35 | "socketdir", | |||||
36 | NULL((void*)0) | |||||
37 | }; | |||||
38 | ||||||
39 | int | |||||
40 | __glusterd_handle_gsync_set (rpcsvc_request_t *req) | |||||
41 | { | |||||
42 | int32_t ret = 0; | |||||
43 | dict_t *dict = NULL((void*)0); | |||||
44 | gf_cli_req cli_req = {{0},}; | |||||
45 | glusterd_op_t cli_op = GD_OP_GSYNC_SET; | |||||
46 | char *master = NULL((void*)0); | |||||
47 | char *slave = NULL((void*)0); | |||||
48 | char operation[256] = {0,}; | |||||
49 | int type = 0; | |||||
50 | glusterd_conf_t *priv = NULL((void*)0); | |||||
51 | char *host_uuid = NULL((void*)0); | |||||
52 | char err_str[2048] = {0,}; | |||||
53 | xlator_t *this = NULL((void*)0); | |||||
54 | ||||||
55 | GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: " "req"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 55, GF_LOG_ERROR, "Assertion failed: " "req") ; } while (0); } } while (0); | |||||
| ||||||
56 | ||||||
57 | this = THIS(*__glusterfs_this_location()); | |||||
58 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 58, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | |||||
59 | priv = this->private; | |||||
60 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 60, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | |||||
61 | ||||||
62 | ret = xdr_to_generic (req->msg[0], &cli_req, | |||||
63 | (xdrproc_t)xdr_gf_cli_req); | |||||
64 | if (ret < 0) { | |||||
65 | req->rpc_err = GARBAGE_ARGS; | |||||
| ||||||
66 | goto out; | |||||
67 | } | |||||
68 | ||||||
69 | if (cli_req.dict.dict_len) { | |||||
70 | dict = dict_new (); | |||||
71 | if (!dict) | |||||
72 | goto out; | |||||
73 | ||||||
74 | ret = dict_unserialize (cli_req.dict.dict_val, | |||||
75 | cli_req.dict.dict_len, | |||||
76 | &dict); | |||||
77 | if (ret < 0) { | |||||
78 | gf_log (this->name, GF_LOG_ERROR, "failed to "do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary" ); } while (0); _gf_log (this->name, "glusterd-geo-rep.c", __FUNCTION__, 79, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary" ); } while (0) | |||||
79 | "unserialize req-buffer to dictionary")do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary" ); } while (0); _gf_log (this->name, "glusterd-geo-rep.c", __FUNCTION__, 79, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary" ); } while (0); | |||||
80 | snprintf (err_str, sizeof (err_str), "Unable to decode " | |||||
81 | "the command"); | |||||
82 | goto out; | |||||
83 | } else { | |||||
84 | dict->extra_stdfree = cli_req.dict.dict_val; | |||||
85 | } | |||||
86 | ||||||
87 | host_uuid = gf_strdup (uuid_utoa(MY_UUID(__glusterd_uuid()))); | |||||
88 | if (host_uuid == NULL((void*)0)) { | |||||
89 | snprintf (err_str, sizeof (err_str), "Failed to get " | |||||
90 | "the uuid of local glusterd"); | |||||
91 | ret = -1; | |||||
92 | goto out; | |||||
93 | } | |||||
94 | ret = dict_set_dynstr (dict, "host-uuid", host_uuid); | |||||
95 | if (ret) | |||||
96 | goto out; | |||||
97 | ||||||
98 | } | |||||
99 | ||||||
100 | ret = dict_get_str (dict, "master", &master); | |||||
101 | if (ret < 0) { | |||||
102 | gf_log (this->name, GF_LOG_INFO, "master not found, while "do { do { if (0) printf ("master not found, while " "handling" "geo-replication"" options"); } while (0); _gf_log (this-> name, "glusterd-geo-rep.c", __FUNCTION__, 103, GF_LOG_INFO, "master not found, while " "handling""geo-replication"" options"); } while (0) | |||||
103 | "handling"GEOREP" options")do { do { if (0) printf ("master not found, while " "handling" "geo-replication"" options"); } while (0); _gf_log (this-> name, "glusterd-geo-rep.c", __FUNCTION__, 103, GF_LOG_INFO, "master not found, while " "handling""geo-replication"" options"); } while (0); | |||||
104 | master = "(No Master)"; | |||||
105 | } | |||||
106 | ||||||
107 | ret = dict_get_str (dict, "slave", &slave); | |||||
108 | if (ret < 0) { | |||||
109 | gf_log (this->name, GF_LOG_INFO, "slave not not found, while"do { do { if (0) printf ("slave not not found, while" "handling " "geo-replication"" options"); } while (0); _gf_log (this-> name, "glusterd-geo-rep.c", __FUNCTION__, 110, GF_LOG_INFO, "slave not not found, while" "handling ""geo-replication"" options"); } while (0) | |||||
110 | "handling "GEOREP" options")do { do { if (0) printf ("slave not not found, while" "handling " "geo-replication"" options"); } while (0); _gf_log (this-> name, "glusterd-geo-rep.c", __FUNCTION__, 110, GF_LOG_INFO, "slave not not found, while" "handling ""geo-replication"" options"); } while (0); | |||||
111 | slave = "(No Slave)"; | |||||
112 | } | |||||
113 | ||||||
114 | ret = dict_get_int32 (dict, "type", &type); | |||||
115 | if (ret < 0) { | |||||
116 | snprintf (err_str, sizeof (err_str), "Command type not found " | |||||
117 | "while handling "GEOREP"geo-replication"" options"); | |||||
118 | gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log (this->name, "glusterd-geo-rep.c", __FUNCTION__, 118, GF_LOG_ERROR , "%s", err_str); } while (0); | |||||
119 | goto out; | |||||
120 | } | |||||
121 | ||||||
122 | switch (type) { | |||||
123 | ||||||
124 | case GF_GSYNC_OPTION_TYPE_START: | |||||
125 | strncpy (operation, "start", sizeof (operation)); | |||||
126 | break; | |||||
127 | ||||||
128 | case GF_GSYNC_OPTION_TYPE_STOP: | |||||
129 | strncpy (operation, "stop", sizeof (operation)); | |||||
130 | break; | |||||
131 | ||||||
132 | case GF_GSYNC_OPTION_TYPE_CONFIG: | |||||
133 | strncpy (operation, "config", sizeof (operation)); | |||||
134 | break; | |||||
135 | ||||||
136 | case GF_GSYNC_OPTION_TYPE_STATUS: | |||||
137 | strncpy (operation, "status", sizeof (operation)); | |||||
138 | break; | |||||
139 | case GF_GSYNC_OPTION_TYPE_ROTATE: | |||||
140 | strncpy (operation, "rotate", sizeof(operation)); | |||||
141 | break; | |||||
142 | } | |||||
143 | ||||||
144 | ret = glusterd_op_begin_synctask (req, GD_OP_GSYNC_SET, dict); | |||||
145 | ||||||
146 | out: | |||||
147 | if (ret) { | |||||
148 | if (err_str[0] == '\0') | |||||
149 | snprintf (err_str, sizeof (err_str), | |||||
150 | "Operation failed"); | |||||
151 | ret = glusterd_op_send_cli_response (cli_op, ret, 0, req, | |||||
152 | dict, err_str); | |||||
153 | } | |||||
154 | return ret; | |||||
155 | } | |||||
156 | ||||||
157 | ||||||
158 | int | |||||
159 | glusterd_handle_gsync_set (rpcsvc_request_t *req) | |||||
160 | { | |||||
161 | return glusterd_big_locked_handler (req, __glusterd_handle_gsync_set); | |||||
162 | } | |||||
163 | ||||||
164 | /***** | |||||
165 | * | |||||
166 | * glusterd_urltransform* internal API | |||||
167 | * | |||||
168 | *****/ | |||||
169 | ||||||
170 | static void | |||||
171 | glusterd_urltransform_init (runner_t *runner, const char *transname) | |||||
172 | { | |||||
173 | runinit (runner); | |||||
174 | runner_add_arg (runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd"); | |||||
175 | runner_argprintf (runner, "--%s-url", transname); | |||||
176 | } | |||||
177 | ||||||
178 | static void | |||||
179 | glusterd_urltransform_add (runner_t *runner, const char *url) | |||||
180 | { | |||||
181 | runner_add_arg (runner, url); | |||||
182 | } | |||||
183 | ||||||
184 | static int | |||||
185 | _glusterd_urltransform_add_iter (dict_t *dict, char *key, data_t *value, void *data) | |||||
186 | { | |||||
187 | runner_t *runner = (runner_t *)data; | |||||
188 | char *slave = NULL((void*)0); | |||||
189 | ||||||
190 | slave = strchr (value->data, ':'); | |||||
191 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 191, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
192 | slave++; | |||||
193 | runner_add_arg (runner, slave); | |||||
194 | ||||||
195 | return 0; | |||||
196 | } | |||||
197 | ||||||
198 | static void | |||||
199 | glusterd_urltransform_free (char **linearr, unsigned n) | |||||
200 | { | |||||
201 | int i = 0; | |||||
202 | ||||||
203 | for (; i < n; i++) | |||||
204 | GF_FREE (linearr[i])__gf_free (linearr[i]); | |||||
205 | ||||||
206 | GF_FREE (linearr)__gf_free (linearr); | |||||
207 | } | |||||
208 | ||||||
209 | static int | |||||
210 | glusterd_urltransform (runner_t *runner, char ***linearrp) | |||||
211 | { | |||||
212 | char **linearr = NULL((void*)0); | |||||
213 | char *line = NULL((void*)0); | |||||
214 | unsigned arr_len = 32; | |||||
215 | unsigned arr_idx = 0; | |||||
216 | gf_boolean_t error = _gf_false; | |||||
217 | ||||||
218 | linearr = GF_CALLOC (arr_len, sizeof (char *), gf_gld_mt_linearr)__gf_calloc (arr_len, sizeof (char *), gf_gld_mt_linearr); | |||||
219 | if (!linearr) { | |||||
220 | error = _gf_true; | |||||
221 | goto out; | |||||
222 | } | |||||
223 | ||||||
224 | runner_redir (runner, STDOUT_FILENO1, RUN_PIPE-1); | |||||
225 | if (runner_start (runner) != 0) { | |||||
226 | gf_log ("", GF_LOG_ERROR, "spawning child failed")do { do { if (0) printf ("spawning child failed"); } while (0 ); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 226, GF_LOG_ERROR , "spawning child failed"); } while (0); | |||||
227 | ||||||
228 | error = _gf_true; | |||||
229 | goto out; | |||||
230 | } | |||||
231 | ||||||
232 | arr_idx = 0; | |||||
233 | for (;;) { | |||||
234 | size_t len; | |||||
235 | line = GF_MALLOC (1024, gf_gld_mt_linebuf)__gf_malloc (1024, gf_gld_mt_linebuf); | |||||
236 | if (!line) { | |||||
237 | error = _gf_true; | |||||
238 | goto out; | |||||
239 | } | |||||
240 | ||||||
241 | if (fgets (line, 1024, runner_chio (runner, STDOUT_FILENO1)) == | |||||
242 | NULL((void*)0)) | |||||
243 | break; | |||||
244 | ||||||
245 | len = strlen (line); | |||||
246 | if (len == 0 || line[len - 1] != '\n') { | |||||
247 | GF_FREE (line)__gf_free (line); | |||||
248 | error = _gf_true; | |||||
249 | goto out; | |||||
250 | } | |||||
251 | line[len - 1] = '\0'; | |||||
252 | ||||||
253 | if (arr_idx == arr_len) { | |||||
254 | void *p = linearr; | |||||
255 | arr_len <<= 1; | |||||
256 | p = GF_REALLOC (linearr, arr_len)__gf_realloc (linearr, arr_len); | |||||
257 | if (!p) { | |||||
258 | GF_FREE (line)__gf_free (line); | |||||
259 | error = _gf_true; | |||||
260 | goto out; | |||||
261 | } | |||||
262 | linearr = p; | |||||
263 | } | |||||
264 | linearr[arr_idx] = line; | |||||
265 | ||||||
266 | arr_idx++; | |||||
267 | } | |||||
268 | ||||||
269 | out: | |||||
270 | ||||||
271 | /* XXX chpid field is not exported by run API | |||||
272 | * but runner_end() does not abort the invoked | |||||
273 | * process (ie. it might block in waitpid(2)) | |||||
274 | * so we resort to a manual kill a the private field | |||||
275 | */ | |||||
276 | if (error && runner->chpid > 0) | |||||
277 | kill (runner->chpid, SIGKILL9); | |||||
278 | ||||||
279 | if (runner_end (runner) != 0) | |||||
280 | error = _gf_true; | |||||
281 | ||||||
282 | if (error) { | |||||
283 | gf_log ("", GF_LOG_ERROR, "reading data from child failed")do { do { if (0) printf ("reading data from child failed"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 283 , GF_LOG_ERROR, "reading data from child failed"); } while (0 ); | |||||
284 | glusterd_urltransform_free (linearr, arr_idx); | |||||
285 | return -1; | |||||
286 | } | |||||
287 | ||||||
288 | *linearrp = linearr; | |||||
289 | return arr_idx; | |||||
290 | } | |||||
291 | ||||||
292 | static int | |||||
293 | glusterd_urltransform_single (const char *url, const char *transname, | |||||
294 | char ***linearrp) | |||||
295 | { | |||||
296 | runner_t runner = {0,}; | |||||
297 | ||||||
298 | glusterd_urltransform_init (&runner, transname); | |||||
299 | glusterd_urltransform_add (&runner, url); | |||||
300 | return glusterd_urltransform (&runner, linearrp); | |||||
301 | } | |||||
302 | ||||||
303 | ||||||
304 | struct dictidxmark { | |||||
305 | unsigned isrch; | |||||
306 | unsigned ithis; | |||||
307 | char *ikey; | |||||
308 | }; | |||||
309 | ||||||
310 | static int | |||||
311 | _dict_mark_atindex (dict_t *dict, char *key, data_t *value, void *data) | |||||
312 | { | |||||
313 | struct dictidxmark *dim = data; | |||||
314 | ||||||
315 | if (dim->isrch == dim->ithis) | |||||
316 | dim->ikey = key; | |||||
317 | ||||||
318 | dim->ithis++; | |||||
319 | return 0; | |||||
320 | } | |||||
321 | ||||||
322 | static char * | |||||
323 | dict_get_by_index (dict_t *dict, unsigned i) | |||||
324 | { | |||||
325 | struct dictidxmark dim = {0,}; | |||||
326 | ||||||
327 | dim.isrch = i; | |||||
328 | dict_foreach (dict, _dict_mark_atindex, &dim); | |||||
329 | ||||||
330 | return dim.ikey; | |||||
331 | } | |||||
332 | ||||||
333 | static int | |||||
334 | glusterd_get_slave (glusterd_volinfo_t *vol, const char *slaveurl, char **slavekey) | |||||
335 | { | |||||
336 | runner_t runner = {0,}; | |||||
337 | int n = 0; | |||||
338 | int i = 0; | |||||
339 | char **linearr = NULL((void*)0); | |||||
340 | ||||||
341 | glusterd_urltransform_init (&runner, "canonicalize"); | |||||
342 | dict_foreach (vol->gsync_slaves, _glusterd_urltransform_add_iter, &runner); | |||||
343 | glusterd_urltransform_add (&runner, slaveurl); | |||||
344 | ||||||
345 | n = glusterd_urltransform (&runner, &linearr); | |||||
346 | if (n == -1) | |||||
347 | return -2; | |||||
348 | ||||||
349 | for (i = 0; i < n - 1; i++) { | |||||
350 | if (strcmp (linearr[i], linearr[n - 1]) == 0) | |||||
351 | break; | |||||
352 | } | |||||
353 | glusterd_urltransform_free (linearr, i); | |||||
354 | ||||||
355 | if (i < n - 1) | |||||
356 | *slavekey = dict_get_by_index (vol->gsync_slaves, i); | |||||
357 | else | |||||
358 | i = -1; | |||||
359 | ||||||
360 | return i; | |||||
361 | } | |||||
362 | ||||||
363 | ||||||
364 | static int | |||||
365 | glusterd_query_extutil_generic (char *resbuf, size_t blen, runner_t *runner, void *data, | |||||
366 | int (*fcbk)(char *resbuf, size_t blen, FILE *fp, void *data)) | |||||
367 | { | |||||
368 | int ret = 0; | |||||
369 | ||||||
370 | runner_redir (runner, STDOUT_FILENO1, RUN_PIPE-1); | |||||
371 | if (runner_start (runner) != 0) { | |||||
372 | gf_log ("", GF_LOG_ERROR, "spawning child failed")do { do { if (0) printf ("spawning child failed"); } while (0 ); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 372, GF_LOG_ERROR , "spawning child failed"); } while (0); | |||||
373 | ||||||
374 | return -1; | |||||
375 | } | |||||
376 | ||||||
377 | ret = fcbk (resbuf, blen, runner_chio (runner, STDOUT_FILENO1), data); | |||||
378 | ||||||
379 | ret |= runner_end (runner); | |||||
380 | if (ret) | |||||
381 | gf_log ("", GF_LOG_ERROR, "reading data from child failed")do { do { if (0) printf ("reading data from child failed"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 381 , GF_LOG_ERROR, "reading data from child failed"); } while (0 ); | |||||
382 | ||||||
383 | return ret ? -1 : 0; | |||||
384 | } | |||||
385 | ||||||
386 | static int | |||||
387 | _fcbk_singleline(char *resbuf, size_t blen, FILE *fp, void *data) | |||||
388 | { | |||||
389 | char *ptr = NULL((void*)0); | |||||
390 | ||||||
391 | errno(*__errno_location ()) = 0; | |||||
392 | ptr = fgets (resbuf, blen, fp); | |||||
393 | if (ptr) { | |||||
394 | size_t len = strlen(resbuf); | |||||
395 | if (len && resbuf[len-1] == '\n') | |||||
396 | resbuf[len-1] = '\0'; //strip off \n | |||||
397 | } | |||||
398 | ||||||
399 | return errno(*__errno_location ()) ? -1 : 0; | |||||
400 | } | |||||
401 | ||||||
402 | static int | |||||
403 | glusterd_query_extutil (char *resbuf, runner_t *runner) | |||||
404 | { | |||||
405 | return glusterd_query_extutil_generic (resbuf, PATH_MAX4096, runner, NULL((void*)0), | |||||
406 | _fcbk_singleline); | |||||
407 | } | |||||
408 | ||||||
409 | static int | |||||
410 | _fcbk_conftodict (char *resbuf, size_t blen, FILE *fp, void *data) | |||||
411 | { | |||||
412 | char *ptr = NULL((void*)0); | |||||
413 | dict_t *dict = data; | |||||
414 | char *v = NULL((void*)0); | |||||
415 | ||||||
416 | for (;;) { | |||||
417 | errno(*__errno_location ()) = 0; | |||||
418 | ptr = fgets (resbuf, blen, fp); | |||||
419 | if (!ptr) | |||||
420 | break; | |||||
421 | v = resbuf + strlen(resbuf) - 1; | |||||
422 | while (isspace (*v)((*__ctype_b_loc ())[(int) ((*v))] & (unsigned short int) _ISspace)) | |||||
423 | /* strip trailing space */ | |||||
424 | *v-- = '\0'; | |||||
425 | if (v == resbuf) | |||||
426 | /* skip empty line */ | |||||
427 | continue; | |||||
428 | v = strchr (resbuf, ':'); | |||||
429 | if (!v) | |||||
430 | return -1; | |||||
431 | *v++ = '\0'; | |||||
432 | while (isspace (*v)((*__ctype_b_loc ())[(int) ((*v))] & (unsigned short int) _ISspace)) | |||||
433 | v++; | |||||
434 | v = gf_strdup (v); | |||||
435 | if (!v) | |||||
436 | return -1; | |||||
437 | if (dict_set_dynstr (dict, resbuf, v) != 0) { | |||||
438 | GF_FREE (v)__gf_free (v); | |||||
439 | return -1; | |||||
440 | } | |||||
441 | } | |||||
442 | ||||||
443 | return errno(*__errno_location ()) ? -1 : 0; | |||||
444 | } | |||||
445 | ||||||
446 | static int | |||||
447 | glusterd_gsync_get_config (char *master, char *slave, char *gl_workdir, dict_t *dict) | |||||
448 | { | |||||
449 | /* key + value, where value must be able to accommodate a path */ | |||||
450 | char resbuf[256 + PATH_MAX4096] = {0,}; | |||||
451 | runner_t runner = {0,}; | |||||
452 | ||||||
453 | runinit (&runner); | |||||
454 | runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "-c", NULL((void*)0)); | |||||
455 | runner_argprintf (&runner, "%s/"GSYNC_CONF"geo-replication""/gsyncd.conf", gl_workdir); | |||||
456 | runner_argprintf (&runner, ":%s", master); | |||||
457 | runner_add_args (&runner, slave, "--config-get-all", NULL((void*)0)); | |||||
458 | ||||||
459 | return glusterd_query_extutil_generic (resbuf, sizeof (resbuf), | |||||
460 | &runner, dict, _fcbk_conftodict); | |||||
461 | } | |||||
462 | ||||||
463 | static int | |||||
464 | glusterd_gsync_get_param_file (char *prmfile, const char *param, char *master, | |||||
465 | char *slave, char *gl_workdir) | |||||
466 | { | |||||
467 | runner_t runner = {0,}; | |||||
468 | ||||||
469 | runinit (&runner); | |||||
470 | runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "-c", NULL((void*)0)); | |||||
471 | runner_argprintf (&runner, "%s/"GSYNC_CONF"geo-replication""/gsyncd.conf", gl_workdir); | |||||
472 | runner_argprintf (&runner, ":%s", master); | |||||
473 | runner_add_args (&runner, slave, "--config-get", NULL((void*)0)); | |||||
474 | runner_argprintf (&runner, "%s-file", param); | |||||
475 | ||||||
476 | return glusterd_query_extutil (prmfile, &runner); | |||||
477 | } | |||||
478 | ||||||
479 | static int | |||||
480 | glusterd_gsync_get_session_owner (char *master, char *slave, char *session_owner, | |||||
481 | char *gl_workdir) | |||||
482 | { | |||||
483 | runner_t runner = {0,}; | |||||
484 | ||||||
485 | runinit(&runner); | |||||
486 | runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "-c", NULL((void*)0)); | |||||
487 | runner_argprintf (&runner, "%s/"GSYNC_CONF"geo-replication""/gsyncd.conf", gl_workdir); | |||||
488 | runner_argprintf (&runner, ":%s", master); | |||||
489 | runner_add_args (&runner, slave, "--config-get", "session-owner", | |||||
490 | NULL((void*)0)); | |||||
491 | ||||||
492 | return glusterd_query_extutil (session_owner, &runner); | |||||
493 | } | |||||
494 | ||||||
495 | /* check whether @slave is local or remote. normalized | |||||
496 | * urls starting with ssh are considered to be remote | |||||
497 | * @returns | |||||
498 | * 1 if slave is remote | |||||
499 | * 0 is slave is local | |||||
500 | */ | |||||
501 | static int | |||||
502 | glusterd_gsync_slave_is_remote (char *slave) | |||||
503 | { | |||||
504 | int ret = 0; | |||||
505 | char *ssh_pos = NULL((void*)0); | |||||
506 | ||||||
507 | ssh_pos = strstr(slave, "ssh://"); | |||||
508 | if ( ssh_pos && ((ssh_pos - slave) == 0) ) | |||||
509 | ret = 1; | |||||
510 | ||||||
511 | return ret; | |||||
512 | } | |||||
513 | ||||||
514 | static int | |||||
515 | glusterd_gsync_get_slave_log_file (char *master, char *slave, char *log_file) | |||||
516 | { | |||||
517 | int ret = -1; | |||||
518 | runner_t runner = {0,}; | |||||
519 | char uuid_str[64] = {0,}; | |||||
520 | glusterd_conf_t *priv = NULL((void*)0); | |||||
521 | char *gl_workdir = NULL((void*)0); | |||||
522 | ||||||
523 | GF_ASSERT(THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 523, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
524 | GF_ASSERT(THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 524, GF_LOG_ERROR, "Assertion failed: " "THIS->private") ; } while (0); } } while (0); | |||||
525 | ||||||
526 | priv = THIS(*__glusterfs_this_location())->private; | |||||
527 | ||||||
528 | GF_VALIDATE_OR_GOTO("gsyncd", master, out)do { if (!master) { (*__errno_location ()) = 22; do { do { if (0) printf ("invalid argument: " "master"); } while (0); _gf_log_callingfn ("gsyncd", "glusterd-geo-rep.c", __FUNCTION__, 528, GF_LOG_ERROR , "invalid argument: " "master"); } while (0); goto out; } } while (0); | |||||
529 | GF_VALIDATE_OR_GOTO("gsyncd", slave, out)do { if (!slave) { (*__errno_location ()) = 22; do { do { if ( 0) printf ("invalid argument: " "slave"); } while (0); _gf_log_callingfn ("gsyncd", "glusterd-geo-rep.c", __FUNCTION__, 529, GF_LOG_ERROR , "invalid argument: " "slave"); } while (0); goto out; } } while (0); | |||||
530 | ||||||
531 | gl_workdir = priv->workdir; | |||||
532 | ||||||
533 | /* get the session owner for the master-slave session */ | |||||
534 | ret = glusterd_gsync_get_session_owner (master, slave, uuid_str, | |||||
535 | gl_workdir); | |||||
536 | if (ret) | |||||
537 | goto out; | |||||
538 | ||||||
539 | /* get the log file for the slave */ | |||||
540 | runinit(&runner); | |||||
541 | runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "-c", NULL((void*)0)); | |||||
542 | runner_argprintf (&runner, "%s/"GSYNC_CONF"geo-replication""/gsyncd.conf", gl_workdir); | |||||
543 | runner_argprintf (&runner, "--session-owner=%s", uuid_str); | |||||
544 | runner_add_args (&runner, slave, "--config-get", "log-file", NULL((void*)0)); | |||||
545 | ||||||
546 | ret = glusterd_query_extutil (log_file, &runner); | |||||
547 | ||||||
548 | out: | |||||
549 | return ret; | |||||
550 | } | |||||
551 | ||||||
552 | static int | |||||
553 | gsyncd_getpidfile (char *master, char *slave, char *pidfile) | |||||
554 | { | |||||
555 | int ret = -1; | |||||
556 | glusterd_conf_t *priv = NULL((void*)0); | |||||
557 | ||||||
558 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 558, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
559 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 559, GF_LOG_ERROR, "Assertion failed: " "THIS->private") ; } while (0); } } while (0); | |||||
560 | ||||||
561 | priv = THIS(*__glusterfs_this_location())->private; | |||||
562 | ||||||
563 | GF_VALIDATE_OR_GOTO ("gsync", master, out)do { if (!master) { (*__errno_location ()) = 22; do { do { if (0) printf ("invalid argument: " "master"); } while (0); _gf_log_callingfn ("gsync", "glusterd-geo-rep.c", __FUNCTION__, 563, GF_LOG_ERROR , "invalid argument: " "master"); } while (0); goto out; } } while (0); | |||||
564 | GF_VALIDATE_OR_GOTO ("gsync", slave, out)do { if (!slave) { (*__errno_location ()) = 22; do { do { if ( 0) printf ("invalid argument: " "slave"); } while (0); _gf_log_callingfn ("gsync", "glusterd-geo-rep.c", __FUNCTION__, 564, GF_LOG_ERROR , "invalid argument: " "slave"); } while (0); goto out; } } while (0); | |||||
565 | ||||||
566 | ret = glusterd_gsync_get_param_file (pidfile, "pid", master, | |||||
567 | slave, priv->workdir); | |||||
568 | if (ret == -1) { | |||||
569 | ret = -2; | |||||
570 | gf_log ("", GF_LOG_WARNING, "failed to create the pidfile string")do { do { if (0) printf ("failed to create the pidfile string" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 570, GF_LOG_WARNING, "failed to create the pidfile string") ; } while (0); | |||||
571 | goto out; | |||||
572 | } | |||||
573 | ||||||
574 | ret = open (pidfile, O_RDWR02); | |||||
575 | ||||||
576 | out: | |||||
577 | return ret; | |||||
578 | } | |||||
579 | ||||||
580 | static int | |||||
581 | glusterd_gsyncd_getlogfile (char *master, char *slave, char *log_file) | |||||
582 | { | |||||
583 | int ret = -1; | |||||
584 | glusterd_conf_t *priv = NULL((void*)0); | |||||
585 | ||||||
586 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 586, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
587 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 587, GF_LOG_ERROR, "Assertion failed: " "THIS->private") ; } while (0); } } while (0); | |||||
588 | ||||||
589 | priv = THIS(*__glusterfs_this_location())->private; | |||||
590 | ||||||
591 | GF_VALIDATE_OR_GOTO ("gsync", master, out)do { if (!master) { (*__errno_location ()) = 22; do { do { if (0) printf ("invalid argument: " "master"); } while (0); _gf_log_callingfn ("gsync", "glusterd-geo-rep.c", __FUNCTION__, 591, GF_LOG_ERROR , "invalid argument: " "master"); } while (0); goto out; } } while (0); | |||||
592 | GF_VALIDATE_OR_GOTO ("gsync", slave, out)do { if (!slave) { (*__errno_location ()) = 22; do { do { if ( 0) printf ("invalid argument: " "slave"); } while (0); _gf_log_callingfn ("gsync", "glusterd-geo-rep.c", __FUNCTION__, 592, GF_LOG_ERROR , "invalid argument: " "slave"); } while (0); goto out; } } while (0); | |||||
593 | ||||||
594 | ret = glusterd_gsync_get_param_file (log_file, "log", master, | |||||
595 | slave, priv->workdir); | |||||
596 | if (ret == -1) { | |||||
597 | ret = -2; | |||||
598 | gf_log ("", GF_LOG_WARNING, "failed to gsyncd logfile")do { do { if (0) printf ("failed to gsyncd logfile"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 598, GF_LOG_WARNING , "failed to gsyncd logfile"); } while (0); | |||||
599 | goto out; | |||||
600 | } | |||||
601 | ||||||
602 | out: | |||||
603 | return ret; | |||||
604 | } | |||||
605 | ||||||
606 | static int | |||||
607 | gsync_status_byfd (int fd) | |||||
608 | { | |||||
609 | GF_ASSERT (fd >= -1)do { if (!(fd >= -1)) { do { do { if (0) printf ("Assertion failed: " "fd >= -1"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 609, GF_LOG_ERROR, "Assertion failed: " "fd >= -1" ); } while (0); } } while (0); | |||||
610 | ||||||
611 | if (lockf (fd, F_TEST3, 0) == -1 && | |||||
612 | (errno(*__errno_location ()) == EAGAIN11 || errno(*__errno_location ()) == EACCES13)) | |||||
613 | /* gsyncd keeps the pidfile locked */ | |||||
614 | return 0; | |||||
615 | ||||||
616 | return -1; | |||||
617 | } | |||||
618 | ||||||
619 | /* status: return 0 when gsync is running | |||||
620 | * return -1 when not running | |||||
621 | */ | |||||
622 | int | |||||
623 | gsync_status (char *master, char *slave, int *status) | |||||
624 | { | |||||
625 | char pidfile[PATH_MAX4096] = {0,}; | |||||
626 | int fd = -1; | |||||
627 | ||||||
628 | fd = gsyncd_getpidfile (master, slave, pidfile); | |||||
629 | if (fd == -2) | |||||
630 | return -1; | |||||
631 | ||||||
632 | *status = gsync_status_byfd (fd); | |||||
633 | ||||||
634 | sys_close (fd); | |||||
635 | ||||||
636 | return 0; | |||||
637 | } | |||||
638 | ||||||
639 | ||||||
640 | static int32_t | |||||
641 | glusterd_gsync_volinfo_dict_set (glusterd_volinfo_t *volinfo, | |||||
642 | char *key, char *value) | |||||
643 | { | |||||
644 | int32_t ret = -1; | |||||
645 | char *gsync_status = NULL((void*)0); | |||||
646 | ||||||
647 | gsync_status = gf_strdup (value); | |||||
648 | if (!gsync_status) { | |||||
649 | gf_log ("", GF_LOG_ERROR, "Unable to allocate memory")do { do { if (0) printf ("Unable to allocate memory"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 649, GF_LOG_ERROR , "Unable to allocate memory"); } while (0); | |||||
650 | goto out; | |||||
651 | } | |||||
652 | ||||||
653 | ret = dict_set_dynstr (volinfo->dict, key, gsync_status); | |||||
654 | if (ret) { | |||||
655 | gf_log ("", GF_LOG_ERROR, "Unable to set dict")do { do { if (0) printf ("Unable to set dict"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 655, GF_LOG_ERROR, "Unable to set dict" ); } while (0); | |||||
656 | goto out; | |||||
657 | } | |||||
658 | ||||||
659 | ret = 0; | |||||
660 | out: | |||||
661 | return 0; | |||||
662 | } | |||||
663 | ||||||
664 | static int | |||||
665 | gsync_verify_config_options (dict_t *dict, char **op_errstr) | |||||
666 | { | |||||
667 | char **resopt = NULL((void*)0); | |||||
668 | int i = 0; | |||||
669 | char *subop = NULL((void*)0); | |||||
670 | char *slave = NULL((void*)0); | |||||
671 | char *op_name = NULL((void*)0); | |||||
672 | char *op_value = NULL((void*)0); | |||||
673 | char *t = NULL((void*)0); | |||||
674 | gf_boolean_t banned = _gf_true; | |||||
675 | ||||||
676 | if (dict_get_str (dict, "subop", &subop) != 0) { | |||||
677 | gf_log ("", GF_LOG_WARNING, "missing subop")do { do { if (0) printf ("missing subop"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 677, GF_LOG_WARNING , "missing subop"); } while (0); | |||||
678 | *op_errstr = gf_strdup ("Invalid config request"); | |||||
679 | return -1; | |||||
680 | } | |||||
681 | ||||||
682 | if (dict_get_str (dict, "slave", &slave) != 0) { | |||||
683 | gf_log ("", GF_LOG_WARNING, GEOREP" CONFIG: no slave given")do { do { if (0) printf ("geo-replication"" CONFIG: no slave given" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 683, GF_LOG_WARNING, "geo-replication"" CONFIG: no slave given" ); } while (0); | |||||
684 | *op_errstr = gf_strdup ("Slave required"); | |||||
685 | return -1; | |||||
686 | } | |||||
687 | ||||||
688 | if (strcmp (subop, "get-all") == 0) | |||||
689 | return 0; | |||||
690 | ||||||
691 | if (dict_get_str (dict, "op_name", &op_name) != 0) { | |||||
692 | gf_log ("", GF_LOG_WARNING, "option name missing")do { do { if (0) printf ("option name missing"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 692, GF_LOG_WARNING , "option name missing"); } while (0); | |||||
693 | *op_errstr = gf_strdup ("Option name missing"); | |||||
694 | return -1; | |||||
695 | } | |||||
696 | ||||||
697 | if (runcmd (GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "--config-check", op_name, NULL((void*)0))) { | |||||
698 | gf_log ("", GF_LOG_WARNING, "Invalid option %s", op_name)do { do { if (0) printf ("Invalid option %s", op_name); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 698, GF_LOG_WARNING , "Invalid option %s", op_name); } while (0); | |||||
699 | *op_errstr = gf_strdup ("Invalid option"); | |||||
700 | ||||||
701 | return -1; | |||||
702 | } | |||||
703 | ||||||
704 | if (strcmp (subop, "get") == 0) | |||||
705 | return 0; | |||||
706 | ||||||
707 | t = strtail (subop, "set"); | |||||
708 | if (!t) | |||||
709 | t = strtail (subop, "del"); | |||||
710 | if (!t || (t[0] && strcmp (t, "-glob") != 0)) { | |||||
711 | gf_log ("", GF_LOG_WARNING, "unknown subop %s", subop)do { do { if (0) printf ("unknown subop %s", subop); } while ( 0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 711, GF_LOG_WARNING , "unknown subop %s", subop); } while (0); | |||||
712 | *op_errstr = gf_strdup ("Invalid config request"); | |||||
713 | return -1; | |||||
714 | } | |||||
715 | ||||||
716 | if (strtail (subop, "set") && | |||||
717 | dict_get_str (dict, "op_value", &op_value) != 0) { | |||||
718 | gf_log ("", GF_LOG_WARNING, "missing value for set")do { do { if (0) printf ("missing value for set"); } while (0 ); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 718, GF_LOG_WARNING , "missing value for set"); } while (0); | |||||
719 | *op_errstr = gf_strdup ("missing value"); | |||||
720 | } | |||||
721 | ||||||
722 | /* match option name against reserved options, modulo -/_ | |||||
723 | * difference | |||||
724 | */ | |||||
725 | for (resopt = gsync_reserved_opts; *resopt; resopt++) { | |||||
726 | banned = _gf_true; | |||||
727 | for (i = 0; (*resopt)[i] && op_name[i]; i++) { | |||||
728 | if ((*resopt)[i] == op_name[i] || | |||||
729 | ((*resopt)[i] == '-' && op_name[i] == '_')) | |||||
730 | continue; | |||||
731 | banned = _gf_false; | |||||
732 | } | |||||
733 | if (banned) { | |||||
734 | gf_log ("", GF_LOG_WARNING, "Reserved option %s", op_name)do { do { if (0) printf ("Reserved option %s", op_name); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 734, GF_LOG_WARNING , "Reserved option %s", op_name); } while (0); | |||||
735 | *op_errstr = gf_strdup ("Reserved option"); | |||||
736 | ||||||
737 | return -1; | |||||
738 | break; | |||||
739 | } | |||||
740 | } | |||||
741 | ||||||
742 | return 0; | |||||
743 | } | |||||
744 | ||||||
745 | static int | |||||
746 | glusterd_get_gsync_status_mst_slv (glusterd_volinfo_t *volinfo, | |||||
747 | char *slave, dict_t *rsp_dict, char *node); | |||||
748 | ||||||
749 | static int | |||||
750 | _get_status_mst_slv (dict_t *this, char *key, data_t *value, void *data) | |||||
751 | { | |||||
752 | glusterd_gsync_status_temp_t *param = NULL((void*)0); | |||||
753 | char *slave = NULL((void*)0); | |||||
754 | int ret = 0; | |||||
755 | ||||||
756 | param = (glusterd_gsync_status_temp_t *)data; | |||||
757 | ||||||
758 | GF_ASSERT (param)do { if (!(param)) { do { do { if (0) printf ("Assertion failed: " "param"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 758, GF_LOG_ERROR, "Assertion failed: " "param" ); } while (0); } } while (0); | |||||
759 | GF_ASSERT (param->volinfo)do { if (!(param->volinfo)) { do { do { if (0) printf ("Assertion failed: " "param->volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 759, GF_LOG_ERROR, "Assertion failed: " "param->volinfo" ); } while (0); } } while (0); | |||||
760 | ||||||
761 | slave = strchr(value->data, ':'); | |||||
762 | if (slave) | |||||
763 | slave ++; | |||||
764 | else | |||||
765 | return 0; | |||||
766 | ||||||
767 | ret = glusterd_get_gsync_status_mst_slv(param->volinfo, | |||||
768 | slave, param->rsp_dict, | |||||
769 | param->node); | |||||
770 | return 0; | |||||
771 | } | |||||
772 | ||||||
773 | ||||||
774 | static int | |||||
775 | _get_max_gsync_slave_num (dict_t *this, char *key, data_t *value, void *data) | |||||
776 | { | |||||
777 | int tmp_slvnum = 0; | |||||
778 | int *slvnum = (int *)data; | |||||
779 | ||||||
780 | sscanf (key, "slave%d", &tmp_slvnum); | |||||
781 | if (tmp_slvnum > *slvnum) | |||||
782 | *slvnum = tmp_slvnum; | |||||
783 | ||||||
784 | return 0; | |||||
785 | } | |||||
786 | ||||||
787 | static int | |||||
788 | glusterd_remove_slave_in_info (glusterd_volinfo_t *volinfo, char *slave, | |||||
789 | char **op_errstr) | |||||
790 | { | |||||
791 | int ret = 0; | |||||
792 | char *slavekey = NULL((void*)0); | |||||
793 | ||||||
794 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 794, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
795 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 795, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
796 | ||||||
797 | ret = glusterd_get_slave (volinfo, slave, &slavekey); | |||||
798 | if (ret < 0) { | |||||
799 | ret++; | |||||
800 | goto out; | |||||
801 | } | |||||
802 | ||||||
803 | dict_del (volinfo->gsync_slaves, slavekey); | |||||
804 | ||||||
805 | ret = glusterd_store_volinfo (volinfo, | |||||
806 | GLUSTERD_VOLINFO_VER_AC_INCREMENT); | |||||
807 | if (ret) { | |||||
808 | *op_errstr = gf_strdup ("Failed to store the Volume" | |||||
809 | "information"); | |||||
810 | goto out; | |||||
811 | } | |||||
812 | out: | |||||
813 | gf_log ("", GF_LOG_DEBUG, "returning %d", ret)do { do { if (0) printf ("returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 813, GF_LOG_DEBUG, "returning %d" , ret); } while (0); | |||||
814 | return ret; | |||||
815 | ||||||
816 | } | |||||
817 | ||||||
818 | static int | |||||
819 | glusterd_gsync_get_uuid (char *slave, glusterd_volinfo_t *vol, | |||||
820 | uuid_t uuid) | |||||
821 | { | |||||
822 | int ret = 0; | |||||
823 | char *slavekey = NULL((void*)0); | |||||
824 | char *slaveentry = NULL((void*)0); | |||||
825 | char *t = NULL((void*)0); | |||||
826 | ||||||
827 | GF_ASSERT (vol)do { if (!(vol)) { do { do { if (0) printf ("Assertion failed: " "vol"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 827, GF_LOG_ERROR, "Assertion failed: " "vol" ); } while (0); } } while (0); | |||||
828 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 828, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
829 | ||||||
830 | ret = glusterd_get_slave (vol, slave, &slavekey); | |||||
831 | if (ret < 0) { | |||||
832 | /* XXX colliding cases of failure and non-extant | |||||
833 | * slave... now just doing this as callers of this | |||||
834 | * function can make sense only of -1 and 0 as retvals; | |||||
835 | * getting at the proper semanticals will involve | |||||
836 | * fixing callers as well. | |||||
837 | */ | |||||
838 | ret = -1; | |||||
839 | goto out; | |||||
840 | } | |||||
841 | ||||||
842 | ret = dict_get_str (vol->gsync_slaves, slavekey, &slaveentry); | |||||
843 | GF_ASSERT (ret == 0)do { if (!(ret == 0)) { do { do { if (0) printf ("Assertion failed: " "ret == 0"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 843, GF_LOG_ERROR, "Assertion failed: " "ret == 0" ); } while (0); } } while (0); | |||||
844 | ||||||
845 | t = strchr (slaveentry, ':'); | |||||
846 | GF_ASSERT (t)do { if (!(t)) { do { do { if (0) printf ("Assertion failed: " "t"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 846, GF_LOG_ERROR, "Assertion failed: " "t"); } while (0); } } while (0); | |||||
847 | *t = '\0'; | |||||
848 | ret = uuid_parse (slaveentry, uuid); | |||||
849 | *t = ':'; | |||||
850 | ||||||
851 | out: | |||||
852 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 852, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | |||||
853 | return ret; | |||||
854 | } | |||||
855 | ||||||
856 | static int | |||||
857 | glusterd_check_gsync_running_local (char *master, char *slave, | |||||
858 | gf_boolean_t *is_run) | |||||
859 | { | |||||
860 | int ret = -1; | |||||
861 | int ret_status = 0; | |||||
862 | ||||||
863 | GF_ASSERT (master)do { if (!(master)) { do { do { if (0) printf ("Assertion failed: " "master"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 863, GF_LOG_ERROR, "Assertion failed: " "master" ); } while (0); } } while (0); | |||||
864 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 864, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
865 | GF_ASSERT (is_run)do { if (!(is_run)) { do { do { if (0) printf ("Assertion failed: " "is_run"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 865, GF_LOG_ERROR, "Assertion failed: " "is_run" ); } while (0); } } while (0); | |||||
866 | ||||||
867 | *is_run = _gf_false; | |||||
868 | ret = gsync_status (master, slave, &ret_status); | |||||
869 | if (ret == 0 && ret_status == 0) { | |||||
870 | *is_run = _gf_true; | |||||
871 | } else if (ret == -1) { | |||||
872 | gf_log ("", GF_LOG_WARNING, GEOREP" validation "do { do { if (0) printf ("geo-replication"" validation " " failed" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 873, GF_LOG_WARNING, "geo-replication"" validation " " failed" ); } while (0) | |||||
873 | " failed")do { do { if (0) printf ("geo-replication"" validation " " failed" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 873, GF_LOG_WARNING, "geo-replication"" validation " " failed" ); } while (0); | |||||
874 | goto out; | |||||
875 | } | |||||
876 | ret = 0; | |||||
877 | out: | |||||
878 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 878, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | |||||
879 | return ret; | |||||
880 | ||||||
881 | } | |||||
882 | ||||||
883 | static int | |||||
884 | glusterd_store_slave_in_info (glusterd_volinfo_t *volinfo, char *slave, | |||||
885 | char *host_uuid, char **op_errstr) | |||||
886 | { | |||||
887 | int ret = 0; | |||||
888 | int maxslv = 0; | |||||
889 | char **linearr = NULL((void*)0); | |||||
890 | char *value = NULL((void*)0); | |||||
891 | char *slavekey = NULL((void*)0); | |||||
892 | char *slaveentry = NULL((void*)0); | |||||
893 | char key[512] = {0, }; | |||||
894 | char *t = NULL((void*)0); | |||||
895 | ||||||
896 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 896, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
897 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 897, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
898 | GF_ASSERT (host_uuid)do { if (!(host_uuid)) { do { do { if (0) printf ("Assertion failed: " "host_uuid"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 898, GF_LOG_ERROR, "Assertion failed: " "host_uuid" ); } while (0); } } while (0); | |||||
899 | ||||||
900 | ret = glusterd_get_slave (volinfo, slave, &slavekey); | |||||
901 | switch (ret) { | |||||
902 | case -2: | |||||
903 | ret = -1; | |||||
904 | goto out; | |||||
905 | case -1: | |||||
906 | break; | |||||
907 | default: | |||||
908 | GF_ASSERT (ret > 0)do { if (!(ret > 0)) { do { do { if (0) printf ("Assertion failed: " "ret > 0"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 908, GF_LOG_ERROR, "Assertion failed: " "ret > 0" ); } while (0); } } while (0); | |||||
909 | ret = dict_get_str (volinfo->gsync_slaves, slavekey, &slaveentry); | |||||
910 | GF_ASSERT (ret == 0)do { if (!(ret == 0)) { do { do { if (0) printf ("Assertion failed: " "ret == 0"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 910, GF_LOG_ERROR, "Assertion failed: " "ret == 0" ); } while (0); } } while (0); | |||||
911 | ||||||
912 | /* same-name + same-uuid slave entries should have been filtered | |||||
913 | * out in glusterd_op_verify_gsync_start_options(), so we can | |||||
914 | * assert an uuid mismatch | |||||
915 | */ | |||||
916 | t = strtail (slaveentry, host_uuid); | |||||
917 | GF_ASSERT (!t || *t != ':')do { if (!(!t || *t != ':')) { do { do { if (0) printf ("Assertion failed: " "!t || *t != ':'"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 917, GF_LOG_ERROR, "Assertion failed: " "!t || *t != ':'" ); } while (0); } } while (0); | |||||
918 | ||||||
919 | gf_log ("", GF_LOG_ERROR, GEOREP" has already been invoked for "do { do { if (0) printf ("geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 922, GF_LOG_ERROR, "geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0) | |||||
920 | "the %s (master) and %s (slave) "do { do { if (0) printf ("geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 922, GF_LOG_ERROR, "geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0) | |||||
921 | "from a different machine",do { do { if (0) printf ("geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 922, GF_LOG_ERROR, "geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0) | |||||
922 | volinfo->volname, slave)do { do { if (0) printf ("geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 922, GF_LOG_ERROR, "geo-replication"" has already been invoked for " "the %s (master) and %s (slave) " "from a different machine" , volinfo->volname, slave); } while (0); | |||||
923 | *op_errstr = gf_strdup (GEOREP"geo-replication"" already running in an an" | |||||
924 | "another machine"); | |||||
925 | ret = -1; | |||||
926 | goto out; | |||||
927 | } | |||||
928 | ||||||
929 | ret = glusterd_urltransform_single (slave, "normalize", &linearr); | |||||
930 | if (ret == -1) | |||||
931 | goto out; | |||||
932 | ||||||
933 | ret = gf_asprintf (&value, "%s:%s", host_uuid, linearr[0]); | |||||
934 | glusterd_urltransform_free (linearr, 1); | |||||
935 | if (ret == -1) | |||||
936 | goto out; | |||||
937 | ||||||
938 | dict_foreach (volinfo->gsync_slaves, _get_max_gsync_slave_num, &maxslv); | |||||
939 | snprintf (key, 512, "slave%d", maxslv + 1); | |||||
940 | ret = dict_set_dynstr (volinfo->gsync_slaves, key, value); | |||||
941 | if (ret) | |||||
942 | goto out; | |||||
943 | ||||||
944 | ret = glusterd_store_volinfo (volinfo, | |||||
945 | GLUSTERD_VOLINFO_VER_AC_INCREMENT); | |||||
946 | if (ret) { | |||||
947 | *op_errstr = gf_strdup ("Failed to store the Volume " | |||||
948 | "information"); | |||||
949 | goto out; | |||||
950 | } | |||||
951 | ret = 0; | |||||
952 | out: | |||||
953 | return ret; | |||||
954 | } | |||||
955 | ||||||
956 | ||||||
957 | static int | |||||
958 | glusterd_op_verify_gsync_start_options (glusterd_volinfo_t *volinfo, | |||||
959 | char *slave, char **op_errstr) | |||||
960 | { | |||||
961 | int ret = -1; | |||||
962 | gf_boolean_t is_running = _gf_false; | |||||
963 | char msg[2048] = {0}; | |||||
964 | uuid_t uuid = {0}; | |||||
965 | glusterd_conf_t *priv = NULL((void*)0); | |||||
966 | xlator_t *this = NULL((void*)0); | |||||
967 | ||||||
968 | this = THIS(*__glusterfs_this_location()); | |||||
969 | ||||||
970 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 970, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
971 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 971, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
972 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 972, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | |||||
973 | GF_ASSERT (this && this->private)do { if (!(this && this->private)) { do { do { if ( 0) printf ("Assertion failed: " "this && this->private" ); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 973, GF_LOG_ERROR, "Assertion failed: " "this && this->private" ); } while (0); } } while (0); | |||||
974 | ||||||
975 | priv = this->private; | |||||
976 | ||||||
977 | if (GLUSTERD_STATUS_STARTED != volinfo->status) { | |||||
978 | snprintf (msg, sizeof (msg), "Volume %s needs to be started " | |||||
979 | "before "GEOREP"geo-replication"" start", volinfo->volname); | |||||
980 | goto out; | |||||
981 | } | |||||
982 | /*Check if the gsync is already started in cmd. inited host | |||||
983 | * If so initiate add it into the glusterd's priv*/ | |||||
984 | ret = glusterd_gsync_get_uuid (slave, volinfo, uuid); | |||||
985 | if ((ret == 0) && (uuid_compare (MY_UUID(__glusterd_uuid()), uuid) == 0)) { | |||||
986 | ret = glusterd_check_gsync_running_local (volinfo->volname, | |||||
987 | slave, &is_running); | |||||
988 | if (ret) { | |||||
989 | snprintf (msg, sizeof (msg), GEOREP"geo-replication"" start option " | |||||
990 | "validation failed "); | |||||
991 | goto out; | |||||
992 | } | |||||
993 | if (_gf_true == is_running) { | |||||
994 | snprintf (msg, sizeof (msg), GEOREP"geo-replication" " session between" | |||||
995 | " %s & %s already started", volinfo->volname, | |||||
996 | slave); | |||||
997 | ret = -1; | |||||
998 | goto out; | |||||
999 | } | |||||
1000 | } | |||||
1001 | ret = 0; | |||||
1002 | out: | |||||
1003 | if (ret && (msg[0] != '\0')) { | |||||
1004 | *op_errstr = gf_strdup (msg); | |||||
1005 | } | |||||
1006 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1006, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1007 | return ret; | |||||
1008 | } | |||||
1009 | ||||||
1010 | int | |||||
1011 | glusterd_check_gsync_running (glusterd_volinfo_t *volinfo, gf_boolean_t *flag) | |||||
1012 | { | |||||
1013 | ||||||
1014 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1014, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
1015 | GF_ASSERT (flag)do { if (!(flag)) { do { do { if (0) printf ("Assertion failed: " "flag"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1015, GF_LOG_ERROR, "Assertion failed: " "flag" ); } while (0); } } while (0); | |||||
1016 | ||||||
1017 | if (volinfo->gsync_slaves->count) | |||||
1018 | *flag = _gf_true; | |||||
1019 | else | |||||
1020 | *flag = _gf_false; | |||||
1021 | ||||||
1022 | return 0; | |||||
1023 | } | |||||
1024 | ||||||
1025 | static int | |||||
1026 | glusterd_op_verify_gsync_running (glusterd_volinfo_t *volinfo, | |||||
1027 | char *slave, char **op_errstr) | |||||
1028 | { | |||||
1029 | int ret = -1; | |||||
1030 | char msg[2048] = {0}; | |||||
1031 | uuid_t uuid = {0}; | |||||
1032 | ||||||
1033 | GF_ASSERT (THIS && THIS->private)do { if (!((*__glusterfs_this_location()) && (*__glusterfs_this_location ())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS && THIS->private"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1033, GF_LOG_ERROR, "Assertion failed: " "THIS && THIS->private"); } while (0); } } while (0); | |||||
1034 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1034, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
1035 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1035, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
1036 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1036, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | |||||
1037 | ||||||
1038 | if (GLUSTERD_STATUS_STARTED != volinfo->status) { | |||||
1039 | snprintf (msg, sizeof (msg), "Volume %s needs to be started " | |||||
1040 | "before "GEOREP"geo-replication"" start", volinfo->volname); | |||||
1041 | ||||||
1042 | goto out; | |||||
1043 | } | |||||
1044 | ret = glusterd_gsync_get_uuid (slave, volinfo, uuid); | |||||
1045 | if (ret == -1) { | |||||
1046 | snprintf (msg, sizeof (msg), GEOREP"geo-replication"" session between %s & %s" | |||||
1047 | " not active", volinfo->volname, slave); | |||||
1048 | goto out; | |||||
1049 | } | |||||
1050 | ||||||
1051 | ret = 0; | |||||
1052 | out: | |||||
1053 | if (ret && (msg[0] != '\0')) { | |||||
1054 | *op_errstr = gf_strdup (msg); | |||||
1055 | } | |||||
1056 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1056, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1057 | return ret; | |||||
1058 | } | |||||
1059 | ||||||
1060 | static int | |||||
1061 | glusterd_verify_gsync_status_opts (dict_t *dict, char **op_errstr) | |||||
1062 | { | |||||
1063 | char *slave = NULL((void*)0); | |||||
1064 | char *volname = NULL((void*)0); | |||||
1065 | char errmsg[PATH_MAX4096] = {0, }; | |||||
1066 | gf_boolean_t exists = _gf_false; | |||||
1067 | glusterd_volinfo_t *volinfo = NULL((void*)0); | |||||
1068 | int ret = 0; | |||||
1069 | ||||||
1070 | ret = dict_get_str (dict, "master", &volname); | |||||
1071 | if (ret < 0) { | |||||
1072 | ret = 0; | |||||
1073 | goto out; | |||||
1074 | } | |||||
1075 | ||||||
1076 | exists = glusterd_check_volume_exists (volname); | |||||
1077 | ret = glusterd_volinfo_find (volname, &volinfo); | |||||
1078 | if ((ret) || (!exists)) { | |||||
1079 | gf_log ("", GF_LOG_WARNING, "volume name does not exist")do { do { if (0) printf ("volume name does not exist"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1079, GF_LOG_WARNING , "volume name does not exist"); } while (0); | |||||
1080 | snprintf (errmsg, sizeof(errmsg), "Volume name %s does not" | |||||
1081 | " exist", volname); | |||||
1082 | *op_errstr = gf_strdup (errmsg); | |||||
1083 | ret = -1; | |||||
1084 | goto out; | |||||
1085 | } | |||||
1086 | ||||||
1087 | ret = dict_get_str (dict, "slave", &slave); | |||||
1088 | if (ret < 0) { | |||||
1089 | ret = 0; | |||||
1090 | goto out; | |||||
1091 | } | |||||
1092 | ||||||
1093 | out: | |||||
1094 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1094, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1095 | return ret; | |||||
1096 | ||||||
1097 | } | |||||
1098 | ||||||
1099 | ||||||
1100 | int | |||||
1101 | glusterd_op_gsync_args_get (dict_t *dict, char **op_errstr, | |||||
1102 | char **master, char **slave) | |||||
1103 | { | |||||
1104 | ||||||
1105 | int ret = -1; | |||||
1106 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1106, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | |||||
1107 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1107, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | |||||
1108 | ||||||
1109 | if (master) { | |||||
1110 | ret = dict_get_str (dict, "master", master); | |||||
1111 | if (ret < 0) { | |||||
1112 | gf_log ("", GF_LOG_WARNING, "master not found")do { do { if (0) printf ("master not found"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1112, GF_LOG_WARNING , "master not found"); } while (0); | |||||
1113 | *op_errstr = gf_strdup ("master not found"); | |||||
1114 | goto out; | |||||
1115 | } | |||||
1116 | } | |||||
1117 | ||||||
1118 | if (slave) { | |||||
1119 | ret = dict_get_str (dict, "slave", slave); | |||||
1120 | if (ret < 0) { | |||||
1121 | gf_log ("", GF_LOG_WARNING, "slave not found")do { do { if (0) printf ("slave not found"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1121, GF_LOG_WARNING , "slave not found"); } while (0); | |||||
1122 | *op_errstr = gf_strdup ("slave not found"); | |||||
1123 | goto out; | |||||
1124 | } | |||||
1125 | } | |||||
1126 | ||||||
1127 | ||||||
1128 | ret = 0; | |||||
1129 | out: | |||||
1130 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1130, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1131 | return ret; | |||||
1132 | } | |||||
1133 | ||||||
1134 | int | |||||
1135 | glusterd_op_stage_gsync_set (dict_t *dict, char **op_errstr) | |||||
1136 | { | |||||
1137 | int ret = 0; | |||||
1138 | int type = 0; | |||||
1139 | char *volname = NULL((void*)0); | |||||
1140 | char *slave = NULL((void*)0); | |||||
1141 | gf_boolean_t exists = _gf_false; | |||||
1142 | glusterd_volinfo_t *volinfo = NULL((void*)0); | |||||
1143 | char errmsg[PATH_MAX4096] = {0,}; | |||||
1144 | dict_t *ctx = NULL((void*)0); | |||||
1145 | ||||||
1146 | ||||||
1147 | ret = dict_get_int32 (dict, "type", &type); | |||||
1148 | if (ret < 0) { | |||||
1149 | gf_log ("", GF_LOG_WARNING, "command type not found")do { do { if (0) printf ("command type not found"); } while ( 0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1149, GF_LOG_WARNING , "command type not found"); } while (0); | |||||
1150 | *op_errstr = gf_strdup ("command unsuccessful"); | |||||
1151 | goto out; | |||||
1152 | } | |||||
1153 | ||||||
1154 | switch (type) { | |||||
1155 | case GF_GSYNC_OPTION_TYPE_STATUS: | |||||
1156 | ret = glusterd_verify_gsync_status_opts (dict, op_errstr); | |||||
1157 | ||||||
1158 | goto out; | |||||
1159 | case GF_GSYNC_OPTION_TYPE_CONFIG: | |||||
1160 | ret = gsync_verify_config_options (dict, op_errstr); | |||||
1161 | ||||||
1162 | goto out; | |||||
1163 | ||||||
1164 | case GF_GSYNC_OPTION_TYPE_ROTATE: | |||||
1165 | /* checks same as status mode */ | |||||
1166 | ret = glusterd_verify_gsync_status_opts(dict, op_errstr); | |||||
1167 | goto out; | |||||
1168 | } | |||||
1169 | ||||||
1170 | ret = glusterd_op_gsync_args_get (dict, op_errstr, &volname, &slave); | |||||
1171 | if (ret) | |||||
1172 | goto out; | |||||
1173 | ||||||
1174 | exists = glusterd_check_volume_exists (volname); | |||||
1175 | ret = glusterd_volinfo_find (volname, &volinfo); | |||||
1176 | if ((ret) || (!exists)) { | |||||
1177 | gf_log ("", GF_LOG_WARNING, "volume name does not exist")do { do { if (0) printf ("volume name does not exist"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1177, GF_LOG_WARNING , "volume name does not exist"); } while (0); | |||||
1178 | snprintf (errmsg, sizeof(errmsg), "Volume name %s does not" | |||||
1179 | " exist", volname); | |||||
1180 | *op_errstr = gf_strdup (errmsg); | |||||
1181 | ret = -1; | |||||
1182 | goto out; | |||||
1183 | } | |||||
1184 | ||||||
1185 | switch (type) { | |||||
1186 | case GF_GSYNC_OPTION_TYPE_START: | |||||
1187 | /* don't attempt to start gsync if replace-brick is | |||||
1188 | * in progress */ | |||||
1189 | if (glusterd_is_rb_ongoing (volinfo)) { | |||||
1190 | snprintf (errmsg, sizeof(errmsg),"replace-brick is in" | |||||
1191 | " progress, not starting geo-replication"); | |||||
1192 | *op_errstr = gf_strdup (errmsg); | |||||
1193 | ret = -1; | |||||
1194 | goto out; | |||||
1195 | } | |||||
1196 | ||||||
1197 | ret = glusterd_op_verify_gsync_start_options (volinfo, slave, | |||||
1198 | op_errstr); | |||||
1199 | if (ret) | |||||
1200 | goto out; | |||||
1201 | ctx = glusterd_op_get_ctx(); | |||||
1202 | if (ctx) { | |||||
1203 | /*gsyncd does a fuse mount to start the geo-rep session*/ | |||||
1204 | if (!glusterd_is_fuse_available ()) { | |||||
1205 | gf_log ("glusterd", GF_LOG_ERROR, "Unable to open"do { do { if (0) printf ("Unable to open" " /dev/fuse (%s), geo-replication start" " failed", strerror ((*__errno_location ()))); } while (0); _gf_log ("glusterd", "glusterd-geo-rep.c", __FUNCTION__, 1207, GF_LOG_ERROR , "Unable to open" " /dev/fuse (%s), geo-replication start" " failed" , strerror ((*__errno_location ()))); } while (0) | |||||
1206 | " /dev/fuse (%s), geo-replication start"do { do { if (0) printf ("Unable to open" " /dev/fuse (%s), geo-replication start" " failed", strerror ((*__errno_location ()))); } while (0); _gf_log ("glusterd", "glusterd-geo-rep.c", __FUNCTION__, 1207, GF_LOG_ERROR , "Unable to open" " /dev/fuse (%s), geo-replication start" " failed" , strerror ((*__errno_location ()))); } while (0) | |||||
1207 | " failed", strerror (errno))do { do { if (0) printf ("Unable to open" " /dev/fuse (%s), geo-replication start" " failed", strerror ((*__errno_location ()))); } while (0); _gf_log ("glusterd", "glusterd-geo-rep.c", __FUNCTION__, 1207, GF_LOG_ERROR , "Unable to open" " /dev/fuse (%s), geo-replication start" " failed" , strerror ((*__errno_location ()))); } while (0); | |||||
1208 | snprintf (errmsg, sizeof(errmsg), | |||||
1209 | "fuse unvailable"); | |||||
1210 | *op_errstr = gf_strdup (errmsg); | |||||
1211 | ret = -1; | |||||
1212 | goto out; | |||||
1213 | } | |||||
1214 | } | |||||
1215 | break; | |||||
1216 | ||||||
1217 | case GF_GSYNC_OPTION_TYPE_STOP: | |||||
1218 | ret = glusterd_op_verify_gsync_running (volinfo, slave, | |||||
1219 | op_errstr); | |||||
1220 | break; | |||||
1221 | } | |||||
1222 | ||||||
1223 | out: | |||||
1224 | return ret; | |||||
1225 | } | |||||
1226 | ||||||
1227 | static int | |||||
1228 | stop_gsync (char *master, char *slave, char **msg) | |||||
1229 | { | |||||
1230 | int32_t ret = 0; | |||||
1231 | int pfd = -1; | |||||
1232 | pid_t pid = 0; | |||||
1233 | char pidfile[PATH_MAX4096] = {0,}; | |||||
1234 | char buf [1024] = {0,}; | |||||
1235 | int i = 0; | |||||
1236 | ||||||
1237 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1237, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
1238 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 1238, GF_LOG_ERROR, "Assertion failed: " "THIS->private" ); } while (0); } } while (0); | |||||
1239 | ||||||
1240 | pfd = gsyncd_getpidfile (master, slave, pidfile); | |||||
1241 | if (pfd == -2) { | |||||
1242 | gf_log ("", GF_LOG_ERROR, GEOREP" stop validation "do { do { if (0) printf ("geo-replication"" stop validation " " failed for %s & %s", master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1243, GF_LOG_ERROR, "geo-replication"" stop validation " " failed for %s & %s" , master, slave); } while (0) | |||||
1243 | " failed for %s & %s", master, slave)do { do { if (0) printf ("geo-replication"" stop validation " " failed for %s & %s", master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1243, GF_LOG_ERROR, "geo-replication"" stop validation " " failed for %s & %s" , master, slave); } while (0); | |||||
1244 | ret = -1; | |||||
1245 | goto out; | |||||
1246 | } | |||||
1247 | if (gsync_status_byfd (pfd) == -1) { | |||||
1248 | gf_log ("", GF_LOG_ERROR, "gsyncd b/w %s & %s is not"do { do { if (0) printf ("gsyncd b/w %s & %s is not" " running" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1249, GF_LOG_ERROR, "gsyncd b/w %s & %s is not" " running", master, slave); } while (0) | |||||
1249 | " running", master, slave)do { do { if (0) printf ("gsyncd b/w %s & %s is not" " running" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1249, GF_LOG_ERROR, "gsyncd b/w %s & %s is not" " running", master, slave); } while (0); | |||||
1250 | if (msg) | |||||
1251 | *msg = gf_strdup ("Warning: "GEOREP"geo-replication"" session was " | |||||
1252 | "defunct at stop time"); | |||||
1253 | /* monitor gsyncd already dead */ | |||||
1254 | goto out; | |||||
1255 | } | |||||
1256 | ||||||
1257 | if (pfd < 0) | |||||
1258 | goto out; | |||||
1259 | ||||||
1260 | ret = read (pfd, buf, 1024); | |||||
1261 | if (ret > 0) { | |||||
1262 | pid = strtol (buf, NULL((void*)0), 10); | |||||
1263 | ret = kill (-pid, SIGTERM15); | |||||
1264 | if (ret) { | |||||
1265 | gf_log ("", GF_LOG_WARNING,do { do { if (0) printf ("failed to kill gsyncd"); } while (0 ); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1266, GF_LOG_WARNING , "failed to kill gsyncd"); } while (0) | |||||
1266 | "failed to kill gsyncd")do { do { if (0) printf ("failed to kill gsyncd"); } while (0 ); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1266, GF_LOG_WARNING , "failed to kill gsyncd"); } while (0); | |||||
1267 | goto out; | |||||
1268 | } | |||||
1269 | for (i = 0; i < 20; i++) { | |||||
1270 | if (gsync_status_byfd (pfd) == -1) { | |||||
1271 | /* monitor gsyncd is dead but worker may | |||||
1272 | * still be alive, give some more time | |||||
1273 | * before SIGKILL (hack) | |||||
1274 | */ | |||||
1275 | usleep (50000); | |||||
1276 | break; | |||||
1277 | } | |||||
1278 | usleep (50000); | |||||
1279 | } | |||||
1280 | kill (-pid, SIGKILL9); | |||||
1281 | unlink (pidfile); | |||||
1282 | } | |||||
1283 | ret = 0; | |||||
1284 | ||||||
1285 | out: | |||||
1286 | sys_close (pfd); | |||||
1287 | return ret; | |||||
1288 | } | |||||
1289 | ||||||
1290 | static int | |||||
1291 | glusterd_check_restart_gsync_session (glusterd_volinfo_t *volinfo, char *slave, | |||||
1292 | dict_t *resp_dict); | |||||
1293 | ||||||
1294 | static int | |||||
1295 | glusterd_gsync_configure (glusterd_volinfo_t *volinfo, char *slave, | |||||
1296 | dict_t *dict, dict_t *resp_dict, char **op_errstr) | |||||
1297 | { | |||||
1298 | int32_t ret = -1; | |||||
1299 | char *op_name = NULL((void*)0); | |||||
1300 | char *op_value = NULL((void*)0); | |||||
1301 | runner_t runner = {0,}; | |||||
1302 | glusterd_conf_t *priv = NULL((void*)0); | |||||
1303 | char *subop = NULL((void*)0); | |||||
1304 | char *master = NULL((void*)0); | |||||
1305 | ||||||
1306 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1306, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
1307 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1307, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | |||||
1308 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1308, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | |||||
1309 | GF_ASSERT (resp_dict)do { if (!(resp_dict)) { do { do { if (0) printf ("Assertion failed: " "resp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1309, GF_LOG_ERROR, "Assertion failed: " "resp_dict" ); } while (0); } } while (0); | |||||
1310 | ||||||
1311 | ret = dict_get_str (dict, "subop", &subop); | |||||
1312 | if (ret != 0) | |||||
1313 | goto out; | |||||
1314 | ||||||
1315 | if (strcmp (subop, "get") == 0 || strcmp (subop, "get-all") == 0) { | |||||
1316 | /* deferred to cli */ | |||||
1317 | gf_log ("", GF_LOG_DEBUG, "Returning 0")do { do { if (0) printf ("Returning 0"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1317, GF_LOG_DEBUG, "Returning 0"); } while (0); | |||||
1318 | return 0; | |||||
1319 | } | |||||
1320 | ||||||
1321 | ret = dict_get_str (dict, "op_name", &op_name); | |||||
1322 | if (ret != 0) | |||||
1323 | goto out; | |||||
1324 | ||||||
1325 | if (strtail (subop, "set")) { | |||||
1326 | ret = dict_get_str (dict, "op_value", &op_value); | |||||
1327 | if (ret != 0) | |||||
1328 | goto out; | |||||
1329 | } | |||||
1330 | ||||||
1331 | if (THIS(*__glusterfs_this_location())) | |||||
1332 | priv = THIS(*__glusterfs_this_location())->private; | |||||
1333 | if (priv == NULL((void*)0)) { | |||||
1334 | gf_log ("", GF_LOG_ERROR, "priv of glusterd not present")do { do { if (0) printf ("priv of glusterd not present"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1334, GF_LOG_ERROR , "priv of glusterd not present"); } while (0); | |||||
1335 | *op_errstr = gf_strdup ("glusterd defunct"); | |||||
1336 | goto out; | |||||
1337 | } | |||||
1338 | ||||||
1339 | master = ""; | |||||
1340 | runinit (&runner); | |||||
1341 | runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "-c", NULL((void*)0)); | |||||
1342 | runner_argprintf (&runner, "%s/"GSYNC_CONF"geo-replication""/gsyncd.conf", priv->workdir); | |||||
1343 | if (volinfo) { | |||||
1344 | master = volinfo->volname; | |||||
1345 | runner_argprintf (&runner, ":%s", master); | |||||
1346 | } | |||||
1347 | runner_add_arg (&runner, slave); | |||||
1348 | runner_argprintf (&runner, "--config-%s", subop); | |||||
1349 | runner_add_arg (&runner, op_name); | |||||
1350 | if (op_value) | |||||
1351 | runner_add_arg (&runner, op_value); | |||||
1352 | synclock_unlock (&priv->big_lock); | |||||
1353 | ret = runner_run (&runner); | |||||
1354 | synclock_lock (&priv->big_lock); | |||||
1355 | if (ret) { | |||||
1356 | gf_log ("", GF_LOG_WARNING, "gsyncd failed to "do { do { if (0) printf ("gsyncd failed to " "%s %s option for %s %s peers" , subop, op_name, master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1358, GF_LOG_WARNING, "gsyncd failed to " "%s %s option for %s %s peers" , subop, op_name, master, slave); } while (0) | |||||
1357 | "%s %s option for %s %s peers",do { do { if (0) printf ("gsyncd failed to " "%s %s option for %s %s peers" , subop, op_name, master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1358, GF_LOG_WARNING, "gsyncd failed to " "%s %s option for %s %s peers" , subop, op_name, master, slave); } while (0) | |||||
1358 | subop, op_name, master, slave)do { do { if (0) printf ("gsyncd failed to " "%s %s option for %s %s peers" , subop, op_name, master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1358, GF_LOG_WARNING, "gsyncd failed to " "%s %s option for %s %s peers" , subop, op_name, master, slave); } while (0); | |||||
1359 | ||||||
1360 | gf_asprintf (op_errstr, GEOREP"geo-replication"" config-%s failed for %s %s", | |||||
1361 | subop, master, slave); | |||||
1362 | ||||||
1363 | goto out; | |||||
1364 | } | |||||
1365 | ret = 0; | |||||
1366 | gf_asprintf (op_errstr, "config-%s successful", subop); | |||||
1367 | ||||||
1368 | out: | |||||
1369 | if (!ret && volinfo) { | |||||
1370 | ret = glusterd_check_restart_gsync_session (volinfo, slave, | |||||
1371 | resp_dict); | |||||
1372 | if (ret) | |||||
1373 | *op_errstr = gf_strdup ("internal error"); | |||||
1374 | } | |||||
1375 | ||||||
1376 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1376, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1377 | return ret; | |||||
1378 | } | |||||
1379 | ||||||
1380 | static int | |||||
1381 | glusterd_gsync_read_frm_status (char *path, char *buf, size_t blen) | |||||
1382 | { | |||||
1383 | int ret = 0; | |||||
1384 | int status_fd = -1; | |||||
1385 | ||||||
1386 | GF_ASSERT (path)do { if (!(path)) { do { do { if (0) printf ("Assertion failed: " "path"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1386, GF_LOG_ERROR, "Assertion failed: " "path" ); } while (0); } } while (0); | |||||
1387 | GF_ASSERT (buf)do { if (!(buf)) { do { do { if (0) printf ("Assertion failed: " "buf"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1387, GF_LOG_ERROR, "Assertion failed: " "buf" ); } while (0); } } while (0); | |||||
1388 | status_fd = open (path, O_RDONLY00); | |||||
1389 | if (status_fd == -1) { | |||||
1390 | gf_log ("", GF_LOG_ERROR, "Unable to read gsyncd status"do { do { if (0) printf ("Unable to read gsyncd status" " file" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1391, GF_LOG_ERROR, "Unable to read gsyncd status" " file") ; } while (0) | |||||
1391 | " file")do { do { if (0) printf ("Unable to read gsyncd status" " file" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1391, GF_LOG_ERROR, "Unable to read gsyncd status" " file") ; } while (0); | |||||
1392 | return -1; | |||||
1393 | } | |||||
1394 | ret = read (status_fd, buf, blen - 1); | |||||
1395 | if (ret > 0) { | |||||
1396 | size_t len = strnlen (buf, ret); | |||||
1397 | /* Ensure there is a NUL byte and that it's not the first. */ | |||||
1398 | if (len == 0 || len == blen - 1) { | |||||
1399 | ret = -1; | |||||
1400 | } else { | |||||
1401 | char *p = buf + len - 1; | |||||
1402 | while (isspace (*p)((*__ctype_b_loc ())[(int) ((*p))] & (unsigned short int) _ISspace)) | |||||
1403 | *p-- = '\0'; | |||||
1404 | ret = 0; | |||||
1405 | } | |||||
1406 | } else if (ret < 0) | |||||
1407 | gf_log ("", GF_LOG_ERROR, "Status file of gsyncd is corrupt")do { do { if (0) printf ("Status file of gsyncd is corrupt"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1407, GF_LOG_ERROR, "Status file of gsyncd is corrupt"); } while (0); | |||||
1408 | ||||||
1409 | close (status_fd); | |||||
1410 | return ret; | |||||
1411 | } | |||||
1412 | ||||||
1413 | static int | |||||
1414 | glusterd_gsync_fetch_status_extra (char *path, char *buf, size_t blen) | |||||
1415 | { | |||||
1416 | char sockpath[PATH_MAX4096] = {0,}; | |||||
1417 | struct sockaddr_un sa = {0,}; | |||||
1418 | size_t l = 0; | |||||
1419 | int s = -1; | |||||
1420 | struct pollfd pfd = {0,}; | |||||
1421 | int ret = 0; | |||||
1422 | ||||||
1423 | l = strlen (buf); | |||||
1424 | /* seek to end of data in buf */ | |||||
1425 | buf += l; | |||||
1426 | blen -= l; | |||||
1427 | ||||||
1428 | glusterd_set_socket_filepath (path, sockpath, sizeof (sockpath)); | |||||
1429 | ||||||
1430 | strncpy(sa.sun_path, sockpath, sizeof(sa.sun_path)); | |||||
1431 | if (sa.sun_path[sizeof (sa.sun_path) - 1]) | |||||
1432 | return -1; | |||||
1433 | sa.sun_family = AF_UNIX1; | |||||
1434 | ||||||
1435 | s = socket(AF_UNIX1, SOCK_STREAMSOCK_STREAM, 0); | |||||
1436 | if (s == -1) | |||||
1437 | return -1; | |||||
1438 | ret = fcntl (s, F_GETFL3); | |||||
1439 | if (ret != -1) | |||||
1440 | ret = fcntl (s, F_SETFL4, ret | O_NONBLOCK04000); | |||||
1441 | if (ret == -1) | |||||
1442 | goto out; | |||||
1443 | ||||||
1444 | ret = connect (s, (struct sockaddr *)&sa, sizeof (sa)); | |||||
1445 | if (ret == -1) | |||||
1446 | goto out; | |||||
1447 | pfd.fd = s; | |||||
1448 | pfd.events = POLLIN0x001; | |||||
1449 | /* we don't want to hang on gsyncd */ | |||||
1450 | if (poll (&pfd, 1, 5000) < 1 || | |||||
1451 | !(pfd.revents & POLLIN0x001)) { | |||||
1452 | ret = -1; | |||||
1453 | goto out; | |||||
1454 | } | |||||
1455 | ret = read(s, buf, blen); | |||||
1456 | /* we expect a terminating 0 byte */ | |||||
1457 | if (ret == 0 || (ret > 0 && buf[ret - 1])) | |||||
1458 | ret = -1; | |||||
1459 | if (ret > 0) | |||||
1460 | ret = 0; | |||||
1461 | ||||||
1462 | out: | |||||
1463 | close (s); | |||||
1464 | return ret; | |||||
1465 | } | |||||
1466 | ||||||
1467 | static int | |||||
1468 | dict_get_param (dict_t *dict, char *key, char **param) | |||||
1469 | { | |||||
1470 | char *dk = NULL((void*)0); | |||||
1471 | char *s = NULL((void*)0); | |||||
1472 | char x = '\0'; | |||||
1473 | int ret = 0; | |||||
1474 | ||||||
1475 | if (dict_get_str (dict, key, param) == 0) | |||||
1476 | return 0; | |||||
1477 | ||||||
1478 | dk = gf_strdup (key); | |||||
1479 | if (!key) | |||||
1480 | return -1; | |||||
1481 | ||||||
1482 | s = strpbrk (dk, "-_"); | |||||
1483 | if (!s) | |||||
1484 | return -1; | |||||
1485 | x = (*s == '-') ? '_' : '-'; | |||||
1486 | *s++ = x; | |||||
1487 | while ((s = strpbrk (s, "-_"))) | |||||
1488 | *s++ = x; | |||||
1489 | ||||||
1490 | ret = dict_get_str (dict, dk, param); | |||||
1491 | ||||||
1492 | GF_FREE (dk)__gf_free (dk); | |||||
1493 | return ret; | |||||
1494 | } | |||||
1495 | ||||||
1496 | static int | |||||
1497 | glusterd_read_status_file (char *master, char *slave, | |||||
1498 | dict_t *dict, char *node) | |||||
1499 | { | |||||
1500 | glusterd_conf_t *priv = NULL((void*)0); | |||||
1501 | int ret = 0; | |||||
1502 | char *statefile = NULL((void*)0); | |||||
1503 | char buf[1024] = {0, }; | |||||
1504 | char nds[1024] = {0, }; | |||||
1505 | char mst[1024] = {0, }; | |||||
1506 | char slv[1024] = {0, }; | |||||
1507 | char sts[1024] = {0, }; | |||||
1508 | char *bufp = NULL((void*)0); | |||||
1509 | dict_t *confd = NULL((void*)0); | |||||
1510 | int gsync_count = 0; | |||||
1511 | int status = 0; | |||||
1512 | char *dyn_node = NULL((void*)0); | |||||
1513 | ||||||
1514 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1514, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
1515 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 1515, GF_LOG_ERROR, "Assertion failed: " "THIS->private" ); } while (0); } } while (0); | |||||
1516 | ||||||
1517 | confd = dict_new (); | |||||
1518 | if (!dict) | |||||
1519 | return -1; | |||||
1520 | ||||||
1521 | priv = THIS(*__glusterfs_this_location())->private; | |||||
1522 | ret = glusterd_gsync_get_config (master, slave, priv->workdir, | |||||
1523 | confd); | |||||
1524 | if (ret) { | |||||
1525 | gf_log ("", GF_LOG_ERROR, "Unable to get configuration data"do { do { if (0) printf ("Unable to get configuration data" "for %s(master), %s(slave)" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1526, GF_LOG_ERROR, "Unable to get configuration data" "for %s(master), %s(slave)", master, slave); } while (0) | |||||
1526 | "for %s(master), %s(slave)", master, slave)do { do { if (0) printf ("Unable to get configuration data" "for %s(master), %s(slave)" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1526, GF_LOG_ERROR, "Unable to get configuration data" "for %s(master), %s(slave)", master, slave); } while (0); | |||||
1527 | goto out; | |||||
1528 | ||||||
1529 | } | |||||
1530 | ||||||
1531 | ret = gsync_status (master, slave, &status); | |||||
1532 | if (ret == 0 && status == -1) { | |||||
1533 | strncpy (buf, "defunct", sizeof (buf)); | |||||
1534 | goto done; | |||||
1535 | } else if (ret == -1) | |||||
1536 | goto out; | |||||
1537 | ||||||
1538 | ret = dict_get_param (confd, "state_file", &statefile); | |||||
1539 | if (ret) | |||||
1540 | goto out; | |||||
1541 | ret = glusterd_gsync_read_frm_status (statefile, buf, sizeof (buf)); | |||||
1542 | if (ret) { | |||||
1543 | gf_log ("", GF_LOG_ERROR, "Unable to read the status"do { do { if (0) printf ("Unable to read the status" "file for %s(master), %s(slave)" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1544, GF_LOG_ERROR, "Unable to read the status" "file for %s(master), %s(slave)", master, slave); } while (0 ) | |||||
1544 | "file for %s(master), %s(slave)", master, slave)do { do { if (0) printf ("Unable to read the status" "file for %s(master), %s(slave)" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1544, GF_LOG_ERROR, "Unable to read the status" "file for %s(master), %s(slave)", master, slave); } while (0 ); | |||||
1545 | strncpy (buf, "defunct", sizeof (buf)); | |||||
1546 | goto done; | |||||
1547 | } | |||||
1548 | if (strcmp (buf, "OK") != 0) | |||||
1549 | goto done; | |||||
1550 | ||||||
1551 | ret = dict_get_param (confd, "state_socket_unencoded", &statefile); | |||||
1552 | if (ret) | |||||
1553 | goto out; | |||||
1554 | ret = glusterd_gsync_fetch_status_extra (statefile, buf, sizeof (buf)); | |||||
1555 | if (ret) { | |||||
1556 | gf_log ("", GF_LOG_ERROR, "Unable to fetch extra status"do { do { if (0) printf ("Unable to fetch extra status" "for %s(master), %s(slave)" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1557, GF_LOG_ERROR, "Unable to fetch extra status" "for %s(master), %s(slave)", master, slave); } while (0) | |||||
1557 | "for %s(master), %s(slave)", master, slave)do { do { if (0) printf ("Unable to fetch extra status" "for %s(master), %s(slave)" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1557, GF_LOG_ERROR, "Unable to fetch extra status" "for %s(master), %s(slave)", master, slave); } while (0); | |||||
1558 | /* there is a slight chance that this occurs due to race | |||||
1559 | * -- in that case, the following options all seem bad: | |||||
1560 | * | |||||
1561 | * - suppress irregurlar behavior by just leaving status | |||||
1562 | * on "OK" | |||||
1563 | * - freak out users with a misleading "defunct" | |||||
1564 | * - overload the meaning of the regular error signal | |||||
1565 | * mechanism of gsyncd, that is, when status is "faulty" | |||||
1566 | * | |||||
1567 | * -- so we just come up with something new... | |||||
1568 | */ | |||||
1569 | strncpy (buf, "N/A", sizeof (buf)); | |||||
1570 | goto done; | |||||
1571 | } | |||||
1572 | ||||||
1573 | done: | |||||
1574 | ret = dict_get_int32 (dict, "gsync-count", &gsync_count); | |||||
1575 | ||||||
1576 | if (ret) | |||||
1577 | gsync_count = 1; | |||||
1578 | else | |||||
1579 | gsync_count++; | |||||
1580 | ||||||
1581 | (void) snprintf (nds, sizeof (nds), "node%d", gsync_count); | |||||
1582 | dyn_node = gf_strdup (node); | |||||
1583 | if (!dyn_node) | |||||
1584 | goto out; | |||||
1585 | ret = dict_set_dynstr (dict, nds, dyn_node); | |||||
1586 | if (ret) { | |||||
1587 | GF_FREE (dyn_node)__gf_free (dyn_node); | |||||
1588 | goto out; | |||||
1589 | } | |||||
1590 | ||||||
1591 | snprintf (mst, sizeof (mst), "master%d", gsync_count); | |||||
1592 | master = gf_strdup (master); | |||||
1593 | if (!master) | |||||
1594 | goto out; | |||||
1595 | ret = dict_set_dynstr (dict, mst, master); | |||||
1596 | if (ret) { | |||||
1597 | GF_FREE (master)__gf_free (master); | |||||
1598 | goto out; | |||||
1599 | } | |||||
1600 | ||||||
1601 | snprintf (slv, sizeof (slv), "slave%d", gsync_count); | |||||
1602 | slave = gf_strdup (slave); | |||||
1603 | if (!slave) | |||||
1604 | goto out; | |||||
1605 | ret = dict_set_dynstr (dict, slv, slave); | |||||
1606 | if (ret) { | |||||
1607 | GF_FREE (slave)__gf_free (slave); | |||||
1608 | goto out; | |||||
1609 | } | |||||
1610 | ||||||
1611 | snprintf (sts, sizeof (slv), "status%d", gsync_count); | |||||
1612 | bufp = gf_strdup (buf); | |||||
1613 | if (!bufp) | |||||
1614 | goto out; | |||||
1615 | ret = dict_set_dynstr (dict, sts, bufp); | |||||
1616 | if (ret) { | |||||
1617 | GF_FREE (bufp)__gf_free (bufp); | |||||
1618 | goto out; | |||||
1619 | } | |||||
1620 | ret = dict_set_int32 (dict, "gsync-count", gsync_count); | |||||
1621 | if (ret) | |||||
1622 | goto out; | |||||
1623 | ||||||
1624 | ret = 0; | |||||
1625 | out: | |||||
1626 | dict_destroy (confd); | |||||
1627 | ||||||
1628 | gf_log ("", GF_LOG_DEBUG, "Returning %d ", ret)do { do { if (0) printf ("Returning %d ", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1628, GF_LOG_DEBUG, "Returning %d ", ret); } while (0); | |||||
1629 | return ret; | |||||
1630 | } | |||||
1631 | ||||||
1632 | static int | |||||
1633 | glusterd_check_restart_gsync_session (glusterd_volinfo_t *volinfo, char *slave, | |||||
1634 | dict_t *resp_dict) | |||||
1635 | { | |||||
1636 | ||||||
1637 | int ret = 0; | |||||
1638 | uuid_t uuid = {0, }; | |||||
1639 | glusterd_conf_t *priv = NULL((void*)0); | |||||
1640 | char *status_msg = NULL((void*)0); | |||||
1641 | ||||||
1642 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1642, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
1643 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1643, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
1644 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1644, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
1645 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 1645, GF_LOG_ERROR, "Assertion failed: " "THIS->private" ); } while (0); } } while (0); | |||||
1646 | ||||||
1647 | priv = THIS(*__glusterfs_this_location())->private; | |||||
1648 | ||||||
1649 | if (glusterd_gsync_get_uuid (slave, volinfo, uuid)) | |||||
1650 | /* session does not exist, nothing to do */ | |||||
1651 | goto out; | |||||
1652 | if (uuid_compare (MY_UUID(__glusterd_uuid()), uuid) == 0) { | |||||
1653 | ret = stop_gsync (volinfo->volname, slave, &status_msg); | |||||
1654 | if (ret == 0 && status_msg) | |||||
1655 | ret = dict_set_str (resp_dict, "gsync-status", | |||||
1656 | status_msg); | |||||
1657 | if (ret == 0) | |||||
1658 | ret = glusterd_start_gsync (volinfo, slave, | |||||
1659 | uuid_utoa(MY_UUID(__glusterd_uuid())), NULL((void*)0)); | |||||
1660 | } | |||||
1661 | ||||||
1662 | out: | |||||
1663 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1663, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1664 | return ret; | |||||
1665 | } | |||||
1666 | ||||||
1667 | static int32_t | |||||
1668 | glusterd_marker_create_volfile (glusterd_volinfo_t *volinfo) | |||||
1669 | { | |||||
1670 | int32_t ret = 0; | |||||
1671 | ||||||
1672 | ret = glusterd_create_volfiles_and_notify_services (volinfo); | |||||
1673 | if (ret) { | |||||
1674 | gf_log ("", GF_LOG_ERROR, "Unable to create volfile"do { do { if (0) printf ("Unable to create volfile" " for setting of marker while '" "geo-replication"" start'"); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1675, GF_LOG_ERROR, "Unable to create volfile" " for setting of marker while '""geo-replication"" start'"); } while (0) | |||||
1675 | " for setting of marker while '"GEOREP" start'")do { do { if (0) printf ("Unable to create volfile" " for setting of marker while '" "geo-replication"" start'"); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1675, GF_LOG_ERROR, "Unable to create volfile" " for setting of marker while '""geo-replication"" start'"); } while (0); | |||||
1676 | ret = -1; | |||||
1677 | goto out; | |||||
1678 | } | |||||
1679 | ||||||
1680 | ret = glusterd_store_volinfo (volinfo, GLUSTERD_VOLINFO_VER_AC_INCREMENT); | |||||
1681 | if (ret) | |||||
1682 | goto out; | |||||
1683 | ||||||
1684 | if (GLUSTERD_STATUS_STARTED == volinfo->status) | |||||
1685 | ret = glusterd_nodesvcs_handle_graph_change (volinfo); | |||||
1686 | ret = 0; | |||||
1687 | out: | |||||
1688 | return ret; | |||||
1689 | } | |||||
1690 | ||||||
1691 | static int | |||||
1692 | glusterd_set_marker_gsync (glusterd_volinfo_t *volinfo) | |||||
1693 | { | |||||
1694 | int ret = -1; | |||||
1695 | int marker_set = _gf_false; | |||||
1696 | char *gsync_status = NULL((void*)0); | |||||
1697 | ||||||
1698 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1698, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
1699 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 1699, GF_LOG_ERROR, "Assertion failed: " "THIS->private" ); } while (0); } } while (0); | |||||
1700 | ||||||
1701 | marker_set = glusterd_volinfo_get_boolean (volinfo, VKEY_MARKER_XTIME"geo-replication"".indexing"); | |||||
1702 | if (marker_set == -1) { | |||||
1703 | gf_log ("", GF_LOG_ERROR, "failed to get the marker status")do { do { if (0) printf ("failed to get the marker status"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1703 , GF_LOG_ERROR, "failed to get the marker status"); } while ( 0); | |||||
1704 | ret = -1; | |||||
1705 | goto out; | |||||
1706 | } | |||||
1707 | ||||||
1708 | if (marker_set == _gf_false) { | |||||
1709 | gsync_status = gf_strdup ("on"); | |||||
1710 | if (gsync_status == NULL((void*)0)) { | |||||
1711 | ret = -1; | |||||
1712 | goto out; | |||||
1713 | } | |||||
1714 | ||||||
1715 | ret = glusterd_gsync_volinfo_dict_set (volinfo, | |||||
1716 | VKEY_MARKER_XTIME"geo-replication"".indexing", gsync_status); | |||||
1717 | if (ret < 0) | |||||
1718 | goto out; | |||||
1719 | ||||||
1720 | ret = glusterd_marker_create_volfile (volinfo); | |||||
1721 | if (ret) { | |||||
1722 | gf_log ("", GF_LOG_ERROR, "Setting dict failed")do { do { if (0) printf ("Setting dict failed"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1722, GF_LOG_ERROR , "Setting dict failed"); } while (0); | |||||
1723 | goto out; | |||||
1724 | } | |||||
1725 | } | |||||
1726 | ret = 0; | |||||
1727 | ||||||
1728 | out: | |||||
1729 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1729, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1730 | return ret; | |||||
1731 | } | |||||
1732 | ||||||
1733 | ||||||
1734 | ||||||
1735 | ||||||
1736 | static int | |||||
1737 | glusterd_get_gsync_status_mst_slv (glusterd_volinfo_t *volinfo, | |||||
1738 | char *slave, dict_t *rsp_dict, | |||||
1739 | char *node) | |||||
1740 | { | |||||
1741 | uuid_t uuid = {0, }; | |||||
1742 | glusterd_conf_t *priv = NULL((void*)0); | |||||
1743 | int ret = 0; | |||||
1744 | ||||||
1745 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1745, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
1746 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1746, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
1747 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1747, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
1748 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 1748, GF_LOG_ERROR, "Assertion failed: " "THIS->private" ); } while (0); } } while (0); | |||||
1749 | ||||||
1750 | priv = THIS(*__glusterfs_this_location())->private; | |||||
1751 | ||||||
1752 | ret = glusterd_gsync_get_uuid (slave, volinfo, uuid); | |||||
1753 | if ((ret == 0) && (uuid_compare (MY_UUID(__glusterd_uuid()), uuid) != 0)) | |||||
1754 | goto out; | |||||
1755 | ||||||
1756 | if (ret) { | |||||
1757 | ret = 0; | |||||
1758 | gf_log ("", GF_LOG_INFO, "geo-replication status %s %s :"do { do { if (0) printf ("geo-replication status %s %s :" "session is not active" , volinfo->volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1759, GF_LOG_INFO, "geo-replication status %s %s :" "session is not active", volinfo->volname, slave); } while (0) | |||||
1759 | "session is not active", volinfo->volname, slave)do { do { if (0) printf ("geo-replication status %s %s :" "session is not active" , volinfo->volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1759, GF_LOG_INFO, "geo-replication status %s %s :" "session is not active", volinfo->volname, slave); } while (0); | |||||
1760 | goto out; | |||||
1761 | } | |||||
1762 | ||||||
1763 | ret = glusterd_read_status_file (volinfo->volname, | |||||
1764 | slave, rsp_dict, node); | |||||
1765 | out: | |||||
1766 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1766, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | |||||
1767 | return ret; | |||||
1768 | } | |||||
1769 | ||||||
1770 | static int | |||||
1771 | glusterd_get_gsync_status_mst (glusterd_volinfo_t *volinfo, dict_t *rsp_dict, | |||||
1772 | char *node) | |||||
1773 | { | |||||
1774 | glusterd_gsync_status_temp_t param = {0, }; | |||||
1775 | ||||||
1776 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1776, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
1777 | ||||||
1778 | param.rsp_dict = rsp_dict; | |||||
1779 | param.volinfo = volinfo; | |||||
1780 | param.node = node; | |||||
1781 | dict_foreach (volinfo->gsync_slaves, _get_status_mst_slv, ¶m); | |||||
1782 | ||||||
1783 | return 0; | |||||
1784 | } | |||||
1785 | ||||||
1786 | static int | |||||
1787 | glusterd_get_gsync_status_all (dict_t *rsp_dict, char *node) | |||||
1788 | { | |||||
1789 | ||||||
1790 | int32_t ret = 0; | |||||
1791 | glusterd_conf_t *priv = NULL((void*)0); | |||||
1792 | glusterd_volinfo_t *volinfo = NULL((void*)0); | |||||
1793 | ||||||
1794 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1794, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
1795 | priv = THIS(*__glusterfs_this_location())->private; | |||||
1796 | ||||||
1797 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 1797, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | |||||
1798 | ||||||
1799 | list_for_each_entry (volinfo, &priv->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&priv-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&priv-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | |||||
1800 | ret = glusterd_get_gsync_status_mst (volinfo, rsp_dict, node); | |||||
1801 | if (ret) | |||||
1802 | goto out; | |||||
1803 | } | |||||
1804 | ||||||
1805 | out: | |||||
1806 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1806, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | |||||
1807 | return ret; | |||||
1808 | ||||||
1809 | } | |||||
1810 | ||||||
1811 | static int | |||||
1812 | glusterd_get_gsync_status (dict_t *dict, char **op_errstr, dict_t *rsp_dict) | |||||
1813 | { | |||||
1814 | char *slave = NULL((void*)0); | |||||
1815 | char *volname = NULL((void*)0); | |||||
1816 | char errmsg[PATH_MAX4096] = {0, }; | |||||
1817 | gf_boolean_t exists = _gf_false; | |||||
1818 | glusterd_volinfo_t *volinfo = NULL((void*)0); | |||||
1819 | int ret = 0; | |||||
1820 | char my_hostname[256] = {0,}; | |||||
1821 | ||||||
1822 | ret = gethostname(my_hostname, 256); | |||||
1823 | if (ret) { | |||||
1824 | /* stick to N/A */ | |||||
1825 | (void) strcpy (my_hostname, "N/A"); | |||||
1826 | } | |||||
1827 | ||||||
1828 | ret = dict_get_str (dict, "master", &volname); | |||||
1829 | if (ret < 0){ | |||||
1830 | ret = glusterd_get_gsync_status_all (rsp_dict, my_hostname); | |||||
1831 | goto out; | |||||
1832 | } | |||||
1833 | ||||||
1834 | exists = glusterd_check_volume_exists (volname); | |||||
1835 | ret = glusterd_volinfo_find (volname, &volinfo); | |||||
1836 | if ((ret) || (!exists)) { | |||||
1837 | gf_log ("", GF_LOG_WARNING, "volume name does not exist")do { do { if (0) printf ("volume name does not exist"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1837, GF_LOG_WARNING , "volume name does not exist"); } while (0); | |||||
1838 | snprintf (errmsg, sizeof(errmsg), "Volume name %s does not" | |||||
1839 | " exist", volname); | |||||
1840 | *op_errstr = gf_strdup (errmsg); | |||||
1841 | ret = -1; | |||||
1842 | goto out; | |||||
1843 | } | |||||
1844 | ||||||
1845 | ||||||
1846 | ret = dict_get_str (dict, "slave", &slave); | |||||
1847 | if (ret < 0) { | |||||
1848 | ret = glusterd_get_gsync_status_mst (volinfo, | |||||
1849 | rsp_dict, my_hostname); | |||||
1850 | goto out; | |||||
1851 | } | |||||
1852 | ||||||
1853 | ret = glusterd_get_gsync_status_mst_slv (volinfo, slave, | |||||
1854 | rsp_dict, my_hostname); | |||||
1855 | ||||||
1856 | out: | |||||
1857 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1857, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
1858 | return ret; | |||||
1859 | } | |||||
1860 | ||||||
1861 | static int | |||||
1862 | glusterd_send_sigstop (pid_t pid) | |||||
1863 | { | |||||
1864 | int ret = 0; | |||||
1865 | ret = kill (pid, SIGSTOP19); | |||||
1866 | if (ret) | |||||
1867 | gf_log ("", GF_LOG_ERROR, GEOREP"failed to send SIGSTOP signal")do { do { if (0) printf ("geo-replication""failed to send SIGSTOP signal" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1867, GF_LOG_ERROR, "geo-replication""failed to send SIGSTOP signal" ); } while (0); | |||||
1868 | return ret; | |||||
1869 | } | |||||
1870 | ||||||
1871 | static int | |||||
1872 | glusterd_send_sigcont (pid_t pid) | |||||
1873 | { | |||||
1874 | int ret = 0; | |||||
1875 | ret = kill (pid, SIGCONT18); | |||||
1876 | if (ret) | |||||
1877 | gf_log ("", GF_LOG_ERROR, GEOREP"failed to send SIGCONT signal")do { do { if (0) printf ("geo-replication""failed to send SIGCONT signal" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1877, GF_LOG_ERROR, "geo-replication""failed to send SIGCONT signal" ); } while (0); | |||||
1878 | return ret; | |||||
1879 | } | |||||
1880 | ||||||
1881 | /* | |||||
1882 | * Log rotations flow is something like this: | |||||
1883 | * - Send SIGSTOP to process group (this will stop monitor/worker process | |||||
1884 | * and also the slave if it's local) | |||||
1885 | * - Rotate log file for monitor/worker | |||||
1886 | * - Rotate log file for slave if it's local | |||||
1887 | * - Send SIGCONT to the process group. Monitor wakes up, kills the worker | |||||
1888 | * (this is done in the SIGCONT handler), which results in the termination | |||||
1889 | * of the slave (local/remote). After returning from signal handler, | |||||
1890 | * monitor detects absence of worker and starts it again, which in-turn | |||||
1891 | * starts the slave. | |||||
1892 | */ | |||||
1893 | static int | |||||
1894 | glusterd_send_log_rotate_signal (pid_t pid, char *logfile1, char *logfile2) | |||||
1895 | { | |||||
1896 | int ret = 0; | |||||
1897 | char rlogfile[PATH_MAX4096] = {0,}; | |||||
1898 | time_t rottime = 0; | |||||
1899 | ||||||
1900 | ret = glusterd_send_sigstop (-pid); | |||||
1901 | rottime = time (NULL((void*)0)); | |||||
1902 | ||||||
1903 | snprintf (rlogfile, sizeof (rlogfile), "%s.%"PRIu64"ll" "u", logfile1, | |||||
1904 | (uint64_t) rottime); | |||||
1905 | ret = rename (logfile1, rlogfile); | |||||
1906 | if (ret) | |||||
1907 | gf_log ("", GF_LOG_ERROR, "rename failed for geo-rep log file")do { do { if (0) printf ("rename failed for geo-rep log file" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1907, GF_LOG_ERROR, "rename failed for geo-rep log file"); } while (0); | |||||
1908 | ||||||
1909 | if (!*logfile2) { | |||||
1910 | gf_log ("", GF_LOG_DEBUG, "Slave is not local,"do { do { if (0) printf ("Slave is not local," " skipping rotation" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1911, GF_LOG_DEBUG, "Slave is not local," " skipping rotation" ); } while (0) | |||||
1911 | " skipping rotation")do { do { if (0) printf ("Slave is not local," " skipping rotation" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1911, GF_LOG_DEBUG, "Slave is not local," " skipping rotation" ); } while (0); | |||||
1912 | ret = 0; | |||||
1913 | goto out; | |||||
1914 | } | |||||
1915 | ||||||
1916 | (void) snprintf (rlogfile, sizeof (rlogfile), "%s.%"PRIu64"ll" "u", logfile2, | |||||
1917 | (uint64_t) rottime); | |||||
1918 | ret = rename (logfile2, rlogfile); | |||||
1919 | if (ret) | |||||
1920 | gf_log ("", GF_LOG_ERROR, "rename failed for geo-rep slave"do { do { if (0) printf ("rename failed for geo-rep slave" " log file" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1921, GF_LOG_ERROR, "rename failed for geo-rep slave" " log file" ); } while (0) | |||||
1921 | " log file")do { do { if (0) printf ("rename failed for geo-rep slave" " log file" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1921, GF_LOG_ERROR, "rename failed for geo-rep slave" " log file" ); } while (0); | |||||
1922 | ||||||
1923 | out: | |||||
1924 | ret = glusterd_send_sigcont (-pid); | |||||
1925 | ||||||
1926 | return ret; | |||||
1927 | } | |||||
1928 | ||||||
1929 | static int | |||||
1930 | glusterd_get_pid_from_file (char *master, char *slave, pid_t *pid) | |||||
1931 | { | |||||
1932 | int ret = -1; | |||||
1933 | int pfd = 0; | |||||
1934 | char pidfile[PATH_MAX4096] = {0,}; | |||||
1935 | char buff[1024] = {0,}; | |||||
1936 | ||||||
1937 | pfd = gsyncd_getpidfile (master, slave, pidfile); | |||||
1938 | if (pfd == -2) { | |||||
1939 | gf_log ("", GF_LOG_ERROR, GEOREP" log-rotate validation "do { do { if (0) printf ("geo-replication"" log-rotate validation " " failed for %s & %s", master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1940, GF_LOG_ERROR, "geo-replication"" log-rotate validation " " failed for %s & %s" , master, slave); } while (0) | |||||
1940 | " failed for %s & %s", master, slave)do { do { if (0) printf ("geo-replication"" log-rotate validation " " failed for %s & %s", master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 1940, GF_LOG_ERROR, "geo-replication"" log-rotate validation " " failed for %s & %s" , master, slave); } while (0); | |||||
1941 | goto out; | |||||
1942 | } | |||||
1943 | if (gsync_status_byfd (pfd) == -1) { | |||||
1944 | gf_log ("", GF_LOG_ERROR, "gsyncd b/w %s & %s is not"do { do { if (0) printf ("gsyncd b/w %s & %s is not" " running" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1945, GF_LOG_ERROR, "gsyncd b/w %s & %s is not" " running", master, slave); } while (0) | |||||
1945 | " running", master, slave)do { do { if (0) printf ("gsyncd b/w %s & %s is not" " running" , master, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c" , __FUNCTION__, 1945, GF_LOG_ERROR, "gsyncd b/w %s & %s is not" " running", master, slave); } while (0); | |||||
1946 | goto out; | |||||
1947 | } | |||||
1948 | ||||||
1949 | if (pfd < 0) | |||||
1950 | goto out; | |||||
1951 | ||||||
1952 | ret = read (pfd, buff, 1024); | |||||
1953 | if (ret < 0) { | |||||
1954 | gf_log ("", GF_LOG_ERROR, GEOREP" cannot read pid from pid-file")do { do { if (0) printf ("geo-replication"" cannot read pid from pid-file" ); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 1954, GF_LOG_ERROR, "geo-replication"" cannot read pid from pid-file" ); } while (0); | |||||
1955 | goto out; | |||||
1956 | } | |||||
1957 | ||||||
1958 | ||||||
1959 | *pid = strtol (buff, NULL((void*)0), 10); | |||||
1960 | ret = 0; | |||||
1961 | ||||||
1962 | out: | |||||
1963 | sys_close(pfd); | |||||
1964 | return ret; | |||||
1965 | } | |||||
1966 | ||||||
1967 | static int | |||||
1968 | glusterd_do_gsync_log_rotate (char *master, char *slave, uuid_t *uuid, char **op_errstr) | |||||
1969 | { | |||||
1970 | int ret = 0; | |||||
1971 | glusterd_conf_t *priv = NULL((void*)0); | |||||
1972 | pid_t pid = 0; | |||||
1973 | char log_file1[PATH_MAX4096] = {0,}; | |||||
1974 | char log_file2[PATH_MAX4096] = {0,}; | |||||
1975 | ||||||
1976 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 1976, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
1977 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 1977, GF_LOG_ERROR, "Assertion failed: " "THIS->private" ); } while (0); } } while (0); | |||||
1978 | ||||||
1979 | priv = THIS(*__glusterfs_this_location())->private; | |||||
1980 | ||||||
1981 | ret = glusterd_get_pid_from_file (master, slave, &pid); | |||||
1982 | if (ret) | |||||
1983 | goto out; | |||||
1984 | ||||||
1985 | /* log file */ | |||||
1986 | ret = glusterd_gsyncd_getlogfile (master, slave, log_file1); | |||||
1987 | if (ret) | |||||
1988 | goto out; | |||||
1989 | ||||||
1990 | /* check if slave is local or remote */ | |||||
1991 | ret = glusterd_gsync_slave_is_remote (slave); | |||||
1992 | if (ret) | |||||
1993 | goto do_rotate; | |||||
1994 | ||||||
1995 | /* slave log file - slave is local and it's log can be rotated */ | |||||
1996 | ret = glusterd_gsync_get_slave_log_file (master, slave, log_file2); | |||||
1997 | if (ret) | |||||
1998 | goto out; | |||||
1999 | ||||||
2000 | do_rotate: | |||||
2001 | ret = glusterd_send_log_rotate_signal (pid, log_file1, log_file2); | |||||
2002 | ||||||
2003 | out: | |||||
2004 | if (ret && op_errstr) | |||||
2005 | *op_errstr = gf_strdup("Error rotating log file"); | |||||
2006 | return ret; | |||||
2007 | } | |||||
2008 | ||||||
2009 | static int | |||||
2010 | glusterd_do_gsync_log_rotation_mst_slv (glusterd_volinfo_t *volinfo, char *slave, | |||||
2011 | char **op_errstr) | |||||
2012 | { | |||||
2013 | uuid_t uuid = {0, }; | |||||
2014 | glusterd_conf_t *priv = NULL((void*)0); | |||||
2015 | int ret = 0; | |||||
2016 | char errmsg[1024] = {0,}; | |||||
2017 | xlator_t *this = NULL((void*)0); | |||||
2018 | ||||||
2019 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2019, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
2020 | GF_ASSERT (slave)do { if (!(slave)) { do { do { if (0) printf ("Assertion failed: " "slave"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2020, GF_LOG_ERROR, "Assertion failed: " "slave" ); } while (0); } } while (0); | |||||
2021 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 2021, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
2022 | this = THIS(*__glusterfs_this_location()); | |||||
2023 | GF_ASSERT (this->private)do { if (!(this->private)) { do { do { if (0) printf ("Assertion failed: " "this->private"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2023, GF_LOG_ERROR, "Assertion failed: " "this->private" ); } while (0); } } while (0); | |||||
2024 | priv = this->private; | |||||
2025 | ||||||
2026 | ret = glusterd_gsync_get_uuid (slave, volinfo, uuid); | |||||
2027 | if ((ret == 0) && (uuid_compare (MY_UUID(__glusterd_uuid()), uuid) != 0)) | |||||
2028 | goto out; | |||||
2029 | ||||||
2030 | if (ret) { | |||||
2031 | snprintf(errmsg, sizeof(errmsg), "geo-replication session b/w %s %s not active", | |||||
2032 | volinfo->volname, slave); | |||||
2033 | gf_log (this->name, GF_LOG_WARNING, "%s", errmsg)do { do { if (0) printf ("%s", errmsg); } while (0); _gf_log ( this->name, "glusterd-geo-rep.c", __FUNCTION__, 2033, GF_LOG_WARNING , "%s", errmsg); } while (0); | |||||
2034 | if (op_errstr) | |||||
2035 | *op_errstr = gf_strdup(errmsg); | |||||
2036 | goto out; | |||||
2037 | } | |||||
2038 | ||||||
2039 | ret = glusterd_do_gsync_log_rotate (volinfo->volname, slave, &uuid, op_errstr); | |||||
2040 | ||||||
2041 | out: | |||||
2042 | gf_log (this->name, GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log (this->name, "glusterd-geo-rep.c", __FUNCTION__ , 2042, GF_LOG_DEBUG, "Returning with %d", ret); } while (0); | |||||
2043 | return ret; | |||||
2044 | } | |||||
2045 | ||||||
2046 | static int | |||||
2047 | _iterate_log_rotate_mst_slv (dict_t *this, char *key, data_t *value, void *data) | |||||
2048 | { | |||||
2049 | glusterd_gsync_status_temp_t *param = NULL((void*)0); | |||||
2050 | char *slave = NULL((void*)0); | |||||
2051 | ||||||
2052 | param = (glusterd_gsync_status_temp_t *) data; | |||||
2053 | ||||||
2054 | GF_ASSERT (param)do { if (!(param)) { do { do { if (0) printf ("Assertion failed: " "param"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2054, GF_LOG_ERROR, "Assertion failed: " "param" ); } while (0); } } while (0); | |||||
2055 | GF_ASSERT (param->volinfo)do { if (!(param->volinfo)) { do { do { if (0) printf ("Assertion failed: " "param->volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2055, GF_LOG_ERROR, "Assertion failed: " "param->volinfo" ); } while (0); } } while (0); | |||||
2056 | ||||||
2057 | slave = strchr (value->data, ':'); | |||||
2058 | if (slave) | |||||
2059 | slave++; | |||||
2060 | else { | |||||
2061 | gf_log ("", GF_LOG_ERROR, "geo-replication log-rotate: slave (%s) "do { do { if (0) printf ("geo-replication log-rotate: slave (%s) " "not conforming to format", slave); } while (0); _gf_log ("" , "glusterd-geo-rep.c", __FUNCTION__, 2062, GF_LOG_ERROR, "geo-replication log-rotate: slave (%s) " "not conforming to format", slave); } while (0) | |||||
2062 | "not conforming to format", slave)do { do { if (0) printf ("geo-replication log-rotate: slave (%s) " "not conforming to format", slave); } while (0); _gf_log ("" , "glusterd-geo-rep.c", __FUNCTION__, 2062, GF_LOG_ERROR, "geo-replication log-rotate: slave (%s) " "not conforming to format", slave); } while (0); | |||||
2063 | return -1; | |||||
2064 | } | |||||
2065 | ||||||
2066 | (void) glusterd_do_gsync_log_rotation_mst_slv (param->volinfo, slave, NULL((void*)0)); | |||||
2067 | return 0; | |||||
2068 | } | |||||
2069 | ||||||
2070 | static int | |||||
2071 | glusterd_do_gsync_log_rotation_mst (glusterd_volinfo_t *volinfo) | |||||
2072 | { | |||||
2073 | glusterd_gsync_status_temp_t param = {0, }; | |||||
2074 | ||||||
2075 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2075, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | |||||
2076 | ||||||
2077 | param.volinfo = volinfo; | |||||
2078 | dict_foreach (volinfo->gsync_slaves, _iterate_log_rotate_mst_slv, ¶m); | |||||
2079 | return 0; | |||||
2080 | } | |||||
2081 | ||||||
2082 | static int | |||||
2083 | glusterd_rotate_gsync_all () | |||||
2084 | { | |||||
2085 | int32_t ret = 0; | |||||
2086 | glusterd_conf_t *priv = NULL((void*)0); | |||||
2087 | glusterd_volinfo_t *volinfo = NULL((void*)0); | |||||
2088 | ||||||
2089 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 2089, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
2090 | priv = THIS(*__glusterfs_this_location())->private; | |||||
2091 | ||||||
2092 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2092, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | |||||
2093 | ||||||
2094 | list_for_each_entry (volinfo, &priv->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&priv-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&priv-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | |||||
2095 | ret = glusterd_do_gsync_log_rotation_mst (volinfo); | |||||
2096 | if (ret) | |||||
2097 | goto out; | |||||
2098 | } | |||||
2099 | ||||||
2100 | out: | |||||
2101 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 2101, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | |||||
2102 | return ret; | |||||
2103 | } | |||||
2104 | ||||||
2105 | static int | |||||
2106 | glusterd_rotate_gsync_logs (dict_t *dict, char **op_errstr, dict_t *rsp_dict) | |||||
2107 | { | |||||
2108 | char *slave = NULL((void*)0); | |||||
2109 | char *volname = NULL((void*)0); | |||||
2110 | char errmsg[1024] = {0,}; | |||||
2111 | gf_boolean_t exists = _gf_false; | |||||
2112 | glusterd_volinfo_t *volinfo = NULL((void*)0); | |||||
2113 | char **linearr = NULL((void*)0); | |||||
2114 | int ret = 0; | |||||
2115 | ||||||
2116 | ret = dict_get_str (dict, "master", &volname); | |||||
2117 | if (ret < 0) { | |||||
2118 | ret = glusterd_rotate_gsync_all (); | |||||
2119 | goto out; | |||||
2120 | } | |||||
2121 | ||||||
2122 | exists = glusterd_check_volume_exists (volname); | |||||
2123 | ret = glusterd_volinfo_find (volname, &volinfo); | |||||
2124 | if ((ret) || (!exists)) { | |||||
2125 | snprintf (errmsg, sizeof(errmsg), "Volume %s does not" | |||||
2126 | " exist", volname); | |||||
2127 | gf_log ("", GF_LOG_WARNING, "%s", errmsg)do { do { if (0) printf ("%s", errmsg); } while (0); _gf_log ( "", "glusterd-geo-rep.c", __FUNCTION__, 2127, GF_LOG_WARNING, "%s", errmsg); } while (0); | |||||
2128 | *op_errstr = gf_strdup (errmsg); | |||||
2129 | ret = -1; | |||||
2130 | goto out; | |||||
2131 | } | |||||
2132 | ||||||
2133 | ret = dict_get_str (dict, "slave", &slave); | |||||
2134 | if (ret < 0) { | |||||
2135 | ret = glusterd_do_gsync_log_rotation_mst (volinfo); | |||||
2136 | goto out; | |||||
2137 | } | |||||
2138 | ||||||
2139 | /* for the given slave use the normalized url */ | |||||
2140 | ret = glusterd_urltransform_single (slave, "normalize", &linearr); | |||||
2141 | if (ret == -1) | |||||
2142 | goto out; | |||||
2143 | ||||||
2144 | ret = glusterd_do_gsync_log_rotation_mst_slv (volinfo, linearr[0], | |||||
2145 | op_errstr); | |||||
2146 | if (ret) | |||||
2147 | gf_log ("gsyncd", GF_LOG_ERROR, "gsyncd log-rotate failed for"do { do { if (0) printf ("gsyncd log-rotate failed for" " %s & %s" , volname, slave); } while (0); _gf_log ("gsyncd", "glusterd-geo-rep.c" , __FUNCTION__, 2148, GF_LOG_ERROR, "gsyncd log-rotate failed for" " %s & %s", volname, slave); } while (0) | |||||
2148 | " %s & %s", volname, slave)do { do { if (0) printf ("gsyncd log-rotate failed for" " %s & %s" , volname, slave); } while (0); _gf_log ("gsyncd", "glusterd-geo-rep.c" , __FUNCTION__, 2148, GF_LOG_ERROR, "gsyncd log-rotate failed for" " %s & %s", volname, slave); } while (0); | |||||
2149 | ||||||
2150 | glusterd_urltransform_free (linearr, 1); | |||||
2151 | out: | |||||
2152 | return ret; | |||||
2153 | } | |||||
2154 | ||||||
2155 | ||||||
2156 | int | |||||
2157 | glusterd_op_gsync_set (dict_t *dict, char **op_errstr, dict_t *rsp_dict) | |||||
2158 | { | |||||
2159 | int32_t ret = -1; | |||||
2160 | int32_t type = -1; | |||||
2161 | dict_t *ctx = NULL((void*)0); | |||||
2162 | dict_t *resp_dict = NULL((void*)0); | |||||
2163 | char *host_uuid = NULL((void*)0); | |||||
2164 | char *slave = NULL((void*)0); | |||||
2165 | char *volname = NULL((void*)0); | |||||
2166 | glusterd_volinfo_t *volinfo = NULL((void*)0); | |||||
2167 | glusterd_conf_t *priv = NULL((void*)0); | |||||
2168 | char *status_msg = NULL((void*)0); | |||||
2169 | uuid_t uuid = {0, }; | |||||
2170 | ||||||
2171 | GF_ASSERT (THIS)do { if (!((*__glusterfs_this_location()))) { do { do { if (0 ) printf ("Assertion failed: " "THIS"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__, 2171, GF_LOG_ERROR, "Assertion failed: " "THIS"); } while (0); } } while (0); | |||||
2172 | GF_ASSERT (THIS->private)do { if (!((*__glusterfs_this_location())->private)) { do { do { if (0) printf ("Assertion failed: " "THIS->private") ; } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c", __FUNCTION__ , 2172, GF_LOG_ERROR, "Assertion failed: " "THIS->private" ); } while (0); } } while (0); | |||||
2173 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2173, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | |||||
2174 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2174, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | |||||
2175 | ||||||
2176 | priv = THIS(*__glusterfs_this_location())->private; | |||||
2177 | ||||||
2178 | ret = dict_get_int32 (dict, "type", &type); | |||||
2179 | if (ret < 0) | |||||
2180 | goto out; | |||||
2181 | ||||||
2182 | ret = dict_get_str (dict, "host-uuid", &host_uuid); | |||||
2183 | if (ret < 0) | |||||
2184 | goto out; | |||||
2185 | ||||||
2186 | ctx = glusterd_op_get_ctx (); | |||||
2187 | resp_dict = ctx ? ctx : rsp_dict; | |||||
2188 | GF_ASSERT (resp_dict)do { if (!(resp_dict)) { do { do { if (0) printf ("Assertion failed: " "resp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-geo-rep.c" , __FUNCTION__, 2188, GF_LOG_ERROR, "Assertion failed: " "resp_dict" ); } while (0); } } while (0); | |||||
2189 | ||||||
2190 | if (type == GF_GSYNC_OPTION_TYPE_STATUS) { | |||||
2191 | ret = glusterd_get_gsync_status (dict, op_errstr, resp_dict); | |||||
2192 | goto out; | |||||
2193 | } | |||||
2194 | ||||||
2195 | if (type == GF_GSYNC_OPTION_TYPE_ROTATE) { | |||||
2196 | ret = glusterd_rotate_gsync_logs (dict, op_errstr, resp_dict); | |||||
2197 | goto out; | |||||
2198 | ||||||
2199 | } | |||||
2200 | ||||||
2201 | ret = dict_get_str (dict, "slave", &slave); | |||||
2202 | if (ret < 0) | |||||
2203 | goto out; | |||||
2204 | ||||||
2205 | if (dict_get_str (dict, "master", &volname) == 0) { | |||||
2206 | ret = glusterd_volinfo_find (volname, &volinfo); | |||||
2207 | if (ret) { | |||||
2208 | gf_log ("", GF_LOG_WARNING, "Volinfo for %s (master) not found",do { do { if (0) printf ("Volinfo for %s (master) not found", volname); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 2209, GF_LOG_WARNING, "Volinfo for %s (master) not found", volname ); } while (0) | |||||
2209 | volname)do { do { if (0) printf ("Volinfo for %s (master) not found", volname); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__ , 2209, GF_LOG_WARNING, "Volinfo for %s (master) not found", volname ); } while (0); | |||||
2210 | goto out; | |||||
2211 | } | |||||
2212 | } | |||||
2213 | ||||||
2214 | if (type == GF_GSYNC_OPTION_TYPE_CONFIG) { | |||||
2215 | ret = glusterd_gsync_configure (volinfo, slave, dict, resp_dict, | |||||
2216 | op_errstr); | |||||
2217 | goto out; | |||||
2218 | } | |||||
2219 | ||||||
2220 | if (!volinfo) { | |||||
2221 | ret = -1; | |||||
2222 | goto out; | |||||
2223 | } | |||||
2224 | ||||||
2225 | if (type == GF_GSYNC_OPTION_TYPE_START) { | |||||
2226 | ||||||
2227 | ret = glusterd_set_marker_gsync (volinfo); | |||||
2228 | if (ret != 0) { | |||||
2229 | gf_log ("", GF_LOG_WARNING, "marker start failed")do { do { if (0) printf ("marker start failed"); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 2229, GF_LOG_WARNING , "marker start failed"); } while (0); | |||||
2230 | *op_errstr = gf_strdup ("failed to initialize indexing"); | |||||
2231 | ret = -1; | |||||
2232 | goto out; | |||||
2233 | } | |||||
2234 | ret = glusterd_store_slave_in_info(volinfo, slave, | |||||
2235 | host_uuid, op_errstr); | |||||
2236 | if (ret) | |||||
2237 | goto out; | |||||
2238 | ||||||
2239 | ret = glusterd_start_gsync (volinfo, slave, host_uuid, | |||||
2240 | op_errstr); | |||||
2241 | } | |||||
2242 | ||||||
2243 | if (type == GF_GSYNC_OPTION_TYPE_STOP) { | |||||
2244 | ||||||
2245 | ret = glusterd_gsync_get_uuid (slave, volinfo, uuid); | |||||
2246 | if (ret) { | |||||
2247 | gf_log ("", GF_LOG_WARNING, GEOREP" is not set up for"do { do { if (0) printf ("geo-replication"" is not set up for" "%s(master) and %s(slave)", volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 2248, GF_LOG_WARNING , "geo-replication"" is not set up for" "%s(master) and %s(slave)" , volname, slave); } while (0) | |||||
2248 | "%s(master) and %s(slave)", volname, slave)do { do { if (0) printf ("geo-replication"" is not set up for" "%s(master) and %s(slave)", volname, slave); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 2248, GF_LOG_WARNING , "geo-replication"" is not set up for" "%s(master) and %s(slave)" , volname, slave); } while (0); | |||||
2249 | *op_errstr = strdup (GEOREP"geo-replication"" is not set up"); | |||||
2250 | goto out; | |||||
2251 | } | |||||
2252 | ||||||
2253 | ret = glusterd_remove_slave_in_info(volinfo, slave, op_errstr); | |||||
2254 | if (ret) | |||||
2255 | goto out; | |||||
2256 | ||||||
2257 | if (uuid_compare (MY_UUID(__glusterd_uuid()), uuid) != 0) { | |||||
2258 | goto out; | |||||
2259 | } | |||||
2260 | ||||||
2261 | ret = stop_gsync (volname, slave, &status_msg); | |||||
2262 | if (ret == 0 && status_msg) | |||||
2263 | ret = dict_set_str (resp_dict, "gsync-status", | |||||
2264 | status_msg); | |||||
2265 | if (ret != 0) | |||||
2266 | *op_errstr = gf_strdup ("internal error"); | |||||
2267 | } | |||||
2268 | ||||||
2269 | out: | |||||
2270 | gf_log ("", GF_LOG_DEBUG,"Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-geo-rep.c", __FUNCTION__, 2270, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | |||||
2271 | return ret; | |||||
2272 | } |