Bug Summary

File:xlators/mgmt/glusterd/src/glusterd-syncop.c
Location:line 771, column 17
Description:Value stored to 'ret' is never read

Annotated Source Code

1/*
2 Copyright (c) 2012-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/* rpc related syncops */
11#include "rpc-clnt.h"
12#include "protocol-common.h"
13#include "xdr-generic.h"
14#include "glusterd1-xdr.h"
15#include "glusterd-syncop.h"
16
17#include "glusterd.h"
18#include "glusterd-op-sm.h"
19#include "glusterd-utils.h"
20
21static inline void
22gd_synctask_barrier_wait (struct syncargs *args, int count)
23{
24 glusterd_conf_t *conf = THIS(*__glusterfs_this_location())->private;
25
26 synclock_unlock (&conf->big_lock);
27 synctask_barrier_wait (args, count)syncbarrier_wait (&args->barrier, count);
28 synclock_lock (&conf->big_lock);
29
30 syncbarrier_destroy (&args->barrier);
31}
32
33static void
34gd_collate_errors (struct syncargs *args, int op_ret, int op_errno,
35 char *op_errstr)
36{
37 if (args->op_ret)
38 return;
39 args->op_ret = op_ret;
40 args->op_errno = op_errno;
41 if (op_ret && op_errstr && strcmp (op_errstr, ""))
42 args->errstr = gf_strdup (op_errstr);
43}
44
45static void
46gd_syncargs_init (struct syncargs *args, dict_t *op_ctx)
47{
48 args->dict = op_ctx;
49 pthread_mutex_init (&args->lock_dict, NULL((void*)0));
50}
51
52static void
53gd_stage_op_req_free (gd1_mgmt_stage_op_req *req)
54{
55 if (!req)
56 return;
57
58 GF_FREE (req->buf.buf_val)__gf_free (req->buf.buf_val);
59 GF_FREE (req)__gf_free (req);
60}
61
62static void
63gd_commit_op_req_free (gd1_mgmt_commit_op_req *req)
64{
65 if (!req)
66 return;
67
68 GF_FREE (req->buf.buf_val)__gf_free (req->buf.buf_val);
69 GF_FREE (req)__gf_free (req);
70}
71
72static void
73gd_brick_op_req_free (gd1_mgmt_brick_op_req *req)
74{
75 if (!req)
76 return;
77
78 if (strcmp (req->name, "") != 0)
79 GF_FREE (req->name)__gf_free (req->name);
80 GF_FREE (req->input.input_val)__gf_free (req->input.input_val);
81 GF_FREE (req)__gf_free (req);
82}
83
84int
85gd_syncop_submit_request (struct rpc_clnt *rpc, void *req,
86 void *cookie, rpc_clnt_prog_t *prog,
87 int procnum, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc)
88{
89 int ret = -1;
90 struct iobuf *iobuf = NULL((void*)0);
91 struct iobref *iobref = NULL((void*)0);
92 int count = 0;
93 struct iovec iov = {0, };
94 ssize_t req_size = 0;
95 call_frame_t *frame = NULL((void*)0);
96
97 GF_ASSERT (rpc)do { if (!(rpc)) { do { do { if (0) printf ("Assertion failed: "
"rpc"); } while (0); _gf_log_callingfn ("", "glusterd-syncop.c"
, __FUNCTION__, 97, GF_LOG_ERROR, "Assertion failed: " "rpc")
; } while (0); } } while (0)
;
98 if (!req)
99 goto out;
100
101 req_size = xdr_sizeof (xdrproc, req);
102 iobuf = iobuf_get2 (rpc->ctx->iobuf_pool, req_size);
103 if (!iobuf)
104 goto out;
105
106 iobref = iobref_new ();
107 if (!iobref)
108 goto out;
109
110 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
111 if (!frame)
112 goto out;
113
114 iobref_add (iobref, iobuf);
115
116 iov.iov_base = iobuf->ptr;
117 iov.iov_len = iobuf_pagesize (iobuf)(iobuf->iobuf_arena->page_size);
118
119 /* Create the xdr payload */
120 ret = xdr_serialize_generic (iov, req, xdrproc);
121 if (ret == -1)
122 goto out;
123
124 iov.iov_len = ret;
125 count = 1;
126
127 frame->local = cookie;
128
129 /* Send the msg */
130 ret = rpc_clnt_submit (rpc, prog, procnum, cbkfn,
131 &iov, count, NULL((void*)0), 0, iobref,
132 frame, NULL((void*)0), 0, NULL((void*)0), 0, NULL((void*)0));
133
134 /* TODO: do we need to start ping also? */
135
136out:
137 iobref_unref (iobref);
138 iobuf_unref (iobuf);
139
140 return ret;
141}
142
143/* Defined in glusterd-rpc-ops.c */
144extern struct rpc_clnt_program gd_mgmt_prog;
145extern struct rpc_clnt_program gd_brick_prog;
146
147static int
148glusterd_syncop_aggr_rsp_dict (glusterd_op_t op, dict_t *aggr, dict_t *rsp)
149{
150 int ret = 0;
151
152 switch (op) {
153 case GD_OP_REPLACE_BRICK:
154 ret = glusterd_rb_use_rsp_dict (aggr, rsp);
155 if (ret)
156 goto out;
157 break;
158
159 case GD_OP_SYNC_VOLUME:
160 ret = glusterd_sync_use_rsp_dict (aggr, rsp);
161 if (ret)
162 goto out;
163 break;
164
165 case GD_OP_PROFILE_VOLUME:
166 ret = glusterd_profile_volume_use_rsp_dict (aggr, rsp);
167 if (ret)
168 goto out;
169 break;
170
171 case GD_OP_GSYNC_SET:
172 ret = glusterd_gsync_use_rsp_dict (aggr, rsp, NULL((void*)0));
173 if (ret)
174 goto out;
175 break;
176
177 case GD_OP_STATUS_VOLUME:
178 ret = glusterd_volume_status_copy_to_op_ctx_dict (aggr, rsp);
179 if (ret)
180 goto out;
181 break;
182
183 case GD_OP_REBALANCE:
184 case GD_OP_DEFRAG_BRICK_VOLUME:
185 ret = glusterd_volume_rebalance_use_rsp_dict (aggr, rsp);
186 if (ret)
187 goto out;
188 break;
189
190 case GD_OP_HEAL_VOLUME:
191 ret = glusterd_volume_heal_use_rsp_dict (aggr, rsp);
192 if (ret)
193 goto out;
194
195 break;
196
197 case GD_OP_QUOTA:
198 case GD_OP_CLEARLOCKS_VOLUME:
199 ret = glusterd_use_rsp_dict (aggr, rsp);
200 if (ret)
201 goto out;
202
203 break;
204
205 default:
206 break;
207 }
208out:
209 return ret;
210}
211
212int32_t
213_gd_syncop_mgmt_lock_cbk (struct rpc_req *req, struct iovec *iov,
214 int count, void *myframe)
215{
216 int ret = -1;
217 struct syncargs *args = NULL((void*)0);
218 gd1_mgmt_cluster_lock_rsp rsp = {{0},};
219 call_frame_t *frame = NULL((void*)0);
220
221 frame = myframe;
222 args = frame->local;
223 frame->local = NULL((void*)0);
224
225 if (-1 == req->rpc_status) {
226 args->op_errno = ENOTCONN107;
227 goto out;
228 }
229
230 ret = xdr_to_generic (*iov, &rsp,
231 (xdrproc_t)xdr_gd1_mgmt_cluster_lock_rsp);
232 if (ret < 0)
233 goto out;
234
235 gd_collate_errors (args, rsp.op_ret, rsp.op_errno, NULL((void*)0));
236 uuid_copy (args->uuid, rsp.uuid);
237
238out:
239 STACK_DESTROY (frame->root);
240 synctask_barrier_wake(args)syncbarrier_wake (&args->barrier);
241 return 0;
242}
243
244int32_t
245gd_syncop_mgmt_lock_cbk (struct rpc_req *req, struct iovec *iov,
246 int count, void *myframe)
247{
248 return glusterd_big_locked_cbk (req, iov, count, myframe,
249 _gd_syncop_mgmt_lock_cbk);
250}
251
252int
253gd_syncop_mgmt_lock (struct rpc_clnt *rpc, struct syncargs *args,
254 uuid_t my_uuid, uuid_t recv_uuid)
255{
256 int ret = -1;
257 gd1_mgmt_cluster_lock_req req = {{0},};
258
259 uuid_copy (req.uuid, my_uuid);
260 ret = gd_syncop_submit_request (rpc, &req, args, &gd_mgmt_prog,
261 GLUSTERD_MGMT_CLUSTER_LOCK,
262 gd_syncop_mgmt_lock_cbk,
263 (xdrproc_t) xdr_gd1_mgmt_cluster_lock_req);
264 return ret;
265}
266
267int32_t
268_gd_syncop_mgmt_unlock_cbk (struct rpc_req *req, struct iovec *iov,
269 int count, void *myframe)
270{
271 int ret = -1;
272 struct syncargs *args = NULL((void*)0);
273 gd1_mgmt_cluster_unlock_rsp rsp = {{0},};
274 call_frame_t *frame = NULL((void*)0);
275
276 frame = myframe;
277 args = frame->local;
278 frame->local = NULL((void*)0);
279
280 if (-1 == req->rpc_status) {
281 args->op_errno = ENOTCONN107;
282 goto out;
283 }
284
285 ret = xdr_to_generic (*iov, &rsp,
286 (xdrproc_t)xdr_gd1_mgmt_cluster_unlock_rsp);
287 if (ret < 0)
288 goto out;
289
290 gd_collate_errors (args, rsp.op_ret, rsp.op_errno, NULL((void*)0));
291 uuid_copy (args->uuid, rsp.uuid);
292
293out:
294 STACK_DESTROY (frame->root);
295 synctask_barrier_wake(args)syncbarrier_wake (&args->barrier);
296 return 0;
297}
298
299int32_t
300gd_syncop_mgmt_unlock_cbk (struct rpc_req *req, struct iovec *iov,
301 int count, void *myframe)
302{
303 return glusterd_big_locked_cbk (req, iov, count, myframe,
304 _gd_syncop_mgmt_unlock_cbk);
305}
306
307
308int
309gd_syncop_mgmt_unlock (struct rpc_clnt *rpc, struct syncargs *args,
310 uuid_t my_uuid, uuid_t recv_uuid)
311{
312 int ret = -1;
313 gd1_mgmt_cluster_unlock_req req = {{0},};
314
315 uuid_copy (req.uuid, my_uuid);
316 ret = gd_syncop_submit_request (rpc, &req, args, &gd_mgmt_prog,
317 GLUSTERD_MGMT_CLUSTER_UNLOCK,
318 gd_syncop_mgmt_unlock_cbk,
319 (xdrproc_t) xdr_gd1_mgmt_cluster_lock_req);
320 return ret;
321}
322
323int32_t
324_gd_syncop_stage_op_cbk (struct rpc_req *req, struct iovec *iov,
325 int count, void *myframe)
326{
327 int ret = -1;
328 gd1_mgmt_stage_op_rsp rsp = {{0},};
329 struct syncargs *args = NULL((void*)0);
330 xlator_t *this = NULL((void*)0);
331 dict_t *rsp_dict = NULL((void*)0);
332 call_frame_t *frame = NULL((void*)0);
333
334 this = THIS(*__glusterfs_this_location());
335 frame = myframe;
336 args = frame->local;
337 frame->local = NULL((void*)0);
338
339 if (-1 == req->rpc_status) {
340 args->op_ret = -1;
341 args->op_errno = ENOTCONN107;
342 goto out;
343 }
344
345 ret = xdr_to_generic (*iov, &rsp,
346 (xdrproc_t)xdr_gd1_mgmt_stage_op_rsp);
347 if (ret < 0)
348 goto out;
349
350 if (rsp.dict.dict_len) {
351 /* Unserialize the dictionary */
352 rsp_dict = dict_new ();
353
354 ret = dict_unserialize (rsp.dict.dict_val,
355 rsp.dict.dict_len,
356 &rsp_dict);
357 if (ret < 0) {
358 GF_FREE (rsp.dict.dict_val)__gf_free (rsp.dict.dict_val);
359 goto out;
360 } else {
361 rsp_dict->extra_stdfree = rsp.dict.dict_val;
362 }
363 }
364
365 gd_collate_errors (args, rsp.op_ret, rsp.op_errno, rsp.op_errstr);
366 uuid_copy (args->uuid, rsp.uuid);
367 if (rsp.op == GD_OP_REPLACE_BRICK) {
368 pthread_mutex_lock (&args->lock_dict);
369 {
370 ret = glusterd_syncop_aggr_rsp_dict (rsp.op, args->dict,
371 rsp_dict);
372 if (ret)
373 gf_log (this->name, GF_LOG_ERROR, "%s",do { do { if (0) printf ("%s", "Failed to aggregate response from "
" node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 375, GF_LOG_ERROR, "%s", "Failed to aggregate response from "
" node/brick"); } while (0)
374 "Failed to aggregate response from "do { do { if (0) printf ("%s", "Failed to aggregate response from "
" node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 375, GF_LOG_ERROR, "%s", "Failed to aggregate response from "
" node/brick"); } while (0)
375 " node/brick")do { do { if (0) printf ("%s", "Failed to aggregate response from "
" node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 375, GF_LOG_ERROR, "%s", "Failed to aggregate response from "
" node/brick"); } while (0)
;
376 }
377 pthread_mutex_unlock (&args->lock_dict);
378 }
379
380out:
381 if (rsp_dict)
382 dict_unref (rsp_dict);
383
384 STACK_DESTROY (frame->root);
385 synctask_barrier_wake(args)syncbarrier_wake (&args->barrier);
386 return 0;
387}
388
389int32_t
390gd_syncop_stage_op_cbk (struct rpc_req *req, struct iovec *iov,
391 int count, void *myframe)
392{
393 return glusterd_big_locked_cbk (req, iov, count, myframe,
394 _gd_syncop_stage_op_cbk);
395}
396
397
398int
399gd_syncop_mgmt_stage_op (struct rpc_clnt *rpc, struct syncargs *args,
400 uuid_t my_uuid, uuid_t recv_uuid, int op,
401 dict_t *dict_out, dict_t *op_ctx)
402{
403 gd1_mgmt_stage_op_req *req = NULL((void*)0);
404 int ret = -1;
405
406 req = GF_CALLOC (1, sizeof (*req), gf_gld_mt_mop_stage_req_t)__gf_calloc (1, sizeof (*req), gf_gld_mt_mop_stage_req_t);
407 if (!req)
408 goto out;
409
410 uuid_copy (req->uuid, my_uuid);
411 req->op = op;
412
413 ret = dict_allocate_and_serialize (dict_out,
414 &req->buf.buf_val, &req->buf.buf_len);
415 if (ret)
416 goto out;
417
418 ret = gd_syncop_submit_request (rpc, req, args, &gd_mgmt_prog,
419 GLUSTERD_MGMT_STAGE_OP,
420 gd_syncop_stage_op_cbk,
421 (xdrproc_t) xdr_gd1_mgmt_stage_op_req);
422out:
423 gd_stage_op_req_free (req);
424 return ret;
425
426}
427
428int32_t
429_gd_syncop_brick_op_cbk (struct rpc_req *req, struct iovec *iov,
430 int count, void *myframe)
431{
432 struct syncargs *args = NULL((void*)0);
433 gd1_mgmt_brick_op_rsp rsp = {0,};
434 int ret = -1;
435 call_frame_t *frame = NULL((void*)0);
436
437 frame = myframe;
438 args = frame->local;
439 frame->local = NULL((void*)0);
440
441 /* initialize */
442 args->op_ret = -1;
443 args->op_errno = EINVAL22;
444
445 if (-1 == req->rpc_status) {
446 args->op_errno = ENOTCONN107;
447 goto out;
448 }
449
450 ret = xdr_to_generic (*iov, &rsp,
451 (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp);
452 if (ret < 0)
453 goto out;
454
455 if (rsp.output.output_len) {
456 args->dict = dict_new ();
457 if (!args->dict) {
458 ret = -1;
459 args->op_errno = ENOMEM12;
460 goto out;
461 }
462
463 ret = dict_unserialize (rsp.output.output_val,
464 rsp.output.output_len,
465 &args->dict);
466 if (ret < 0)
467 goto out;
468 }
469
470 args->op_ret = rsp.op_ret;
471 args->op_errno = rsp.op_errno;
472 args->errstr = gf_strdup (rsp.op_errstr);
473
474out:
475 if (strcmp (rsp.op_errstr, "") != 0)
476 free (rsp.op_errstr);
477 free (rsp.output.output_val);
478
479 STACK_DESTROY (frame->root);
480 __wake (args)do { if (args->task) { synctask_wake (args->task); } else
{ pthread_mutex_lock (&args->mutex); { args->done =
1; pthread_cond_signal (&args->cond); } pthread_mutex_unlock
(&args->mutex); } } while (0)
;
481
482 return 0;
483}
484
485int32_t
486gd_syncop_brick_op_cbk (struct rpc_req *req, struct iovec *iov,
487 int count, void *myframe)
488{
489 return glusterd_big_locked_cbk (req, iov, count, myframe,
490 _gd_syncop_brick_op_cbk);
491}
492
493int
494gd_syncop_mgmt_brick_op (struct rpc_clnt *rpc, glusterd_pending_node_t *pnode,
495 int op, dict_t *dict_out, dict_t *op_ctx,
496 char **errstr)
497{
498 struct syncargs args = {0, };
499 gd1_mgmt_brick_op_req *req = NULL((void*)0);
500 int ret = 0;
501 xlator_t *this = NULL((void*)0);
502
503 this = THIS(*__glusterfs_this_location());
504 args.op_ret = -1;
505 args.op_errno = ENOTCONN107;
506
507 if ((pnode->type == GD_NODE_NFS) ||
508 ((pnode->type == GD_NODE_SHD) &&
509 (op == GD_OP_STATUS_VOLUME))) {
510 ret = glusterd_node_op_build_payload
511 (op, &req, dict_out);
512
513 } else {
514 ret = glusterd_brick_op_build_payload
515 (op, pnode->node, &req, dict_out);
516
517 }
518
519 if (ret)
520 goto out;
521
522 GD_SYNCOP (rpc, (&args), gd_syncop_brick_op_cbk,do { int ret = 0; struct synctask *task = ((void*)0); glusterd_conf_t
*conf= (*__glusterfs_this_location())->private; task = synctask_get
(); (&args)->task = task; synclock_unlock (&conf->
big_lock); ret = gd_syncop_submit_request (rpc, req, (&args
), &gd_brick_prog, req->op, gd_syncop_brick_op_cbk, (xdrproc_t
)xdr_gd1_mgmt_brick_op_req); if (!ret) synctask_yield ((&
args)->task); synclock_lock (&conf->big_lock); } while
(0)
523 req, &gd_brick_prog, req->op,do { int ret = 0; struct synctask *task = ((void*)0); glusterd_conf_t
*conf= (*__glusterfs_this_location())->private; task = synctask_get
(); (&args)->task = task; synclock_unlock (&conf->
big_lock); ret = gd_syncop_submit_request (rpc, req, (&args
), &gd_brick_prog, req->op, gd_syncop_brick_op_cbk, (xdrproc_t
)xdr_gd1_mgmt_brick_op_req); if (!ret) synctask_yield ((&
args)->task); synclock_lock (&conf->big_lock); } while
(0)
524 xdr_gd1_mgmt_brick_op_req)do { int ret = 0; struct synctask *task = ((void*)0); glusterd_conf_t
*conf= (*__glusterfs_this_location())->private; task = synctask_get
(); (&args)->task = task; synclock_unlock (&conf->
big_lock); ret = gd_syncop_submit_request (rpc, req, (&args
), &gd_brick_prog, req->op, gd_syncop_brick_op_cbk, (xdrproc_t
)xdr_gd1_mgmt_brick_op_req); if (!ret) synctask_yield ((&
args)->task); synclock_lock (&conf->big_lock); } while
(0)
;
525
526 if (args.errstr && errstr)
527 *errstr = args.errstr;
528 else
529 GF_FREE (args.errstr)__gf_free (args.errstr);
530
531 if (GD_OP_STATUS_VOLUME == op) {
532 ret = dict_set_int32 (args.dict, "index", pnode->index);
533 if (ret) {
534 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Error setting index on brick status"
" rsp dict"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 536, GF_LOG_ERROR, "Error setting index on brick status"
" rsp dict"); } while (0)
535 "Error setting index on brick status"do { do { if (0) printf ("Error setting index on brick status"
" rsp dict"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 536, GF_LOG_ERROR, "Error setting index on brick status"
" rsp dict"); } while (0)
536 " rsp dict")do { do { if (0) printf ("Error setting index on brick status"
" rsp dict"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 536, GF_LOG_ERROR, "Error setting index on brick status"
" rsp dict"); } while (0)
;
537 args.op_ret = -1;
538 goto out;
539 }
540 }
541 if (args.op_ret == 0)
542 glusterd_handle_node_rsp (dict_out, pnode->node, op,
543 args.dict, op_ctx, errstr,
544 pnode->type);
545
546out:
547 errno(*__errno_location ()) = args.op_errno;
548 if (args.dict)
549 dict_unref (args.dict);
550 gd_brick_op_req_free (req);
551 return args.op_ret;
552
553}
554
555int32_t
556_gd_syncop_commit_op_cbk (struct rpc_req *req, struct iovec *iov,
557 int count, void *myframe)
558{
559 int ret = -1;
560 gd1_mgmt_commit_op_rsp rsp = {{0},};
561 struct syncargs *args = NULL((void*)0);
562 xlator_t *this = NULL((void*)0);
563 dict_t *rsp_dict = NULL((void*)0);
564 call_frame_t *frame = NULL((void*)0);
565
566 this = THIS(*__glusterfs_this_location());
567 frame = myframe;
568 args = frame->local;
569 frame->local = NULL((void*)0);
570
571 if (-1 == req->rpc_status) {
572 args->op_errno = ENOTCONN107;
573 goto out;
574 }
575
576 ret = xdr_to_generic (*iov, &rsp,
577 (xdrproc_t)xdr_gd1_mgmt_commit_op_rsp);
578 if (ret < 0) {
579 goto out;
580 }
581
582 if (rsp.dict.dict_len) {
583 /* Unserialize the dictionary */
584 rsp_dict = dict_new ();
585
586 ret = dict_unserialize (rsp.dict.dict_val,
587 rsp.dict.dict_len,
588 &rsp_dict);
589 if (ret < 0) {
590 GF_FREE (rsp.dict.dict_val)__gf_free (rsp.dict.dict_val);
591 goto out;
592 } else {
593 rsp_dict->extra_stdfree = rsp.dict.dict_val;
594 }
595 }
596
597 gd_collate_errors (args, rsp.op_ret, rsp.op_errno, rsp.op_errstr);
598 uuid_copy (args->uuid, rsp.uuid);
599 pthread_mutex_lock (&args->lock_dict);
600 {
601 ret = glusterd_syncop_aggr_rsp_dict (rsp.op, args->dict,
602 rsp_dict);
603 if (ret)
604 gf_log (this->name, GF_LOG_ERROR, "%s",do { do { if (0) printf ("%s", "Failed to aggregate response from "
" node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 606, GF_LOG_ERROR, "%s", "Failed to aggregate response from "
" node/brick"); } while (0)
605 "Failed to aggregate response from "do { do { if (0) printf ("%s", "Failed to aggregate response from "
" node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 606, GF_LOG_ERROR, "%s", "Failed to aggregate response from "
" node/brick"); } while (0)
606 " node/brick")do { do { if (0) printf ("%s", "Failed to aggregate response from "
" node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 606, GF_LOG_ERROR, "%s", "Failed to aggregate response from "
" node/brick"); } while (0)
;
607 }
608 pthread_mutex_unlock (&args->lock_dict);
609out:
610 if (rsp_dict)
611 dict_unref (rsp_dict);
612
613 STACK_DESTROY (frame->root);
614 synctask_barrier_wake(args)syncbarrier_wake (&args->barrier);
615
616 return 0;
617}
618
619int32_t
620gd_syncop_commit_op_cbk (struct rpc_req *req, struct iovec *iov,
621 int count, void *myframe)
622{
623 return glusterd_big_locked_cbk (req, iov, count, myframe,
624 _gd_syncop_commit_op_cbk);
625}
626
627
628int
629gd_syncop_mgmt_commit_op (struct rpc_clnt *rpc, struct syncargs *args,
630 uuid_t my_uuid, uuid_t recv_uuid,
631 int op, dict_t *dict_out, dict_t *op_ctx)
632{
633 gd1_mgmt_commit_op_req *req = NULL((void*)0);
634 int ret = -1;
635
636 req = GF_CALLOC (1, sizeof (*req), gf_gld_mt_mop_commit_req_t)__gf_calloc (1, sizeof (*req), gf_gld_mt_mop_commit_req_t);
637 if (!req)
638 goto out;
639
640 uuid_copy (req->uuid, my_uuid);
641 req->op = op;
642
643 ret = dict_allocate_and_serialize (dict_out,
644 &req->buf.buf_val, &req->buf.buf_len);
645 if (ret)
646 goto out;
647
648 ret = gd_syncop_submit_request (rpc, req, args, &gd_mgmt_prog,
649 GLUSTERD_MGMT_COMMIT_OP ,
650 gd_syncop_commit_op_cbk,
651 (xdrproc_t) xdr_gd1_mgmt_commit_op_req);
652out:
653 gd_commit_op_req_free (req);
654 return ret;
655}
656
657
658int
659gd_build_peers_list (struct list_head *peers, struct list_head *xact_peers,
660 glusterd_op_t op)
661{
662 glusterd_peerinfo_t *peerinfo = NULL((void*)0);
663 int npeers = 0;
664
665 list_for_each_entry (peerinfo, peers, uuid_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((peers)->next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->uuid_list
))); &peerinfo->uuid_list != (peers); peerinfo = ((typeof
(*peerinfo) *)((char *)(peerinfo->uuid_list.next)-(unsigned
long)(&((typeof(*peerinfo) *)0)->uuid_list))))
{
666 if (!peerinfo->connected)
667 continue;
668 if (op != GD_OP_SYNC_VOLUME &&
669 peerinfo->state.state != GD_FRIEND_STATE_BEFRIENDED)
670 continue;
671
672 list_add_tail (&peerinfo->op_peers_list, xact_peers);
673 npeers++;
674 }
675 return npeers;
676}
677
678int
679gd_lock_op_phase (struct list_head *peers, glusterd_op_t op, dict_t *op_ctx,
680 char **op_errstr, int npeers)
681{
682 int ret = -1;
683 int peer_cnt = 0;
684 uuid_t peer_uuid = {0};
685 xlator_t *this = NULL((void*)0);
686 glusterd_peerinfo_t *peerinfo = NULL((void*)0);
687 struct syncargs args = {0};
688
689 if (!npeers) {
690 ret = 0;
691 goto out;
692 }
693
694 this = THIS(*__glusterfs_this_location());
695 synctask_barrier_init((&args))syncbarrier_init (&(&args)->barrier);
696 peer_cnt = 0;
697 list_for_each_entry (peerinfo, peers, op_peers_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((peers)->next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))); &peerinfo->op_peers_list != (peers); peerinfo = (
(typeof(*peerinfo) *)((char *)(peerinfo->op_peers_list.next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))))
{
698 gd_syncop_mgmt_lock (peerinfo->rpc, &args, MY_UUID(__glusterd_uuid()), peer_uuid);
699 peer_cnt++;
700 }
701 gd_synctask_barrier_wait((&args), peer_cnt);
702 ret = args.op_ret;
703 if (ret) {
704 gf_asprintf (op_errstr, "Another transaction could be "
705 "in progress. Please try again after "
706 "sometime.");
707 gf_log (this->name, GF_LOG_ERROR, "Failed to acquire lock")do { do { if (0) printf ("Failed to acquire lock"); } while (
0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 707, GF_LOG_ERROR, "Failed to acquire lock"); } while (0)
;
708 goto out;
709 }
710
711 ret = 0;
712out:
713 return ret;
714}
715
716int
717gd_stage_op_phase (struct list_head *peers, glusterd_op_t op, dict_t *op_ctx,
718 dict_t *req_dict, char **op_errstr, int npeers)
719{
720 int ret = -1;
721 int peer_cnt = 0;
722 dict_t *rsp_dict = NULL((void*)0);
723 char *hostname = NULL((void*)0);
724 xlator_t *this = NULL((void*)0);
725 glusterd_peerinfo_t *peerinfo = NULL((void*)0);
726 uuid_t tmp_uuid = {0};
727 char *errstr = NULL((void*)0);
728 struct syncargs args = {0};
729
730 this = THIS(*__glusterfs_this_location());
731 rsp_dict = dict_new ();
732 if (!rsp_dict)
733 goto out;
734
735 ret = glusterd_op_stage_validate (op, req_dict, op_errstr, rsp_dict);
736 if (ret) {
737 hostname = "localhost";
738 goto stage_done;
739 }
740
741 if ((op == GD_OP_REPLACE_BRICK)) {
742 ret = glusterd_syncop_aggr_rsp_dict (op, op_ctx, rsp_dict);
743 if (ret) {
744 gf_log (this->name, GF_LOG_ERROR, "%s",do { do { if (0) printf ("%s", "Failed to aggregate response from node/brick"
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 745, GF_LOG_ERROR, "%s", "Failed to aggregate response from node/brick"
); } while (0)
745 "Failed to aggregate response from node/brick")do { do { if (0) printf ("%s", "Failed to aggregate response from node/brick"
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 745, GF_LOG_ERROR, "%s", "Failed to aggregate response from node/brick"
); } while (0)
;
746 goto out;
747 }
748 }
749 dict_unref (rsp_dict);
750 rsp_dict = NULL((void*)0);
751
752stage_done:
753 if (ret) {
754 gf_log (this->name, GF_LOG_ERROR, LOGSTR_STAGE_FAIL,do { do { if (0) printf ("Staging of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 756, GF_LOG_ERROR, "Staging of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0)
755 gd_op_list[op], hostname, (*op_errstr) ? ":" : " ",do { do { if (0) printf ("Staging of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 756, GF_LOG_ERROR, "Staging of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0)
756 (*op_errstr) ? *op_errstr : " ")do { do { if (0) printf ("Staging of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 756, GF_LOG_ERROR, "Staging of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0)
;
757 if (*op_errstr == NULL((void*)0))
758 gf_asprintf (op_errstr, OPERRSTR_STAGE_FAIL"Staging failed on %s. Please check the log file " "for more details.", hostname);
759 goto out;
760 }
761
762 if (!npeers) {
763 ret = 0;
764 goto out;
765 }
766
767 gd_syncargs_init (&args, op_ctx);
768 synctask_barrier_init((&args))syncbarrier_init (&(&args)->barrier);
769 peer_cnt = 0;
770 list_for_each_entry (peerinfo, peers, op_peers_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((peers)->next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))); &peerinfo->op_peers_list != (peers); peerinfo = (
(typeof(*peerinfo) *)((char *)(peerinfo->op_peers_list.next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))))
{
771 ret = gd_syncop_mgmt_stage_op (peerinfo->rpc, &args,
Value stored to 'ret' is never read
772 MY_UUID(__glusterd_uuid()), tmp_uuid,
773 op, req_dict, op_ctx);
774 peer_cnt++;
775 }
776 gd_synctask_barrier_wait((&args), peer_cnt);
777 ret = args.op_ret;
778 if (dict_get_str (op_ctx, "errstr", &errstr) == 0)
779 *op_errstr = gf_strdup (errstr);
780
781out:
782 if (rsp_dict)
783 dict_unref (rsp_dict);
784 return ret;
785}
786
787int
788gd_commit_op_phase (struct list_head *peers, glusterd_op_t op, dict_t *op_ctx,
789 dict_t *req_dict, char **op_errstr, int npeers)
790{
791 dict_t *rsp_dict = NULL((void*)0);
792 int peer_cnt = -1;
793 int ret = -1;
794 char *hostname = NULL((void*)0);
795 glusterd_peerinfo_t *peerinfo = NULL((void*)0);
796 xlator_t *this = NULL((void*)0);
797 uuid_t tmp_uuid = {0};
798 char *errstr = NULL((void*)0);
799 struct syncargs args = {0};
800
801 this = THIS(*__glusterfs_this_location());
802 rsp_dict = dict_new ();
803 if (!rsp_dict) {
804 ret = -1;
805 goto out;
806 }
807
808 ret = glusterd_op_commit_perform (op, req_dict, op_errstr, rsp_dict);
809 if (ret) {
810 hostname = "localhost";
811 goto commit_done;
812 }
813 if (op != GD_OP_SYNC_VOLUME) {
814 ret = glusterd_syncop_aggr_rsp_dict (op, op_ctx, rsp_dict);
815 if (ret) {
816 gf_log (this->name, GF_LOG_ERROR, "%s",do { do { if (0) printf ("%s", "Failed to aggregate response "
"from node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 818, GF_LOG_ERROR, "%s", "Failed to aggregate response "
"from node/brick"); } while (0)
817 "Failed to aggregate response "do { do { if (0) printf ("%s", "Failed to aggregate response "
"from node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 818, GF_LOG_ERROR, "%s", "Failed to aggregate response "
"from node/brick"); } while (0)
818 "from node/brick")do { do { if (0) printf ("%s", "Failed to aggregate response "
"from node/brick"); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 818, GF_LOG_ERROR, "%s", "Failed to aggregate response "
"from node/brick"); } while (0)
;
819 goto out;
820 }
821 }
822 dict_unref (rsp_dict);
823 rsp_dict = NULL((void*)0);
824
825commit_done:
826 if (ret) {
827 gf_log (this->name, GF_LOG_ERROR, LOGSTR_COMMIT_FAIL,do { do { if (0) printf ("Commit of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 829, GF_LOG_ERROR, "Commit of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0)
828 gd_op_list[op], hostname, (*op_errstr) ? ":" : " ",do { do { if (0) printf ("Commit of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 829, GF_LOG_ERROR, "Commit of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0)
829 (*op_errstr) ? *op_errstr : " ")do { do { if (0) printf ("Commit of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 829, GF_LOG_ERROR, "Commit of operation 'Volume %s' failed on %s %s %s"
, gd_op_list[op], hostname, (*op_errstr) ? ":" : " ", (*op_errstr
) ? *op_errstr : " "); } while (0)
;
830 if (*op_errstr == NULL((void*)0))
831 gf_asprintf (op_errstr, OPERRSTR_COMMIT_FAIL"Commit failed on %s. Please check the log file " "for more details.",
832 hostname);
833 goto out;
834 } else {
835 glusterd_op_modify_op_ctx (op, op_ctx);
836 }
837
838 if (!npeers) {
839 ret = 0;
840 goto out;
841 }
842 gd_syncargs_init (&args, op_ctx);
843 synctask_barrier_init((&args))syncbarrier_init (&(&args)->barrier);
844 peer_cnt = 0;
845 list_for_each_entry (peerinfo, peers, op_peers_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((peers)->next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))); &peerinfo->op_peers_list != (peers); peerinfo = (
(typeof(*peerinfo) *)((char *)(peerinfo->op_peers_list.next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))))
{
846 ret = gd_syncop_mgmt_commit_op (peerinfo->rpc, &args,
847 MY_UUID(__glusterd_uuid()), tmp_uuid,
848 op, req_dict, op_ctx);
849 peer_cnt++;
850 }
851 gd_synctask_barrier_wait((&args), peer_cnt);
852 ret = args.op_ret;
853 if (dict_get_str (op_ctx, "errstr", &errstr) == 0)
854 *op_errstr = gf_strdup (errstr);
855
856out:
857 if (rsp_dict)
858 dict_unref (rsp_dict);
859 return ret;
860}
861
862int
863gd_unlock_op_phase (struct list_head *peers, glusterd_op_t op, int op_ret,
864 rpcsvc_request_t *req, dict_t *op_ctx, char *op_errstr,
865 int npeers)
866{
867 glusterd_peerinfo_t *peerinfo = NULL((void*)0);
868 glusterd_peerinfo_t *tmp = NULL((void*)0);
869 uuid_t tmp_uuid = {0};
870 int peer_cnt = 0;
871 int ret = -1;
872 xlator_t *this = NULL((void*)0);
873 struct syncargs args = {0};
874
875 if (!npeers) {
876 ret = 0;
877 goto out;
878 }
879
880 this = THIS(*__glusterfs_this_location());
881 synctask_barrier_init((&args))syncbarrier_init (&(&args)->barrier);
882 peer_cnt = 0;
883 list_for_each_entry_safe (peerinfo, tmp, peers, op_peers_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((peers)->next
)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))), tmp = ((typeof(*peerinfo) *)((char *)(peerinfo->op_peers_list
.next)-(unsigned long)(&((typeof(*peerinfo) *)0)->op_peers_list
))); &peerinfo->op_peers_list != (peers); peerinfo = tmp
, tmp = ((typeof(*tmp) *)((char *)(tmp->op_peers_list.next
)-(unsigned long)(&((typeof(*tmp) *)0)->op_peers_list)
)))
{
884 gd_syncop_mgmt_unlock (peerinfo->rpc, &args, MY_UUID(__glusterd_uuid()), tmp_uuid);
885 list_del_init (&peerinfo->op_peers_list);
886 peer_cnt++;
887 }
888 gd_synctask_barrier_wait((&args), peer_cnt);
889 ret = args.op_ret;
890 if (ret) {
891 gf_log (this->name, GF_LOG_ERROR, "Failed to unlock "do { do { if (0) printf ("Failed to unlock " "on some peer(s)"
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 892, GF_LOG_ERROR, "Failed to unlock " "on some peer(s)"); }
while (0)
892 "on some peer(s)")do { do { if (0) printf ("Failed to unlock " "on some peer(s)"
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 892, GF_LOG_ERROR, "Failed to unlock " "on some peer(s)"); }
while (0)
;
893 }
894
895out:
896 glusterd_op_send_cli_response (op, op_ret, 0, req, op_ctx, op_errstr);
897 glusterd_op_clear_op (op);
898 glusterd_unlock (MY_UUID(__glusterd_uuid()));
899
900 return 0;
901}
902
903int
904gd_get_brick_count (struct list_head *bricks)
905{
906 glusterd_pending_node_t *pending_node = NULL((void*)0);
907 int npeers = 0;
908 list_for_each_entry (pending_node, bricks, list)for (pending_node = ((typeof(*pending_node) *)((char *)((bricks
)->next)-(unsigned long)(&((typeof(*pending_node) *)0)
->list))); &pending_node->list != (bricks); pending_node
= ((typeof(*pending_node) *)((char *)(pending_node->list.
next)-(unsigned long)(&((typeof(*pending_node) *)0)->list
))))
{
909 npeers++;
910 }
911 return npeers;
912}
913
914int
915gd_brick_op_phase (glusterd_op_t op, dict_t *op_ctx, dict_t *req_dict, char **op_errstr)
916{
917 glusterd_pending_node_t *pending_node = NULL((void*)0);
918 struct list_head selected = {0,};
919 xlator_t *this = NULL((void*)0);
920 int brick_count = 0;
921 int ret = -1;
922 rpc_clnt_t *rpc = NULL((void*)0);
923 dict_t *rsp_dict = NULL((void*)0);
924 glusterd_conf_t *conf = NULL((void*)0);
925
926 this = THIS(*__glusterfs_this_location());
927 conf = this->private;
928 rsp_dict = dict_new ();
929 if (!rsp_dict) {
930 ret = -1;
931 goto out;
932 }
933
934 INIT_LIST_HEAD (&selected)do { (&selected)->next = (&selected)->prev = &
selected; } while (0)
;
935 ret = glusterd_op_bricks_select (op, req_dict, op_errstr, &selected, rsp_dict);
936 if (ret) {
937 gf_log (this->name, GF_LOG_ERROR, "%s",do { do { if (0) printf ("%s", (*op_errstr)? *op_errstr: "Brick op failed. Check "
"glusterd log file for more details."); } while (0); _gf_log
(this->name, "glusterd-syncop.c", __FUNCTION__, 939, GF_LOG_ERROR
, "%s", (*op_errstr)? *op_errstr: "Brick op failed. Check " "glusterd log file for more details."
); } while (0)
938 (*op_errstr)? *op_errstr: "Brick op failed. Check "do { do { if (0) printf ("%s", (*op_errstr)? *op_errstr: "Brick op failed. Check "
"glusterd log file for more details."); } while (0); _gf_log
(this->name, "glusterd-syncop.c", __FUNCTION__, 939, GF_LOG_ERROR
, "%s", (*op_errstr)? *op_errstr: "Brick op failed. Check " "glusterd log file for more details."
); } while (0)
939 "glusterd log file for more details.")do { do { if (0) printf ("%s", (*op_errstr)? *op_errstr: "Brick op failed. Check "
"glusterd log file for more details."); } while (0); _gf_log
(this->name, "glusterd-syncop.c", __FUNCTION__, 939, GF_LOG_ERROR
, "%s", (*op_errstr)? *op_errstr: "Brick op failed. Check " "glusterd log file for more details."
); } while (0)
;
940 goto out;
941 }
942
943 if (op == GD_OP_HEAL_VOLUME) {
944 ret = glusterd_syncop_aggr_rsp_dict (op, op_ctx, rsp_dict);
945 if (ret)
946 goto out;
947 }
948 dict_unref (rsp_dict);
949 rsp_dict = NULL((void*)0);
950
951 brick_count = 0;
952 list_for_each_entry (pending_node, &selected, list)for (pending_node = ((typeof(*pending_node) *)((char *)((&
selected)->next)-(unsigned long)(&((typeof(*pending_node
) *)0)->list))); &pending_node->list != (&selected
); pending_node = ((typeof(*pending_node) *)((char *)(pending_node
->list.next)-(unsigned long)(&((typeof(*pending_node) *
)0)->list))))
{
953 rpc = glusterd_pending_node_get_rpc (pending_node);
954 if (!rpc) {
955 if (pending_node->type == GD_NODE_REBALANCE) {
956 ret = 0;
957 glusterd_defrag_volume_node_rsp (req_dict,
958 NULL((void*)0), op_ctx);
959 goto out;
960 }
961
962 ret = -1;
963 gf_log (this->name, GF_LOG_ERROR, "Brick Op failed "do { do { if (0) printf ("Brick Op failed " "due to rpc failure."
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 964, GF_LOG_ERROR, "Brick Op failed " "due to rpc failure."
); } while (0)
964 "due to rpc failure.")do { do { if (0) printf ("Brick Op failed " "due to rpc failure."
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 964, GF_LOG_ERROR, "Brick Op failed " "due to rpc failure."
); } while (0)
;
965 goto out;
966 }
967 ret = gd_syncop_mgmt_brick_op (rpc, pending_node, op, req_dict,
968 op_ctx, op_errstr);
969 if (ret)
970 goto out;
971
972 brick_count++;
973 }
974
975 ret = 0;
976out:
977 if (rsp_dict)
978 dict_unref (rsp_dict);
979 gf_log (this->name, GF_LOG_DEBUG, "Sent op req to %d bricks",do { do { if (0) printf ("Sent op req to %d bricks", brick_count
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 980, GF_LOG_DEBUG, "Sent op req to %d bricks", brick_count)
; } while (0)
980 brick_count)do { do { if (0) printf ("Sent op req to %d bricks", brick_count
); } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 980, GF_LOG_DEBUG, "Sent op req to %d bricks", brick_count)
; } while (0)
;
981 return ret;
982}
983
984void
985gd_sync_task_begin (dict_t *op_ctx, rpcsvc_request_t * req)
986{
987 int ret = -1;
988 int npeers = 0;
989 dict_t *req_dict = NULL((void*)0);
990 glusterd_conf_t *conf = NULL((void*)0);
991 glusterd_op_t op = 0;
992 int32_t tmp_op = 0;
993 char *op_errstr = NULL((void*)0);
994 xlator_t *this = NULL((void*)0);
995
996 this = THIS(*__glusterfs_this_location());
997 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-syncop.c"
, __FUNCTION__, 997, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
998 conf = this->private;
999 GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: "
"conf"); } while (0); _gf_log_callingfn ("", "glusterd-syncop.c"
, __FUNCTION__, 999, GF_LOG_ERROR, "Assertion failed: " "conf"
); } while (0); } } while (0)
;
1000
1001 ret = dict_get_int32 (op_ctx, GD_SYNC_OPCODE_KEY"sync-mgmt-operation", &tmp_op);
1002 if (ret) {
1003 gf_log (this->name, GF_LOG_ERROR, "Failed to get volume "do { do { if (0) printf ("Failed to get volume " "operation")
; } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 1004, GF_LOG_ERROR, "Failed to get volume " "operation"); }
while (0)
1004 "operation")do { do { if (0) printf ("Failed to get volume " "operation")
; } while (0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 1004, GF_LOG_ERROR, "Failed to get volume " "operation"); }
while (0)
;
1005 goto out;
1006 }
1007
1008 op = tmp_op;
1009 ret = glusterd_lock (MY_UUID(__glusterd_uuid()));
1010 if (ret) {
1011 gf_log (this->name, GF_LOG_ERROR, "Unable to acquire lock")do { do { if (0) printf ("Unable to acquire lock"); } while (
0); _gf_log (this->name, "glusterd-syncop.c", __FUNCTION__
, 1011, GF_LOG_ERROR, "Unable to acquire lock"); } while (0)
;
1012 gf_asprintf (&op_errstr, "Another transaction is in progress. "
1013 "Please try again after sometime.");
1014 goto out;
1015 }
1016
1017 /* storing op globally to access in synctask code paths
1018 * This is still acceptable, as we are performing this under
1019 * the 'cluster' lock*/
1020 glusterd_op_set_op (op);
1021 INIT_LIST_HEAD (&conf->xaction_peers)do { (&conf->xaction_peers)->next = (&conf->
xaction_peers)->prev = &conf->xaction_peers; } while
(0)
;
1022 npeers = gd_build_peers_list (&conf->peers, &conf->xaction_peers, op);
1023
1024 ret = gd_lock_op_phase (&conf->xaction_peers, op, op_ctx, &op_errstr, npeers);
1025 if (ret)
1026 goto out;
1027
1028 ret = glusterd_op_build_payload (&req_dict, &op_errstr, op_ctx);
1029 if (ret) {
1030 gf_log (this->name, GF_LOG_ERROR, LOGSTR_BUILD_PAYLOAD,do { do { if (0) printf ("Failed to build payload for operation 'Volume %s'"
, gd_op_list[op]); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 1031, GF_LOG_ERROR, "Failed to build payload for operation 'Volume %s'"
, gd_op_list[op]); } while (0)
1031 gd_op_list[op])do { do { if (0) printf ("Failed to build payload for operation 'Volume %s'"
, gd_op_list[op]); } while (0); _gf_log (this->name, "glusterd-syncop.c"
, __FUNCTION__, 1031, GF_LOG_ERROR, "Failed to build payload for operation 'Volume %s'"
, gd_op_list[op]); } while (0)
;
1032 if (op_errstr == NULL((void*)0))
1033 gf_asprintf (&op_errstr, OPERRSTR_BUILD_PAYLOAD"Failed to build payload. Please check the log " "file for more details.");
1034 goto out;
1035 }
1036
1037 ret = gd_stage_op_phase (&conf->xaction_peers, op, op_ctx, req_dict,
1038 &op_errstr, npeers);
1039 if (ret)
1040 goto out;
1041
1042 ret = gd_brick_op_phase (op, op_ctx, req_dict, &op_errstr);
1043 if (ret)
1044 goto out;
1045
1046 ret = gd_commit_op_phase (&conf->xaction_peers, op, op_ctx, req_dict,
1047 &op_errstr, npeers);
1048 if (ret)
1049 goto out;
1050
1051 ret = 0;
1052out:
1053 (void) gd_unlock_op_phase (&conf->xaction_peers, op, ret, req,
1054 op_ctx, op_errstr, npeers);
1055
1056 if (req_dict)
1057 dict_unref (req_dict);
1058
1059 if (op_errstr)
1060 GF_FREE (op_errstr)__gf_free (op_errstr);
1061
1062 return;
1063}
1064
1065int32_t
1066glusterd_op_begin_synctask (rpcsvc_request_t *req, glusterd_op_t op,
1067 void *dict)
1068{
1069 int ret = 0;
1070
1071 ret = dict_set_int32 (dict, GD_SYNC_OPCODE_KEY"sync-mgmt-operation", op);
1072 if (ret) {
1073 gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("dict set failed for setting operations"
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-syncop.c", __FUNCTION__, 1074, GF_LOG_ERROR, "dict set failed for setting operations"
); } while (0)
1074 "dict set failed for setting operations")do { do { if (0) printf ("dict set failed for setting operations"
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-syncop.c", __FUNCTION__, 1074, GF_LOG_ERROR, "dict set failed for setting operations"
); } while (0)
;
1075 goto out;
1076 }
1077
1078 gd_sync_task_begin (dict, req);
1079 ret = 0;
1080out:
1081
1082 return ret;
1083}