Bug Summary

File:cli/src/cli-xml-output.c
Location:line 2557, column 48
Description:Access to field 'writer' results in a dereference of a null pointer (loaded from variable 'local')

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 <stdlib.h>
11#include "cli.h"
12#include "cli1-xdr.h"
13#include "run.h"
14#include "compat.h"
15#include "syscall.h"
16
17/*
18 * IMPORTANT NOTE:
19 * All exported functions in this file which use libxml need use a
20 * #if (HAVE_LIB_XML), #else, #endif
21 * For eg,
22 * int exported_func () {
23 * #if (HAVE_LIB_XML)
24 * <Stuff using libxml>
25 * #else
26 * return 0;
27 * #endif
28 * }
29 *
30 * All other functions, which are called internally within this file need to be
31 * within #if (HAVE_LIB_XML), #endif statements
32 * For eg,
33 * #if (HAVE_LIB_XML)
34 * int internal_func ()
35 * {
36 * }
37 * #endif
38 *
39 * Following the above formate ensures that all xml related code is compliled
40 * only when libxml2 is present, and also keeps the rest of the codebase free
41 * of #if (HAVE_LIB_XML)
42 */
43
44
45#if (HAVE_LIB_XML1)
46
47#include <libxml/encoding.h>
48#include <libxml/xmlwriter.h>
49
50#define XML_RET_CHECK_AND_GOTO(ret, label)do { if (ret < 0) { ret = -1; goto label; } else ret = 0; }
while (0)
do { \
51 if (ret < 0) { \
52 ret = -1; \
53 goto label; \
54 } \
55 else \
56 ret = 0; \
57 }while (0) \
58
59int
60cli_begin_xml_output (xmlTextWriterPtr *writer, xmlDocPtr *doc)
61{
62 int ret = -1;
63
64 *writer = xmlNewTextWriterDoc (doc, 0);
65 if (writer == NULL((void*)0)) {
66 ret = -1;
67 goto out;
68 }
69
70 ret = xmlTextWriterStartDocument (*writer, "1.0", "UTF-8", "yes");
71 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
72
73 /* <cliOutput> */
74 ret = xmlTextWriterStartElement (*writer, (xmlChar *)"cliOutput");
75 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
76
77out:
78 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 78, GF_LOG_DEBUG, "Returning %d"
, ret); } while (0)
;
79 return ret;
80}
81
82int
83cli_end_xml_output (xmlTextWriterPtr writer, xmlDocPtr doc)
84{
85 int ret = -1;
86
87 /* </cliOutput> */
88 ret = xmlTextWriterEndElement (writer);
89 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
90
91 ret = xmlTextWriterEndDocument (writer);
92 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
93
94
95 /* Dump xml document to stdout and pretty format it */
96 xmlSaveFormatFileEnc ("-", doc, "UTF-8", 1);
97
98 xmlFreeTextWriter (writer);
99 xmlFreeDoc (doc);
100
101out:
102 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 102, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
103 return ret;
104}
105
106int
107cli_xml_output_common (xmlTextWriterPtr writer, int op_ret, int op_errno,
108 char *op_errstr)
109{
110 int ret = -1;
111
112 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"opRet",
113 "%d", op_ret);
114 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
115
116 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"opErrno",
117 "%d", op_errno);
118 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
119
120 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"opErrstr",
121 "%s", op_errstr);
122 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
123
124out:
125 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 125, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
126 return ret;
127}
128#endif
129
130int
131cli_xml_output_str (char *op, char *str, int op_ret, int op_errno,
132 char *op_errstr)
133{
134#if (HAVE_LIB_XML1)
135 int ret = -1;
136 xmlTextWriterPtr writer = NULL((void*)0);
137 xmlDocPtr doc = NULL((void*)0);
138
139 ret = cli_begin_xml_output (&writer, &doc);
140 if (ret)
141 goto out;
142
143 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
144 if (ret)
145 goto out;
146
147 if (op) {
148 ret = xmlTextWriterWriteFormatElement (writer,
149 (xmlChar *)"cliOp",
150 "%s", op);
151 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
152 }
153
154 if (str) {
155 ret = xmlTextWriterWriteFormatElement (writer,
156 (xmlChar *)"output",
157 "%s", str);
158 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
159 }
160
161 ret = cli_end_xml_output (writer, doc);
162
163out:
164 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 164, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
165 return ret;
166#else
167 return 0;
168#endif
169}
170
171#if (HAVE_LIB_XML1)
172int
173cli_xml_output_data_pair (dict_t *this, char *key, data_t *value,
174 void *data)
175{
176 int ret = -1;
177 xmlTextWriterPtr *writer = NULL((void*)0);
178
179 writer = (xmlTextWriterPtr *)data;
180
181 ret = xmlTextWriterWriteFormatElement (*writer, (xmlChar *)key,
182 "%s", value->data);
183
184 return ret;
185}
186#endif
187
188int
189cli_xml_output_dict ( char *op, dict_t *dict, int op_ret, int op_errno,
190 char *op_errstr)
191{
192#if (HAVE_LIB_XML1)
193 int ret = -1;
194 xmlTextWriterPtr writer = NULL((void*)0);
195 xmlDocPtr doc = NULL((void*)0);
196
197 ret = cli_begin_xml_output (&writer, &doc);
198 if (ret)
199 goto out;
200
201 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
202 if (ret)
203 goto out;
204
205 /* <"op"> */
206 ret = xmlTextWriterStartElement (writer, (xmlChar *)op);
207 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
208
209 if (dict)
210 dict_foreach (dict, cli_xml_output_data_pair, &writer);
211
212 /* </"op"> */
213 ret = xmlTextWriterEndElement (writer);
214 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
215
216 ret = cli_end_xml_output (writer, doc);
217out:
218 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 218, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
219 return ret;
220#else
221 return 0;
222#endif
223}
224
225#if (HAVE_LIB_XML1)
226int
227cli_xml_output_vol_status_common (xmlTextWriterPtr writer, dict_t *dict,
228 int brick_index, int *online,
229 gf_boolean_t *node_present)
230{
231 int ret = -1;
232 char *hostname = NULL((void*)0);
233 char *path = NULL((void*)0);
234 int port = 0;
235 int status = 0;
236 int pid = 0;
237 char key[1024] = {0,};
238
239 snprintf (key, sizeof (key), "brick%d.hostname", brick_index);
240 ret = dict_get_str (dict, key, &hostname);
241 if (ret) {
242 *node_present = _gf_false;
243 goto out;
244 }
245 *node_present = _gf_true;
246
247 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hostname",
248 "%s", hostname);
249 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
250
251 memset (key, 0, sizeof (key));
252 snprintf (key, sizeof (key), "brick%d.path", brick_index);
253 ret = dict_get_str (dict, key, &path);
254 if (ret)
255 goto out;
256 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"path",
257 "%s", path);
258 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
259
260 memset (key, 0, sizeof (key));
261 snprintf (key, sizeof (key), "brick%d.status", brick_index);
262 ret = dict_get_int32 (dict, key, &status);
263 if (ret)
264 goto out;
265 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"status",
266 "%d", status);
267 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
268 *online = status;
269
270 memset (key, 0, sizeof (key));
271 snprintf (key, sizeof (key), "brick%d.port", brick_index);
272 ret = dict_get_int32 (dict, key, &port);
273 if (ret)
274 goto out;
275
276 /* If the process is either offline or doesn't provide a port (shd)
277 * port = "N/A"
278 * else print the port number of the process.
279 */
280
281 if (*online == 1 && port != 0)
282 ret = xmlTextWriterWriteFormatElement (writer,
283 (xmlChar *)"port",
284 "%d", port);
285 else
286 ret = xmlTextWriterWriteFormatElement (writer,
287 (xmlChar *)"port",
288 "%s", "N/A");
289 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
290
291 memset (key, 0, sizeof (key));
292 snprintf (key, sizeof (key), "brick%d.pid", brick_index);
293 ret = dict_get_int32 (dict, key, &pid);
294 if (ret)
295 goto out;
296 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"pid",
297 "%d", pid);
298 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
299
300out:
301 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 301, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
302 return ret;
303}
304
305int
306cli_xml_output_vol_status_detail (xmlTextWriterPtr writer, dict_t *dict,
307 int brick_index)
308{
309 int ret = -1;
310 uint64_t size_total = 0;
311 uint64_t size_free = 0;
312 char *device = NULL((void*)0);
313 uint64_t block_size = 0;
314 char *mnt_options = NULL((void*)0);
315 char *fs_name = NULL((void*)0);
316 char *inode_size = NULL((void*)0);
317 uint64_t inodes_total = 0;
318 uint64_t inodes_free = 0;
319 char key[1024] = {0,};
320
321 snprintf (key, sizeof (key), "brick%d.total", brick_index);
322 ret = dict_get_uint64 (dict, key, &size_total);
323 if (ret)
324 goto out;
325 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"sizeTotal",
326 "%"PRIu64"ll" "u", size_total);
327 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
328
329 memset (key, 0, sizeof (key));
330 snprintf (key, sizeof (key), "brick%d.free", brick_index);
331 ret = dict_get_uint64 (dict, key, &size_free);
332 if (ret)
333 goto out;
334 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"sizeFree",
335 "%"PRIu64"ll" "u", size_free);
336 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
337
338 memset (key, 0, sizeof (key));
339 snprintf (key, sizeof (key), "brick%d.device", brick_index);
340 ret = dict_get_str (dict, key, &device);
341 if (ret)
342 goto out;
343 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"device",
344 "%s", device);
345 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
346
347 memset (key, 0, sizeof (key));
348 snprintf (key, sizeof (key), "brick%d.block_size", brick_index);
349 ret = dict_get_uint64 (dict, key, &block_size);
350 if (ret)
351 goto out;
352 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"blockSize",
353 "%"PRIu64"ll" "u", block_size);
354 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
355
356 memset (key, 0, sizeof (key));
357 snprintf (key, sizeof (key), "brick%d.mnt_options", brick_index);
358 ret = dict_get_str (dict, key, &mnt_options);
359 if (ret)
360 goto out;
361 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"mntOptions",
362 "%s", mnt_options);
363 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
364
365 memset (key, 0, sizeof (key));
366 snprintf (key, sizeof (key), "brick%d.fs_name", brick_index);
367 ret = dict_get_str (dict, key, &fs_name);
368 if (ret)
369 goto out;
370 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"fsName",
371 "%s", fs_name);
372 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
373
374 /* inode details are only available for ext 2/3/4 & xfs */
375 if (!IS_EXT_FS(fs_name)(!strcmp (fs_name, "ext2") || !strcmp (fs_name, "ext3") || !strcmp
(fs_name, "ext4"))
|| strcmp (fs_name, "xfs")) {
376 ret = 0;
377 goto out;
378 }
379
380 memset (key, 0, sizeof (key));
381 snprintf (key, sizeof (key), "brick%d.inode_size", brick_index);
382 ret = dict_get_str (dict, key, &inode_size);
383 if (ret)
384 goto out;
385 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"inodeSize",
386 "%s", fs_name);
387 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
388
389 memset (key, 0, sizeof (key));
390 snprintf (key, sizeof (key), "brick%d.total_inodes", brick_index);
391 ret = dict_get_uint64 (dict, key, &inodes_total);
392 if (ret)
393 goto out;
394 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"inodesTotal",
395 "%"PRIu64"ll" "u", inodes_total);
396 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
397
398 memset (key, 0, sizeof (key));
399 snprintf (key, sizeof (key), "brick%d.free_inodes", brick_index);
400 ret = dict_get_uint64 (dict, key, &inodes_free);
401 if (ret)
402 goto out;
403 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"inodesFree",
404 "%"PRIu64"ll" "u", inodes_free);
405 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
406
407out:
408 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 408, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
409 return ret;
410}
411
412int
413cli_xml_output_vol_status_mempool (xmlTextWriterPtr writer, dict_t *dict,
414 char *prefix)
415{
416 int ret = -1;
417 int mempool_count = 0;
418 char *name = NULL((void*)0);
419 int hotcount = 0;
420 int coldcount = 0;
421 uint64_t paddedsizeof = 0;
422 uint64_t alloccount = 0;
423 int maxalloc = 0;
424 char key[1024] = {0,};
425 int i = 0;
426
427 /* <mempool> */
428 ret = xmlTextWriterStartElement (writer, (xmlChar *)"mempool");
429 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
430
431 snprintf (key, sizeof (key), "%s.mempool-count", prefix);
432 ret = dict_get_int32 (dict, key, &mempool_count);
433 if (ret)
434 goto out;
435 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
436 "%d", mempool_count);
437 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
438
439 for (i = 0; i < mempool_count; i++) {
440 /* <pool> */
441 ret = xmlTextWriterStartElement (writer, (xmlChar *)"pool");
442 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
443
444 memset (key, 0, sizeof (key));
445 snprintf (key, sizeof (key), "%s.pool%d.name", prefix, i);
446 ret = dict_get_str (dict, key, &name);
447 if (ret)
448 goto out;
449 ret = xmlTextWriterWriteFormatElement (writer,
450 (xmlChar *)"name",
451 "%s", name);
452 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
453
454 memset (key, 0, sizeof (key));
455 snprintf (key, sizeof (key), "%s.pool%d.hotcount", prefix, i);
456 ret = dict_get_int32 (dict, key, &hotcount);
457 if (ret)
458 goto out;
459 ret = xmlTextWriterWriteFormatElement (writer,
460 (xmlChar *)"hotCount",
461 "%d", hotcount);
462 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
463
464 memset (key, 0, sizeof (key));
465 snprintf (key, sizeof (key), "%s.pool%d.coldcount", prefix, i);
466 ret = dict_get_int32 (dict, key, &coldcount);
467 if (ret)
468 goto out;
469 ret = xmlTextWriterWriteFormatElement (writer,
470 (xmlChar *)"coldCount",
471 "%d", coldcount);
472 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
473
474 memset (key, 0, sizeof (key));
475 snprintf (key, sizeof (key), "%s.pool%d.paddedsizeof",
476 prefix, i);
477 ret = dict_get_uint64 (dict, key, &paddedsizeof);
478 if (ret)
479 goto out;
480 ret = xmlTextWriterWriteFormatElement
481 (writer, (xmlChar *)"padddedSizeOf", "%"PRIu64"ll" "u",
482 paddedsizeof);
483 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
484
485 memset (key, 0, sizeof (key));
486 snprintf (key, sizeof (key), "%s.pool%d.alloccount", prefix, i);
487 ret = dict_get_uint64 (dict, key, &alloccount);
488 if (ret)
489 goto out;
490 ret = xmlTextWriterWriteFormatElement (writer,
491 (xmlChar *)"allocCount",
492 "%"PRIu64"ll" "u", alloccount);
493 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
494
495 memset (key, 0, sizeof (key));
496 snprintf (key, sizeof (key), "%s.pool%d.max_alloc", prefix, i);
497 ret = dict_get_int32 (dict, key, &maxalloc);
498 if (ret)
499 goto out;
500 ret = xmlTextWriterWriteFormatElement (writer,
501 (xmlChar *)"maxAlloc",
502 "%d", maxalloc);
503 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
504
505 memset (key, 0, sizeof (key));
506 snprintf (key, sizeof (key), "%s.pool%d.pool-misses", prefix, i);
507 ret = dict_get_uint64 (dict, key, &alloccount);
508 if (ret)
509 goto out;
510 ret = xmlTextWriterWriteFormatElement (writer,
511 (xmlChar *)"poolMisses",
512 "%"PRIu64"ll" "u", alloccount);
513 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
514
515 memset (key, 0, sizeof (key));
516 snprintf (key, sizeof (key), "%s.pool%d.max-stdalloc", prefix, i);
517 ret = dict_get_int32 (dict, key, &maxalloc);
518 if (ret)
519 goto out;
520 ret = xmlTextWriterWriteFormatElement (writer,
521 (xmlChar *)"maxStdAlloc",
522 "%d", maxalloc);
523 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
524
525
526 /* </pool> */
527 ret = xmlTextWriterEndElement (writer);
528 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
529 }
530
531 /* </mempool> */
532 ret = xmlTextWriterEndElement (writer);
533 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
534
535out:
536 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 536, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
537 return ret;
538}
539
540int
541cli_xml_output_vol_status_mem (xmlTextWriterPtr writer, dict_t *dict,
542 int brick_index)
543{
544 int ret = -1;
545 int arena = 0;
546 int ordblks = 0;
547 int smblks = 0;
548 int hblks = 0;
549 int hblkhd = 0;
550 int usmblks = 0;
551 int fsmblks = 0;
552 int uordblks = 0;
553 int fordblks = 0;
554 int keepcost = 0;
555 char key[1024] = {0,};
556
557 /* <memStatus> */
558 ret = xmlTextWriterStartElement (writer, (xmlChar *)"memStatus");
559 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
560
561 /* <mallinfo> */
562 ret = xmlTextWriterStartElement (writer, (xmlChar *)"mallinfo");
563 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
564
565 snprintf (key, sizeof (key), "brick%d.mallinfo.arena", brick_index);
566 ret = dict_get_int32 (dict, key, &arena);
567 if (ret)
568 goto out;
569 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"arena",
570 "%d", arena);
571 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
572
573 memset (key, 0, sizeof (key));
574 snprintf (key, sizeof (key), "brick%d.mallinfo.ordblks", brick_index);
575 ret = dict_get_int32 (dict, key, &ordblks);
576 if (ret)
577 goto out;
578 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"ordblks",
579 "%d", ordblks);
580 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
581
582 memset (key, 0, sizeof (key));
583 snprintf (key, sizeof (key), "brick%d.mallinfo.smblks", brick_index);
584 ret = dict_get_int32 (dict, key, &smblks);
585 if (ret)
586 goto out;
587 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"smblks",
588 "%d", smblks);
589 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
590
591 memset (key, 0, sizeof (key));
592 snprintf (key, sizeof (key), "brick%d.mallinfo.hblks", brick_index);
593 ret = dict_get_int32 (dict, key, &hblks);
594 if (ret)
595 goto out;
596 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hblks",
597 "%d", hblks);
598 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
599
600 memset (key, 0, sizeof (key));
601 snprintf (key, sizeof (key), "brick%d.mallinfo.hblkhd", brick_index);
602 ret = dict_get_int32 (dict, key, &hblkhd);
603 if (ret)
604 goto out;
605 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"hblkhd",
606 "%d", hblkhd);
607 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
608
609 memset (key, 0, sizeof (key));
610 snprintf (key, sizeof (key), "brick%d.mallinfo.usmblks", brick_index);
611 ret = dict_get_int32 (dict, key, &usmblks);
612 if (ret)
613 goto out;
614 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"usmblks",
615 "%d", usmblks);
616 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
617
618 memset (key, 0, sizeof (key));
619 snprintf (key, sizeof (key), "brick%d.mallinfo.fsmblks", brick_index);
620 ret = dict_get_int32 (dict, key, &fsmblks);
621 if (ret)
622 goto out;
623 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"fsmblks",
624 "%d", fsmblks);
625 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
626
627 memset (key, 0, sizeof (key));
628 snprintf (key, sizeof (key), "brick%d.mallinfo.uordblks", brick_index);
629 ret = dict_get_int32 (dict, key, &uordblks);
630 if (ret)
631 goto out;
632 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"uordblks",
633 "%d", uordblks);
634 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
635
636 memset (key, 0, sizeof (key));
637 snprintf (key, sizeof (key), "brick%d.mallinfo.fordblks", brick_index);
638 ret = dict_get_int32 (dict, key, &fordblks);
639 if (ret)
640 goto out;
641 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"fordblks",
642 "%d", fordblks);
643 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
644
645 memset (key, 0, sizeof (key));
646 snprintf (key, sizeof (key), "brick%d.mallinfo.keepcost", brick_index);
647 ret = dict_get_int32 (dict, key, &keepcost);
648 if (ret)
649 goto out;
650 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"keepcost",
651 "%d", keepcost);
652 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
653
654 /* </mallinfo> */
655 ret = xmlTextWriterEndElement (writer);
656 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
657
658 memset (key, 0, sizeof (key));
659 snprintf (key, sizeof (key), "brick%d", brick_index);
660 ret = cli_xml_output_vol_status_mempool (writer, dict, key);
661 if (ret)
662 goto out;
663
664 /* </memStatus> */
665 ret = xmlTextWriterEndElement (writer);
666 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
667
668out:
669 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 669, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
670 return ret;
671}
672
673int
674cli_xml_output_vol_status_clients (xmlTextWriterPtr writer, dict_t *dict,
675 int brick_index)
676{
677 int ret = -1;
678 int client_count = 0;
679 char *hostname = NULL((void*)0);
680 uint64_t bytes_read = 0;
681 uint64_t bytes_write = 0;
682 char key[1024] = {0,};
683 int i = 0;
684
685 /* <clientsStatus> */
686 ret = xmlTextWriterStartElement (writer, (xmlChar *)"clientsStatus");
687 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
688
689 snprintf (key, sizeof (key), "brick%d.clientcount", brick_index);
690 ret = dict_get_int32 (dict, key, &client_count);
691 if (ret)
692 goto out;
693 ret = xmlTextWriterWriteFormatElement (writer,
694 (xmlChar *)"clientCount",
695 "%d", client_count);
696 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
697
698 for (i = 0; i < client_count; i++) {
699 /* <client> */
700 ret = xmlTextWriterStartElement (writer, (xmlChar *)"client");
701 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
702
703 memset (key, 0, sizeof (key));
704 snprintf (key, sizeof (key), "brick%d.client%d.hostname",
705 brick_index, i);
706 ret = dict_get_str (dict, key, &hostname);
707 if (ret)
708 goto out;
709 ret = xmlTextWriterWriteFormatElement (writer,
710 (xmlChar *)"hostname",
711 "%s", hostname);
712 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
713
714 memset (key, 0, sizeof (key));
715 snprintf (key, sizeof (key), "brick%d.client%d.bytesread",
716 brick_index, i);
717 ret = dict_get_uint64 (dict, key, &bytes_read);
718 if (ret)
719 goto out;
720 ret = xmlTextWriterWriteFormatElement (writer,
721 (xmlChar *)"bytesRead",
722 "%"PRIu64"ll" "u", bytes_read);
723 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
724
725 memset (key, 0, sizeof (key));
726 snprintf (key, sizeof (key), "brick%d.client%d.byteswrite",
727 brick_index, i);
728 ret = dict_get_uint64 (dict, key, &bytes_write);
729 if (ret)
730 goto out;
731 ret = xmlTextWriterWriteFormatElement (writer,
732 (xmlChar *)"bytesWrite",
733 "%"PRIu64"ll" "u", bytes_write);
734 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
735
736 /* </client> */
737 ret = xmlTextWriterEndElement (writer);
738 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
739 }
740
741 /* </clientsStatus> */
742 ret = xmlTextWriterEndElement (writer);
743 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
744out:
745 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 745, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
746 return ret;
747}
748
749int
750cli_xml_output_vol_status_inode_entry (xmlTextWriterPtr writer, dict_t *dict,
751 char *prefix)
752{
753 int ret = -1;
754 char *gfid = NULL((void*)0);
755 uint64_t nlookup = 0;
756 uint32_t ref = 0;
757 int ia_type = 0;
758 char key[1024] = {0,};
759
760 /* <inode> */
761 ret = xmlTextWriterStartElement (writer, (xmlChar *)"inode");
762 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
763
764 snprintf (key, sizeof (key), "%s.gfid", prefix);
765 ret = dict_get_str (dict, key, &gfid);
766 if (ret)
767 goto out;
768 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"gfid",
769 "%s", gfid);
770 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
771
772 memset (key,0, sizeof (key));
773 snprintf (key, sizeof (key), "%s.nlookup", prefix);
774 ret = dict_get_uint64 (dict, key, &nlookup);
775 if (ret)
776 goto out;
777 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nLookup",
778 "%"PRIu64"ll" "u", nlookup);
779 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
780
781 memset (key,0, sizeof (key));
782 snprintf (key, sizeof (key), "%s.ref", prefix);
783 ret = dict_get_uint32 (dict, key, &ref);
784 if (ret)
785 goto out;
786 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"ref",
787 "%"PRIu32"u", ref);
788 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
789
790 memset (key,0, sizeof (key));
791 snprintf (key, sizeof (key), "%s.ia_type", prefix);
792 ret = dict_get_int32 (dict, key, &ia_type);
793 if (ret)
794 goto out;
795 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"iaType",
796 "%d", ia_type);
797 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
798
799 /* </inode> */
800 ret = xmlTextWriterEndElement (writer);
801 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
802
803out:
804 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 804, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
805 return ret;
806}
807
808int
809cli_xml_output_vol_status_itable (xmlTextWriterPtr writer, dict_t *dict,
810 char *prefix)
811{
812 int ret = -1;
813 uint32_t active_size = 0;
814 uint32_t lru_size = 0;
815 uint32_t purge_size = 0;
816 char key[1024] = {0,};
817 int i = 0;
818
819 snprintf (key, sizeof (key), "%s.active_size", prefix);
820 ret = dict_get_uint32 (dict, key, &active_size);
821 if (ret)
822 goto out;
823 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"activeSize",
824 "%"PRIu32"u", active_size);
825 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
826 if (active_size != 0) {
827 /* <active> */
828 ret = xmlTextWriterStartElement (writer, (xmlChar *)"active");
829 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
830
831 for (i = 0; i < active_size; i++) {
832 memset (key, 0, sizeof (key));
833 snprintf (key, sizeof (key), "%s.active%d", prefix, i);
834 ret = cli_xml_output_vol_status_inode_entry
835 (writer, dict, key);
836 if (ret)
837 goto out;
838 }
839 /* </active> */
840 ret = xmlTextWriterEndElement (writer);
841 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
842 }
843
844 memset (key, 0, sizeof (key));
845 snprintf (key, sizeof (key), "%s.lru_size", prefix);
846 ret = dict_get_uint32 (dict, key, &lru_size);
847 if (ret)
848 goto out;
849 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"lruSize",
850 "%"PRIu32"u", lru_size);
851 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
852 if (lru_size != 0) {
853 /* <lru> */
854 ret = xmlTextWriterStartElement (writer, (xmlChar *)"lru");
855 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
856
857 for (i = 0; i < lru_size; i++) {
858 memset (key, 0, sizeof (key));
859 snprintf (key, sizeof (key), "%s.lru%d", prefix, i);
860 ret = cli_xml_output_vol_status_inode_entry
861 (writer, dict, key);
862 if (ret)
863 goto out;
864 }
865 /* </lru> */
866 ret = xmlTextWriterEndElement (writer);
867 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
868 }
869
870 memset (key, 0, sizeof (key));
871 snprintf (key, sizeof (key), "%s.purge_size", prefix);
872 ret = dict_get_uint32 (dict, key, &purge_size);
873 if (ret)
874 goto out;
875 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"purgeSize",
876 "%"PRIu32"u", purge_size);
877 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
878 if (purge_size != 0) {
879 /* <purge> */
880 ret = xmlTextWriterStartElement (writer, (xmlChar *)"purge");
881 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
882
883 for (i = 0; i < purge_size; i++) {
884 memset (key, 0, sizeof (key));
885 snprintf (key, sizeof (key), "%s.purge%d", prefix, i);
886 ret = cli_xml_output_vol_status_inode_entry
887 (writer, dict, key);
888 if (ret)
889 goto out;
890 }
891 /* </purge> */
892 ret = xmlTextWriterEndElement (writer);
893 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
894 }
895
896out:
897 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 897, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
898 return ret;
899}
900
901int
902cli_xml_output_vol_status_inode (xmlTextWriterPtr writer, dict_t *dict,
903 int brick_index)
904{
905 int ret = -1;
906 int conn_count = 0;
907 char key[1024] = {0,};
908 int i = 0;
909
910 /* <inodeStatus> */
911 ret = xmlTextWriterStartElement (writer, (xmlChar *)"inodeStatus");
912 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
913
914 snprintf (key, sizeof (key), "brick%d.conncount", brick_index);
915 ret = dict_get_int32 (dict, key, &conn_count);
916 if (ret)
917 goto out;
918 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"connections",
919 "%d", conn_count);
920 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
921
922 for (i = 0; i < conn_count; i++) {
923 /* <connection> */
924 ret = xmlTextWriterStartElement (writer,
925 (xmlChar *)"connection");
926 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
927
928 memset (key, 0, sizeof (key));
929 snprintf (key, sizeof (key), "brick%d.conn%d.itable",
930 brick_index, i);
931 ret = cli_xml_output_vol_status_itable (writer, dict, key);
932 if (ret)
933 goto out;
934
935 /* </connection> */
936 ret = xmlTextWriterEndElement (writer);
937 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
938 }
939
940 /* </inodeStatus> */
941 ret= xmlTextWriterEndElement (writer);
942 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
943
944out:
945 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 945, GF_LOG_DEBUG,
"Returning %d", ret); } while (0)
;
946 return ret;
947}
948
949int
950cli_xml_output_vol_status_fdtable (xmlTextWriterPtr writer, dict_t *dict,
951 char *prefix)
952{
953 int ret = -1;
954 int refcount = 0;
955 uint32_t maxfds = 0;
956 int firstfree = 0;
957 int openfds = 0;
958 int fd_pid = 0;
959 int fd_refcount = 0;
960 int fd_flags = 0;
961 char key[1024] = {0,};
962 int i = 0;
963
964 /* <fdTable> */
965 ret = xmlTextWriterStartElement (writer, (xmlChar *)"fdTable");
966 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
967
968 snprintf (key, sizeof (key), "%s.refcount", prefix);
969 ret = dict_get_int32 (dict, key, &refcount);
970 if (ret)
971 goto out;
972 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"refCount",
973 "%d", refcount);
974 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
975
976 memset (key, 0, sizeof (key));
977 snprintf (key, sizeof (key), "%s.maxfds", prefix);
978 ret = dict_get_uint32 (dict, key, &maxfds);
979 if (ret)
980 goto out;
981 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"maxFds",
982 "%"PRIu32"u", maxfds);
983 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
984
985 memset (key, 0, sizeof (key));
986 snprintf (key, sizeof (key), "%s.firstfree", prefix);
987 ret = dict_get_int32 (dict, key, &firstfree);
988 if (ret)
989 goto out;
990 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"firstFree",
991 "%d", firstfree);
992 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
993
994 memset (key, 0, sizeof (key));
995 snprintf (key, sizeof (key), "%s.openfds", prefix);
996 ret = dict_get_int32 (dict, key, &openfds);
997 if (ret)
998 goto out;
999 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"openFds",
1000 "%d", openfds);
1001 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1002
1003 for (i = 0; i < maxfds; i++) {
1004 memset (key, 0, sizeof (key));
1005 snprintf (key, sizeof (key), "%s.fdentry%d.pid", prefix, i);
1006 ret = dict_get_int32 (dict, key, &fd_pid);
1007 if (ret)
1008 continue;
1009
1010 memset (key, 0, sizeof (key));
1011 snprintf (key, sizeof (key), "%s.fdentry%d.refcount",
1012 prefix, i);
1013 ret = dict_get_int32 (dict, key, &fd_refcount);
1014 if (ret)
1015 continue;
1016
1017 memset (key, 0, sizeof (key));
1018 snprintf (key, sizeof (key), "%s.fdentry%d.flags", prefix, i);
1019 ret = dict_get_int32 (dict, key, &fd_flags);
1020 if (ret)
1021 continue;
1022
1023 /* <fd> */
1024 ret = xmlTextWriterStartElement (writer, (xmlChar *)"fd");
1025 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1026
1027 ret = xmlTextWriterWriteFormatElement (writer,
1028 (xmlChar *)"entry",
1029 "%d", i+1);
1030 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1031
1032 ret = xmlTextWriterWriteFormatElement (writer,
1033 (xmlChar *)"pid",
1034 "%d", fd_pid);
1035 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1036
1037 ret = xmlTextWriterWriteFormatElement (writer,
1038 (xmlChar *)"refCount",
1039 "%d", fd_refcount);
1040 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1041
1042 ret = xmlTextWriterWriteFormatElement (writer,
1043 (xmlChar *)"flags",
1044 "%d", fd_flags);
1045 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1046
1047 /* </fd> */
1048 ret = xmlTextWriterEndElement (writer);
1049 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1050 }
1051
1052 /* </fdTable> */
1053 ret = xmlTextWriterEndElement (writer);
1054 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1055
1056out:
1057 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1057, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1058 return ret;
1059}
1060
1061int
1062cli_xml_output_vol_status_fd (xmlTextWriterPtr writer, dict_t *dict,
1063 int brick_index)
1064{
1065 int ret = -1;
1066 int conn_count = 0;
1067 char key[1024] = {0,};
1068 int i = 0;
1069
1070 /* <fdStatus> */
1071 ret = xmlTextWriterStartElement (writer, (xmlChar *)"fdStatus");
1072 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1073
1074 snprintf (key, sizeof (key), "brick%d.conncount", brick_index);
1075 ret = dict_get_int32 (dict, key, &conn_count);
1076 if (ret)
1077 goto out;
1078 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"connections",
1079 "%d", conn_count);
1080 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1081
1082 for (i = 0; i < conn_count; i++) {
1083 /* <connection> */
1084 ret = xmlTextWriterStartElement (writer,
1085 (xmlChar *)"connection");
1086 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1087
1088 memset (key, 0, sizeof (key));
1089 snprintf (key, sizeof (key), "brick%d.conn%d.fdtable",
1090 brick_index, i);
1091 ret = cli_xml_output_vol_status_fdtable (writer, dict, key);
1092 if (ret)
1093 goto out;
1094
1095 /* </connection> */
1096 ret = xmlTextWriterEndElement (writer);
1097 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1098 }
1099
1100 /* </fdStatus> */
1101 ret = xmlTextWriterEndElement (writer);
1102 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1103
1104out:
1105 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1105, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1106 return ret;
1107}
1108
1109int
1110cli_xml_output_vol_status_callframe (xmlTextWriterPtr writer, dict_t *dict,
1111 char *prefix)
1112{
1113 int ret = -1;
1114 int ref_count = 0;
1115 char *translator = NULL((void*)0);
1116 int complete = 0;
1117 char *parent = NULL((void*)0);
1118 char *wind_from = NULL((void*)0);
1119 char *wind_to = NULL((void*)0);
1120 char *unwind_from = NULL((void*)0);
1121 char *unwind_to = NULL((void*)0);
1122 char key[1024] = {0,};
1123
1124 /* <callFrame> */
1125 ret = xmlTextWriterStartElement (writer, (xmlChar *)"callFrame");
1126 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1127
1128 snprintf (key, sizeof (key), "%s.refcount", prefix);
1129 ret = dict_get_int32 (dict, key, &ref_count);
1130 if (ret)
1131 goto out;
1132 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"refCount",
1133 "%d", ref_count);
1134 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1135
1136 memset (key, 0, sizeof (key));
1137 snprintf (key, sizeof (key), "%s.translator", prefix);
1138 ret = dict_get_str (dict, key, &translator);
1139 if (ret)
1140 goto out;
1141 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"translator",
1142 "%s", translator);
1143 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1144
1145 memset (key, 0, sizeof (key));
1146 snprintf (key, sizeof (key), "%s.complete", prefix);
1147 ret = dict_get_int32 (dict, key, &complete);
1148 if (ret)
1149 goto out;
1150 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"complete",
1151 "%d", complete);
1152 XML_RET_CHECK_AND_GOTO (ret ,out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1153
1154 memset (key, 0, sizeof (key));
1155 snprintf (key, sizeof (key), "%s.parent", prefix);
1156 ret = dict_get_str (dict, key, &parent);
1157 if (!ret) {
1158 ret = xmlTextWriterWriteFormatElement (writer,
1159 (xmlChar *)"parent",
1160 "%s", parent);
1161 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1162 }
1163
1164 memset (key, 0, sizeof (key));
1165 snprintf (key, sizeof (key), "%s.windfrom", prefix);
1166 ret = dict_get_str (dict, key, &wind_from);
1167 if (!ret) {
1168 ret = xmlTextWriterWriteFormatElement (writer,
1169 (xmlChar *)"windFrom",
1170 "%s", wind_from);
1171 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1172 }
1173
1174 memset (key, 0, sizeof (key));
1175 snprintf (key, sizeof (key), "%s.windto", prefix);
1176 ret = dict_get_str (dict, key, &wind_to);
1177 if (!ret) {
1178 ret = xmlTextWriterWriteFormatElement (writer,
1179 (xmlChar *)"windTo",
1180 "%s", wind_to);
1181 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1182 }
1183
1184 memset (key, 0, sizeof (key));
1185 snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
1186 ret = dict_get_str (dict, key, &unwind_from);
1187 if (!ret) {
1188 ret = xmlTextWriterWriteFormatElement (writer,
1189 (xmlChar *)"unwindFrom",
1190 "%s", unwind_from);
1191 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1192 }
1193
1194 memset (key, 0, sizeof (key));
1195 snprintf (key, sizeof (key), "%s.unwindto", prefix);
1196 ret = dict_get_str (dict, key, &unwind_to);
1197 if (!ret) {
1198 ret = xmlTextWriterWriteFormatElement (writer,
1199 (xmlChar *)"unwindTo",
1200 "%s", unwind_to);
1201 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1202 }
1203
1204 /* </callFrame> */
1205 ret = xmlTextWriterEndElement (writer);
1206 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1207out:
1208 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1208, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1209 return ret;
1210}
1211
1212int
1213cli_xml_output_vol_status_callstack (xmlTextWriterPtr writer, dict_t *dict,
1214 char *prefix)
1215{
1216 int ret = -1;
1217 int uid = 0;
1218 int gid = 0;
1219 int pid = 0;
1220 uint64_t unique = 0;
1221 int frame_count = 0;
1222 char key[1024] = {0,};
1223 int i = 0;
1224
1225 /* <callStack> */
1226 ret = xmlTextWriterStartElement (writer, (xmlChar *)"callStack");
1227 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1228
1229 snprintf (key, sizeof (key), "%s.uid", prefix);
1230 ret = dict_get_int32 (dict, key, &uid);
1231 if (ret)
1232 goto out;
1233 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"uid",
1234 "%d", uid);
1235 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1236
1237 memset (key, 0, sizeof (key));
1238 snprintf (key, sizeof (key), "%s.gid", prefix);
1239 ret = dict_get_int32 (dict, key, &gid);
1240 if (ret)
1241 goto out;
1242 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"gid",
1243 "%d", gid);
1244 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1245
1246 memset (key, 0, sizeof (key));
1247 snprintf (key, sizeof (key), "%s.pid", prefix);
1248 ret = dict_get_int32 (dict, key, &pid);
1249 if (ret)
1250 goto out;
1251 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"pid",
1252 "%d", pid);
1253 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1254
1255 memset (key, 0, sizeof (key));
1256 snprintf (key, sizeof (key), "%s.unique", prefix);
1257 ret = dict_get_uint64 (dict, key, &unique);
1258 if (ret)
1259 goto out;
1260 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"unique",
1261 "%"PRIu64"ll" "u", unique);
1262 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1263
1264 memset (key, 0, sizeof (key));
1265 snprintf (key, sizeof (key), "%s.count", prefix);
1266 ret = dict_get_int32 (dict, key, &frame_count);
1267 if (ret)
1268 goto out;
1269 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"frameCount",
1270 "%d", frame_count);
1271 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1272
1273 for (i = 0; i < frame_count; i++) {
1274 memset (key, 0, sizeof (key));
1275 snprintf (key, sizeof (key), "%s.frame%d", prefix, i);
1276 ret = cli_xml_output_vol_status_callframe (writer, dict,
1277 key);
1278 if (ret)
1279 goto out;
1280 }
1281
1282 /* </callStack> */
1283 ret = xmlTextWriterEndElement (writer);
1284 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1285out:
1286 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1286, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1287 return ret;
1288}
1289
1290int
1291cli_xml_output_vol_status_callpool (xmlTextWriterPtr writer, dict_t *dict,
1292 int brick_index)
1293{
1294 int ret = -1;
1295 int call_count = 0;
1296 char key[1024] = {0,};
1297 int i = 0;
1298
1299 /* <callpoolStatus> */
1300 ret = xmlTextWriterStartElement (writer, (xmlChar *)"callpoolStatus");
1301 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1302
1303 snprintf (key, sizeof (key), "brick%d.callpool.count", brick_index);
1304 ret = dict_get_int32 (dict, key, &call_count);
1305 if (ret)
1306 goto out;
1307 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
1308 "%d", call_count);
1309
1310 for (i = 0; i < call_count; i++) {
1311 memset (key, 0, sizeof (key));
1312 snprintf (key, sizeof (key), "brick%d.callpool.stack%d",
1313 brick_index, i);
1314 ret = cli_xml_output_vol_status_callstack (writer, dict,
1315 key);
1316 if (ret)
1317 goto out;
1318 }
1319
1320 /* </callpoolStatus> */
1321 ret = xmlTextWriterEndElement (writer);
1322 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1323
1324out:
1325 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1325, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1326 return ret;
1327}
1328#endif
1329
1330int
1331cli_xml_output_vol_status_begin (cli_local_t *local, int op_ret, int op_errno,
1332 char *op_errstr)
1333{
1334#if (HAVE_LIB_XML1)
1335 int ret = -1;
1336
1337 ret = cli_begin_xml_output (&(local->writer), &(local->doc));
1338 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1339
1340 ret = cli_xml_output_common (local->writer, op_ret, op_errno,
1341 op_errstr);
1342 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1343
1344 /* <volStatus> */
1345 ret = xmlTextWriterStartElement (local->writer,
1346 (xmlChar *) "volStatus");
1347 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1348
1349 /* <volumes> */
1350 ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volumes");
1351 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1352
1353out:
1354 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1354, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1355 return ret;
1356#else
1357 return 0;
1358#endif
1359}
1360
1361int
1362cli_xml_output_vol_status_end (cli_local_t *local)
1363{
1364#if (HAVE_LIB_XML1)
1365 int ret = -1;
1366
1367 /* </volumes> */
1368 ret = xmlTextWriterEndElement (local->writer);
1369 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1370
1371 /* </volStatus> */
1372 ret = xmlTextWriterEndElement (local->writer);
1373 XML_RET_CHECK_AND_GOTO(ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1374
1375 ret = cli_end_xml_output (local->writer, local->doc);
1376out:
1377 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1377, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1378 return ret;
1379#else
1380 return 0;
1381#endif
1382}
1383
1384#if (HAVE_LIB_XML1)
1385int
1386cli_xml_output_vol_status_tasks (cli_local_t *local, dict_t *dict) {
1387 int ret = -1;
1388 char *task_type = NULL((void*)0);
1389 char *task_id_str = NULL((void*)0);
1390 int status = 0;
1391 int tasks = 0;
1392 char key[1024] = {0,};
1393 int i = 0;
1394
1395 /* <tasks> */
1396 ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"tasks");
1397 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1398
1399 ret = dict_get_int32 (dict, "tasks", &tasks);
1400 if (ret)
1401 goto out;
1402
1403 for (i = 0; i < tasks; i++) {
1404 /* <task> */
1405 ret = xmlTextWriterStartElement (local->writer,
1406 (xmlChar *)"task");
1407 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1408
1409 memset (key, 0, sizeof (key));
1410 snprintf (key, sizeof (key), "task%d.type", i);
1411 ret = dict_get_str (dict, key, &task_type);
1412 if (ret)
1413 goto out;
1414 ret = xmlTextWriterWriteFormatElement (local->writer,
1415 (xmlChar *)"type",
1416 "%s", task_type);
1417 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1418
1419 memset (key, 0, sizeof (key));
1420 snprintf (key, sizeof (key), "task%d.id", i);
1421 ret = dict_get_str (dict, key, &task_id_str);
1422 if (ret)
1423 goto out;
1424 ret = xmlTextWriterWriteFormatElement (local->writer,
1425 (xmlChar *)"id",
1426 "%s", task_id_str);
1427 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1428
1429 memset (key, 0, sizeof (key));
1430 snprintf (key, sizeof (key), "task%d.status", i);
1431 ret = dict_get_int32 (dict, key, &status);
1432 if (ret)
1433 goto out;
1434 ret = xmlTextWriterWriteFormatElement (local->writer,
1435 (xmlChar *)"status",
1436 "%d", status);
1437 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1438
1439 /* </task> */
1440 ret = xmlTextWriterEndElement (local->writer);
1441 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1442 }
1443
1444 /* </tasks> */
1445 ret = xmlTextWriterEndElement (local->writer);
1446
1447
1448out:
1449 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1449, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1450 return ret;
1451}
1452#endif
1453
1454int
1455cli_xml_output_vol_status (cli_local_t *local, dict_t *dict)
1456{
1457#if (HAVE_LIB_XML1)
1458 int ret = -1;
1459 char *volname = NULL((void*)0);
1460 int brick_count = 0;
1461 int brick_index_max = -1;
1462 int other_count = 0;
1463 int index_max = 0;
1464 uint32_t cmd = GF_CLI_STATUS_NONE;
1465 int online = 0;
1466 gf_boolean_t node_present = _gf_true;
1467 int i;
1468
1469
1470 /* <volume> */
1471 ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volume");
1472 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1473
1474 ret = dict_get_str (dict, "volname", &volname);
1475 if (ret)
1476 goto out;
1477 ret = xmlTextWriterWriteFormatElement (local->writer,
1478 (xmlChar *)"volName", "%s",
1479 volname);
1480 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1481
1482 ret = dict_get_int32 (dict, "count", &brick_count);
1483 if (ret)
1484 goto out;
1485 ret = xmlTextWriterWriteFormatElement (local->writer,
1486 (xmlChar *)"nodeCount", "%d",
1487 brick_count);
1488 if (ret)
1489 goto out;
1490
1491 ret = dict_get_uint32 (dict, "cmd", &cmd);
1492 if (ret)
1493 goto out;
1494
1495 ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
1496 if (ret)
1497 goto out;
1498 ret = dict_get_int32 (dict, "other-count", &other_count);
1499 if (ret)
1500 goto out;
1501
1502 index_max = brick_index_max + other_count;
1503
1504 for (i = 0; i <= index_max; i++) {
1505 /* <node> */
1506 ret = xmlTextWriterStartElement (local->writer,
1507 (xmlChar *)"node");
1508 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1509
1510 ret = cli_xml_output_vol_status_common (local->writer, dict, i,
1511 &online, &node_present);
1512 if (ret) {
1513 if (node_present)
1514 goto out;
1515 else
1516 continue;
1517 }
1518
1519 switch (cmd & GF_CLI_STATUS_MASK) {
1520 case GF_CLI_STATUS_DETAIL:
1521 ret = cli_xml_output_vol_status_detail (local->writer,
1522 dict, i);
1523 if (ret)
1524 goto out;
1525 break;
1526
1527 case GF_CLI_STATUS_MEM:
1528 if (online) {
1529 ret = cli_xml_output_vol_status_mem
1530 (local->writer, dict, i);
1531 if (ret)
1532 goto out;
1533 }
1534 break;
1535
1536 case GF_CLI_STATUS_CLIENTS:
1537 if (online) {
1538 ret = cli_xml_output_vol_status_clients
1539 (local->writer, dict, i);
1540 if (ret)
1541 goto out;
1542 }
1543 break;
1544
1545 case GF_CLI_STATUS_INODE:
1546 if (online) {
1547 ret = cli_xml_output_vol_status_inode
1548 (local->writer, dict, i);
1549 if (ret)
1550 goto out;
1551 }
1552 break;
1553
1554 case GF_CLI_STATUS_FD:
1555 if (online) {
1556 ret = cli_xml_output_vol_status_fd
1557 (local->writer, dict, i);
1558 if (ret)
1559 goto out;
1560 }
1561 break;
1562
1563 case GF_CLI_STATUS_CALLPOOL:
1564 if (online) {
1565 ret = cli_xml_output_vol_status_callpool
1566 (local->writer, dict, i);
1567 if (ret)
1568 goto out;
1569 }
1570 break;
1571
1572 default:
1573 break;
1574
1575 }
1576 /* </node> */
1577 ret = xmlTextWriterEndElement (local->writer);
1578 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1579 }
1580
1581 if ((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE) {
1582 ret = cli_xml_output_vol_status_tasks (local, dict);
1583 if (ret)
1584 goto out;
1585 }
1586
1587 /* </volume> */
1588 ret = xmlTextWriterEndElement (local->writer);
1589 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1590
1591out:
1592 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1592, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1593 return ret;
1594#else
1595 return 0;
1596#endif
1597}
1598
1599#if (HAVE_LIB_XML1)
1600int
1601cli_xml_output_vol_top_rw_perf (xmlTextWriterPtr writer, dict_t *dict,
1602 int brick_index, int member_index)
1603{
1604 int ret = -1;
1605 char *filename = NULL((void*)0);
1606 uint64_t throughput = 0;
1607 long int time_sec = 0;
1608 long int time_usec = 0;
1609 char timestr[256] = {0,};
1610 char key[1024] = {0,};
1611
1612 /* <file> */
1613 ret = xmlTextWriterStartElement (writer, (xmlChar *)"file");
1614 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1615
1616 snprintf (key, sizeof (key), "%d-filename-%d", brick_index,
1617 member_index);
1618 ret = dict_get_str (dict, key, &filename);
1619 if (ret)
1620 goto out;
1621 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"filename",
1622 "%s", filename);
1623 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1624
1625 memset (key, 0, sizeof (key));
1626 snprintf (key, sizeof (key), "%d-value-%d", brick_index, member_index);
1627 ret = dict_get_uint64 (dict, key, &throughput);
1628 if (ret)
1629 goto out;
1630 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
1631 "%"PRIu64"ll" "u", throughput);
1632 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1633
1634 memset (key, 0, sizeof (key));
1635 snprintf (key, sizeof (key), "%d-time-sec-%d", brick_index,
1636 member_index);
1637 ret = dict_get_int32 (dict, key, (int32_t *)&time_sec);
1638 if (ret)
1639 goto out;
1640
1641 memset (key, 0, sizeof (key));
1642 snprintf (key, sizeof (key), "%d-time-usec-%d", brick_index,
1643 member_index);
1644 ret = dict_get_int32 (dict, key, (int32_t *)&time_usec);
1645 if (ret)
1646 goto out;
1647
1648 gf_time_fmt (timestr, sizeof timestr, time_sec, gf_timefmt_FT);
1649 snprintf (timestr + strlen (timestr),
1650 sizeof timestr - strlen (timestr),
1651 ".%"GF_PRI_SUSECONDS"06ld", time_usec);
1652 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"time",
1653 "%s", timestr);
1654 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1655
1656 /* </file> */
1657 ret = xmlTextWriterEndElement (writer);
1658 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1659
1660out:
1661 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1661, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1662 return ret;
1663}
1664
1665int
1666cli_xml_output_vol_top_other (xmlTextWriterPtr writer, dict_t *dict,
1667 int brick_index, int member_index)
1668{
1669 int ret = -1;
1670 char *filename = NULL((void*)0);
1671 uint64_t count = 0;
1672 char key[1024] = {0,};
1673
1674 /* <file> */
1675 ret = xmlTextWriterStartElement (writer, (xmlChar *)"file");
1676 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1677
1678 snprintf (key, sizeof (key), "%d-filename-%d", brick_index,
1679 member_index);
1680 ret = dict_get_str (dict, key, &filename);
1681 if (ret)
1682 goto out;
1683 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"filename",
1684 "%s", filename);
1685 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1686
1687 memset (key, 0, sizeof (key));
1688 snprintf (key, sizeof (key), "%d-value-%d", brick_index, member_index);
1689 ret = dict_get_uint64 (dict, key, &count);
1690 if (ret)
1691 goto out;
1692 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
1693 "%"PRIu64"ll" "u", count);
1694 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1695
1696 /* </file> */
1697 ret = xmlTextWriterEndElement (writer);
1698 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1699
1700out:
1701 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1701, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1702 return ret;
1703}
1704#endif
1705
1706int
1707cli_xml_output_vol_top (dict_t *dict, int op_ret, int op_errno,
1708 char *op_errstr)
1709{
1710#if (HAVE_LIB_XML1)
1711 int ret = -1;
1712 xmlTextWriterPtr writer = NULL((void*)0);
1713 xmlDocPtr doc = NULL((void*)0);
1714 int brick_count = 0;
1715 int top_op = GF_CLI_TOP_NONE;
1716 char *brick_name = NULL((void*)0);
1717 int members = 0;
1718 uint64_t current_open = 0;
1719 uint64_t max_open = 0;
1720 char *max_open_time = NULL((void*)0);
1721 double throughput = 0.0;
1722 double time_taken = 0.0;
1723 char key[1024] = {0,};
1724 int i = 0;
1725 int j = 0;
1726
1727 ret = cli_begin_xml_output (&writer, &doc);
1728 if (ret)
1729 goto out;
1730
1731 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
1732 if (ret)
1733 goto out;
1734
1735 /* <volTop> */
1736 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volTop");
1737 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1738
1739 ret = dict_get_int32 (dict, "count", &brick_count);
1740 if (ret)
1741 goto out;
1742 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"brickCount",
1743 "%d", brick_count);
1744 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1745
1746 ret = dict_get_int32 (dict, "1-top-op", &top_op);
1747 if (ret)
1748 goto out;
1749 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"topOp",
1750 "%d", top_op);
1751 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1752
1753 while (i < brick_count) {
1754 i++;
1755
1756 /* <brick> */
1757 ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
1758 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1759
1760 memset (key, 0, sizeof (key));
1761 snprintf (key, sizeof (key), "%d-brick", i);
1762 ret = dict_get_str (dict, key, &brick_name);
1763 if (ret)
1764 goto out;
1765 ret = xmlTextWriterWriteFormatElement (writer,
1766 (xmlChar *)"name",
1767 "%s", brick_name);
1768 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1769
1770 memset (key, 0, sizeof (key));
1771 snprintf (key , sizeof (key), "%d-members", i);
1772 ret = dict_get_int32 (dict, key, &members);
1773 if (ret)
1774 goto out;
1775 ret = xmlTextWriterWriteFormatElement (writer,
1776 (xmlChar *)"members",
1777 "%d", members);
1778 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1779
1780 switch (top_op) {
1781 case GF_CLI_TOP_OPEN:
1782 memset (key, 0, sizeof (key));
1783 snprintf (key, sizeof (key), "%d-current-open", i);
1784 ret = dict_get_uint64 (dict, key, &current_open);
1785 if (ret)
1786 goto out;
1787 ret = xmlTextWriterWriteFormatElement
1788 (writer, (xmlChar *)"currentOpen", "%"PRIu64"ll" "u",
1789 current_open);
1790 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1791
1792 memset (key, 0, sizeof (key));
1793 snprintf (key, sizeof (key), "%d-max-open", i);
1794 ret = dict_get_uint64 (dict, key, &max_open);
1795 if (ret)
1796 goto out;
1797 ret = xmlTextWriterWriteFormatElement
1798 (writer, (xmlChar *)"maxOpen", "%"PRIu64"ll" "u",
1799 max_open);
1800 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1801
1802 memset (key, 0, sizeof (key));
1803 snprintf (key, sizeof (key), "%d-max-openfd-time", i);
1804 ret = dict_get_str (dict, key, &max_open_time);
1805 if (ret)
1806 goto out;
1807 ret = xmlTextWriterWriteFormatElement
1808 (writer, (xmlChar *)"maxOpenTime", "%s",
1809 max_open_time);
1810 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1811
1812 case GF_CLI_TOP_READ:
1813 case GF_CLI_TOP_WRITE:
1814 case GF_CLI_TOP_OPENDIR:
1815 case GF_CLI_TOP_READDIR:
1816
1817 break;
1818
1819 case GF_CLI_TOP_READ_PERF:
1820 case GF_CLI_TOP_WRITE_PERF:
1821 memset (key, 0, sizeof (key));
1822 snprintf (key, sizeof (key), "%d-throughput", i);
1823 ret = dict_get_double (dict, key, &throughput);
1824 if (!ret) {
1825 memset (key, 0, sizeof (key));
1826 snprintf (key, sizeof (key), "%d-time", i);
1827 ret = dict_get_double (dict, key, &time_taken);
1828 }
1829
1830 if (!ret) {
1831 ret = xmlTextWriterWriteFormatElement
1832 (writer, (xmlChar *)"throughput",
1833 "%f", throughput);
1834 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1835
1836 ret = xmlTextWriterWriteFormatElement
1837 (writer, (xmlChar *)"timeTaken",
1838 "%f", time_taken);
1839 }
1840
1841 break;
1842
1843 default:
1844 ret = -1;
1845 goto out;
1846 }
1847
1848 for (j = 1; j <= members; j++) {
1849 if (top_op == GF_CLI_TOP_READ_PERF ||
1850 top_op == GF_CLI_TOP_WRITE_PERF) {
1851 ret = cli_xml_output_vol_top_rw_perf
1852 (writer, dict, i, j);
1853 } else {
1854 ret = cli_xml_output_vol_top_other
1855 (writer, dict, i, j);
1856 }
1857 if (ret)
1858 goto out;
1859 }
1860
1861
1862 /* </brick> */
1863 ret = xmlTextWriterEndElement (writer);
1864 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1865 }
1866
1867 /* </volTop> */
1868 ret = xmlTextWriterEndElement (writer);
1869 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1870 ret = cli_end_xml_output (writer, doc);
1871
1872out:
1873 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 1873, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1874 return ret;
1875#else
1876 return 0;
1877#endif
1878}
1879
1880#if (HAVE_LIB_XML1)
1881int
1882cli_xml_output_vol_profile_stats (xmlTextWriterPtr writer, dict_t *dict,
1883 int brick_index, int interval)
1884{
1885 int ret = -1;
1886 uint64_t read_count = 0;
1887 uint64_t write_count = 0;
1888 uint64_t hits = 0;
1889 double avg_latency = 0.0;
1890 double max_latency = 0.0;
1891 double min_latency = 0.0;
1892 uint64_t duration = 0;
1893 uint64_t total_read = 0;
1894 uint64_t total_write = 0;
1895 char key[1024] = {0};
1896 int i = 0;
1897
1898 /* <cumulativeStats> || <intervalStats> */
1899 if (interval == -1)
1900 ret = xmlTextWriterStartElement (writer,
1901 (xmlChar *)"cumulativeStats");
1902 else
1903 ret = xmlTextWriterStartElement (writer,
1904 (xmlChar *)"intervalStats");
1905 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1906
1907 /* <blockStats> */
1908 ret = xmlTextWriterStartElement (writer, (xmlChar *)"blockStats");
1909 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1910
1911 for (i = 0; i < 32; i++) {
1912 /* <block> */
1913 ret = xmlTextWriterStartElement (writer, (xmlChar *)"block");
1914 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1915
1916 ret = xmlTextWriterWriteFormatElement
1917 (writer, (xmlChar *)"size", "%"PRIu32"u", (1 << i));
1918 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1919
1920 memset (key, 0, sizeof (key));
1921 snprintf (key, sizeof (key), "%d-%d-read-%d", brick_index,
1922 interval, (1 << i));
1923 ret = dict_get_uint64 (dict, key, &read_count);
1924 if (ret)
1925 read_count = 0;
1926 ret = xmlTextWriterWriteFormatElement
1927 (writer, (xmlChar *)"reads", "%"PRIu64"ll" "u", read_count);
1928 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1929
1930 memset (key, 0, sizeof (key));
1931 snprintf (key, sizeof (key), "%d-%d-write-%d", brick_index,
1932 interval, (1 << i));
1933 ret = dict_get_uint64 (dict, key, &write_count);
1934 if (ret)
1935 write_count = 0;
1936 ret = xmlTextWriterWriteFormatElement
1937 (writer, (xmlChar *)"writes", "%"PRIu64"ll" "u", write_count);
1938 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1939
1940 /* </block> */
1941 ret = xmlTextWriterEndElement (writer);
1942 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1943 }
1944
1945 /* </blockStats> */
1946 ret = xmlTextWriterEndElement (writer);
1947 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1948
1949 /* <fopStats> */
1950 ret = xmlTextWriterStartElement (writer, (xmlChar *)"fopStats");
1951 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1952
1953 for (i = 0; i < GF_FOP_MAXVALUE; i++) {
1954 memset (key, 0, sizeof (key));
1955 snprintf (key, sizeof (key), "%d-%d-%d-hits", brick_index,
1956 interval, i);
1957 ret = dict_get_uint64 (dict, key, &hits);
1958 if (ret)
1959 goto cont;
1960
1961 memset (key, 0, sizeof (key));
1962 snprintf (key, sizeof (key), "%d-%d-%d-avglatency", brick_index,
1963 interval, i);
1964 ret = dict_get_double (dict, key, &avg_latency);
1965 if (ret)
1966 goto cont;
1967
1968 memset (key, 0, sizeof (key));
1969 snprintf (key, sizeof (key), "%d-%d-%d-minlatency", brick_index,
1970 interval, i);
1971 ret = dict_get_double (dict, key, &min_latency);
1972 if (ret)
1973 goto cont;
1974
1975 memset (key, 0, sizeof (key));
1976 snprintf (key, sizeof (key), "%d-%d-%d-maxlatency", brick_index,
1977 interval, i);
1978 ret = dict_get_double (dict, key, &max_latency);
1979 if (ret)
1980 goto cont;
1981
1982 /* <fop> */
1983 ret = xmlTextWriterStartElement (writer, (xmlChar *)"fop");
1984 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1985
1986 ret = xmlTextWriterWriteFormatElement
1987 (writer, (xmlChar *)"name","%s", gf_fop_list[i]);
1988 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1989
1990 ret = xmlTextWriterWriteFormatElement
1991 (writer, (xmlChar *)"hits", "%"PRIu64"ll" "u", hits);
1992 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1993
1994 ret = xmlTextWriterWriteFormatElement
1995 (writer, (xmlChar *)"avgLatency", "%f", avg_latency);
1996 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
1997
1998 ret = xmlTextWriterWriteFormatElement
1999 (writer, (xmlChar *)"minLatency", "%f", min_latency);
2000 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2001
2002 ret = xmlTextWriterWriteFormatElement
2003 (writer, (xmlChar *)"maxLatency", "%f", max_latency);
2004 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2005
2006 /* </fop> */
2007 ret = xmlTextWriterEndElement (writer);
2008 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2009
2010cont:
2011 hits = 0;
2012 avg_latency = 0.0;
2013 min_latency = 0.0;
2014 max_latency = 0.0;
2015 }
2016
2017 /* </fopStats> */
2018 ret = xmlTextWriterEndElement (writer);
2019 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2020
2021 memset (key, 0, sizeof (key));
2022 snprintf (key, sizeof (key), "%d-%d-duration", brick_index, interval);
2023 ret = dict_get_uint64 (dict, key, &duration);
2024 if (ret)
2025 goto out;
2026 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"duration",
2027 "%"PRIu64"ll" "u", duration);
2028 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2029
2030 memset (key, 0, sizeof (key));
2031 snprintf (key, sizeof (key), "%d-%d-total-read", brick_index, interval);
2032 ret = dict_get_uint64 (dict, key, &total_read);
2033 if (ret)
2034 goto out;
2035 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"totalRead",
2036 "%"PRIu64"ll" "u", total_read);
2037 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2038
2039 memset (key, 0, sizeof (key));
2040 snprintf (key, sizeof (key), "%d-%d-total-write", brick_index, interval);
2041 ret = dict_get_uint64 (dict, key, &total_write);
2042 if (ret)
2043 goto out;
2044 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"totalWrite",
2045 "%"PRIu64"ll" "u", total_write);
2046 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2047
2048 /* </cumulativeStats> || </intervalStats> */
2049 ret = xmlTextWriterEndElement (writer);
2050 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2051
2052out:
2053 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2053, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2054 return ret;
2055}
2056#endif
2057
2058int
2059cli_xml_output_vol_profile (dict_t *dict, int op_ret, int op_errno,
2060 char *op_errstr)
2061{
2062#if (HAVE_LIB_XML1)
2063 int ret = -1;
2064 xmlTextWriterPtr writer = NULL((void*)0);
2065 xmlDocPtr doc = NULL((void*)0);
2066 char *volname = NULL((void*)0);
2067 int op = GF_CLI_STATS_NONE;
2068 int brick_count = 0;
2069 char *brick_name = NULL((void*)0);
2070 int interval = 0;
2071 char key[1024] = {0,};
2072 int i = 0;
2073
2074 ret = cli_begin_xml_output (&writer, &doc);
2075 if (ret)
2076 goto out;
2077
2078 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
2079 if (ret)
2080 goto out;
2081
2082 /* <volProfile> */
2083 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volProfile");
2084 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2085
2086 ret = dict_get_str (dict, "volname", &volname);
2087 if (ret)
2088 goto out;
2089 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"volname",
2090 "%s", volname);
2091 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2092
2093 ret = dict_get_int32 (dict, "op", &op);
2094 if (ret)
2095 goto out;
2096 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"profileOp",
2097 "%d", op);
2098 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2099
2100 if (op != GF_CLI_STATS_INFO)
2101 goto cont;
2102
2103 ret = dict_get_int32 (dict, "count", &brick_count);
2104 if (ret)
2105 goto out;
2106 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"brickCount",
2107 "%d", brick_count);
2108 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2109
2110 while (i < brick_count) {
2111 i++;
2112
2113 /* <brick> */
2114 ret = xmlTextWriterStartElement (writer, (xmlChar *)"brick");
2115 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2116
2117 snprintf (key, sizeof (key), "%d-brick", i);
2118 ret = dict_get_str (dict, key, &brick_name);
2119 if (ret)
2120 goto out;
2121 ret = xmlTextWriterWriteFormatElement
2122 (writer, (xmlChar *)"brickName", "%s", brick_name);
2123 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2124
2125 snprintf (key, sizeof (key), "%d-cumulative", i);
2126 ret = dict_get_int32 (dict, key, &interval);
2127 if (ret == 0) {
2128 ret = cli_xml_output_vol_profile_stats
2129 (writer, dict, i, interval);
2130 if (ret)
2131 goto out;
2132 }
2133
2134 memset (key, 0, sizeof (key));
2135 snprintf (key, sizeof (key), "%d-interval", i);
2136 ret = dict_get_int32 (dict, key, &interval);
2137 if (ret == 0) {
2138 ret = cli_xml_output_vol_profile_stats
2139 (writer, dict, i, interval);
2140 if (ret)
2141 goto out;
2142 }
2143
2144 /* </brick> */
2145 ret = xmlTextWriterEndElement (writer);
2146 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2147 }
2148
2149cont:
2150 /* </volProfile> */
2151 ret = xmlTextWriterEndElement (writer);
2152 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2153
2154 ret = cli_end_xml_output (writer, doc);
2155out:
2156 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2156, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2157 return ret;
2158#else
2159 return 0;
2160#endif
2161}
2162
2163int
2164cli_xml_output_vol_list (dict_t *dict, int op_ret, int op_errno,
2165 char *op_errstr)
2166{
2167#if (HAVE_LIB_XML1)
2168 int ret = -1;
2169 xmlTextWriterPtr writer = NULL((void*)0);
2170 xmlDocPtr doc = NULL((void*)0);
2171 int count = 0;
2172 char *volname = NULL((void*)0);
2173 char key[1024] = {0,};
2174 int i = 0;
2175
2176 ret = cli_begin_xml_output (&writer, &doc);
2177 if (ret)
2178 goto out;
2179
2180 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
2181 if (ret)
2182 goto out;
2183
2184 /* <volList> */
2185 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volList");
2186 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2187
2188 ret = dict_get_int32 (dict, "count", &count);
2189 if (ret)
2190 goto out;
2191 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"count",
2192 "%d", count);
2193 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2194
2195 for (i = 0; i < count; i++) {
2196 memset (key, 0, sizeof (key));
2197 snprintf (key, sizeof (key), "volume%d", i);
2198 ret = dict_get_str (dict, key, &volname);
2199 if (ret)
2200 goto out;
2201 ret = xmlTextWriterWriteFormatElement (writer,
2202 (xmlChar *)"volume",
2203 "%s", volname);
2204 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2205 }
2206
2207 /* </volList> */
2208 ret = xmlTextWriterEndElement (writer);
2209 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2210
2211 ret = cli_end_xml_output (writer, doc);
2212out:
2213 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2213, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2214 return ret;
2215#else
2216 return 0;
2217#endif
2218}
2219
2220#if (HAVE_LIB_XML1)
2221int
2222cli_xml_output_vol_info_option (xmlTextWriterPtr writer, char *substr,
2223 char *optstr, char *valstr)
2224{
2225 int ret = -1;
2226 char *ptr1 = NULL((void*)0);
2227 char *ptr2 = NULL((void*)0);
2228
2229 ptr1 = substr;
2230 ptr2 = optstr;
2231
2232 while (ptr1) {
2233 if (*ptr1 != *ptr2)
2234 break;
2235 ptr1++;
2236 ptr2++;
2237 if (!ptr1)
2238 goto out;
2239 if (!ptr2)
2240 goto out;
2241 }
2242 if (*ptr2 == '\0')
2243 goto out;
2244
2245 /* <option> */
2246 ret = xmlTextWriterStartElement (writer, (xmlChar *)"option");
2247 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2248
2249 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"name",
2250 "%s", ptr2);
2251 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2252
2253 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"value",
2254 "%s", valstr);
2255 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2256
2257 /* </option> */
2258 ret = xmlTextWriterEndElement (writer);
2259 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2260out:
2261 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2261, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2262 return ret;
2263}
2264
2265struct tmp_xml_option_logger {
2266 char *key;
2267 xmlTextWriterPtr writer;
2268};
2269
2270static int
2271_output_vol_info_option (dict_t *d, char *k, data_t *v,
2272 void *data)
2273{
2274 int ret = 0;
2275 char *ptr = NULL((void*)0);
2276 struct tmp_xml_option_logger *tmp = NULL((void*)0);
2277
2278 tmp = data;
2279
2280 ptr = strstr (k, "option.");
2281 if (!ptr)
2282 goto out;
2283
2284 if (!v) {
2285 ret = -1;
2286 goto out;
2287 }
2288 ret = cli_xml_output_vol_info_option (tmp->writer, tmp->key, k,
2289 v->data);
2290
2291out:
2292 return ret;
2293}
2294
2295int
2296cli_xml_output_vol_info_options (xmlTextWriterPtr writer, dict_t *dict,
2297 char *prefix)
2298{
2299 int ret = -1;
2300 int opt_count = 0;
2301 char key[1024] = {0,};
2302 struct tmp_xml_option_logger tmp = {0,};
2303
2304 snprintf (key, sizeof (key), "%s.opt_count", prefix);
2305 ret = dict_get_int32 (dict, key, &opt_count);
2306 if (ret)
2307 goto out;
2308 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"optCount",
2309 "%d", opt_count);
2310 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2311
2312 /* <options> */
2313 ret = xmlTextWriterStartElement (writer, (xmlChar *)"options");
2314 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2315 snprintf (key, sizeof (key), "%s.option.", prefix);
2316
2317 tmp.key = key;
2318 tmp.writer = writer;
2319 ret = dict_foreach (dict, _output_vol_info_option, &tmp);
2320 if (ret)
2321 goto out;
2322
2323 /* </options> */
2324 ret = xmlTextWriterEndElement (writer);
2325 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2326out:
2327 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2327, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2328 return ret;
2329}
2330#endif
2331
2332int
2333cli_xml_output_vol_info (cli_local_t *local, dict_t *dict)
2334{
2335#if (HAVE_LIB_XML1)
2336 int ret = 0;
2337 int count = 0;
2338 char *volname = NULL((void*)0);
2339 char *volume_id = NULL((void*)0);
2340 int type = 0;
2341 int status = 0;
2342 int brick_count = 0;
2343 int dist_count = 0;
2344 int stripe_count = 0;
2345 int replica_count = 0;
2346 int transport = 0;
2347 char *brick = NULL((void*)0);
2348 char key[1024] = {0,};
2349 int i = 0;
2350 int j = 1;
2351
2352
2353 ret = dict_get_int32 (dict, "count", &count);
2354 if (ret)
2355 goto out;
2356
2357 for (i = 0; i < count; i++) {
2358 /* <volume> */
2359 ret = xmlTextWriterStartElement (local->writer,
2360 (xmlChar *)"volume");
2361 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2362
2363 memset (key, 0, sizeof (key));
2364 snprintf (key, sizeof (key), "volume%d.name", i);
2365 ret = dict_get_str (dict, key, &volname);
2366 if (ret)
2367 goto out;
2368 ret = xmlTextWriterWriteFormatElement (local->writer,
2369 (xmlChar *)"name",
2370 "%s", volname);
2371 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2372
2373 memset (key, 0, sizeof (key));
2374 snprintf (key, sizeof (key), "volume%d.volume_id", i);
2375 ret = dict_get_str (dict, key, &volume_id);
2376 if (ret)
2377 goto out;
2378 ret = xmlTextWriterWriteFormatElement (local->writer,
2379 (xmlChar *)"id",
2380 "%s", volume_id);
2381 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2382
2383 memset (key, 0, sizeof (key));
2384 snprintf (key, sizeof (key), "volume%d.status", i);
2385 ret = dict_get_int32 (dict, key, &status);
2386 if (ret)
2387 goto out;
2388 ret = xmlTextWriterWriteFormatElement (local->writer,
2389 (xmlChar *)"status",
2390 "%d", status);
2391 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2392
2393 ret =xmlTextWriterWriteFormatElement
2394 (local->writer, (xmlChar *)"statusStr", "%s",
2395 cli_vol_status_str[status]);
2396 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2397
2398 memset (key, 0, sizeof (key));
2399 snprintf (key, sizeof (key), "volume%d.brick_count", i);
2400 ret = dict_get_int32 (dict, key, &brick_count);
2401 if (ret)
2402 goto out;
2403 ret = xmlTextWriterWriteFormatElement (local->writer,
2404 (xmlChar *)"brickCount",
2405 "%d", brick_count);
2406 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2407
2408 memset (key, 0, sizeof (key));
2409 snprintf (key, sizeof (key), "volume%d.dist_count", i);
2410 ret = dict_get_int32 (dict, key, &dist_count);
2411 if (ret)
2412 goto out;
2413 ret = xmlTextWriterWriteFormatElement (local->writer,
2414 (xmlChar *)"distCount",
2415 "%d", dist_count);
2416 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2417
2418 memset (key, 0, sizeof (key));
2419 snprintf (key, sizeof (key), "volume%d.stripe_count", i);
2420 ret = dict_get_int32 (dict, key, &stripe_count);
2421 if (ret)
2422 goto out;
2423 ret = xmlTextWriterWriteFormatElement (local->writer,
2424 (xmlChar *)"stripeCount",
2425 "%d", stripe_count);
2426 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2427
2428 memset (key, 0, sizeof (key));
2429 snprintf (key, sizeof (key), "volume%d.replica_count", i);
2430 ret = dict_get_int32 (dict, key, &replica_count);
2431 if (ret)
2432 goto out;
2433 ret = xmlTextWriterWriteFormatElement (local->writer,
2434 (xmlChar *)"replicaCount",
2435 "%d", replica_count);
2436 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2437
2438 memset (key, 0, sizeof (key));
2439 snprintf (key, sizeof (key), "volume%d.type", i);
2440 ret = dict_get_int32 (dict, key, &type);
2441 if (ret)
2442 goto out;
2443 /* For Distributed-(stripe,replicate,stipe-replicate) types */
2444 if ((type > 0) && (dist_count < brick_count))
2445 type += 3;
2446 ret = xmlTextWriterWriteFormatElement (local->writer,
2447 (xmlChar *)"type",
2448 "%d", type);
2449 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2450
2451 ret = xmlTextWriterWriteFormatElement (local->writer,
2452 (xmlChar *)"typeStr",
2453 "%s",
2454 cli_vol_type_str[type]);
2455 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2456
2457 memset (key, 0, sizeof (key));
2458 snprintf (key, sizeof (key), "volume%d.transport", i);
2459 ret = dict_get_int32 (dict, key, &transport);
2460 if (ret)
2461 goto out;
2462 ret = xmlTextWriterWriteFormatElement (local->writer,
2463 (xmlChar *)"transport",
2464 "%d", transport);
2465 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2466
2467 /* <bricks> */
2468 ret = xmlTextWriterStartElement (local->writer,
2469 (xmlChar *)"bricks");
2470 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2471 while (j <= brick_count) {
2472 memset (key, 0, sizeof (key));
2473 snprintf (key, sizeof (key), "volume%d.brick%d", i, j);
2474 ret = dict_get_str (dict, key, &brick);
2475 if (ret)
2476 goto out;
2477 ret = xmlTextWriterWriteFormatElement
2478 (local->writer, (xmlChar *)"brick", "%s",
2479 brick);
2480 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2481 j++;
2482 }
2483 /* </bricks> */
2484 ret = xmlTextWriterEndElement (local->writer);
2485 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2486
2487 memset (key, 0, sizeof (key));
2488 snprintf (key, sizeof (key), "volume%d", i);
2489 ret = cli_xml_output_vol_info_options (local->writer, dict,
2490 key);
2491 if (ret)
2492 goto out;
2493
2494 /* </volume> */
2495 ret = xmlTextWriterEndElement (local->writer);
2496 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2497 }
2498
2499 if (volname) {
2500 GF_FREE (local->get_vol.volname)__gf_free (local->get_vol.volname);
2501 local->get_vol.volname = gf_strdup (volname);
2502 local->vol_count += count;
2503 }
2504out:
2505 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2505, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2506 return ret;
2507#else
2508 return 0;
2509#endif
2510}
2511
2512int
2513cli_xml_output_vol_info_begin (cli_local_t *local, int op_ret, int op_errno,
2514 char *op_errstr)
2515{
2516#if (HAVE_LIB_XML1)
2517 int ret = -1;
2518
2519 GF_ASSERT (local)do { if (!(local)) { do { do { if (0) printf ("Assertion failed: "
"local"); } while (0); _gf_log_callingfn ("", "cli-xml-output.c"
, __FUNCTION__, 2519, GF_LOG_ERROR, "Assertion failed: " "local"
); } while (0); } } while (0)
;
2520
2521 ret = cli_begin_xml_output (&(local->writer), &(local->doc));
2522 if (ret)
2523 goto out;
2524
2525 ret = cli_xml_output_common (local->writer, op_ret, op_errno,
2526 op_errstr);
2527 if (ret)
2528 goto out;
2529
2530 /* <volInfo> */
2531 ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volInfo");
2532 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2533
2534 /* <volumes> */
2535 ret = xmlTextWriterStartElement (local->writer, (xmlChar *)"volumes");
2536 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2537
2538 /* Init vol count */
2539 local->vol_count = 0;
2540
2541out:
2542 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2542, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2543 return ret;
2544#else
2545 return 0;
2546#endif
2547}
2548
2549int
2550cli_xml_output_vol_info_end (cli_local_t *local)
2551{
2552#if (HAVE_LIB_XML1)
2553 int ret = -1;
2554
2555 GF_ASSERT (local)do { if (!(local)) { do { do { if (0) printf ("Assertion failed: "
"local"); } while (0); _gf_log_callingfn ("", "cli-xml-output.c"
, __FUNCTION__, 2555, GF_LOG_ERROR, "Assertion failed: " "local"
); } while (0); } } while (0)
;
1
Within the expansion of the macro 'GF_ASSERT':
a
Assuming 'local' is null
2556
2557 ret = xmlTextWriterWriteFormatElement (local->writer,
2
Access to field 'writer' results in a dereference of a null pointer (loaded from variable 'local')
2558 (xmlChar *)"count",
2559 "%d", local->vol_count);
2560
2561 /* </volumes> */
2562 ret = xmlTextWriterEndElement (local->writer);
2563 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2564
2565 /* </volInfo> */
2566 ret = xmlTextWriterEndElement (local->writer);
2567 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2568
2569 ret = cli_end_xml_output (local->writer, local->doc);
2570
2571out:
2572 gf_log ("cli", GF_LOG_ERROR, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2572, GF_LOG_ERROR
, "Returning %d", ret); } while (0)
;
2573 return ret;
2574#else
2575 return 0;
2576#endif
2577}
2578
2579int
2580cli_xml_output_vol_quota_limit_list (char *volname, char *limit_list,
2581 int op_ret, int op_errno,
2582 char *op_errstr)
2583{
2584#if (HAVE_LIB_XML1)
2585 int ret = -1;
2586 xmlTextWriterPtr writer = NULL((void*)0);
2587 xmlDocPtr doc = NULL((void*)0);
2588 int64_t size = 0;
2589 int64_t limit_value = 0;
2590 int i = 0;
2591 int j = 0;
2592 int k = 0;
2593 int len = 0;
2594 char *size_str = NULL((void*)0);
2595 char path[PATH_MAX4096] = {0,};
2596 char ret_str[1024] = {0,};
2597 char value[1024] = {0,};
2598 char mountdir[] = "/tmp/mountXXXXXX";
2599 char abspath[PATH_MAX4096] = {0,};
2600 runner_t runner = {0,};
2601
2602 GF_ASSERT (volname)do { if (!(volname)) { do { do { if (0) printf ("Assertion failed: "
"volname"); } while (0); _gf_log_callingfn ("", "cli-xml-output.c"
, __FUNCTION__, 2602, GF_LOG_ERROR, "Assertion failed: " "volname"
); } while (0); } } while (0)
;
2603 GF_ASSERT (limit_list)do { if (!(limit_list)) { do { do { if (0) printf ("Assertion failed: "
"limit_list"); } while (0); _gf_log_callingfn ("", "cli-xml-output.c"
, __FUNCTION__, 2603, GF_LOG_ERROR, "Assertion failed: " "limit_list"
); } while (0); } } while (0)
;
2604
2605 ret = cli_begin_xml_output (&writer, &doc);
2606 if (ret)
2607 goto out;
2608
2609 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
2610 if (ret)
2611 goto out;
2612
2613 /* <volQuota> */
2614 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volQuota");
2615 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2616
2617 if (!limit_list)
2618 goto cont;
2619
2620 len = strlen (limit_list);
2621 if (len == 0)
2622 goto cont;
2623
2624 if (mkdtemp (mountdir) == NULL((void*)0)) {
2625 gf_log ("cli", GF_LOG_ERROR, "failed to create a temporary"do { do { if (0) printf ("failed to create a temporary" " mount directory"
); } while (0); _gf_log ("cli", "cli-xml-output.c", __FUNCTION__
, 2626, GF_LOG_ERROR, "failed to create a temporary" " mount directory"
); } while (0)
2626 " mount directory")do { do { if (0) printf ("failed to create a temporary" " mount directory"
); } while (0); _gf_log ("cli", "cli-xml-output.c", __FUNCTION__
, 2626, GF_LOG_ERROR, "failed to create a temporary" " mount directory"
); } while (0)
;
2627 ret = -1;
2628 goto out;
2629 }
2630
2631 ret = runcmd (SBIN_DIR"/usr/local/sbin""/glusterfs", "-s", "localhost",
2632 "--volfile-id", volname, "-l",
2633 DEFAULT_LOG_FILE_DIRECTORY"/usr/local/var" "/log/glusterfs""/quota-list-xml.log",
2634 mountdir, NULL((void*)0));
2635 if (ret) {
2636 gf_log ("cli", GF_LOG_ERROR,do { do { if (0) printf ("failed to mount glusterfs client");
} while (0); _gf_log ("cli", "cli-xml-output.c", __FUNCTION__
, 2637, GF_LOG_ERROR, "failed to mount glusterfs client"); } while
(0)
2637 "failed to mount glusterfs client")do { do { if (0) printf ("failed to mount glusterfs client");
} while (0); _gf_log ("cli", "cli-xml-output.c", __FUNCTION__
, 2637, GF_LOG_ERROR, "failed to mount glusterfs client"); } while
(0)
;
2638 ret = -1;
2639 goto rm_dir;
2640 }
2641
2642 while (i < len) {
2643 j = 0;
2644 k = 0;
2645 size = 0;
2646
2647 while (limit_list[i] != ':')
2648 path[k++] = limit_list[i++];
2649 path[k] = '\0';
2650
2651 i++;
2652
2653 while (limit_list[i] != ',' && limit_list[i] != '\0')
2654 value[j++] = limit_list[i++];
2655 i++;
2656
2657 snprintf (abspath, sizeof (abspath), "%s/%s", mountdir, path);
2658 ret = sys_lgetxattr (abspath, "trusted.limit.list",
2659 (void *)ret_str, 4096);
2660 if (ret >= 0) {
2661 sscanf (ret_str, "%"SCNd64"ll" "d"",%"SCNd64"ll" "d", &size,
2662 &limit_value);
2663 size_str = gf_uint64_2human_readable ((uint64_t)size);
2664 }
2665
2666 /* <quota> */
2667 ret = xmlTextWriterStartElement (writer, (xmlChar *)"quota");
2668 XML_RET_CHECK_AND_GOTO (ret, unmount)do { if (ret < 0) { ret = -1; goto unmount; } else ret = 0
; }while (0)
;
2669
2670 ret = xmlTextWriterWriteFormatElement
2671 (writer, (xmlChar *)"path", "%s", path);
2672 XML_RET_CHECK_AND_GOTO (ret, unmount)do { if (ret < 0) { ret = -1; goto unmount; } else ret = 0
; }while (0)
;
2673
2674 ret = xmlTextWriterWriteFormatElement
2675 (writer, (xmlChar *)"limit", "%s", value);
2676 XML_RET_CHECK_AND_GOTO (ret, unmount)do { if (ret < 0) { ret = -1; goto unmount; } else ret = 0
; }while (0)
;
2677
2678 if (size_str) {
2679 ret = xmlTextWriterWriteFormatElement
2680 (writer, (xmlChar *)"size", "%s", size_str);
2681 XML_RET_CHECK_AND_GOTO (ret, unmount)do { if (ret < 0) { ret = -1; goto unmount; } else ret = 0
; }while (0)
;
2682 GF_FREE (size_str)__gf_free (size_str);
2683 } else {
2684 ret = xmlTextWriterWriteFormatElement
2685 (writer, (xmlChar *)"size", "%"PRId64"ll" "d", size);
2686 XML_RET_CHECK_AND_GOTO (ret, unmount)do { if (ret < 0) { ret = -1; goto unmount; } else ret = 0
; }while (0)
;
2687 }
2688
2689 /* </quota> */
2690 ret = xmlTextWriterEndElement (writer);
2691 XML_RET_CHECK_AND_GOTO (ret, unmount)do { if (ret < 0) { ret = -1; goto unmount; } else ret = 0
; }while (0)
;
2692
2693 }
2694
2695unmount:
2696 runinit (&runner);
2697 runner_add_args (&runner, "umount",
2698#if GF_LINUX_HOST_OS1
2699 "-l",
2700#endif
2701 mountdir, NULL((void*)0));
2702 ret = runner_run_reuse (&runner);
2703 if (ret)
2704 runner_log (&runner, "cli", GF_LOG_WARNING, "error executing");
2705 runner_end (&runner);
2706
2707rm_dir:
2708 rmdir (mountdir);
2709
2710cont:
2711 /* </volQuota> */
2712 ret = xmlTextWriterEndElement (writer);
2713 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2714
2715 ret = cli_end_xml_output (writer, doc);
2716
2717out:
2718 GF_FREE (size_str)__gf_free (size_str);
2719 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2719, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2720 return ret;
2721#else
2722 return 0;
2723#endif
2724}
2725
2726int
2727cli_xml_output_peer_status (dict_t *dict, int op_ret, int op_errno,
2728 char *op_errstr)
2729{
2730#if (HAVE_LIB_XML1)
2731 int ret = -1;
2732 xmlTextWriterPtr writer = NULL((void*)0);
2733 xmlDocPtr doc = NULL((void*)0);
2734 int count = 0;
2735 char *uuid = NULL((void*)0);
2736 char *hostname = NULL((void*)0);
2737 int connected = 0;
2738 int state_id = 0;
2739 char *state_str = NULL((void*)0);
2740 int port = 0;
2741 int i = 1;
2742 char key[1024] = {0,};
2743
2744 ret = cli_begin_xml_output (&writer, &doc);
2745 if (ret)
2746 goto out;
2747
2748 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
2749 if (ret)
2750 goto out;
2751
2752 /* <peerStatus> */
2753 ret = xmlTextWriterStartElement (writer, (xmlChar *)"peerStatus");
2754 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2755
2756 if (!dict)
2757 goto cont;
2758
2759 ret = dict_get_int32 (dict, "count", &count);
2760 if (ret)
2761 goto out;
2762
2763 while (i <= count) {
2764 /* <peer> */
2765 ret = xmlTextWriterStartElement (writer, (xmlChar *)"peer");
2766 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2767
2768 memset (key, 0, sizeof (key));
2769 snprintf (key, sizeof (key), "friend%d.uuid", i);
2770 ret = dict_get_str (dict, key, &uuid);
2771 if (ret)
2772 goto out;
2773
2774 ret = xmlTextWriterWriteFormatElement (writer,
2775 (xmlChar *)"uuid",
2776 "%s", uuid);
2777 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2778
2779 memset (key, 0, sizeof (key));
2780 snprintf (key, sizeof (key), "friend%d.hostname", i);
2781 ret = dict_get_str (dict, key, &hostname);
2782 if (ret)
2783 goto out;
2784
2785 ret = xmlTextWriterWriteFormatElement (writer,
2786 (xmlChar *)"hostname",
2787 "%s", hostname);
2788 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2789
2790 memset (key, 0, sizeof (key));
2791 snprintf (key, sizeof (key), "friend%d.connected", i);
2792 ret = dict_get_int32 (dict, key, &connected);
2793 if (ret)
2794 goto out;
2795
2796 ret = xmlTextWriterWriteFormatElement (writer,
2797 (xmlChar *)"connected",
2798 "%d", connected);
2799 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2800
2801 memset (key, 0, sizeof (key));
2802 snprintf (key, sizeof (key), "friend%d.stateId", i);
2803 ret = dict_get_int32 (dict, key, &state_id);
2804 if (!ret) {
2805 /* ignore */
2806
2807 ret = xmlTextWriterWriteFormatElement (writer,
2808 (xmlChar *)"state", "%d", state_id);
2809 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2810 }
2811
2812 memset (key, 0, sizeof (key));
2813 snprintf (key, sizeof (key), "friend%d.state", i);
2814 ret = dict_get_str (dict, key, &state_str);
2815 if (!ret) {
2816 /* ignore */
2817
2818 ret = xmlTextWriterWriteFormatElement (writer,
2819 (xmlChar *)"stateStr", "%s", state_str);
2820 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2821 }
2822
2823 memset (key, 0, sizeof (key));
2824 snprintf (key, sizeof (key), "friend%d.port", i);
2825 ret = dict_get_int32 (dict, key, &port);
2826 if (!ret) {
2827 /* ignore */
2828 ret = xmlTextWriterWriteFormatElement
2829 (writer, (xmlChar *)"port", "%d", port);
2830 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2831
2832 port = 0;
2833 }
2834
2835 /* </peer> */
2836 ret = xmlTextWriterEndElement (writer);
2837 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2838
2839 i++;
2840 }
2841
2842cont:
2843 /* </peerStatus> */
2844 ret = xmlTextWriterEndElement (writer);
2845 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2846
2847 ret = cli_end_xml_output (writer, doc);
2848
2849out:
2850 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2850, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2851 return ret;
2852#else
2853 return 0;
2854#endif
2855}
2856
2857#if (HAVE_LIB_XML1)
2858/* Used for rebalance stop/status, remove-brick status */
2859int
2860cli_xml_output_vol_rebalance_status (xmlTextWriterPtr writer, dict_t *dict)
2861{
2862 int ret = -1;
2863 int count = 0;
2864 char *node_name = NULL((void*)0);
2865 uint64_t files = 0;
2866 uint64_t size = 0;
2867 uint64_t lookups = 0;
2868 int status_rcd = 0;
2869 uint64_t failures = 0;
2870 uint64_t total_files = 0;
2871 uint64_t total_size = 0;
2872 uint64_t total_lookups = 0;
2873 uint64_t total_failures = 0;
2874 char key[1024] = {0,};
2875 int i = 0;
2876
2877 if (!dict) {
2878 ret = 0;
2879 goto out;
2880 }
2881
2882 ret = dict_get_int32 (dict, "count", &count);
2883 if (ret)
2884 goto out;
2885 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"nodeCount",
2886 "%d", count);
2887 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2888
2889 while (i < count) {
2890 i++;
2891
2892 /* <node> */
2893 ret = xmlTextWriterStartElement (writer, (xmlChar *)"node");
2894 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2895
2896 memset (key, 0, sizeof (key));
2897 snprintf (key, sizeof (key), "node-uuid-%d", i);
2898 ret = dict_get_str (dict, key, &node_name);
2899 if (ret)
2900 goto out;
2901 ret = xmlTextWriterWriteFormatElement (writer,
2902 (xmlChar *)"nodeName",
2903 "%s", node_name);
2904 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2905
2906 memset (key, 0, sizeof (key));
2907 snprintf (key, sizeof (key), "files-%d", i);
2908 ret = dict_get_uint64 (dict, key, &files);
2909 if (ret)
2910 goto out;
2911 total_files += files;
2912 ret = xmlTextWriterWriteFormatElement (writer,
2913 (xmlChar *)"files",
2914 "%"PRIu64"ll" "u", files);
2915 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2916
2917 memset (key, 0, sizeof (key));
2918 snprintf (key, sizeof (key), "size-%d", i);
2919 ret = dict_get_uint64 (dict, key, &size);
2920 if (ret)
2921 goto out;
2922 total_size += size;
2923 ret = xmlTextWriterWriteFormatElement (writer,
2924 (xmlChar *)"size",
2925 "%"PRIu64"ll" "u",size);
2926 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2927
2928 memset (key, 0, sizeof (key));
2929 snprintf (key, sizeof (key), "lookups-%d", i);
2930 ret = dict_get_uint64 (dict, key, &lookups);
2931 if (ret)
2932 goto out;
2933 total_lookups += lookups;
2934 ret = xmlTextWriterWriteFormatElement (writer,
2935 (xmlChar *)"lookups",
2936 "%"PRIu64"ll" "u", lookups);
2937 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2938
2939 memset (key, 0, sizeof (key));
2940 snprintf (key, sizeof (key), "failures-%d", i);
2941 ret = dict_get_uint64 (dict, key, &failures);
2942 if (ret)
2943 goto out;
2944 total_failures += failures;
2945 ret = xmlTextWriterWriteFormatElement (writer,
2946 (xmlChar *)"failures",
2947 "%"PRIu64"ll" "u", failures);
2948 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2949
2950 memset (key, 0, sizeof (key));
2951 snprintf (key, sizeof (key), "status-%d", i);
2952 ret = dict_get_int32 (dict, key, &status_rcd);
2953 if (ret)
2954 goto out;
2955 ret = xmlTextWriterWriteFormatElement (writer,
2956 (xmlChar *)"status",
2957 "%d", status_rcd);
2958 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2959
2960 /* </node> */
2961 ret = xmlTextWriterEndElement (writer);
2962 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2963 }
2964
2965 /* Aggregate status */
2966 /* <aggregate> */
2967 ret = xmlTextWriterStartElement (writer, (xmlChar *)"aggregate");
2968 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2969
2970 ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"files",
2971 "%"PRIu64"ll" "u", total_files);
2972 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2973
2974 ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"size",
2975 "%"PRIu64"ll" "u", total_size);
2976 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2977
2978 ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"lookups",
2979 "%"PRIu64"ll" "u", total_lookups);
2980 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2981
2982 ret = xmlTextWriterWriteFormatElement (writer,(xmlChar *)"failures",
2983 "%"PRIu64"ll" "u", total_failures);
2984 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2985
2986 // TODO : Aggregate status
2987
2988 /* </aggregate> */
2989 ret = xmlTextWriterEndElement (writer);
2990 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
2991
2992out:
2993 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 2993, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
2994 return ret;
2995}
2996#endif
2997
2998int
2999cli_xml_output_vol_rebalance (gf_cli_defrag_type op, dict_t *dict, int op_ret,
3000 int op_errno, char *op_errstr)
3001{
3002#if (HAVE_LIB_XML1)
3003 int ret = -1;
3004 xmlTextWriterPtr writer = NULL((void*)0);
3005 xmlDocPtr doc = NULL((void*)0);
3006 char *task_id_str = NULL((void*)0);
3007
3008 ret = cli_begin_xml_output (&writer, &doc);
3009 if (ret)
3010 goto out;
3011
3012 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
3013 if (ret)
3014 goto out;
3015
3016 /* <volRebalance> */
3017 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volRebalance");
3018 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3019
3020 ret = dict_get_str (dict, GF_REBALANCE_TID_KEY"rebalance-id", &task_id_str);
3021 if (ret == 0) {
3022 ret = xmlTextWriterWriteFormatElement (writer,
3023 (xmlChar *)"task-id",
3024 "%s", task_id_str);
3025 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3026 }
3027
3028 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"op",
3029 "%d", op);
3030 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3031
3032 if ((GF_DEFRAG_CMD_STOP == op) || (GF_DEFRAG_CMD_STATUS == op)) {
3033 ret = cli_xml_output_vol_rebalance_status (writer, dict);
3034 if (ret)
3035 goto out;
3036 }
3037
3038 /* </volRebalance> */
3039 ret = xmlTextWriterEndElement (writer);
3040 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3041
3042
3043 ret = cli_end_xml_output (writer, doc);
3044
3045out:
3046 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3046, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
3047 return ret;
3048#else
3049 return 0;
3050#endif
3051}
3052
3053int
3054cli_xml_output_vol_remove_brick (gf_boolean_t status_op, dict_t *dict,
3055 int op_ret, int op_errno, char *op_errstr)
3056{
3057#if (HAVE_LIB_XML1)
3058 int ret = -1;
3059 xmlTextWriterPtr writer = NULL((void*)0);
3060 xmlDocPtr doc = NULL((void*)0);
3061 char *task_id_str = NULL((void*)0);
3062
3063 ret = cli_begin_xml_output (&writer, &doc);
3064 if (ret)
3065 goto out;
3066
3067 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
3068 if (ret)
3069 goto out;
3070
3071 /* <volRemoveBrick> */
3072 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volRemoveBrick");
3073 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3074
3075 ret = dict_get_str (dict, GF_REMOVE_BRICK_TID_KEY"remove-brick-id", &task_id_str);
3076 if (ret == 0) {
3077 ret = xmlTextWriterWriteFormatElement (writer,
3078 (xmlChar *)"task-id",
3079 "%s", task_id_str);
3080 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3081 }
3082
3083 if (status_op) {
3084 ret = cli_xml_output_vol_rebalance_status (writer, dict);
3085 if (ret)
3086 goto out;
3087 }
3088
3089 /* </volRemoveBrick> */
3090 ret = xmlTextWriterEndElement (writer);
3091 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3092
3093
3094 ret = cli_end_xml_output (writer, doc);
3095
3096out:
3097 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3097, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
3098 return ret;
3099#else
3100 return 0;
3101#endif
3102}
3103
3104int
3105cli_xml_output_vol_replace_brick (gf1_cli_replace_op op, dict_t *dict,
3106 int op_ret, int op_errno, char *op_errstr)
3107{
3108#if (HAVE_LIB_XML1)
3109 int ret = -1;
3110 int status = 0;
3111 uint64_t files = 0;
3112 char *current_file = 0;
3113 char *task_id_str = NULL((void*)0);
3114 xmlTextWriterPtr writer = NULL((void*)0);
3115 xmlDocPtr doc = NULL((void*)0);
3116
3117 ret = cli_begin_xml_output (&writer, &doc);
3118 if (ret)
3119 goto out;
3120
3121 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
3122 if (ret)
3123 goto out;
3124
3125 /* <volReplaceBrick> */
3126 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volReplaceBrick");
3127 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3128
3129 ret = dict_get_str (dict, GF_REPLACE_BRICK_TID_KEY"replace-brick-id", &task_id_str);
3130 if (ret == 0) {
3131 ret = xmlTextWriterWriteFormatElement (writer,
3132 (xmlChar *)"task-id",
3133 "%s", task_id_str);
3134 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3135 }
3136
3137 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"op",
3138 "%d", op);
3139 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3140
3141 if (GF_REPLACE_OP_STATUS == op) {
3142 ret = dict_get_int32 (dict, "status", &status);
3143 if (ret)
3144 goto out;
3145 ret = xmlTextWriterWriteFormatElement (writer,
3146 (xmlChar *)"status",
3147 "%d", status);
3148 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3149
3150 ret = dict_get_uint64 (dict, "files", &files);
3151 if (ret)
3152 goto out;
3153 ret = xmlTextWriterWriteFormatElement (writer,
3154 (xmlChar *)"files",
3155 "%"PRIu64"ll" "u", files);
3156 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3157
3158 if (status)
3159 goto cont;
3160
3161 ret = dict_get_str (dict, "current_file", &current_file);
3162 if (ret)
3163 goto out;
3164 ret = xmlTextWriterWriteFormatElement (writer,
3165 (xmlChar *)"currentFile",
3166 "%s", current_file);
3167 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3168 }
3169cont:
3170 /* </volReplaceBrick> */
3171 ret = xmlTextWriterEndElement (writer);
3172 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3173
3174 ret = cli_end_xml_output (writer, doc);
3175
3176out:
3177 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3177, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
3178 return ret;
3179#else
3180 return 0;
3181#endif
3182}
3183
3184int
3185cli_xml_output_vol_create (dict_t *dict, int op_ret, int op_errno,
3186 char *op_errstr)
3187{
3188#if (HAVE_LIB_XML1)
3189 int ret = -1;
3190 xmlTextWriterPtr writer = NULL((void*)0);
3191 xmlDocPtr doc = NULL((void*)0);
3192 char *volname = NULL((void*)0);
3193 char *volid = NULL((void*)0);
3194
3195 ret = cli_begin_xml_output (&writer, &doc);
3196 if (ret)
3197 goto out;
3198
3199 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
3200 if (ret)
3201 goto out;
3202
3203 if (dict) {
3204 /* <volCreate> */
3205 ret = xmlTextWriterStartElement (writer,
3206 (xmlChar *)"volCreate");
3207 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3208
3209 /* <volume> */
3210 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
3211 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3212
3213 ret = dict_get_str (dict, "volname", &volname);
3214 if (ret)
3215 goto out;
3216 ret = xmlTextWriterWriteFormatElement (writer,
3217 (xmlChar *) "name",
3218 "%s", volname);
3219 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3220
3221 ret = dict_get_str (dict, "volume-id", &volid);
3222 if (ret)
3223 goto out;
3224 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"id",
3225 "%s", volid);
3226 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3227
3228 /* </volume> */
3229 ret = xmlTextWriterEndElement (writer);
3230 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3231
3232 /* </volCreate> */
3233 ret = xmlTextWriterEndElement (writer);
3234 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3235 }
3236
3237 ret = cli_end_xml_output (writer, doc);
3238
3239out:
3240 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3240, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
3241 return ret;
3242#else
3243 return 0;
3244#endif
3245}
3246
3247int
3248cli_xml_output_generic_volume (char *op, dict_t *dict, int op_ret, int op_errno,
3249 char *op_errstr)
3250{
3251#if (HAVE_LIB_XML1)
3252 int ret = -1;
3253 xmlTextWriterPtr writer = NULL((void*)0);
3254 xmlDocPtr doc = NULL((void*)0);
3255 char *volname = NULL((void*)0);
3256 char *volid = NULL((void*)0);
3257
3258 GF_ASSERT (op)do { if (!(op)) { do { do { if (0) printf ("Assertion failed: "
"op"); } while (0); _gf_log_callingfn ("", "cli-xml-output.c"
, __FUNCTION__, 3258, GF_LOG_ERROR, "Assertion failed: " "op"
); } while (0); } } while (0)
;
3259
3260 ret = cli_begin_xml_output (&writer, &doc);
3261 if (ret)
3262 goto out;
3263
3264 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
3265 if (ret)
3266 goto out;
3267
3268 if (dict) {
3269 /* <"op"> */
3270 ret = xmlTextWriterStartElement (writer, (xmlChar *)op);
3271 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3272
3273 /* <volume> */
3274 ret = xmlTextWriterStartElement (writer, (xmlChar *)"volume");
3275 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3276
3277 ret = dict_get_str (dict, "volname", &volname);
3278 if (ret)
3279 goto out;
3280 ret = xmlTextWriterWriteFormatElement (writer,
3281 (xmlChar *) "name",
3282 "%s", volname);
3283 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3284
3285 ret = dict_get_str (dict, "vol-id", &volid);
3286 if (ret)
3287 goto out;
3288 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"id",
3289 "%s", volid);
3290 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3291
3292 /* </volume> */
3293 ret = xmlTextWriterEndElement (writer);
3294 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3295
3296 /* </"op"> */
3297 ret = xmlTextWriterEndElement (writer);
3298 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3299 }
3300
3301 ret = cli_end_xml_output (writer, doc);
3302
3303out:
3304 gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3304, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
3305 return ret;
3306#else
3307 return 0;
3308#endif
3309}
3310
3311#if (HAVE_LIB_XML1)
3312int
3313cli_xml_output_vol_gsync_status (dict_t *dict, xmlTextWriterPtr writer)
3314{
3315 char master_key[PATH_MAX4096] = "";
3316 char slave_key[PATH_MAX4096] = "";
3317 char status_key[PATH_MAX4096] = "";
3318 char node_key[PATH_MAX4096] = "";
3319 char *master = NULL((void*)0);
3320 char *slave = NULL((void*)0);
3321 char *status = NULL((void*)0);
3322 char *node = NULL((void*)0);
3323 int ret = -1;
3324 int gsync_count = 0;
3325 int i = 1;
3326
3327 ret = dict_get_int32 (dict, "gsync-count", &gsync_count);
3328 if (ret)
3329 goto out;
3330
3331 for (i=1; i <= gsync_count; i++) {
3332 snprintf (node_key, sizeof(node_key), "node%d", i);
3333 snprintf (master_key, sizeof(master_key), "master%d", i);
3334 snprintf (slave_key, sizeof(slave_key), "slave%d", i);
3335 snprintf (status_key, sizeof(status_key), "status%d", i);
3336
3337 ret = dict_get_str (dict, node_key, &node);
3338 if (ret)
3339 goto out;
3340
3341 ret = dict_get_str (dict, master_key, &master);
3342 if (ret)
3343 goto out;
3344
3345 ret = dict_get_str (dict, slave_key, &slave);
3346 if (ret)
3347 goto out;
3348
3349 ret = dict_get_str (dict, status_key, &status);
3350 if (ret)
3351 goto out;
3352
3353 /* <pair> */
3354 ret = xmlTextWriterStartElement (writer, (xmlChar *)"pair");
3355 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3356
3357 ret = xmlTextWriterWriteFormatElement (writer,
3358 (xmlChar *)"node",
3359 "%s", node);
3360 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3361
3362 ret = xmlTextWriterWriteFormatElement (writer,
3363 (xmlChar *)"master",
3364 "%s", master);
3365 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3366
3367 ret = xmlTextWriterWriteFormatElement (writer,
3368 (xmlChar *)"slave",
3369 "%s", slave);
3370 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3371
3372 ret = xmlTextWriterWriteFormatElement (writer,
3373 (xmlChar *)"status",
3374 "%s", status);
3375 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3376
3377 /* </pair> */
3378 ret = xmlTextWriterEndElement (writer);
3379 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3380
3381 }
3382
3383out:
3384 gf_log ("cli",GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3384, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
3385 return ret;
3386}
3387#endif
3388
3389int
3390cli_xml_output_vol_gsync (dict_t *dict, int op_ret, int op_errno,
3391 char *op_errstr)
3392{
3393#if (HAVE_LIB_XML1)
3394 int ret = -1;
3395 xmlTextWriterPtr writer = NULL((void*)0);
3396 xmlDocPtr doc = NULL((void*)0);
3397 char *master = NULL((void*)0);
3398 char *slave = NULL((void*)0);
3399 int type = 0;
3400
3401 GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: "
"dict"); } while (0); _gf_log_callingfn ("", "cli-xml-output.c"
, __FUNCTION__, 3401, GF_LOG_ERROR, "Assertion failed: " "dict"
); } while (0); } } while (0)
;
3402
3403 ret = cli_begin_xml_output (&writer, &doc);
3404 if (ret)
3405 goto out;
3406
3407 ret = cli_xml_output_common (writer, op_ret, op_errno, op_errstr);
3408 if (ret)
3409 goto out;
3410
3411 /* <geoRep> */
3412 ret = xmlTextWriterStartElement (writer, (xmlChar *)"geoRep");
3413 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3414
3415 ret = dict_get_int32 (dict, "type", &type);
3416 if (ret) {
3417 gf_log ("cli", GF_LOG_ERROR, "Failed to get type")do { do { if (0) printf ("Failed to get type"); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3417, GF_LOG_ERROR
, "Failed to get type"); } while (0)
;
3418 goto out;
3419 }
3420
3421 ret = xmlTextWriterWriteFormatElement (writer, (xmlChar *)"type",
3422 "%d", type);
3423 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3424
3425 switch (type) {
3426 case GF_GSYNC_OPTION_TYPE_START:
3427 case GF_GSYNC_OPTION_TYPE_STOP:
3428 if (dict_get_str (dict, "master", &master) != 0)
3429 master = "???";
3430 if (dict_get_str (dict, "slave", &slave) != 0)
3431 slave = "???";
3432
3433 ret = xmlTextWriterWriteFormatElement (writer,
3434 (xmlChar *)"master",
3435 "%s", master);
3436 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3437
3438 ret = xmlTextWriterWriteFormatElement (writer,
3439 (xmlChar *)"slave",
3440 "%s", slave);
3441 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3442
3443 break;
3444
3445 case GF_GSYNC_OPTION_TYPE_CONFIG:
3446 break;
3447 case GF_GSYNC_OPTION_TYPE_STATUS:
3448 ret = cli_xml_output_vol_gsync_status(dict, writer);
3449 break;
3450 default:
3451 ret = 0;
3452 break;
3453 }
3454
3455 /* </geoRep> */
3456 ret = xmlTextWriterEndElement (writer);
3457 XML_RET_CHECK_AND_GOTO (ret, out)do { if (ret < 0) { ret = -1; goto out; } else ret = 0; }while
(0)
;
3458
3459 ret = cli_end_xml_output (writer, doc);
3460out:
3461 gf_log ("cli",GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("cli", "cli-xml-output.c", __FUNCTION__, 3461, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
3462 return ret;
3463#else
3464 return 0;
3465#endif
3466}