Bug Summary

File:cli/src/cli-cmd-volume.c
Location:line 72, column 17
Description:Value stored to 'parse_error' is never read

Annotated Source Code

1/*
2 Copyright (c) 2010-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#include <stdio.h>
11#include <string.h>
12#include <stdlib.h>
13#include <stdint.h>
14#include <pthread.h>
15
16#include <sys/socket.h>
17#include <netdb.h>
18#include <sys/types.h>
19#include <netinet/in.h>
20
21#ifndef _CONFIG_H
22#define _CONFIG_H
23#include "config.h"
24#endif
25
26#include "cli.h"
27#include "cli-cmd.h"
28#include "cli-mem-types.h"
29#include "cli1-xdr.h"
30#include "run.h"
31
32extern struct rpc_clnt *global_rpc;
33
34extern rpc_clnt_prog_t *cli_rpc_prog;
35
36int
37cli_cmd_volume_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
38 const char **words, int wordcount);
39
40int
41cli_cmd_volume_info_cbk (struct cli_state *state, struct cli_cmd_word *word,
42 const char **words, int wordcount)
43{
44 int ret = -1;
45 rpc_clnt_procedure_t *proc = NULL((void*)0);
46 call_frame_t *frame = NULL((void*)0);
47 cli_cmd_volume_get_ctx_t ctx = {0,};
48 cli_local_t *local = NULL((void*)0);
49 int sent = 0;
50 int parse_error = 0;
51
52 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
53
54 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
55 if (!frame)
56 goto out;
57
58 if ((wordcount == 2) || (wordcount == 3 &&
59 !strcmp (words[2], "all"))) {
60 ctx.flags = GF_CLI_GET_NEXT_VOLUME;
61 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_NEXT_VOLUME];
62 } else if (wordcount == 3) {
63 ctx.flags = GF_CLI_GET_VOLUME;
64 ctx.volname = (char *)words[2];
65 if (strlen (ctx.volname) > 1024) {
66 cli_out ("Invalid volume name")do { do { if (0) printf ("Invalid volume name"); } while (0);
_cli_out("Invalid volume name"); } while (0)
;
67 goto out;
68 }
69 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME];
70 } else {
71 cli_usage_out (word->pattern);
72 parse_error = 1;
Value stored to 'parse_error' is never read
73 return -1;
74 }
75
76 local = cli_local_get ();
77
78 if (!local)
79 goto out;
80
81 local->get_vol.flags = ctx.flags;
82 if (ctx.volname)
83 local->get_vol.volname = gf_strdup (ctx.volname);
84
85 frame->local = local;
86
87 if (proc->fn) {
88 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), &ctx);
89 }
90
91out:
92 if (ret) {
93 cli_cmd_sent_status_get (&sent);
94 if ((sent == 0) && (parse_error == 0))
95 cli_out ("Getting Volume information failed!")do { do { if (0) printf ("Getting Volume information failed!"
); } while (0); _cli_out("Getting Volume information failed!"
); } while (0)
;
96 }
97
98 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 98, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
99
100 return ret;
101
102}
103
104int
105cli_cmd_sync_volume_cbk (struct cli_state *state, struct cli_cmd_word *word,
106 const char **words, int wordcount)
107{
108 int ret = -1;
109 rpc_clnt_procedure_t *proc = NULL((void*)0);
110 call_frame_t *frame = NULL((void*)0);
111 int sent = 0;
112 int parse_error = 0;
113 dict_t *dict = NULL((void*)0);
114 cli_local_t *local = NULL((void*)0);
115 gf_answer_t answer = GF_ANSWER_NO;
116 const char *question = "Sync volume may make data "
117 "inaccessible while the sync "
118 "is in progress. Do you want "
119 "to continue?";
120
121 if ((wordcount < 3) || (wordcount > 4)) {
122 cli_usage_out (word->pattern);
123 parse_error = 1;
124 goto out;
125 }
126
127 dict = dict_new ();
128 if (!dict)
129 goto out;
130
131 if ((wordcount == 3) || !strcmp(words[3], "all")) {
132 ret = dict_set_int32 (dict, "flags", (int32_t)
133 GF_CLI_SYNC_ALL);
134 if (ret) {
135 gf_log (THIS->name, GF_LOG_ERROR, "failed to set"do { do { if (0) printf ("failed to set" "flag"); } while (0)
; _gf_log ((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 136, GF_LOG_ERROR, "failed to set" "flag"); }
while (0)
136 "flag")do { do { if (0) printf ("failed to set" "flag"); } while (0)
; _gf_log ((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 136, GF_LOG_ERROR, "failed to set" "flag"); }
while (0)
;
137 goto out;
138 }
139 } else {
140 ret = dict_set_str (dict, "volname", (char *) words[3]);
141 if (ret) {
142 gf_log (THIS->name, GF_LOG_ERROR, "failed to set "do { do { if (0) printf ("failed to set " "volume"); } while (
0); _gf_log ((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 143, GF_LOG_ERROR, "failed to set " "volume")
; } while (0)
143 "volume")do { do { if (0) printf ("failed to set " "volume"); } while (
0); _gf_log ((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 143, GF_LOG_ERROR, "failed to set " "volume")
; } while (0)
;
144 goto out;
145 }
146 }
147
148 ret = dict_set_str (dict, "hostname", (char *) words[2]);
149 if (ret) {
150 gf_log (THIS->name, GF_LOG_ERROR, "failed to set hostname")do { do { if (0) printf ("failed to set hostname"); } while (
0); _gf_log ((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 150, GF_LOG_ERROR, "failed to set hostname");
} while (0)
;
151 goto out;
152 }
153
154 if (!(state->mode & GLUSTER_MODE_SCRIPT(1 << 0))) {
155 answer = cli_cmd_get_confirmation (state, question);
156 if (GF_ANSWER_NO == answer) {
157 ret = 0;
158 goto out;
159 }
160 }
161
162 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SYNC_VOLUME];
163
164 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
165 if (!frame)
166 goto out;
167
168 CLI_LOCAL_INIT (local, words, frame, dict)do { local = cli_local_get (); if (local) { local->words =
words; if (dict) local->dict = dict; if (frame) frame->
local = local; } } while (0)
;
169
170 if (proc->fn) {
171 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), dict);
172 }
173
174out:
175 if (ret) {
176 cli_cmd_sent_status_get (&sent);
177 if ((sent == 0) && (parse_error == 0))
178 cli_out ("Volume sync failed")do { do { if (0) printf ("Volume sync failed"); } while (0); _cli_out
("Volume sync failed"); } while (0)
;
179 }
180
181 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 181, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
182
183 return ret;
184}
185
186gf_ai_compare_t
187cli_cmd_compare_addrinfo (struct addrinfo *first, struct addrinfo *next)
188{
189 int ret = -1;
190 struct addrinfo *tmp1 = NULL((void*)0);
191 struct addrinfo *tmp2 = NULL((void*)0);
192 char firstip[NI_MAXHOST1025] = {0.};
193 char nextip[NI_MAXHOST1025] = {0,};
194
195 for (tmp1 = first; tmp1 != NULL((void*)0); tmp1 = tmp1->ai_next) {
196 ret = getnameinfo (tmp1->ai_addr, tmp1->ai_addrlen, firstip,
197 NI_MAXHOST1025, NULL((void*)0), 0, NI_NUMERICHOST1);
198 if (ret)
199 return GF_AI_COMPARE_ERROR;
200 for (tmp2 = next; tmp2 != NULL((void*)0); tmp2 = tmp2->ai_next) {
201 ret = getnameinfo (tmp2->ai_addr, tmp2->ai_addrlen, nextip,
202 NI_MAXHOST1025, NULL((void*)0), 0, NI_NUMERICHOST1);
203 if (ret)
204 return GF_AI_COMPARE_ERROR;
205 if (!strcmp (firstip, nextip)) {
206 return GF_AI_COMPARE_MATCH;
207 }
208 }
209 }
210 return GF_AI_COMPARE_NO_MATCH;
211}
212
213/* Check for non optimal brick order for replicate :
214 * Checks if bricks belonging to a replicate volume
215 * are present on the same server
216 */
217int32_t
218cli_cmd_check_brick_order (struct cli_state *state, const char *bricks,
219 int brick_count, int sub_count)
220{
221 int ret = -1;
222 int i = 0;
223 int j = 0;
224 int k = 0;
225 addrinfo_list_t *ai_list = NULL((void*)0);
226 addrinfo_list_t *ai_list_tmp1 = NULL((void*)0);
227 addrinfo_list_t *ai_list_tmp2 = NULL((void*)0);
228 char *brick = NULL((void*)0);
229 char *brick_list = NULL((void*)0);
230 char *brick_list_dup = NULL((void*)0);
231 char *tmpptr = NULL((void*)0);
232 struct addrinfo *ai_info = NULL((void*)0);
233 gf_answer_t answer = GF_ANSWER_NO;
234 const char *failed_question = NULL((void*)0);
235 const char *found_question = NULL((void*)0);
236 failed_question = "Failed to perform brick order check. "
237 "Do you want to continue creating the volume? ";
238 found_question = "Multiple bricks of a replicate volume are present"
239 " on the same server. This setup is not optimal.\n"
240 "Do you still want to continue creating the volume? ";
241
242 GF_ASSERT (bricks)do { if (!(bricks)) { do { do { if (0) printf ("Assertion failed: "
"bricks"); } while (0); _gf_log_callingfn ("", "cli-cmd-volume.c"
, __FUNCTION__, 242, GF_LOG_ERROR, "Assertion failed: " "bricks"
); } while (0); } } while (0)
;
243 GF_ASSERT (brick_count > 0)do { if (!(brick_count > 0)) { do { do { if (0) printf ("Assertion failed: "
"brick_count > 0"); } while (0); _gf_log_callingfn ("", "cli-cmd-volume.c"
, __FUNCTION__, 243, GF_LOG_ERROR, "Assertion failed: " "brick_count > 0"
); } while (0); } } while (0)
;
244 GF_ASSERT (sub_count > 0)do { if (!(sub_count > 0)) { do { do { if (0) printf ("Assertion failed: "
"sub_count > 0"); } while (0); _gf_log_callingfn ("", "cli-cmd-volume.c"
, __FUNCTION__, 244, GF_LOG_ERROR, "Assertion failed: " "sub_count > 0"
); } while (0); } } while (0)
;
245
246 ai_list = malloc (sizeof (addrinfo_list_t));
247 ai_list->info = NULL((void*)0);
248 INIT_LIST_HEAD (&ai_list->list)do { (&ai_list->list)->next = (&ai_list->list
)->prev = &ai_list->list; } while (0)
;
249 brick_list = gf_strdup (bricks);
250 if (brick_list == NULL((void*)0)) {
251 gf_log ("cli", GF_LOG_DEBUG, "failed to allocate memory")do { do { if (0) printf ("failed to allocate memory"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 251, GF_LOG_DEBUG
, "failed to allocate memory"); } while (0)
;
252 goto check_failed;
253 }
254 brick_list_dup = brick_list;
255 /* Resolve hostnames and get addrinfo */
256 while (i < brick_count) {
257 ++i;
258 brick = strtok_r (brick_list, " \n", &tmpptr);
259 brick_list = tmpptr;
260 if (brick == NULL((void*)0))
261 goto check_failed;
262 brick = strtok_r (brick, ":", &tmpptr);
263 if (brick == NULL((void*)0))
264 goto check_failed;
265 ret = getaddrinfo (brick, NULL((void*)0), NULL((void*)0), &ai_info);
266 if (ret)
267 goto check_failed;
268 ai_list_tmp1 = malloc (sizeof (addrinfo_list_t));
269 if (ai_list_tmp1 == NULL((void*)0))
270 goto check_failed;
271 ai_list_tmp1->info = ai_info;
272 list_add_tail (&ai_list_tmp1->list, &ai_list->list);
273 ai_list_tmp1 = NULL((void*)0);
274 }
275
276 i = 0;
277 ai_list_tmp1 = list_entry (ai_list->list.next, addrinfo_list_t, list)((addrinfo_list_t *)((char *)(ai_list->list.next)-(unsigned
long)(&((addrinfo_list_t *)0)->list)))
;
278
279 /* Check for bad brick order */
280 while (i < brick_count) {
281 ++i;
282 ai_info = ai_list_tmp1->info;
283 ai_list_tmp1 = list_entry (ai_list_tmp1->list.next,((addrinfo_list_t *)((char *)(ai_list_tmp1->list.next)-(unsigned
long)(&((addrinfo_list_t *)0)->list)))
284 addrinfo_list_t, list)((addrinfo_list_t *)((char *)(ai_list_tmp1->list.next)-(unsigned
long)(&((addrinfo_list_t *)0)->list)))
;
285 if ( 0 == i % sub_count) {
286 j = 0;
287 continue;
288 }
289 ai_list_tmp2 = ai_list_tmp1;
290 k = j;
291 while (k < sub_count - 1) {
292 ++k;
293 ret = cli_cmd_compare_addrinfo (ai_info,
294 ai_list_tmp2->info);
295 if (GF_AI_COMPARE_ERROR == ret)
296 goto check_failed;
297 if (GF_AI_COMPARE_MATCH == ret)
298 goto found_bad_brick_order;
299 ai_list_tmp2 = list_entry (ai_list_tmp2->list.next,((addrinfo_list_t *)((char *)(ai_list_tmp2->list.next)-(unsigned
long)(&((addrinfo_list_t *)0)->list)))
300 addrinfo_list_t, list)((addrinfo_list_t *)((char *)(ai_list_tmp2->list.next)-(unsigned
long)(&((addrinfo_list_t *)0)->list)))
;
301 }
302 ++j;
303 }
304 gf_log ("cli", GF_LOG_INFO, "Brick order okay")do { do { if (0) printf ("Brick order okay"); } while (0); _gf_log
("cli", "cli-cmd-volume.c", __FUNCTION__, 304, GF_LOG_INFO, "Brick order okay"
); } while (0)
;
305 ret = 0;
306 goto out;
307
308check_failed:
309 gf_log ("cli", GF_LOG_INFO, "Failed bad brick order check")do { do { if (0) printf ("Failed bad brick order check"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 309, GF_LOG_INFO
, "Failed bad brick order check"); } while (0)
;
310 answer = cli_cmd_get_confirmation(state, failed_question);
311 if (GF_ANSWER_YES == answer)
312 ret = 0;
313 goto out;
314
315found_bad_brick_order:
316 gf_log ("cli", GF_LOG_INFO, "Bad brick order found")do { do { if (0) printf ("Bad brick order found"); } while (0
); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 316, GF_LOG_INFO
, "Bad brick order found"); } while (0)
;
317 answer = cli_cmd_get_confirmation (state, found_question);
318 if (GF_ANSWER_YES == answer)
319 ret = 0;
320out:
321 ai_list_tmp2 = NULL((void*)0);
322 i = 0;
323 GF_FREE (brick_list_dup)__gf_free (brick_list_dup);
324 list_for_each_entry (ai_list_tmp1, &ai_list->list, list)for (ai_list_tmp1 = ((typeof(*ai_list_tmp1) *)((char *)((&
ai_list->list)->next)-(unsigned long)(&((typeof(*ai_list_tmp1
) *)0)->list))); &ai_list_tmp1->list != (&ai_list
->list); ai_list_tmp1 = ((typeof(*ai_list_tmp1) *)((char *
)(ai_list_tmp1->list.next)-(unsigned long)(&((typeof(*
ai_list_tmp1) *)0)->list))))
{
325 if (ai_list_tmp1->info)
326 freeaddrinfo (ai_list_tmp1->info);
327 free (ai_list_tmp2);
328 ai_list_tmp2 = ai_list_tmp1;
329 }
330 free (ai_list_tmp2);
331 return ret;
332}
333
334int
335cli_cmd_volume_create_cbk (struct cli_state *state, struct cli_cmd_word *word,
336 const char **words, int wordcount)
337{
338 int ret = -1;
339 rpc_clnt_procedure_t *proc = NULL((void*)0);
340 call_frame_t *frame = NULL((void*)0);
341 dict_t *options = NULL((void*)0);
342 int sent = 0;
343 int parse_error = 0;
344 char *brick_list = NULL((void*)0);
345 int32_t brick_count = 0;
346 int32_t sub_count = 0;
347 int32_t type = GF_CLUSTER_TYPE_NONE;
348 cli_local_t *local = NULL((void*)0);
349
350 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CREATE_VOLUME];
351
352 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
353 if (!frame)
354 goto out;
355
356 ret = cli_cmd_volume_create_parse (words, wordcount, &options);
357
358 if (ret) {
359 cli_usage_out (word->pattern);
360 parse_error = 1;
361 goto out;
362 }
363 /*Check brick order if type is replicate*/
364 ret = dict_get_int32 (options, "type", &type);
365 if (ret) {
366 gf_log ("cli", GF_LOG_ERROR, "Could not get brick type")do { do { if (0) printf ("Could not get brick type"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 366, GF_LOG_ERROR
, "Could not get brick type"); } while (0)
;
367 goto out;
368 }
369 if ((type == GF_CLUSTER_TYPE_REPLICATE) ||
370 (type == GF_CLUSTER_TYPE_STRIPE_REPLICATE)) {
371 if ((ret = dict_get_str (options, "bricks", &brick_list)) != 0) {
372 gf_log ("cli", GF_LOG_ERROR, "Replica bricks check : "do { do { if (0) printf ("Replica bricks check : " "Could not retrieve bricks list"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 373, GF_LOG_ERROR, "Replica bricks check : " "Could not retrieve bricks list"
); } while (0)
373 "Could not retrieve bricks list")do { do { if (0) printf ("Replica bricks check : " "Could not retrieve bricks list"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 373, GF_LOG_ERROR, "Replica bricks check : " "Could not retrieve bricks list"
); } while (0)
;
374 goto out;
375 }
376 if ((ret = dict_get_int32 (options, "count", &brick_count)) != 0) {
377 gf_log ("cli", GF_LOG_ERROR, "Replica bricks check : "do { do { if (0) printf ("Replica bricks check : " "Could not retrieve brick count"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 378, GF_LOG_ERROR, "Replica bricks check : " "Could not retrieve brick count"
); } while (0)
378 "Could not retrieve brick count")do { do { if (0) printf ("Replica bricks check : " "Could not retrieve brick count"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 378, GF_LOG_ERROR, "Replica bricks check : " "Could not retrieve brick count"
); } while (0)
;
379 goto out;
380 }
381 if ((ret = dict_get_int32 (options, "replica-count", &sub_count)) != 0) {
382 gf_log ("cli", GF_LOG_ERROR, "Replica bricks check : "do { do { if (0) printf ("Replica bricks check : " "Could not retrieve replica count"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 383, GF_LOG_ERROR, "Replica bricks check : " "Could not retrieve replica count"
); } while (0)
383 "Could not retrieve replica count")do { do { if (0) printf ("Replica bricks check : " "Could not retrieve replica count"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 383, GF_LOG_ERROR, "Replica bricks check : " "Could not retrieve replica count"
); } while (0)
;
384 goto out;
385 }
386 gf_log ("cli", GF_LOG_INFO, "Replicate cluster type found."do { do { if (0) printf ("Replicate cluster type found." " Checking brick order."
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 387, GF_LOG_INFO, "Replicate cluster type found." " Checking brick order."
); } while (0)
387 " Checking brick order.")do { do { if (0) printf ("Replicate cluster type found." " Checking brick order."
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 387, GF_LOG_INFO, "Replicate cluster type found." " Checking brick order."
); } while (0)
;
388 ret = cli_cmd_check_brick_order (state, brick_list, brick_count, sub_count);
389 if (ret) {
390 gf_log("cli", GF_LOG_INFO, "Not creating volume because of bad brick order")do { do { if (0) printf ("Not creating volume because of bad brick order"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 390, GF_LOG_INFO, "Not creating volume because of bad brick order"
); } while (0)
;
391 goto out;
392 }
393 }
394
395 if (state->mode & GLUSTER_MODE_SCRIPT(1 << 0)) {
396 ret = dict_set_int32 (options, "force", _gf_true);
397 if (ret) {
398 gf_log ("cli", GF_LOG_ERROR, "Failed to set force "do { do { if (0) printf ("Failed to set force " "option"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 399, GF_LOG_ERROR
, "Failed to set force " "option"); } while (0)
399 "option")do { do { if (0) printf ("Failed to set force " "option"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 399, GF_LOG_ERROR
, "Failed to set force " "option"); } while (0)
;
400 goto out;
401 }
402 }
403
404 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
405
406 if (proc->fn) {
407 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
408 }
409
410out:
411 if (ret) {
412 cli_cmd_sent_status_get (&sent);
413 if ((sent == 0) && (parse_error == 0))
414 cli_out ("Volume create failed")do { do { if (0) printf ("Volume create failed"); } while (0)
; _cli_out("Volume create failed"); } while (0)
;
415 }
416
417 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 417, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
418
419 return ret;
420}
421
422
423int
424cli_cmd_volume_delete_cbk (struct cli_state *state, struct cli_cmd_word *word,
425 const char **words, int wordcount)
426{
427 int ret = -1;
428 rpc_clnt_procedure_t *proc = NULL((void*)0);
429 call_frame_t *frame = NULL((void*)0);
430 char *volname = NULL((void*)0);
431 gf_answer_t answer = GF_ANSWER_NO;
432 const char *question = NULL((void*)0);
433 int sent = 0;
434 int parse_error = 0;
435 cli_local_t *local = NULL((void*)0);
436 dict_t *dict = NULL((void*)0);
437
438 question = "Deleting volume will erase all information about the volume. "
439 "Do you want to continue?";
440 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DELETE_VOLUME];
441
442 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
443 if (!frame)
444 goto out;
445
446 dict = dict_new ();
447 if (!dict)
448 goto out;
449
450 if (wordcount != 3) {
451 cli_usage_out (word->pattern);
452 parse_error = 1;
453 goto out;
454 }
455
456 answer = cli_cmd_get_confirmation (state, question);
457
458 if (GF_ANSWER_NO == answer) {
459 ret = 0;
460 goto out;
461 }
462
463 volname = (char *)words[2];
464
465 ret = dict_set_str (dict, "volname", volname);
466
467 if (ret) {
468 gf_log (THIS->name, GF_LOG_WARNING, "dict set failed")do { do { if (0) printf ("dict set failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 468, GF_LOG_WARNING, "dict set failed"); } while
(0)
;
469 goto out;
470 }
471
472 CLI_LOCAL_INIT (local, words, frame, dict)do { local = cli_local_get (); if (local) { local->words =
words; if (dict) local->dict = dict; if (frame) frame->
local = local; } } while (0)
;
473
474 if (proc->fn) {
475 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), dict);
476 }
477
478out:
479 if (ret) {
480 cli_cmd_sent_status_get (&sent);
481 if ((sent == 0) && (parse_error == 0))
482 cli_out ("Volume delete failed")do { do { if (0) printf ("Volume delete failed"); } while (0)
; _cli_out("Volume delete failed"); } while (0)
;
483 }
484
485 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 485, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
486
487 return ret;
488}
489
490int
491cli_cmd_volume_start_cbk (struct cli_state *state, struct cli_cmd_word *word,
492 const char **words, int wordcount)
493{
494 int ret = -1;
495 rpc_clnt_procedure_t *proc = NULL((void*)0);
496 call_frame_t *frame = NULL((void*)0);
497 int sent = 0;
498 int parse_error = 0;
499 dict_t *dict = NULL((void*)0);
500 int flags = 0;
501 cli_local_t *local = NULL((void*)0);
502
503 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
504 if (!frame)
505 goto out;
506
507 if (wordcount < 3 || wordcount > 4) {
508 cli_usage_out (word->pattern);
509 parse_error = 1;
510 goto out;
511 }
512
513 dict = dict_new ();
514 if (!dict) {
515 goto out;
516 }
517
518 if (!words[2])
519 goto out;
520
521 ret = dict_set_str (dict, "volname", (char *)words[2]);
522 if (ret) {
523 gf_log (THIS->name, GF_LOG_ERROR, "dict set failed")do { do { if (0) printf ("dict set failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 523, GF_LOG_ERROR, "dict set failed"); } while
(0)
;
524 goto out;
525 }
526
527 if (wordcount == 4) {
528 if (!strcmp("force", words[3])) {
529 flags |= GF_CLI_FLAG_OP_FORCE;
530 } else {
531 ret = -1;
532 cli_usage_out (word->pattern);
533 parse_error = 1;
534 goto out;
535 }
536 }
537 ret = dict_set_int32 (dict, "flags", flags);
538 if (ret) {
539 gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("dict set failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 540, GF_LOG_ERROR, "dict set failed"); } while
(0)
540 "dict set failed")do { do { if (0) printf ("dict set failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 540, GF_LOG_ERROR, "dict set failed"); } while
(0)
;
541 goto out;
542 }
543
544 if (ret < 0) {
545 gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to serialize dict"); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 546, GF_LOG_ERROR, "failed to serialize dict"
); } while (0)
546 "failed to serialize dict")do { do { if (0) printf ("failed to serialize dict"); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 546, GF_LOG_ERROR, "failed to serialize dict"
); } while (0)
;
547 goto out;
548 }
549
550 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_START_VOLUME];
551
552 CLI_LOCAL_INIT (local, words, frame, dict)do { local = cli_local_get (); if (local) { local->words =
words; if (dict) local->dict = dict; if (frame) frame->
local = local; } } while (0)
;
553
554 if (proc->fn) {
555 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), dict);
556 }
557
558out:
559 if (ret) {
560 cli_cmd_sent_status_get (&sent);
561 if ((sent == 0) && (parse_error == 0))
562 cli_out ("Volume start failed")do { do { if (0) printf ("Volume start failed"); } while (0);
_cli_out("Volume start failed"); } while (0)
;
563 }
564
565 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 565, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
566
567 return ret;
568}
569
570gf_answer_t
571cli_cmd_get_confirmation (struct cli_state *state, const char *question)
572{
573 char answer[5] = {'\0', };
574 char flush = '\0';
575 size_t len;
576
577 if (state->mode & GLUSTER_MODE_SCRIPT(1 << 0))
578 return GF_ANSWER_YES;
579
580 printf ("%s (y/n) ", question);
581
582 if (fgets (answer, 4, stdinstdin) == NULL((void*)0)) {
583 cli_out("gluster cli read error")do { do { if (0) printf ("gluster cli read error"); } while (
0); _cli_out("gluster cli read error"); } while (0)
;
584 goto out;
585 }
586
587 len = strlen (answer);
588
589 if (len && answer [len - 1] == '\n'){
590 answer [--len] = '\0';
591 } else {
592 do{
593 flush = getchar ();
594 }while (flush != '\n');
595 }
596
597 if (len > 3)
598 goto out;
599
600 if (!strcasecmp (answer, "y") || !strcasecmp (answer, "yes"))
601 return GF_ANSWER_YES;
602
603 else if (!strcasecmp (answer, "n") || !strcasecmp (answer, "no"))
604 return GF_ANSWER_NO;
605
606out:
607 cli_out ("Invalid input, please enter y/n")do { do { if (0) printf ("Invalid input, please enter y/n"); }
while (0); _cli_out("Invalid input, please enter y/n"); } while
(0)
;
608
609 return GF_ANSWER_NO;
610}
611
612int
613cli_cmd_volume_stop_cbk (struct cli_state *state, struct cli_cmd_word *word,
614 const char **words, int wordcount)
615{
616 int ret = -1;
617 rpc_clnt_procedure_t *proc = NULL((void*)0);
618 call_frame_t *frame = NULL((void*)0);
619 int flags = 0;
620 gf_answer_t answer = GF_ANSWER_NO;
621 int sent = 0;
622 int parse_error = 0;
623 dict_t *dict = NULL((void*)0);
624 char *volname = NULL((void*)0);
625 cli_local_t *local = NULL((void*)0);
626
627 const char *question = "Stopping volume will make its data inaccessible. "
628 "Do you want to continue?";
629
630 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
631 if (!frame)
632 goto out;
633
634 if (wordcount < 3 || wordcount > 4) {
635 cli_usage_out (word->pattern);
636 parse_error = 1;
637 goto out;
638 }
639
640 volname = (char*) words[2];
641
642 dict = dict_new ();
643 ret = dict_set_str (dict, "volname", volname);
644 if (ret) {
645 gf_log (THIS->name, GF_LOG_ERROR, "dict set failed")do { do { if (0) printf ("dict set failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 645, GF_LOG_ERROR, "dict set failed"); } while
(0)
;
646 goto out;
647 }
648
649 if (wordcount == 4) {
650 if (!strcmp("force", words[3])) {
651 flags |= GF_CLI_FLAG_OP_FORCE;
652 } else {
653 ret = -1;
654 cli_usage_out (word->pattern);
655 parse_error = 1;
656 goto out;
657 }
658 }
659 ret = dict_set_int32 (dict, "flags", flags);
660 if (ret) {
661 gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("dict set failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 662, GF_LOG_ERROR, "dict set failed"); } while
(0)
662 "dict set failed")do { do { if (0) printf ("dict set failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "cli-cmd-volume.c"
, __FUNCTION__, 662, GF_LOG_ERROR, "dict set failed"); } while
(0)
;
663 goto out;
664 }
665
666 answer = cli_cmd_get_confirmation (state, question);
667
668 if (GF_ANSWER_NO == answer) {
669 ret = 0;
670 goto out;
671 }
672
673 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STOP_VOLUME];
674
675 CLI_LOCAL_INIT (local, words, frame, dict)do { local = cli_local_get (); if (local) { local->words =
words; if (dict) local->dict = dict; if (frame) frame->
local = local; } } while (0)
;
676
677 if (proc->fn) {
678 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), dict);
679 }
680
681out:
682 if (ret) {
683 cli_cmd_sent_status_get (&sent);
684 if ((sent == 0) && (parse_error == 0))
685 cli_out ("Volume stop on '%s' failed", volname)do { do { if (0) printf ("Volume stop on '%s' failed", volname
); } while (0); _cli_out("Volume stop on '%s' failed", volname
); } while (0)
;
686 }
687
688 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 688, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
689
690 return ret;
691}
692
693
694int
695cli_cmd_volume_rename_cbk (struct cli_state *state, struct cli_cmd_word *word,
696 const char **words, int wordcount)
697{
698 int ret = -1;
699 rpc_clnt_procedure_t *proc = NULL((void*)0);
700 call_frame_t *frame = NULL((void*)0);
701 dict_t *dict = NULL((void*)0);
702 int sent = 0;
703 int parse_error = 0;
704
705
706 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
707 if (!frame)
708 goto out;
709
710 dict = dict_new ();
711 if (!dict)
712 goto out;
713
714 if (wordcount != 4) {
715 cli_usage_out (word->pattern);
716 parse_error = 1;
717 goto out;
718 }
719
720 ret = dict_set_str (dict, "old-volname", (char *)words[2]);
721
722 if (ret)
723 goto out;
724
725 ret = dict_set_str (dict, "new-volname", (char *)words[3]);
726
727 if (ret)
728 goto out;
729
730 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RENAME_VOLUME];
731
732 if (proc->fn) {
733 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), dict);
734 }
735
736out:
737 if (dict)
738 dict_destroy (dict);
739
740 if (ret) {
741 cli_cmd_sent_status_get (&sent);
742 if ((sent == 0) && (parse_error == 0))
743 cli_out ("Volume rename on '%s' failed", (char *)words[2])do { do { if (0) printf ("Volume rename on '%s' failed", (char
*)words[2]); } while (0); _cli_out("Volume rename on '%s' failed"
, (char *)words[2]); } while (0)
;
744 }
745
746 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 746, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
747
748 return ret;
749}
750
751int
752cli_cmd_volume_defrag_cbk (struct cli_state *state, struct cli_cmd_word *word,
753 const char **words, int wordcount)
754{
755 int ret = -1;
756 rpc_clnt_procedure_t *proc = NULL((void*)0);
757 call_frame_t *frame = NULL((void*)0);
758 dict_t *dict = NULL((void*)0);
759 int sent = 0;
760 int parse_error = 0;
761 cli_local_t *local = NULL((void*)0);
762#ifdef GF_SOLARIS_HOST_OS
763 cli_out ("Command not supported on Solaris")do { do { if (0) printf ("Command not supported on Solaris");
} while (0); _cli_out("Command not supported on Solaris"); }
while (0)
;
764 goto out;
765#endif
766
767 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
768 if (!frame)
769 goto out;
770
771 ret = cli_cmd_volume_defrag_parse (words, wordcount, &dict);
772
773 if (ret) {
774 cli_usage_out (word->pattern);
775 parse_error = 1;
776 }
777
778 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_DEFRAG_VOLUME];
779
780 CLI_LOCAL_INIT (local, words, frame, dict)do { local = cli_local_get (); if (local) { local->words =
words; if (dict) local->dict = dict; if (frame) frame->
local = local; } } while (0)
;
781
782 if (proc->fn) {
783 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), dict);
784 }
785
786out:
787 if (ret) {
788 cli_cmd_sent_status_get (&sent);
789 if ((sent == 0) && (parse_error == 0))
790 cli_out ("Volume rebalance failed")do { do { if (0) printf ("Volume rebalance failed"); } while (
0); _cli_out("Volume rebalance failed"); } while (0)
;
791 }
792
793 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 793, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
794
795 return ret;
796}
797
798int
799cli_cmd_volume_reset_cbk (struct cli_state *state, struct cli_cmd_word *word,
800 const char **words, int wordcount)
801{
802 int sent = 0;
803 int parse_error = 0;
804 int ret = -1;
805 rpc_clnt_procedure_t *proc = NULL((void*)0);
806 call_frame_t *frame = NULL((void*)0);
807 dict_t *options = NULL((void*)0);
808 cli_local_t *local = NULL((void*)0);
809
810 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_RESET_VOLUME];
811
812 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
813 if (!frame)
814 goto out;
815
816 ret = cli_cmd_volume_reset_parse (words, wordcount, &options);
817 if (ret) {
818 cli_usage_out (word->pattern);
819 parse_error = 1;
820 goto out;
821 }
822
823 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
824
825 if (proc->fn) {
826 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
827 }
828
829out:
830 if (ret) {
831 cli_cmd_sent_status_get (&sent);
832 if ((sent == 0) && (parse_error == 0))
833 cli_out ("Volume reset failed")do { do { if (0) printf ("Volume reset failed"); } while (0);
_cli_out("Volume reset failed"); } while (0)
;
834 }
835
836 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 836, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
837
838 return ret;
839
840}
841
842int
843cli_cmd_volume_profile_cbk (struct cli_state *state, struct cli_cmd_word *word,
844 const char **words, int wordcount)
845{
846 int sent = 0;
847 int parse_error = 0;
848
849 int ret = -1;
850 rpc_clnt_procedure_t *proc = NULL((void*)0);
851 call_frame_t *frame = NULL((void*)0);
852 dict_t *options = NULL((void*)0);
853 cli_local_t *local = NULL((void*)0);
854
855 ret = cli_cmd_volume_profile_parse (words, wordcount, &options);
856
857 if (ret) {
858 cli_usage_out (word->pattern);
859 parse_error = 1;
860 goto out;
861 }
862
863 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_PROFILE_VOLUME];
864
865 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
866 if (!frame)
867 goto out;
868
869 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
870
871 if (proc->fn) {
872 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
873 }
874
875out:
876 if (ret) {
877 cli_cmd_sent_status_get (&sent);
878 if ((sent == 0) && (parse_error == 0))
879 cli_out ("Volume profile failed")do { do { if (0) printf ("Volume profile failed"); } while (0
); _cli_out("Volume profile failed"); } while (0)
;
880 }
881
882 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 882, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
883
884 return ret;
885
886}
887
888int
889cli_cmd_volume_set_cbk (struct cli_state *state, struct cli_cmd_word *word,
890 const char **words, int wordcount)
891{
892 int sent = 0;
893 int parse_error = 0;
894
895 int ret = -1;
896 rpc_clnt_procedure_t *proc = NULL((void*)0);
897 call_frame_t *frame = NULL((void*)0);
898 dict_t *options = NULL((void*)0);
899 cli_local_t *local = NULL((void*)0);
900
901 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_SET_VOLUME];
902
903 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
904 if (!frame)
905 goto out;
906
907 ret = cli_cmd_volume_set_parse (words, wordcount, &options);
908 if (ret) {
909 cli_usage_out (word->pattern);
910 parse_error = 1;
911 goto out;
912 }
913
914 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
915
916 if (proc->fn) {
917 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
918 }
919
920out:
921 if (ret) {
922 cli_cmd_sent_status_get (&sent);
923 if ((sent == 0) && (parse_error == 0))
924 cli_out ("Volume set failed")do { do { if (0) printf ("Volume set failed"); } while (0); _cli_out
("Volume set failed"); } while (0)
;
925 }
926
927 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 927, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
928
929 return ret;
930
931}
932
933int
934cli_cmd_volume_add_brick_cbk (struct cli_state *state,
935 struct cli_cmd_word *word, const char **words,
936 int wordcount)
937{
938 int ret = -1;
939 rpc_clnt_procedure_t *proc = NULL((void*)0);
940 call_frame_t *frame = NULL((void*)0);
941 dict_t *options = NULL((void*)0);
942 int sent = 0;
943 int parse_error = 0;
944 gf_answer_t answer = GF_ANSWER_NO;
945 cli_local_t *local = NULL((void*)0);
946
947 const char *question = "Changing the 'stripe count' of the volume is "
948 "not a supported feature. In some cases it may result in data "
949 "loss on the volume. Also there may be issues with regular "
950 "filesystem operations on the volume after the change. Do you "
951 "really want to continue with 'stripe' count option ? ";
952
953 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
954 if (!frame)
955 goto out;
956
957 ret = cli_cmd_volume_add_brick_parse (words, wordcount, &options);
958 if (ret) {
959 cli_usage_out (word->pattern);
960 parse_error = 1;
961 goto out;
962 }
963
964 /* TODO: there are challenges in supporting changing of
965 stripe-count, untill it is properly supported give warning to user */
966 if (dict_get (options, "stripe-count")) {
967 answer = cli_cmd_get_confirmation (state, question);
968
969 if (GF_ANSWER_NO == answer) {
970 ret = 0;
971 goto out;
972 }
973 }
974
975 if (state->mode & GLUSTER_MODE_SCRIPT(1 << 0)) {
976 ret = dict_set_int32 (options, "force", _gf_true);
977 if (ret) {
978 gf_log ("cli", GF_LOG_ERROR, "Failed to set force "do { do { if (0) printf ("Failed to set force " "option"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 979, GF_LOG_ERROR
, "Failed to set force " "option"); } while (0)
979 "option")do { do { if (0) printf ("Failed to set force " "option"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 979, GF_LOG_ERROR
, "Failed to set force " "option"); } while (0)
;
980 goto out;
981 }
982 }
983
984 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_ADD_BRICK];
985
986 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
987
988 if (proc->fn) {
989 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
990 }
991
992out:
993 if (ret) {
994 cli_cmd_sent_status_get (&sent);
995 if ((sent == 0) && (parse_error == 0))
996 cli_out ("Volume add-brick failed")do { do { if (0) printf ("Volume add-brick failed"); } while (
0); _cli_out("Volume add-brick failed"); } while (0)
;
997 }
998
999 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 999, GF_LOG_DEBUG
, "frame->local " "is not NULL (%p)", frame->local); } while
(0); cli_local_wipe (frame->local); frame->local = ((void
*)0); } STACK_DESTROY (frame->root); } } while (0);
;
1000
1001 return ret;
1002}
1003
1004int
1005cli_cmd_quota_cbk (struct cli_state *state, struct cli_cmd_word *word,
1006 const char **words, int wordcount)
1007{
1008
1009 int ret = 0;
1010 int parse_err = 0;
1011 int32_t type = 0;
1012 rpc_clnt_procedure_t *proc = NULL((void*)0);
1013 call_frame_t *frame = NULL((void*)0);
1014 dict_t *options = NULL((void*)0);
1015 gf_answer_t answer = GF_ANSWER_NO;
1016 cli_local_t *local = NULL((void*)0);
1017 const char *question = "Disabling quota will delete all the quota "
1018 "configuration. Do you want to continue?";
1019
1020 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_QUOTA];
1021 if (proc == NULL((void*)0)) {
1022 ret = -1;
1023 goto out;
1024 }
1025
1026 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1027 if (!frame) {
1028 ret = -1;
1029 goto out;
1030 }
1031
1032 ret = cli_cmd_quota_parse (words, wordcount, &options);
1033
1034 if (ret < 0) {
1035 cli_usage_out (word->pattern);
1036 parse_err = 1;
1037 goto out;
1038 } else if (dict_get_int32 (options, "type", &type) == 0 &&
1039 type == GF_QUOTA_OPTION_TYPE_DISABLE) {
1040 answer = cli_cmd_get_confirmation (state, question);
1041 if (answer == GF_ANSWER_NO)
1042 goto out;
1043 }
1044
1045 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1046
1047 if (proc->fn)
1048 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1049
1050out:
1051 if (ret && parse_err == 0)
1052 cli_out ("Quota command failed")do { do { if (0) printf ("Quota command failed"); } while (0)
; _cli_out("Quota command failed"); } while (0)
;
1053
1054 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1054,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1055
1056 return ret;
1057
1058}
1059
1060int
1061cli_cmd_volume_remove_brick_cbk (struct cli_state *state,
1062 struct cli_cmd_word *word, const char **words,
1063 int wordcount)
1064{
1065 int ret = -1;
1066 rpc_clnt_procedure_t *proc = NULL((void*)0);
1067 call_frame_t *frame = NULL((void*)0);
1068 dict_t *options = NULL((void*)0);
1069 gf_answer_t answer = GF_ANSWER_NO;
1070 int sent = 0;
1071 int parse_error = 0;
1072 int need_question = 0;
1073 cli_local_t *local = NULL((void*)0);
1074
1075 const char *question = "Removing brick(s) can result in data loss. "
1076 "Do you want to Continue?";
1077
1078 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1079 if (!frame)
1080 goto out;
1081
1082 ret = cli_cmd_volume_remove_brick_parse (words, wordcount, &options,
1083 &need_question);
1084 if (ret) {
1085 cli_usage_out (word->pattern);
1086 parse_error = 1;
1087 goto out;
1088 }
1089
1090 if (!(state->mode & GLUSTER_MODE_SCRIPT(1 << 0)) && need_question) {
1091 /* we need to ask question only in case of 'commit or force' */
1092 answer = cli_cmd_get_confirmation (state, question);
1093 if (GF_ANSWER_NO == answer) {
1094 ret = 0;
1095 goto out;
1096 }
1097 }
1098
1099 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REMOVE_BRICK];
1100
1101 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1102
1103 if (proc->fn) {
1104 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1105 }
1106
1107out:
1108 if (ret) {
1109 cli_cmd_sent_status_get (&sent);
1110 if ((sent == 0) && (parse_error == 0))
1111 cli_out ("Volume remove-brick failed")do { do { if (0) printf ("Volume remove-brick failed"); } while
(0); _cli_out("Volume remove-brick failed"); } while (0)
;
1112 }
1113
1114 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1114,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1115
1116 return ret;
1117
1118}
1119
1120int
1121cli_cmd_volume_replace_brick_cbk (struct cli_state *state,
1122 struct cli_cmd_word *word,
1123 const char **words,
1124 int wordcount)
1125{
1126 int ret = -1;
1127 rpc_clnt_procedure_t *proc = NULL((void*)0);
1128 call_frame_t *frame = NULL((void*)0);
1129 dict_t *options = NULL((void*)0);
1130 int sent = 0;
1131 int parse_error = 0;
1132 cli_local_t *local = NULL((void*)0);
1133
1134#ifdef GF_SOLARIS_HOST_OS
1135 cli_out ("Command not supported on Solaris")do { do { if (0) printf ("Command not supported on Solaris");
} while (0); _cli_out("Command not supported on Solaris"); }
while (0)
;
1136 goto out;
1137#endif
1138 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_REPLACE_BRICK];
1139
1140 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1141 if (!frame)
1142 goto out;
1143
1144 ret = cli_cmd_volume_replace_brick_parse (words, wordcount, &options);
1145
1146 if (ret) {
1147 cli_usage_out (word->pattern);
1148 parse_error = 1;
1149 goto out;
1150 }
1151
1152 if (state->mode & GLUSTER_MODE_SCRIPT(1 << 0)) {
1153 ret = dict_set_int32 (options, "force", _gf_true);
1154 if (ret) {
1155 gf_log ("cli", GF_LOG_ERROR, "Failed to set force"do { do { if (0) printf ("Failed to set force" "option"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1156,
GF_LOG_ERROR, "Failed to set force" "option"); } while (0)
1156 "option")do { do { if (0) printf ("Failed to set force" "option"); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1156,
GF_LOG_ERROR, "Failed to set force" "option"); } while (0)
;
1157 goto out;
1158 }
1159 }
1160
1161 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1162
1163 if (proc->fn) {
1164 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1165 }
1166
1167out:
1168 if (ret) {
1169 cli_cmd_sent_status_get (&sent);
1170 if ((sent == 0) && (parse_error == 0))
1171 cli_out ("Volume replace-brick failed")do { do { if (0) printf ("Volume replace-brick failed"); } while
(0); _cli_out("Volume replace-brick failed"); } while (0)
;
1172 }
1173
1174 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1174,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1175
1176 return ret;
1177}
1178
1179
1180int
1181cli_cmd_volume_set_transport_cbk (struct cli_state *state,
1182 struct cli_cmd_word *word,
1183 const char **words, int wordcount)
1184{
1185 cli_cmd_broadcast_response (0);
1186 return 0;
1187}
1188
1189int
1190cli_cmd_volume_top_cbk (struct cli_state *state, struct cli_cmd_word *word,
1191 const char **words, int wordcount)
1192{
1193
1194 int ret = -1;
1195 rpc_clnt_procedure_t *proc = NULL((void*)0);
1196 call_frame_t *frame = NULL((void*)0);
1197 dict_t *options = NULL((void*)0);
1198 int sent = 0;
1199 int parse_error = 0;
1200 cli_local_t *local = NULL((void*)0);
1201
1202 ret = cli_cmd_volume_top_parse (words, wordcount, &options);
1203
1204 if (ret) {
1205 parse_error = 1;
1206 cli_usage_out (word->pattern);
1207 goto out;
1208 }
1209
1210 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_TOP_VOLUME];
1211
1212 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1213 if (!frame)
1214 goto out;
1215
1216 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1217
1218 if (proc->fn) {
1219 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1220 }
1221
1222out:
1223 if (ret) {
1224 cli_cmd_sent_status_get (&sent);
1225 if ((sent == 0) && (parse_error == 0))
1226 cli_out ("Volume top failed")do { do { if (0) printf ("Volume top failed"); } while (0); _cli_out
("Volume top failed"); } while (0)
;
1227 }
1228
1229 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1229,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1230
1231 return ret;
1232
1233}
1234
1235
1236int
1237cli_cmd_log_rotate_cbk (struct cli_state *state, struct cli_cmd_word *word,
1238 const char **words, int wordcount)
1239{
1240 int ret = -1;
1241 rpc_clnt_procedure_t *proc = NULL((void*)0);
1242 call_frame_t *frame = NULL((void*)0);
1243 dict_t *options = NULL((void*)0);
1244 int sent = 0;
1245 int parse_error = 0;
1246 cli_local_t *local = NULL((void*)0);
1247
1248 if (!((wordcount == 4) || (wordcount == 5))) {
1249 cli_usage_out (word->pattern);
1250 parse_error = 1;
1251 goto out;
1252 }
1253
1254 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LOG_ROTATE];
1255
1256 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1257 if (!frame)
1258 goto out;
1259
1260 ret = cli_cmd_log_rotate_parse (words, wordcount, &options);
1261 if (ret)
1262 goto out;
1263
1264 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1265
1266 if (proc->fn) {
1267 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1268 }
1269
1270out:
1271 if (ret) {
1272 cli_cmd_sent_status_get (&sent);
1273 if ((sent == 0) && (parse_error == 0))
1274 cli_out ("Volume log rotate failed")do { do { if (0) printf ("Volume log rotate failed"); } while
(0); _cli_out("Volume log rotate failed"); } while (0)
;
1275 }
1276 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1276,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1277
1278 return ret;
1279}
1280
1281#if (SYNCDAEMON_COMPILE1)
1282static int
1283cli_check_gsync_present ()
1284{
1285 char buff[PATH_MAX4096] = {0, };
1286 runner_t runner = {0,};
1287 char *ptr = NULL((void*)0);
1288 int ret = 0;
1289
1290 ret = setenv ("_GLUSTERD_CALLED_", "1", 1);
1291 if (-1 == ret) {
1292 gf_log ("", GF_LOG_WARNING, "setenv syscall failed, hence could"do { do { if (0) printf ("setenv syscall failed, hence could"
"not assert if geo-replication is installed"); } while (0); _gf_log
("", "cli-cmd-volume.c", __FUNCTION__, 1293, GF_LOG_WARNING,
"setenv syscall failed, hence could" "not assert if geo-replication is installed"
); } while (0)
1293 "not assert if geo-replication is installed")do { do { if (0) printf ("setenv syscall failed, hence could"
"not assert if geo-replication is installed"); } while (0); _gf_log
("", "cli-cmd-volume.c", __FUNCTION__, 1293, GF_LOG_WARNING,
"setenv syscall failed, hence could" "not assert if geo-replication is installed"
); } while (0)
;
1294 goto out;
1295 }
1296
1297 runinit (&runner);
1298 runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "--version", NULL((void*)0));
1299 runner_redir (&runner, STDOUT_FILENO1, RUN_PIPE-1);
1300 ret = runner_start (&runner);
1301 if (ret == -1) {
1302 gf_log ("", GF_LOG_INFO, "geo-replication not installed")do { do { if (0) printf ("geo-replication not installed"); } while
(0); _gf_log ("", "cli-cmd-volume.c", __FUNCTION__, 1302, GF_LOG_INFO
, "geo-replication not installed"); } while (0)
;
1303 goto out;
1304 }
1305
1306 ptr = fgets(buff, sizeof(buff), runner_chio (&runner, STDOUT_FILENO1));
1307 if (ptr) {
1308 if (!strstr (buff, "gsyncd")) {
1309 ret = -1;
1310 goto out;
1311 }
1312 } else {
1313 ret = -1;
1314 goto out;
1315 }
1316
1317 ret = runner_end (&runner);
1318
1319 if (ret)
1320 gf_log ("", GF_LOG_ERROR, "geo-replication not installed")do { do { if (0) printf ("geo-replication not installed"); } while
(0); _gf_log ("", "cli-cmd-volume.c", __FUNCTION__, 1320, GF_LOG_ERROR
, "geo-replication not installed"); } while (0)
;
1321
1322out:
1323 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-cmd-volume.c", __FUNCTION__, 1323, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1324 return ret ? -1 : 0;
1325
1326}
1327
1328void
1329cli_cmd_check_gsync_exists_cbk (struct cli_cmd *this)
1330{
1331
1332 int ret = 0;
1333
1334 ret = cli_check_gsync_present ();
1335 if (ret)
1336 this->disable = _gf_true;
1337
1338}
1339#endif
1340
1341int
1342cli_cmd_volume_gsync_set_cbk (struct cli_state *state, struct cli_cmd_word *word,
1343 const char **words, int wordcount)
1344{
1345 int ret = 0;
1346 int parse_err = 0;
1347 dict_t *options = NULL((void*)0);
1348 rpc_clnt_procedure_t *proc = NULL((void*)0);
1349 call_frame_t *frame = NULL((void*)0);
1350 cli_local_t *local = NULL((void*)0);
1351
1352 proc = &cli_rpc_prog->proctable [GLUSTER_CLI_GSYNC_SET];
1353 if (proc == NULL((void*)0)) {
1354 ret = -1;
1355 goto out;
1356 }
1357
1358 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1359 if (frame == NULL((void*)0)) {
1360 ret = -1;
1361 goto out;
1362 }
1363
1364 ret = cli_cmd_gsync_set_parse (words, wordcount, &options);
1365 if (ret) {
1366 cli_usage_out (word->pattern);
1367 parse_err = 1;
1368 goto out;
1369 }
1370
1371 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1372
1373 if (proc->fn)
1374 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1375
1376out:
1377 if (ret && parse_err == 0)
1378 cli_out (GEOREP" command failed")do { do { if (0) printf ("geo-replication"" command failed");
} while (0); _cli_out("geo-replication"" command failed"); }
while (0)
;
1379
1380 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1380,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1381
1382 return ret;
1383}
1384
1385int
1386cli_cmd_volume_status_cbk (struct cli_state *state,
1387 struct cli_cmd_word *word,
1388 const char **words, int wordcount)
1389{
1390 int ret = -1;
1391 rpc_clnt_procedure_t *proc = NULL((void*)0);
1392 call_frame_t *frame = NULL((void*)0);
1393 dict_t *dict = NULL((void*)0);
1394 uint32_t cmd = 0;
1395 cli_local_t *local = NULL((void*)0);
1396
1397 ret = cli_cmd_volume_status_parse (words, wordcount, &dict);
1398
1399 if (ret) {
1400 cli_usage_out (word->pattern);
1401 goto out;
1402 }
1403
1404 ret = dict_get_uint32 (dict, "cmd", &cmd);
1405 if (ret)
1406 goto out;
1407
1408 if (!(cmd & GF_CLI_STATUS_ALL)) {
1409 /* for one volume or brick */
1410 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_VOLUME];
1411 } else {
1412 /* volume status all or all detail */
1413 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATUS_ALL];
1414 }
1415
1416 if (!proc->fn)
1417 goto out;
1418
1419 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1420 if (!frame)
1421 goto out;
1422
1423 CLI_LOCAL_INIT (local, words, frame, dict)do { local = cli_local_get (); if (local) { local->words =
words; if (dict) local->dict = dict; if (frame) frame->
local = local; } } while (0)
;
1424
1425 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), dict);
1426
1427out:
1428 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1428,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1429
1430 return ret;
1431}
1432
1433
1434int
1435cli_get_detail_status (dict_t *dict, int i, cli_volume_status_t *status)
1436{
1437 uint64_t free = 0;
1438 uint64_t total = 0;
1439 char key[1024] = {0};
1440 int ret = 0;
1441
1442 memset (key, 0, sizeof (key));
1443 snprintf (key, sizeof (key), "brick%d.free", i);
1444 ret = dict_get_uint64 (dict, key, &free);
1445
1446 status->free = gf_uint64_2human_readable (free);
1447 if (!status->free)
1448 goto out;
1449
1450 memset (key, 0, sizeof (key));
1451 snprintf (key, sizeof (key), "brick%d.total", i);
1452 ret = dict_get_uint64 (dict, key, &total);
1453
1454 status->total = gf_uint64_2human_readable (total);
1455 if (!status->total)
1456 goto out;
1457
1458#ifdef GF_LINUX_HOST_OS1
1459 memset (key, 0, sizeof (key));
1460 snprintf (key, sizeof (key), "brick%d.device", i);
1461 ret = dict_get_str (dict, key, &(status->device));
1462 if (ret)
1463 status->device = NULL((void*)0);
1464#endif
1465
1466 memset (key, 0, sizeof (key));
1467 snprintf (key, sizeof (key), "brick%d.block_size", i);
1468 ret = dict_get_uint64 (dict, key, &(status->block_size));
1469 if (ret) {
1470 ret = 0;
1471 status->block_size = 0;
1472 }
1473
1474#ifdef GF_LINUX_HOST_OS1
1475 memset (key, 0, sizeof (key));
1476 snprintf (key, sizeof (key), "brick%d.mnt_options", i);
1477 ret = dict_get_str (dict, key, &(status->mount_options));
1478 if (ret)
1479 status->mount_options = NULL((void*)0);
1480
1481 memset (key, 0, sizeof (key));
1482 snprintf (key, sizeof (key), "brick%d.fs_name", i);
1483 ret = dict_get_str (dict, key, &(status->fs_name));
1484 if (ret) {
1485 ret = 0;
1486 status->fs_name = NULL((void*)0);
1487 }
1488
1489 memset (key, 0, sizeof (key));
1490 snprintf (key, sizeof (key), "brick%d.inode_size", i);
1491 ret = dict_get_str (dict, key, &(status->inode_size));
1492 if (ret)
1493 status->inode_size = NULL((void*)0);
1494#endif /* GF_LINUX_HOST_OS */
1495
1496 memset (key, 0, sizeof (key));
1497 snprintf (key, sizeof (key), "brick%d.total_inodes", i);
1498 ret = dict_get_uint64 (dict, key,
1499 &(status->total_inodes));
1500 if (ret)
1501 status->total_inodes = 0;
1502
1503 memset (key, 0, sizeof (key));
1504 snprintf (key, sizeof (key), "brick%d.free_inodes", i);
1505 ret = dict_get_uint64 (dict, key, &(status->free_inodes));
1506 if (ret) {
1507 ret = 0;
1508 status->free_inodes = 0;
1509 }
1510
1511
1512 out:
1513 return ret;
1514}
1515
1516void
1517cli_print_detailed_status (cli_volume_status_t *status)
1518{
1519 cli_out ("%-20s : %-20s", "Brick", status->brick)do { do { if (0) printf ("%-20s : %-20s", "Brick", status->
brick); } while (0); _cli_out("%-20s : %-20s", "Brick", status
->brick); } while (0)
;
1520 if (status->online)
1521 cli_out ("%-20s : %-20d", "Port", status->port)do { do { if (0) printf ("%-20s : %-20d", "Port", status->
port); } while (0); _cli_out("%-20s : %-20d", "Port", status->
port); } while (0)
;
1522 else
1523 cli_out ("%-20s : %-20s", "Port", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Port", "N/A"); } while
(0); _cli_out("%-20s : %-20s", "Port", "N/A"); } while (0)
;
1524 cli_out ("%-20s : %-20c", "Online", (status->online) ? 'Y' : 'N')do { do { if (0) printf ("%-20s : %-20c", "Online", (status->
online) ? 'Y' : 'N'); } while (0); _cli_out("%-20s : %-20c", "Online"
, (status->online) ? 'Y' : 'N'); } while (0)
;
1525 cli_out ("%-20s : %-20s", "Pid", status->pid_str)do { do { if (0) printf ("%-20s : %-20s", "Pid", status->pid_str
); } while (0); _cli_out("%-20s : %-20s", "Pid", status->pid_str
); } while (0)
;
1526
1527#ifdef GF_LINUX_HOST_OS1
1528 if (status->fs_name)
1529 cli_out ("%-20s : %-20s", "File System", status->fs_name)do { do { if (0) printf ("%-20s : %-20s", "File System", status
->fs_name); } while (0); _cli_out("%-20s : %-20s", "File System"
, status->fs_name); } while (0)
;
1530 else
1531 cli_out ("%-20s : %-20s", "File System", "N/A")do { do { if (0) printf ("%-20s : %-20s", "File System", "N/A"
); } while (0); _cli_out("%-20s : %-20s", "File System", "N/A"
); } while (0)
;
1532
1533 if (status->device)
1534 cli_out ("%-20s : %-20s", "Device", status->device)do { do { if (0) printf ("%-20s : %-20s", "Device", status->
device); } while (0); _cli_out("%-20s : %-20s", "Device", status
->device); } while (0)
;
1535 else
1536 cli_out ("%-20s : %-20s", "Device", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Device", "N/A"); }
while (0); _cli_out("%-20s : %-20s", "Device", "N/A"); } while
(0)
;
1537
1538 if (status->mount_options) {
1539 cli_out ("%-20s : %-20s", "Mount Options",do { do { if (0) printf ("%-20s : %-20s", "Mount Options", status
->mount_options); } while (0); _cli_out("%-20s : %-20s", "Mount Options"
, status->mount_options); } while (0)
1540 status->mount_options)do { do { if (0) printf ("%-20s : %-20s", "Mount Options", status
->mount_options); } while (0); _cli_out("%-20s : %-20s", "Mount Options"
, status->mount_options); } while (0)
;
1541 } else {
1542 cli_out ("%-20s : %-20s", "Mount Options", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Mount Options", "N/A"
); } while (0); _cli_out("%-20s : %-20s", "Mount Options", "N/A"
); } while (0)
;
1543 }
1544
1545 if (status->inode_size) {
1546 cli_out ("%-20s : %-20s", "Inode Size",do { do { if (0) printf ("%-20s : %-20s", "Inode Size", status
->inode_size); } while (0); _cli_out("%-20s : %-20s", "Inode Size"
, status->inode_size); } while (0)
1547 status->inode_size)do { do { if (0) printf ("%-20s : %-20s", "Inode Size", status
->inode_size); } while (0); _cli_out("%-20s : %-20s", "Inode Size"
, status->inode_size); } while (0)
;
1548 } else {
1549 cli_out ("%-20s : %-20s", "Inode Size", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Inode Size", "N/A"
); } while (0); _cli_out("%-20s : %-20s", "Inode Size", "N/A"
); } while (0)
;
1550 }
1551#endif
1552 if (status->free)
1553 cli_out ("%-20s : %-20s", "Disk Space Free", status->free)do { do { if (0) printf ("%-20s : %-20s", "Disk Space Free", status
->free); } while (0); _cli_out("%-20s : %-20s", "Disk Space Free"
, status->free); } while (0)
;
1554 else
1555 cli_out ("%-20s : %-20s", "Disk Space Free", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Disk Space Free", "N/A"
); } while (0); _cli_out("%-20s : %-20s", "Disk Space Free", "N/A"
); } while (0)
;
1556
1557 if (status->total)
1558 cli_out ("%-20s : %-20s", "Total Disk Space", status->total)do { do { if (0) printf ("%-20s : %-20s", "Total Disk Space",
status->total); } while (0); _cli_out("%-20s : %-20s", "Total Disk Space"
, status->total); } while (0)
;
1559 else
1560 cli_out ("%-20s : %-20s", "Total Disk Space", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Total Disk Space",
"N/A"); } while (0); _cli_out("%-20s : %-20s", "Total Disk Space"
, "N/A"); } while (0)
;
1561
1562
1563 if (status->total_inodes) {
1564 cli_out ("%-20s : %-20ld", "Inode Count",do { do { if (0) printf ("%-20s : %-20ld", "Inode Count", status
->total_inodes); } while (0); _cli_out("%-20s : %-20ld", "Inode Count"
, status->total_inodes); } while (0)
1565 status->total_inodes)do { do { if (0) printf ("%-20s : %-20ld", "Inode Count", status
->total_inodes); } while (0); _cli_out("%-20s : %-20ld", "Inode Count"
, status->total_inodes); } while (0)
;
1566 } else {
1567 cli_out ("%-20s : %-20s", "Inode Count", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Inode Count", "N/A"
); } while (0); _cli_out("%-20s : %-20s", "Inode Count", "N/A"
); } while (0)
;
1568 }
1569
1570 if (status->free_inodes) {
1571 cli_out ("%-20s : %-20ld", "Free Inodes",do { do { if (0) printf ("%-20s : %-20ld", "Free Inodes", status
->free_inodes); } while (0); _cli_out("%-20s : %-20ld", "Free Inodes"
, status->free_inodes); } while (0)
1572 status->free_inodes)do { do { if (0) printf ("%-20s : %-20ld", "Free Inodes", status
->free_inodes); } while (0); _cli_out("%-20s : %-20ld", "Free Inodes"
, status->free_inodes); } while (0)
;
1573 } else {
1574 cli_out ("%-20s : %-20s", "Free Inodes", "N/A")do { do { if (0) printf ("%-20s : %-20s", "Free Inodes", "N/A"
); } while (0); _cli_out("%-20s : %-20s", "Free Inodes", "N/A"
); } while (0)
;
1575 }
1576}
1577
1578int
1579cli_print_brick_status (cli_volume_status_t *status)
1580{
1581 int fieldlen = CLI_VOL_STATUS_BRICK_LEN55;
1582 int bricklen = 0;
1583 char *p = NULL((void*)0);
1584 int num_tabs = 0;
1585
1586 p = status->brick;
1587 bricklen = strlen (p);
1588 while (bricklen > 0) {
1589 if (bricklen > fieldlen) {
1590 cli_out ("%.*s", fieldlen, p)do { do { if (0) printf ("%.*s", fieldlen, p); } while (0); _cli_out
("%.*s", fieldlen, p); } while (0)
;
1591 p += fieldlen;
1592 bricklen -= fieldlen;
1593 } else {
1594 num_tabs = (fieldlen - bricklen) / CLI_TAB_LENGTH8 + 1;
1595 printf ("%s", p);
1596 while (num_tabs-- != 0)
1597 printf ("\t");
1598 if (status->port) {
1599 if (status->online)
1600 cli_out ("%d\t%c\t%s",do { do { if (0) printf ("%d\t%c\t%s", status->port, status
->online?'Y':'N', status->pid_str); } while (0); _cli_out
("%d\t%c\t%s", status->port, status->online?'Y':'N', status
->pid_str); } while (0)
1601 status->port,do { do { if (0) printf ("%d\t%c\t%s", status->port, status
->online?'Y':'N', status->pid_str); } while (0); _cli_out
("%d\t%c\t%s", status->port, status->online?'Y':'N', status
->pid_str); } while (0)
1602 status->online?'Y':'N',do { do { if (0) printf ("%d\t%c\t%s", status->port, status
->online?'Y':'N', status->pid_str); } while (0); _cli_out
("%d\t%c\t%s", status->port, status->online?'Y':'N', status
->pid_str); } while (0)
1603 status->pid_str)do { do { if (0) printf ("%d\t%c\t%s", status->port, status
->online?'Y':'N', status->pid_str); } while (0); _cli_out
("%d\t%c\t%s", status->port, status->online?'Y':'N', status
->pid_str); } while (0)
;
1604 else
1605 cli_out ("%s\t%c\t%s",do { do { if (0) printf ("%s\t%c\t%s", "N/A", status->online
?'Y':'N', status->pid_str); } while (0); _cli_out("%s\t%c\t%s"
, "N/A", status->online?'Y':'N', status->pid_str); } while
(0)
1606 "N/A",do { do { if (0) printf ("%s\t%c\t%s", "N/A", status->online
?'Y':'N', status->pid_str); } while (0); _cli_out("%s\t%c\t%s"
, "N/A", status->online?'Y':'N', status->pid_str); } while
(0)
1607 status->online?'Y':'N',do { do { if (0) printf ("%s\t%c\t%s", "N/A", status->online
?'Y':'N', status->pid_str); } while (0); _cli_out("%s\t%c\t%s"
, "N/A", status->online?'Y':'N', status->pid_str); } while
(0)
1608 status->pid_str)do { do { if (0) printf ("%s\t%c\t%s", "N/A", status->online
?'Y':'N', status->pid_str); } while (0); _cli_out("%s\t%c\t%s"
, "N/A", status->online?'Y':'N', status->pid_str); } while
(0)
;
1609 }
1610 else
1611 cli_out ("%s\t%c\t%s",do { do { if (0) printf ("%s\t%c\t%s", "N/A", status->online
?'Y':'N', status->pid_str); } while (0); _cli_out("%s\t%c\t%s"
, "N/A", status->online?'Y':'N', status->pid_str); } while
(0)
1612 "N/A", status->online?'Y':'N',do { do { if (0) printf ("%s\t%c\t%s", "N/A", status->online
?'Y':'N', status->pid_str); } while (0); _cli_out("%s\t%c\t%s"
, "N/A", status->online?'Y':'N', status->pid_str); } while
(0)
1613 status->pid_str)do { do { if (0) printf ("%s\t%c\t%s", "N/A", status->online
?'Y':'N', status->pid_str); } while (0); _cli_out("%s\t%c\t%s"
, "N/A", status->online?'Y':'N', status->pid_str); } while
(0)
;
1614 bricklen = 0;
1615 }
1616 }
1617
1618 return 0;
1619}
1620
1621int
1622cli_cmd_volume_heal_cbk (struct cli_state *state, struct cli_cmd_word *word,
1623 const char **words, int wordcount)
1624{
1625 int ret = -1;
1626 rpc_clnt_procedure_t *proc = NULL((void*)0);
1627 call_frame_t *frame = NULL((void*)0);
1628 int sent = 0;
1629 int parse_error = 0;
1630 dict_t *options = NULL((void*)0);
1631 xlator_t *this = NULL((void*)0);
1632 cli_local_t *local = NULL((void*)0);
1633
1634 this = THIS(*__glusterfs_this_location());
1635 frame = create_frame (this, this->ctx->pool);
1636 if (!frame)
1637 goto out;
1638
1639 if (wordcount < 3) {
1640 cli_usage_out (word->pattern);
1641 parse_error = 1;
1642 goto out;
1643 }
1644
1645 ret = cli_cmd_volume_heal_options_parse (words, wordcount, &options);
1646 if (ret) {
1647 cli_usage_out (word->pattern);
1648 parse_error = 1;
1649 goto out;
1650 }
1651
1652 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_HEAL_VOLUME];
1653
1654 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1655
1656 if (proc->fn) {
1657 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1658 }
1659
1660out:
1661 if (ret) {
1662 cli_cmd_sent_status_get (&sent);
1663 if ((sent == 0) && (parse_error == 0))
1664 cli_out ("Volume heal failed")do { do { if (0) printf ("Volume heal failed"); } while (0); _cli_out
("Volume heal failed"); } while (0)
;
1665 }
1666
1667 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1667,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1668
1669 return ret;
1670}
1671
1672int
1673cli_cmd_volume_statedump_cbk (struct cli_state *state, struct cli_cmd_word *word,
1674 const char **words, int wordcount)
1675{
1676 int ret = -1;
1677 rpc_clnt_procedure_t *proc = NULL((void*)0);
1678 call_frame_t *frame = NULL((void*)0);
1679 dict_t *options = NULL((void*)0);
1680 int sent = 0;
1681 int parse_error = 0;
1682 cli_local_t *local = NULL((void*)0);
1683
1684 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1685 if (!frame)
1686 goto out;
1687
1688 if (wordcount < 3) {
1689 cli_usage_out (word->pattern);
1690 parse_error = 1;
1691 goto out;
1692 }
1693
1694 if (wordcount >= 3) {
1695 ret = cli_cmd_volume_statedump_options_parse (words, wordcount,
1696 &options);
1697 if (ret) {
1698 parse_error = 1;
1699 gf_log ("cli", GF_LOG_ERROR, "Error parsing "do { do { if (0) printf ("Error parsing " "statedump options"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 1700, GF_LOG_ERROR, "Error parsing " "statedump options"); }
while (0)
1700 "statedump options")do { do { if (0) printf ("Error parsing " "statedump options"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 1700, GF_LOG_ERROR, "Error parsing " "statedump options"); }
while (0)
;
1701 cli_out ("Error parsing options")do { do { if (0) printf ("Error parsing options"); } while (0
); _cli_out("Error parsing options"); } while (0)
;
1702 cli_usage_out (word->pattern);
1703 }
1704 }
1705
1706 ret = dict_set_str (options, "volname", (char *)words[2]);
1707 if (ret)
1708 goto out;
1709
1710 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_STATEDUMP_VOLUME];
1711
1712 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1713
1714 if (proc->fn) {
1715 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1716 }
1717
1718out:
1719 if (ret) {
1720 cli_cmd_sent_status_get (&sent);
1721 if ((sent == 0) && (parse_error = 0))
1722 cli_out ("Volume statedump failed")do { do { if (0) printf ("Volume statedump failed"); } while (
0); _cli_out("Volume statedump failed"); } while (0)
;
1723 }
1724
1725 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1725,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1726
1727 return ret;
1728}
1729
1730int
1731cli_cmd_volume_list_cbk (struct cli_state *state, struct cli_cmd_word *word,
1732 const char **words, int wordcount)
1733{
1734 int ret = -1;
1735 call_frame_t *frame = NULL((void*)0);
1736 rpc_clnt_procedure_t *proc = NULL((void*)0);
1737 int sent = 0;
1738
1739 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1740 if (!frame)
1741 goto out;
1742
1743 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_LIST_VOLUME];
1744 if (proc->fn) {
1745 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), NULL((void*)0));
1746 }
1747
1748out:
1749 if (ret) {
1750 cli_cmd_sent_status_get (&sent);
1751 if (sent == 0)
1752 cli_out ("Volume list failed")do { do { if (0) printf ("Volume list failed"); } while (0); _cli_out
("Volume list failed"); } while (0)
;
1753 }
1754
1755 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1755,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1756
1757 return ret;
1758}
1759
1760int
1761cli_cmd_volume_clearlocks_cbk (struct cli_state *state,
1762 struct cli_cmd_word *word,
1763 const char **words, int wordcount)
1764{
1765 int ret = -1;
1766 rpc_clnt_procedure_t *proc = NULL((void*)0);
1767 call_frame_t *frame = NULL((void*)0);
1768 dict_t *options = NULL((void*)0);
1769 int sent = 0;
1770 int parse_error = 0;
1771 cli_local_t *local = NULL((void*)0);
1772
1773 frame = create_frame (THIS(*__glusterfs_this_location()), THIS(*__glusterfs_this_location())->ctx->pool);
1774 if (!frame)
1775 goto out;
1776
1777 if (wordcount < 7 || wordcount > 8) {
1778 cli_usage_out (word->pattern);
1779 parse_error = 1;
1780 goto out;
1781 }
1782
1783 ret = cli_cmd_volume_clrlks_opts_parse (words, wordcount, &options);
1784 if (ret) {
1785 parse_error = 1;
1786 gf_log ("cli", GF_LOG_ERROR, "Error parsing "do { do { if (0) printf ("Error parsing " "clear-locks options"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 1787, GF_LOG_ERROR, "Error parsing " "clear-locks options")
; } while (0)
1787 "clear-locks options")do { do { if (0) printf ("Error parsing " "clear-locks options"
); } while (0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__
, 1787, GF_LOG_ERROR, "Error parsing " "clear-locks options")
; } while (0)
;
1788 cli_out ("Error parsing options")do { do { if (0) printf ("Error parsing options"); } while (0
); _cli_out("Error parsing options"); } while (0)
;
1789 cli_usage_out (word->pattern);
1790 }
1791
1792 ret = dict_set_str (options, "volname", (char *)words[2]);
1793 if (ret)
1794 goto out;
1795
1796 ret = dict_set_str (options, "path", (char *)words[3]);
1797 if (ret)
1798 goto out;
1799
1800 proc = &cli_rpc_prog->proctable[GLUSTER_CLI_CLRLOCKS_VOLUME];
1801
1802 CLI_LOCAL_INIT (local, words, frame, options)do { local = cli_local_get (); if (local) { local->words =
words; if (options) local->dict = options; if (frame) frame
->local = local; } } while (0)
;
1803
1804 if (proc->fn) {
1805 ret = proc->fn (frame, THIS(*__glusterfs_this_location()), options);
1806 }
1807
1808out:
1809 if (ret) {
1810 cli_cmd_sent_status_get (&sent);
1811 if ((sent == 0) && (parse_error = 0))
1812 cli_out ("Volume clear-locks failed")do { do { if (0) printf ("Volume clear-locks failed"); } while
(0); _cli_out("Volume clear-locks failed"); } while (0)
;
1813 }
1814
1815 CLI_STACK_DESTROY (frame)do { if (frame) { if (frame->local) { do { do { if (0) printf
("frame->local " "is not NULL (%p)", frame->local); } while
(0); _gf_log ("cli", "cli-cmd-volume.c", __FUNCTION__, 1815,
GF_LOG_DEBUG, "frame->local " "is not NULL (%p)", frame->
local); } while (0); cli_local_wipe (frame->local); frame->
local = ((void*)0); } STACK_DESTROY (frame->root); } } while
(0);
;
1816
1817 return ret;
1818}
1819
1820struct cli_cmd volume_cmds[] = {
1821 { "volume info [all|<VOLNAME>]",
1822 cli_cmd_volume_info_cbk,
1823 "list information of all volumes"},
1824
1825 { "volume create <NEW-VOLNAME> [stripe <COUNT>] [replica <COUNT>] "
1826#ifdef HAVE_BD_XLATOR
1827 "[device vg] "
1828#endif
1829 "[transport <tcp|rdma|tcp,rdma>] <NEW-BRICK> ... [force]",
1830 cli_cmd_volume_create_cbk,
1831 "create a new volume of specified type with mentioned bricks"},
1832
1833 { "volume delete <VOLNAME>",
1834 cli_cmd_volume_delete_cbk,
1835 "delete volume specified by <VOLNAME>"},
1836
1837 { "volume start <VOLNAME> [force]",
1838 cli_cmd_volume_start_cbk,
1839 "start volume specified by <VOLNAME>"},
1840
1841 { "volume stop <VOLNAME> [force]",
1842 cli_cmd_volume_stop_cbk,
1843 "stop volume specified by <VOLNAME>"},
1844
1845 /*{ "volume rename <VOLNAME> <NEW-VOLNAME>",
1846 cli_cmd_volume_rename_cbk,
1847 "rename volume <VOLNAME> to <NEW-VOLNAME>"},*/
1848
1849 { "volume add-brick <VOLNAME> [<stripe|replica> <COUNT>] <NEW-BRICK> ... [force]",
1850 cli_cmd_volume_add_brick_cbk,
1851 "add brick to volume <VOLNAME>"},
1852
1853 { "volume remove-brick <VOLNAME> [replica <COUNT>] <BRICK> ... {start|stop|status|commit|force}",
1854 cli_cmd_volume_remove_brick_cbk,
1855 "remove brick from volume <VOLNAME>"},
1856
1857 { "volume rebalance <VOLNAME> [fix-layout] {start|stop|status} [force]",
1858 cli_cmd_volume_defrag_cbk,
1859 "rebalance operations"},
1860
1861 { "volume replace-brick <VOLNAME> <BRICK> <NEW-BRICK> {start [force]|pause|abort|status|commit [force]}",
1862 cli_cmd_volume_replace_brick_cbk,
1863 "replace-brick operations"},
1864
1865 /*{ "volume set-transport <VOLNAME> <TRANSPORT-TYPE> [<TRANSPORT-TYPE>] ...",
1866 cli_cmd_volume_set_transport_cbk,
1867 "set transport type for volume <VOLNAME>"},*/
1868
1869 { "volume set <VOLNAME> <KEY> <VALUE>",
1870 cli_cmd_volume_set_cbk,
1871 "set options for volume <VOLNAME>"},
1872
1873 { "volume help",
1874 cli_cmd_volume_help_cbk,
1875 "display help for the volume command"},
1876
1877 { "volume log rotate <VOLNAME> [BRICK]",
1878 cli_cmd_log_rotate_cbk,
1879 "rotate the log file for corresponding volume/brick"},
1880
1881 { "volume sync <HOSTNAME> [all|<VOLNAME>]",
1882 cli_cmd_sync_volume_cbk,
1883 "sync the volume information from a peer"},
1884
1885 { "volume reset <VOLNAME> [option] [force]",
1886 cli_cmd_volume_reset_cbk,
1887 "reset all the reconfigured options"},
1888
1889#if (SYNCDAEMON_COMPILE1)
1890 {"volume "GEOREP"geo-replication"" [<VOLNAME>] [<SLAVE-URL>] {start|stop|config|status|log-rotate} [options...]",
1891 cli_cmd_volume_gsync_set_cbk,
1892 "Geo-sync operations",
1893 cli_cmd_check_gsync_exists_cbk},
1894#endif
1895
1896 { "volume profile <VOLNAME> {start|stop|info [nfs]}",
1897 cli_cmd_volume_profile_cbk,
1898 "volume profile operations"},
1899
1900 { "volume quota <VOLNAME> <enable|disable|limit-usage|list|remove> [path] [value]",
1901 cli_cmd_quota_cbk,
1902 "quota translator specific operations"},
1903
1904 { "volume top <VOLNAME> {open|read|write|opendir|readdir|clear} [nfs|brick <brick>] [list-cnt <value>] |\n"
1905 "volume top <VOLNAME> {read-perf|write-perf} [bs <size> count <count>] [brick <brick>] [list-cnt <value>]",
1906 cli_cmd_volume_top_cbk,
1907 "volume top operations"},
1908
1909 { "volume status [all | <VOLNAME> [nfs|shd|<BRICK>]]"
1910 " [detail|clients|mem|inode|fd|callpool]",
1911 cli_cmd_volume_status_cbk,
1912 "display status of all or specified volume(s)/brick"},
1913
1914 { "volume heal <VOLNAME> [{full | info {healed | heal-failed | split-brain}}]",
1915 cli_cmd_volume_heal_cbk,
1916 "self-heal commands on volume specified by <VOLNAME>"},
1917
1918 {"volume statedump <VOLNAME> [nfs] [all|mem|iobuf|callpool|priv|fd|"
1919 "inode|history]...",
1920 cli_cmd_volume_statedump_cbk,
1921 "perform statedump on bricks"},
1922
1923 {"volume list",
1924 cli_cmd_volume_list_cbk,
1925 "list all volumes in cluster"},
1926
1927 {"volume clear-locks <VOLNAME> <path> kind {blocked|granted|all}"
1928 "{inode [range]|entry [basename]|posix [range]}",
1929 cli_cmd_volume_clearlocks_cbk,
1930 "Clear locks held on path"
1931 },
1932
1933 { NULL((void*)0), NULL((void*)0), NULL((void*)0) }
1934};
1935
1936int
1937cli_cmd_volume_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,
1938 const char **words, int wordcount)
1939{
1940 struct cli_cmd *cmd = NULL((void*)0);
1941
1942 for (cmd = volume_cmds; cmd->pattern; cmd++)
1943 if (_gf_false == cmd->disable)
1944 cli_out ("%s - %s", cmd->pattern, cmd->desc)do { do { if (0) printf ("%s - %s", cmd->pattern, cmd->
desc); } while (0); _cli_out("%s - %s", cmd->pattern, cmd->
desc); } while (0)
;
1945
1946 return 0;
1947}
1948
1949int
1950cli_cmd_volume_register (struct cli_state *state)
1951{
1952 int ret = 0;
1953 struct cli_cmd *cmd = NULL((void*)0);
1954
1955 for (cmd = volume_cmds; cmd->pattern; cmd++) {
1956
1957 ret = cli_cmd_register (&state->tree, cmd);
1958 if (ret)
1959 goto out;
1960 }
1961out:
1962 return ret;
1963}