Bug Summary

File:xlators/mgmt/glusterd/src/glusterd-geo-rep.c
Location:line 2266, column 36
Description:Dereference of null pointer (loaded from variable 'op_errstr')

Annotated Source Code

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
28static 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
39int
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
146out:
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
158int
159glusterd_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
170static void
171glusterd_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
178static void
179glusterd_urltransform_add (runner_t *runner, const char *url)
180{
181 runner_add_arg (runner, url);
182}
183
184static 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
198static void
199glusterd_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
209static int
210glusterd_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
292static int
293glusterd_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
304struct dictidxmark {
305 unsigned isrch;
306 unsigned ithis;
307 char *ikey;
308};
309
310static 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
322static char *
323dict_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
333static int
334glusterd_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
364static int
365glusterd_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
386static 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
402static int
403glusterd_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
409static 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
446static int
447glusterd_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
463static int
464glusterd_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
479static int
480glusterd_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 */
501static int
502glusterd_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
514static int
515glusterd_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
552static int
553gsyncd_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
580static int
581glusterd_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
606static int
607gsync_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 */
622int
623gsync_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
640static int32_t
641glusterd_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;
660out:
661 return 0;
662}
663
664static int
665gsync_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
745static int
746glusterd_get_gsync_status_mst_slv (glusterd_volinfo_t *volinfo,
747 char *slave, dict_t *rsp_dict, char *node);
748
749static 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
774static 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
787static int
788glusterd_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
818static int
819glusterd_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
856static int
857glusterd_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
883static int
884glusterd_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
957static int
958glusterd_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;
1002out:
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
1010int
1011glusterd_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
1025static int
1026glusterd_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;
1052out:
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
1060static int
1061glusterd_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
1100int
1101glusterd_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;
1129out:
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
1134int
1135glusterd_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
1223out:
1224 return ret;
1225}
1226
1227static int
1228stop_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
1285out:
1286 sys_close (pfd);
1287 return ret;
1288}
1289
1290static int
1291glusterd_check_restart_gsync_session (glusterd_volinfo_t *volinfo, char *slave,
1292 dict_t *resp_dict);
1293
1294static int
1295glusterd_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
1368out:
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
1380static int
1381glusterd_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
1413static int
1414glusterd_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
1467static int
1468dict_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
1496static int
1497glusterd_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
1632static int
1633glusterd_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
1667static int32_t
1668glusterd_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;
1687out:
1688 return ret;
1689}
1690
1691static int
1692glusterd_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
1728out:
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
1736static int
1737glusterd_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
1770static int
1771glusterd_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, &param);
1782
1783 return 0;
1784}
1785
1786static int
1787glusterd_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
1805out:
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
1811static int
1812glusterd_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
1861static int
1862glusterd_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
1871static int
1872glusterd_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 */
1893static int
1894glusterd_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
1929static int
1930glusterd_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
1962out:
1963 sys_close(pfd);
1964 return ret;
1965}
1966
1967static int
1968glusterd_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
2009static int
2010glusterd_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
2046static 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
2070static int
2071glusterd_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, &param);
2079 return 0;
2080}
2081
2082static int
2083glusterd_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
2105static int
2106glusterd_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
2156int
2157glusterd_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)
;
1
Within the expansion of the macro 'GF_ASSERT':
a
Assuming 'op_errstr' is null
2175
2176 priv = THIS(*__glusterfs_this_location())->private;
2177
2178 ret = dict_get_int32 (dict, "type", &type);
2179 if (ret < 0)
2
Assuming 'ret' is >= 0
3
Taking false branch
2180 goto out;
2181
2182 ret = dict_get_str (dict, "host-uuid", &host_uuid);
2183 if (ret < 0)
4
Assuming 'ret' is >= 0
5
Taking false branch
2184 goto out;
2185
2186 ctx = glusterd_op_get_ctx ();
2187 resp_dict = ctx ? ctx : rsp_dict;
6
Assuming 'ctx' is non-null
7
'?' condition is true
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) {
8
Assuming 'type' is not equal to GF_GSYNC_OPTION_TYPE_STATUS
9
Taking false branch
2191 ret = glusterd_get_gsync_status (dict, op_errstr, resp_dict);
2192 goto out;
2193 }
2194
2195 if (type == GF_GSYNC_OPTION_TYPE_ROTATE) {
10
Assuming 'type' is not equal to GF_GSYNC_OPTION_TYPE_ROTATE
11
Taking false branch
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)
12
Assuming 'ret' is >= 0
13
Taking false branch
2203 goto out;
2204
2205 if (dict_get_str (dict, "master", &volname) == 0) {
14
Taking true branch
2206 ret = glusterd_volinfo_find (volname, &volinfo);
2207 if (ret) {
15
Assuming 'ret' is 0
16
Taking false branch
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) {
17
Assuming 'type' is not equal to GF_GSYNC_OPTION_TYPE_CONFIG
18
Taking false branch
2215 ret = glusterd_gsync_configure (volinfo, slave, dict, resp_dict,
2216 op_errstr);
2217 goto out;
2218 }
2219
2220 if (!volinfo) {
19
Assuming 'volinfo' is non-null
20
Taking false branch
2221 ret = -1;
2222 goto out;
2223 }
2224
2225 if (type == GF_GSYNC_OPTION_TYPE_START) {
21
Assuming 'type' is not equal to GF_GSYNC_OPTION_TYPE_START
22
Taking false branch
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) {
23
Assuming 'type' is equal to GF_GSYNC_OPTION_TYPE_STOP
24
Taking true branch
2244
2245 ret = glusterd_gsync_get_uuid (slave, volinfo, uuid);
2246 if (ret) {
25
Assuming 'ret' is 0
26
Taking false branch
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)
27
Assuming 'ret' is 0
28
Taking false branch
2255 goto out;
2256
2257 if (uuid_compare (MY_UUID(__glusterd_uuid()), uuid) != 0) {
29
Taking false branch
2258 goto out;
2259 }
2260
2261 ret = stop_gsync (volname, slave, &status_msg);
2262 if (ret == 0 && status_msg)
30
Assuming 'ret' is not equal to 0
2263 ret = dict_set_str (resp_dict, "gsync-status",
2264 status_msg);
2265 if (ret != 0)
31
Taking true branch
2266 *op_errstr = gf_strdup ("internal error");
32
Dereference of null pointer (loaded from variable 'op_errstr')
2267 }
2268
2269out:
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}