PageRenderTime 88ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/cli/src/cli-rpc-ops.c

https://github.com/xiushu2012/glusterfs
C | 6510 lines | 5396 code | 1053 blank | 61 comment | 1020 complexity | 05b7acac85471e1509bbbf49103023a3 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-3.0, LGPL-2.0, Apache-2.0, BSD-3-Clause 
    

  1. /*
    2. 

  2.    Copyright (c) 2010-2012 Red Hat, Inc. <http://www.redhat.com>
    3. 

  3.    This file is part of GlusterFS.
    4. 

    5. 

  5.    This file is licensed to you under your choice of the GNU Lesser
    6. 

  6.    General Public License, version 3 or any later version (LGPLv3 or
    7. 

  7.    later), or the GNU General Public License, version 2 (GPLv2), in all
    8. 

  8.    cases as published by the Free Software Foundation.
    9. 

  9. */
    10. 

  10. 

  11. #ifndef _CONFIG_H
    12. 

  12. #define _CONFIG_H
    13. 

  13. #include "config.h"
    14. 

  14. #endif
    15. 

  15. 

  16. #ifndef GSYNC_CONF
    17. 

  17. #define GSYNC_CONF GEOREP"/gsyncd.conf"
    18. 

  18. #endif
    19. 

  19. 

  20. /* Widths of various columns in top read/write-perf output
    21. 

  21.  * Total width of top read/write-perf should be 80 chars
    22. 

  22.  * including one space between column
    23. 

  23.  */
    24. 

  24. #define VOL_TOP_PERF_FILENAME_DEF_WIDTH 47
    25. 

  25. #define VOL_TOP_PERF_FILENAME_ALT_WIDTH 44
    26. 

  26. #define VOL_TOP_PERF_SPEED_WIDTH        4
    27. 

  27. #define VOL_TOP_PERF_TIME_WIDTH         26
    28. 

  28. 

  29. #include "cli.h"
    30. 

  30. #include "compat-errno.h"
    31. 

  31. #include "cli-cmd.h"
    32. 

  32. #include <sys/uio.h>
    33. 

  33. #include <stdlib.h>
    34. 

  34. #include <sys/mount.h>
    35. 

  35. #include "cli1-xdr.h"
    36. 

  36. #include "xdr-generic.h"
    37. 

  37. #include "protocol-common.h"
    38. 

  38. #include "cli-mem-types.h"
    39. 

  39. #include "compat.h"
    40. 

  40. 

  41. #include "syscall.h"
    42. 

  42. #include "glusterfs3.h"
    43. 

  43. #include "portmap-xdr.h"
    44. 

  44. 

  45. #include "run.h"
    46. 

  46. 

  47. extern rpc_clnt_prog_t *cli_rpc_prog;
    48. 

  48. extern int              cli_op_ret;
    49. 

  49. extern int              connected;
    50. 

  50. 

  51. char *cli_vol_type_str[] = {"Distribute",
    52. 

  52.                             "Stripe",
    53. 

  53.                             "Replicate",
    54. 

  54.                             "Striped-Replicate",
    55. 

  55.                             "Distributed-Stripe",
    56. 

  56.                             "Distributed-Replicate",
    57. 

  57.                             "Distributed-Striped-Replicate",
    58. 

  58.                            };
    59. 

  59. 

  60. char *cli_vol_status_str[] = {"Created",
    61. 

  61.                               "Started",
    62. 

  62.                               "Stopped",
    63. 

  63.                              };
    64. 

  64. 

  65. char *cli_volume_backend[] = {"",
    66. 

  66.                            "Volume Group",
    67. 

  67. };
    68. 

  68. 

  69. int32_t
    70. 

  70. gf_cli_get_volume (call_frame_t *frame, xlator_t *this,
    71. 

  71.                       void *data);
    72. 

  72. 

  73. int
    74. 

  74. cli_to_glusterd (gf_cli_req *req, call_frame_t *frame, fop_cbk_fn_t cbkfn,
    75. 

  75.                  xdrproc_t xdrproc, dict_t *dict, int procnum, xlator_t *this,
    76. 

  76.                  rpc_clnt_prog_t *prog, struct iobref *iobref);
    77. 

  77. 

  78. rpc_clnt_prog_t cli_handshake_prog = {
    79. 

  79.         .progname  = "cli handshake",
    80. 

  80.         .prognum   = GLUSTER_HNDSK_PROGRAM,
    81. 

  81.         .progver   = GLUSTER_HNDSK_VERSION,
    82. 

  82. };
    83. 

  83. 

  84. rpc_clnt_prog_t cli_pmap_prog = {
    85. 

  85.         .progname   = "cli portmap",
    86. 

  86.         .prognum    = GLUSTER_PMAP_PROGRAM,
    87. 

  87.         .progver    = GLUSTER_PMAP_VERSION,
    88. 

  88. };
    89. 

  89. 

  90. void
    91. 

  91. gf_cli_probe_strerror (gf1_cli_probe_rsp *rsp, char *msg, size_t len)
    92. 

  92. {
    93. 

  93.         switch (rsp->op_errno) {
    94. 

  94.         case GF_PROBE_ANOTHER_CLUSTER:
    95. 

  95.                 snprintf (msg, len, "%s is already part of another cluster",
    96. 

  96.                           rsp->hostname);
    97. 

  97.                 break;
    98. 

  98.         case GF_PROBE_VOLUME_CONFLICT:
    99. 

  99.                 snprintf (msg, len, "Atleast one volume on %s conflicts with "
    100. 

  100.                           "existing volumes in the cluster", rsp->hostname);
    101. 

  101.                 break;
    102. 

  102.         case GF_PROBE_UNKNOWN_PEER:
    103. 

  103.                 snprintf (msg, len, "%s responded with 'unknown peer' error, "
    104. 

  104.                           "this could happen if %s doesn't have localhost in "
    105. 

  105.                           "its peer database", rsp->hostname, rsp->hostname);
    106. 

  106.                 break;
    107. 

  107.         case GF_PROBE_ADD_FAILED:
    108. 

  108.                 snprintf (msg, len, "Failed to add peer information on %s" ,
    109. 

  109.                           rsp->hostname);
    110. 

  110.                 break;
    111. 

  111.         case GF_PROBE_SAME_UUID:
    112. 

  112.                 snprintf (msg, len, "Peer uuid (host %s) is same as local uuid",
    113. 

  113.                           rsp->hostname);
    114. 

  114.                 break;
    115. 

  115.         case GF_PROBE_QUORUM_NOT_MET:
    116. 

  116.                 snprintf (msg, len, "Cluster quorum is not met. Changing "
    117. 

  117.                           "peers is not allowed in this state");
    118. 

  118.                 break;
    119. 

  119.         default:
    120. 

  120.                 snprintf (msg, len, "Probe returned with unknown "
    121. 

  121.                           "errno %d", rsp->op_errno);
    122. 

  122.                 break;
    123. 

  123.         }
    124. 

  124. }
    125. 

  125. 

  126. int
    127. 

  127. gf_cli_probe_cbk (struct rpc_req *req, struct iovec *iov,
    128. 

  128.                         int count, void *myframe)
    129. 

  129. {
    130. 

  130.         gf1_cli_probe_rsp     rsp   = {0,};
    131. 

  131.         int                   ret   = -1;
    132. 

  132.         char                  msg[1024] = {0,};
    133. 

  133. 

  134.         if (-1 == req->rpc_status) {
    135. 

  135.                 goto out;
    136. 

  136.         }
    137. 

  137. 

  138.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_probe_rsp);
    139. 

  139.         if (ret < 0) {
    140. 

  140.                 gf_log ("", GF_LOG_ERROR, "error");
    141. 

  141.                 //rsp.op_ret   = -1;
    142. 

  142.                 //rsp.op_errno = EINVAL;
    143. 

  143.                 goto out;
    144. 

  144.         }
    145. 

  145. 

  146.         gf_log ("cli", GF_LOG_INFO, "Received resp to probe");
    147. 

  147.          if (!rsp.op_ret) {
    148. 

  148.                 switch (rsp.op_errno) {
    149. 

  149.                         case GF_PROBE_SUCCESS:
    150. 

  150.                                 snprintf (msg, sizeof (msg),
    151. 

  151.                                           "success");
    152. 

  152.                                 break;
    153. 

  153.                         case GF_PROBE_LOCALHOST:
    154. 

  154.                                 snprintf (msg, sizeof (msg),
    155. 

  155.                                           "success: on localhost not needed");
    156. 

  156.                                 break;
    157. 

  157.                         case GF_PROBE_FRIEND:
    158. 

  158.                                 snprintf (msg, sizeof (msg),
    159. 

  159.                                           "success: host %s port %d already"
    160. 

  160.                                           " in peer list", rsp.hostname,
    161. 

  161.                                           rsp.port);
    162. 

  162.                                 break;
    163. 

  163.                         default:
    164. 

  164.                                 rsp.op_ret = -1;
    165. 

  165.                                 snprintf (msg, sizeof (msg),
    166. 

  166.                                           "Probe returned with unknown errno"
    167. 

  167.                                           " %d", rsp.op_errno);
    168. 

  168.                                 break;
    169. 

  169.                 }
    170. 

  170.          }
    171. 

  171. 

  172.         if (rsp.op_ret) {
    173. 

  173.                 if (rsp.op_errstr && (strlen (rsp.op_errstr) > 0)) {
    174. 

  174.                         snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    175. 

  175.                 } else {
    176. 

  176.                         gf_cli_probe_strerror (&rsp, msg, sizeof (msg));
    177. 

  177.                 }
    178. 

  178.                 gf_log ("cli", GF_LOG_ERROR, "%s", msg);
    179. 

  179.         }
    180. 

  180. 

  181.         if (global_state->mode & GLUSTER_MODE_XML) {
    182. 

  182.                 ret = cli_xml_output_str (NULL,
    183. 

  183.                                           (rsp.op_ret)? NULL : msg,
    184. 

  184.                                           rsp.op_ret, rsp.op_errno,
    185. 

  185.                                           (rsp.op_ret)? msg : NULL);
    186. 

  186.                 if (ret)
    187. 

  187.                         gf_log ("cli", GF_LOG_ERROR,
    188. 

  188.                                 "Error outputting to xml");
    189. 

  189.                 goto out;
    190. 

  190.         }
    191. 

  191. 

  192.         if (!rsp.op_ret)
    193. 

  193.                 cli_out ("peer probe: %s", msg);
    194. 

  194.         else
    195. 

  195.                 cli_err ("peer probe: failed: %s", msg);
    196. 

  196. 

  197.         ret = rsp.op_ret;
    198. 

  198. 

  199. out:
    200. 

  200.         cli_cmd_broadcast_response (ret);
    201. 

  201.         return ret;
    202. 

  202. }
    203. 

  203. 

  204. int
    205. 

  205. gf_cli_deprobe_cbk (struct rpc_req *req, struct iovec *iov,
    206. 

  206.                        int count, void *myframe)
    207. 

  207. {
    208. 

  208.         gf1_cli_deprobe_rsp    rsp   = {0,};
    209. 

  209.         int                   ret   = -1;
    210. 

  210.         char                  msg[1024] = {0,};
    211. 

  211. 

  212.         if (-1 == req->rpc_status) {
    213. 

  213.                 goto out;
    214. 

  214.         }
    215. 

  215. 

  216.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_deprobe_rsp);
    217. 

  217.         if (ret < 0) {
    218. 

  218.                 gf_log ("", GF_LOG_ERROR, "error");
    219. 

  219.                 //rsp.op_ret   = -1;
    220. 

  220.                 //rsp.op_errno = EINVAL;
    221. 

  221.                 goto out;
    222. 

  222.         }
    223. 

  223. 

  224.         gf_log ("cli", GF_LOG_INFO, "Received resp to deprobe");
    225. 

  225.         if (rsp.op_ret) {
    226. 

  226.                 if (strlen (rsp.op_errstr) > 0) {
    227. 

  227.                         snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    228. 

  228.                         gf_log ("cli", GF_LOG_ERROR, "%s", rsp.op_errstr);
    229. 

  229.                 } else {
    230. 

  230.                         switch (rsp.op_errno) {
    231. 

  231.                                 case GF_DEPROBE_LOCALHOST:
    232. 

  232.                                         snprintf (msg, sizeof (msg),
    233. 

  233.                                                   "%s is localhost",
    234. 

  234.                                                   rsp.hostname);
    235. 

  235.                                         break;
    236. 

  236.                                 case GF_DEPROBE_NOT_FRIEND:
    237. 

  237.                                         snprintf (msg, sizeof (msg),
    238. 

  238.                                                   "%s is not part of cluster",
    239. 

  239.                                                   rsp.hostname);
    240. 

  240.                                         break;
    241. 

  241.                                 case GF_DEPROBE_BRICK_EXIST:
    242. 

  242.                                         snprintf (msg, sizeof (msg),
    243. 

  243.                                                   "Brick(s) with the peer %s "
    244. 

  244.                                                   "exist in cluster",
    245. 

  245.                                                   rsp.hostname);
    246. 

  246.                                         break;
    247. 

  247.                                 case GF_DEPROBE_FRIEND_DOWN:
    248. 

  248.                                         snprintf (msg, sizeof (msg),
    249. 

  249.                                                   "One of the peers is probably"
    250. 

  250.                                                   " down. Check with 'peer "
    251. 

  251.                                                   "status'.");
    252. 

  252.                                         break;
    253. 

  253.                                 case GF_DEPROBE_QUORUM_NOT_MET:
    254. 

  254.                                         snprintf (msg, sizeof (msg), "Cluster "
    255. 

  255.                                                   "quorum is not met. Changing "
    256. 

  256.                                                   "peers is not allowed in this"
    257. 

  257.                                                   " state");
    258. 

  258.                                         break;
    259. 

  259.                                 default:
    260. 

  260.                                         snprintf (msg, sizeof (msg),
    261. 

  261.                                                   "Detach returned with unknown"
    262. 

  262.                                                   " errno %d", rsp.op_errno);
    263. 

  263.                                         break;
    264. 

  264.                         }
    265. 

  265.                         gf_log ("cli", GF_LOG_ERROR,"Detach failed with op_ret "
    266. 

  266.                                 "%d and op_errno %d", rsp.op_ret, rsp.op_errno);
    267. 

  267.                 }
    268. 

  268.         } else {
    269. 

  269.                 snprintf (msg, sizeof (msg), "success");
    270. 

  270.         }
    271. 

  271. 

  272.         if (global_state->mode & GLUSTER_MODE_XML) {
    273. 

  273.                 ret = cli_xml_output_str (NULL,
    274. 

  274.                                           (rsp.op_ret)? NULL : msg,
    275. 

  275.                                           rsp.op_ret, rsp.op_errno,
    276. 

  276.                                           (rsp.op_ret)? msg : NULL);
    277. 

  277.                 if (ret)
    278. 

  278.                         gf_log ("cli", GF_LOG_ERROR,
    279. 

  279.                                 "Error outputting to xml");
    280. 

  280.                 goto out;
    281. 

  281.         }
    282. 

  282. 

  283.         if (!rsp.op_ret)
    284. 

  284.                 cli_out ("peer detach: %s", msg);
    285. 

  285.         else
    286. 

  286.                 cli_err ("peer detach: failed: %s", msg);
    287. 

  287. 

  288.         ret = rsp.op_ret;
    289. 

  289. 

  290. out:
    291. 

  291.         cli_cmd_broadcast_response (ret);
    292. 

  292.         return ret;
    293. 

  293. }
    294. 

  294. 

  295. int
    296. 

  296. gf_cli_list_friends_cbk (struct rpc_req *req, struct iovec *iov,
    297. 

  297.                              int count, void *myframe)
    298. 

  298. {
    299. 

  299.         gf1_cli_peer_list_rsp      rsp   = {0,};
    300. 

  300.         int                        ret   = -1;
    301. 

  301.         dict_t                     *dict = NULL;
    302. 

  302.         char                       *uuid_buf = NULL;
    303. 

  303.         char                       *hostname_buf = NULL;
    304. 

  304.         int32_t                    i = 1;
    305. 

  305.         char                       key[256] = {0,};
    306. 

  306.         char                       *state = NULL;
    307. 

  307.         int32_t                    port = 0;
    308. 

  308.         int32_t                    connected = 0;
    309. 

  309.         char                       *connected_str = NULL;
    310. 

  310.         char                       msg[1024] = {0,};
    311. 

  311. 

  312.         if (-1 == req->rpc_status) {
    313. 

  313.                 goto out;
    314. 

  314.         }
    315. 

  315. 

  316.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_peer_list_rsp);
    317. 

  317.         if (ret < 0) {
    318. 

  318.                 gf_log ("", GF_LOG_ERROR, "error");
    319. 

  319.                 //rsp.op_ret   = -1;
    320. 

  320.                 //rsp.op_errno = EINVAL;
    321. 

  321.                 goto out;
    322. 

  322.         }
    323. 

  323. 

  324.         gf_log ("cli", GF_LOG_INFO, "Received resp to list: %d",
    325. 

  325.                 rsp.op_ret);
    326. 

  326. 

  327.         ret = rsp.op_ret;
    328. 

  328. 

  329.         if (!rsp.op_ret) {
    330. 

  330. 

  331.                 if (!rsp.friends.friends_len) {
    332. 

  332.                         snprintf (msg, sizeof (msg),
    333. 

  333.                                   "peer status: No peers present");
    334. 

  334.                         if (global_state->mode & GLUSTER_MODE_XML) {
    335. 

  335.                                 ret = cli_xml_output_peer_status (dict,
    336. 

  336.                                                                   rsp.op_ret,
    337. 

  337.                                                                   rsp.op_errno,
    338. 

  338.                                                                   msg);
    339. 

  339.                                 if (ret)
    340. 

  340.                                         gf_log ("cli", GF_LOG_ERROR,
    341. 

  341.                                                 "Error outputting to xml");
    342. 

  342.                                 goto out;
    343. 

  343.                         }
    344. 

  344.                         cli_err ("%s", msg);
    345. 

  345.                         ret = 0;
    346. 

  346.                         goto out;
    347. 

  347.                 }
    348. 

  348. 

  349.                 dict = dict_new ();
    350. 

  350. 

  351.                 if (!dict) {
    352. 

  352.                         ret = -1;
    353. 

  353.                         goto out;
    354. 

  354.                 }
    355. 

  355. 

  356.                 ret = dict_unserialize (rsp.friends.friends_val,
    357. 

  357.                                         rsp.friends.friends_len,
    358. 

  358.                                         &dict);
    359. 

  359. 

  360.                 if (ret) {
    361. 

  361.                         gf_log ("", GF_LOG_ERROR,
    362. 

  362.                                         "Unable to allocate memory");
    363. 

  363.                         goto out;
    364. 

  364.                 }
    365. 

  365. 

  366.                 if (global_state->mode & GLUSTER_MODE_XML) {
    367. 

  367.                         ret = cli_xml_output_peer_status (dict, rsp.op_ret,
    368. 

  368.                                                           rsp.op_errno, msg);
    369. 

  369.                         if (ret)
    370. 

  370.                                 gf_log ("cli", GF_LOG_ERROR,
    371. 

  371.                                         "Error outputting to xml");
    372. 

  372.                         goto out;
    373. 

  373.                 }
    374. 

  374. 

  375.                 ret = dict_get_int32 (dict, "count", &count);
    376. 

  376.                 if (ret) {
    377. 

  377.                         goto out;
    378. 

  378.                 }
    379. 

  379. 

  380.                 cli_out ("Number of Peers: %d", count);
    381. 

  381.                 i = 1;
    382. 

  382.                 while ( i <= count) {
    383. 

  383.                         snprintf (key, 256, "friend%d.uuid", i);
    384. 

  384.                         ret = dict_get_str (dict, key, &uuid_buf);
    385. 

  385.                         if (ret)
    386. 

  386.                                 goto out;
    387. 

  387. 

  388.                         snprintf (key, 256, "friend%d.hostname", i);
    389. 

  389.                         ret = dict_get_str (dict, key, &hostname_buf);
    390. 

  390.                         if (ret)
    391. 

  391.                                 goto out;
    392. 

  392. 

  393.                         snprintf (key, 256, "friend%d.connected", i);
    394. 

  394.                         ret = dict_get_int32 (dict, key, &connected);
    395. 

  395.                         if (ret)
    396. 

  396.                                 goto out;
    397. 

  397.                         if (connected)
    398. 

  398.                                 connected_str = "Connected";
    399. 

  399.                         else
    400. 

  400.                                 connected_str = "Disconnected";
    401. 

  401. 

  402.                         snprintf (key, 256, "friend%d.port", i);
    403. 

  403.                         ret = dict_get_int32 (dict, key, &port);
    404. 

  404.                         if (ret)
    405. 

  405.                                 goto out;
    406. 

  406. 

  407.                         snprintf (key, 256, "friend%d.state", i);
    408. 

  408.                         ret = dict_get_str (dict, key, &state);
    409. 

  409.                         if (ret)
    410. 

  410.                                 goto out;
    411. 

  411. 

  412.                         if (!port) {
    413. 

  413.                                 cli_out ("\nHostname: %s\nUuid: %s\nState: %s "
    414. 

  414.                                          "(%s)",
    415. 

  415.                                          hostname_buf, uuid_buf, state,
    416. 

  416.                                          connected_str);
    417. 

  417.                         } else {
    418. 

  418.                                 cli_out ("\nHostname: %s\nPort: %d\nUuid: %s\n"
    419. 

  419.                                          "State: %s (%s)", hostname_buf, port,
    420. 

  420.                                          uuid_buf, state, connected_str);
    421. 

  421.                         }
    422. 

  422.                         i++;
    423. 

  423.                 }
    424. 

  424.         } else {
    425. 

  425.                 if (global_state->mode & GLUSTER_MODE_XML) {
    426. 

  426.                         ret = cli_xml_output_peer_status (dict, rsp.op_ret,
    427. 

  427.                                                           rsp.op_errno, NULL);
    428. 

  428.                         if (ret)
    429. 

  429.                                 gf_log ("cli", GF_LOG_ERROR,
    430. 

  430.                                         "Error outputting to xml");
    431. 

  431.                 } else {
    432. 

  432.                         ret = -1;
    433. 

  433.                 }
    434. 

  434.                 goto out;
    435. 

  435.         }
    436. 

  436. 

  437. 

  438.         ret = 0;
    439. 

  439. 

  440. out:
    441. 

  441.         cli_cmd_broadcast_response (ret);
    442. 

  442.         if (ret)
    443. 

  443.                 cli_err ("peer status: failed");
    444. 

  444. 

  445.         if (dict)
    446. 

  446.                 dict_destroy (dict);
    447. 

  447. 

  448.         return ret;
    449. 

  449. }
    450. 

  450. 

  451. void
    452. 

  452. cli_out_options ( char *substr, char *optstr, char *valstr)
    453. 

  453. {
    454. 

  454.         char                    *ptr1 = NULL;
    455. 

  455.         char                    *ptr2 = NULL;
    456. 

  456. 

  457.         ptr1 = substr;
    458. 

  458.         ptr2 = optstr;
    459. 

  459. 

  460.         while (ptr1)
    461. 

  461.         {
    462. 

  462.                 if (*ptr1 != *ptr2)
    463. 

  463.                         break;
    464. 

  464.                 ptr1++;
    465. 

  465.                 ptr2++;
    466. 

  466.                 if (!ptr1)
    467. 

  467.                         return;
    468. 

  468.                 if (!ptr2)
    469. 

  469.                         return;
    470. 

  470.         }
    471. 

  471. 

  472.         if (*ptr2 == '\0')
    473. 

  473.                 return;
    474. 

  474.         cli_out ("%s: %s",ptr2 , valstr);
    475. 

  475. }
    476. 

  476. 

  477. static int
    478. 

  478. _gf_cli_output_volinfo_opts (dict_t *d, char *k,
    479. 

  479.                              data_t *v, void *tmp)
    480. 

  480. {
    481. 

  481.         int     ret   = 0;
    482. 

  482.         char   *key   = NULL;
    483. 

  483.         char   *ptr   = NULL;
    484. 

  484.         data_t *value = NULL;
    485. 

  485. 

  486.         key = tmp;
    487. 

  487. 

  488.         ptr = strstr (k, "option.");
    489. 

  489.         if (ptr) {
    490. 

  490.                 value = v;
    491. 

  491.                 if (!value) {
    492. 

  492.                         ret = -1;
    493. 

  493.                         goto out;
    494. 

  494.                 }
    495. 

  495.                 cli_out_options (key, k, v->data);
    496. 

  496.         }
    497. 

  497. out:
    498. 

  498.         return ret;
    499. 

  499. }
    500. 

  500. 

  501. 

  502. int
    503. 

  503. gf_cli_get_volume_cbk (struct rpc_req *req, struct iovec *iov,
    504. 

  504.                           int count, void *myframe)
    505. 

  505. {
    506. 

  506.         int                        ret                  = -1;
    507. 

  507.         int                        opt_count            = 0;
    508. 

  508.         int32_t                    i                    = 0;
    509. 

  509.         int32_t                    j                    = 1;
    510. 

  510.         int32_t                    status               = 0;
    511. 

  511.         int32_t                    type                 = 0;
    512. 

  512.         int32_t                    brick_count          = 0;
    513. 

  513.         int32_t                    dist_count           = 0;
    514. 

  514.         int32_t                    stripe_count         = 0;
    515. 

  515.         int32_t                    replica_count        = 0;
    516. 

  516.         int32_t                    vol_type             = 0;
    517. 

  517.         int32_t                    transport            = 0;
    518. 

  518.         char                      *volume_id_str        = NULL;
    519. 

  519.         char                      *brick                = NULL;
    520. 

  520.         char                      *volname              = NULL;
    521. 

  521.         dict_t                    *dict                 = NULL;
    522. 

  522.         cli_local_t               *local                = NULL;
    523. 

  523.         char                       key[1024]            = {0};
    524. 

  524.         char                       err_str[2048]        = {0};
    525. 

  525.         gf_cli_rsp                 rsp                  = {0};
    526. 

  526.         int32_t                    backend              = 0;
    527. 

  527. 

  528.         if (-1 == req->rpc_status)
    529. 

  529.                 goto out;
    530. 

  530. 

  531.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    532. 

  532.         if (ret < 0) {
    533. 

  533.                 gf_log ("cli", GF_LOG_ERROR, "error");
    534. 

  534.                 goto out;
    535. 

  535.         }
    536. 

  536. 

  537.         gf_log ("cli", GF_LOG_INFO, "Received resp to get vol: %d",
    538. 

  538.                 rsp.op_ret);
    539. 

  539. 

  540.         if (rsp.op_ret) {
    541. 

  541.                 ret = -1;
    542. 

  542.                 goto out;
    543. 

  543.         }
    544. 

  544. 

  545.         if (!rsp.dict.dict_len) {
    546. 

  546.                 if (global_state->mode & GLUSTER_MODE_XML)
    547. 

  547.                         goto xml_output;
    548. 

  548.                 cli_err ("No volumes present");
    549. 

  549.                 ret = 0;
    550. 

  550.                 goto out;
    551. 

  551.         }
    552. 

  552. 

  553.         dict = dict_new ();
    554. 

  554. 

  555.         if (!dict) {
    556. 

  556.                 ret = -1;
    557. 

  557.                 goto out;
    558. 

  558.         }
    559. 

  559. 

  560.         ret = dict_unserialize (rsp.dict.dict_val,
    561. 

  561.                                 rsp.dict.dict_len,
    562. 

  562.                                 &dict);
    563. 

  563. 

  564.         if (ret) {
    565. 

  565.                 gf_log ("cli", GF_LOG_ERROR,
    566. 

  566.                         "Unable to allocate memory");
    567. 

  567.                 goto out;
    568. 

  568.         }
    569. 

  569. 

  570.         ret = dict_get_int32 (dict, "count", &count);
    571. 

  571.         if (ret)
    572. 

  572.                 goto out;
    573. 

  573. 

  574.         local = ((call_frame_t *)myframe)->local;
    575. 

  575. 

  576.         if (!count) {
    577. 

  577.                 switch (local->get_vol.flags) {
    578. 

  578. 

  579.                 case GF_CLI_GET_NEXT_VOLUME:
    580. 

  580.                         GF_FREE (local->get_vol.volname);
    581. 

  581.                         local->get_vol.volname = NULL;
    582. 

  582.                         ret = 0;
    583. 

  583.                         goto out;
    584. 

  584. 

  585.                 case GF_CLI_GET_VOLUME:
    586. 

  586.                         memset (err_str, 0, sizeof (err_str));
    587. 

  587.                         snprintf (err_str, sizeof (err_str),
    588. 

  588.                                   "Volume %s does not exist",
    589. 

  589.                                   local->get_vol.volname);
    590. 

  590.                         ret = -1;
    591. 

  591.                         if (!(global_state->mode & GLUSTER_MODE_XML))
    592. 

  592.                                 goto out;
    593. 

  593.                 }
    594. 

  594.         }
    595. 

  595. 

  596. xml_output:
    597. 

  597.         if (global_state->mode & GLUSTER_MODE_XML) {
    598. 

  598.                 /* For GET_NEXT_VOLUME output is already begun in
    599. 

  599.                  * and will also end in gf_cli_get_next_volume()
    600. 

  600.                  */
    601. 

  601.                 if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
    602. 

  602.                         ret = cli_xml_output_vol_info_begin
    603. 

  603.                                 (local, rsp.op_ret, rsp.op_errno,
    604. 

  604.                                  rsp.op_errstr);
    605. 

  605.                         if (ret) {
    606. 

  606.                                 gf_log ("cli", GF_LOG_ERROR,
    607. 

  607.                                         "Error outputting to xml");
    608. 

  608.                                 goto out;
    609. 

  609.                         }
    610. 

  610.                 }
    611. 

  611. 

  612.                 if (dict) {
    613. 

  613.                         ret = cli_xml_output_vol_info (local, dict);
    614. 

  614.                         if (ret) {
    615. 

  615.                                 gf_log ("cli", GF_LOG_ERROR,
    616. 

  616.                                         "Error outputting to xml");
    617. 

  617.                                 goto out;
    618. 

  618.                         }
    619. 

  619.                 }
    620. 

  620. 

  621.                 if (local->get_vol.flags == GF_CLI_GET_VOLUME) {
    622. 

  622.                         ret = cli_xml_output_vol_info_end (local);
    623. 

  623.                         if (ret)
    624. 

  624.                                 gf_log ("cli", GF_LOG_ERROR,
    625. 

  625.                                         "Error outputting to xml");
    626. 

  626.                 }
    627. 

  627.                 goto out;
    628. 

  628.         }
    629. 

  629. 

  630.         while ( i < count) {
    631. 

  631.                 cli_out (" ");
    632. 

  632.                 snprintf (key, 256, "volume%d.name", i);
    633. 

  633.                 ret = dict_get_str (dict, key, &volname);
    634. 

  634.                 if (ret)
    635. 

  635.                         goto out;
    636. 

  636. 

  637.                 snprintf (key, 256, "volume%d.type", i);
    638. 

  638.                 ret = dict_get_int32 (dict, key, &type);
    639. 

  639.                 if (ret)
    640. 

  640.                         goto out;
    641. 

  641. 

  642.                 snprintf (key, 256, "volume%d.status", i);
    643. 

  643.                 ret = dict_get_int32 (dict, key, &status);
    644. 

  644.                 if (ret)
    645. 

  645.                         goto out;
    646. 

  646. 

  647.                 snprintf (key, 256, "volume%d.brick_count", i);
    648. 

  648.                 ret = dict_get_int32 (dict, key, &brick_count);
    649. 

  649.                 if (ret)
    650. 

  650.                         goto out;
    651. 

  651. 

  652.                 snprintf (key, 256, "volume%d.dist_count", i);
    653. 

  653.                 ret = dict_get_int32 (dict, key, &dist_count);
    654. 

  654.                 if (ret)
    655. 

  655.                         goto out;
    656. 

  656. 

  657.                 snprintf (key, 256, "volume%d.stripe_count", i);
    658. 

  658.                 ret = dict_get_int32 (dict, key, &stripe_count);
    659. 

  659.                 if (ret)
    660. 

  660.                         goto out;
    661. 

  661. 

  662.                 snprintf (key, 256, "volume%d.replica_count", i);
    663. 

  663.                 ret = dict_get_int32 (dict, key, &replica_count);
    664. 

  664.                 if (ret)
    665. 

  665.                         goto out;
    666. 

  666. 

  667.                 snprintf (key, 256, "volume%d.transport", i);
    668. 

  668.                 ret = dict_get_int32 (dict, key, &transport);
    669. 

  669.                 if (ret)
    670. 

  670.                         goto out;
    671. 

  671. 

  672.                 snprintf (key, 256, "volume%d.volume_id", i);
    673. 

  673.                 ret = dict_get_str (dict, key, &volume_id_str);
    674. 

  674.                 if (ret)
    675. 

  675.                         goto out;
    676. 

  676. 

  677.                 snprintf (key, 256, "volume%d.backend", i);
    678. 

  678.                 ret = dict_get_int32 (dict, key, &backend);
    679. 

  679. 

  680.                 vol_type = type;
    681. 

  681. 

  682.                 // Distributed (stripe/replicate/stripe-replica) setups
    683. 

  683.                 if ((type > 0) && ( dist_count < brick_count))
    684. 

  684.                         vol_type = type + 3;
    685. 

  685. 

  686.                 cli_out ("Volume Name: %s", volname);
    687. 

  687.                 cli_out ("Type: %s", cli_vol_type_str[vol_type]);
    688. 

  688.                 cli_out ("Volume ID: %s", volume_id_str);
    689. 

  689.                 cli_out ("Status: %s", cli_vol_status_str[status]);
    690. 

  690. 

  691.                 if (backend)
    692. 

  692.                         goto next;
    693. 

  693. 

  694.                 if (type == GF_CLUSTER_TYPE_STRIPE_REPLICATE) {
    695. 

  695.                         cli_out ("Number of Bricks: %d x %d x %d = %d",
    696. 

  696.                                  (brick_count / dist_count),
    697. 

  697.                                  stripe_count,
    698. 

  698.                                  replica_count,
    699. 

  699.                                  brick_count);
    700. 

  700.                 } else if (type == GF_CLUSTER_TYPE_NONE) {
    701. 

  701.                         cli_out ("Number of Bricks: %d", brick_count);
    702. 

  702.                 } else {
    703. 

  703.                         /* For both replicate and stripe, dist_count is
    704. 

  704.                            good enough */
    705. 

  705.                         cli_out ("Number of Bricks: %d x %d = %d",
    706. 

  706.                                  (brick_count / dist_count),
    707. 

  707.                                  dist_count, brick_count);
    708. 

  708.                 }
    709. 

  709. 

  710.                 cli_out ("Transport-type: %s",
    711. 

  711.                          ((transport == 0)?"tcp":
    712. 

  712.                           (transport == 1)?"rdma":
    713. 

  713.                           "tcp,rdma"));
    714. 

  714. 

  715. next:
    716. 

  716.                 if (backend) {
    717. 

  717.                         cli_out ("Backend Type: Block, %s",
    718. 

  718.                                  cli_volume_backend[backend]);
    719. 

  719.                 }
    720. 

  720.                 j = 1;
    721. 

  721. 

  722.                 GF_FREE (local->get_vol.volname);
    723. 

  723.                 local->get_vol.volname = gf_strdup (volname);
    724. 

  724. 

  725.                 if (brick_count)
    726. 

  726.                         cli_out ("Bricks:");
    727. 

  727. 

  728.                 while (j <= brick_count) {
    729. 

  729.                         snprintf (key, 1024, "volume%d.brick%d", i, j);
    730. 

  730.                         ret = dict_get_str (dict, key, &brick);
    731. 

  731.                         if (ret)
    732. 

  732.                                 goto out;
    733. 

  733. 

  734.                         cli_out ("Brick%d: %s", j, brick);
    735. 

  735.                         j++;
    736. 

  736.                 }
    737. 

  737. 

  738.                 snprintf (key, 256, "volume%d.opt_count",i);
    739. 

  739.                 ret = dict_get_int32 (dict, key, &opt_count);
    740. 

  740.                 if (ret)
    741. 

  741.                         goto out;
    742. 

  742. 

  743.                 if (!opt_count)
    744. 

  744.                         goto out;
    745. 

  745. 

  746.                 cli_out ("Options Reconfigured:");
    747. 

  747. 

  748.                 snprintf (key, 256, "volume%d.option.",i);
    749. 

  749. 

  750.                 ret = dict_foreach (dict, _gf_cli_output_volinfo_opts, key);
    751. 

  751.                 if (ret)
    752. 

  752.                         goto out;
    753. 

  753. 

  754.                 i++;
    755. 

  755.         }
    756. 

  756. 

  757. 

  758.         ret = 0;
    759. 

  759. out:
    760. 

  760.         cli_cmd_broadcast_response (ret);
    761. 

  761.         if (ret)
    762. 

  762.                 cli_err ("%s", err_str);
    763. 

  763. 

  764.         if (dict)
    765. 

  765.                 dict_destroy (dict);
    766. 

  766. 

  767.         free (rsp.dict.dict_val);
    768. 

  768. 

  769.         free (rsp.op_errstr);
    770. 

  770. 

  771.         gf_log ("cli", GF_LOG_INFO, "Returning: %d", ret);
    772. 

  772.         return ret;
    773. 

  773. }
    774. 

  774. 

  775. int
    776. 

  776. gf_cli_create_volume_cbk (struct rpc_req *req, struct iovec *iov,
    777. 

  777.                              int count, void *myframe)
    778. 

  778. {
    779. 

  779.         gf_cli_rsp              rsp   = {0,};
    780. 

  780.         int                     ret   = -1;
    781. 

  781.         cli_local_t             *local = NULL;
    782. 

  782.         char                    *volname = NULL;
    783. 

  783.         dict_t                  *dict = NULL;
    784. 

  784.         dict_t                  *rsp_dict = NULL;
    785. 

  785. 

  786.         if (-1 == req->rpc_status) {
    787. 

  787.                 goto out;
    788. 

  788.         }
    789. 

  789. 

  790.         local = ((call_frame_t *) (myframe))->local;
    791. 

  791. 

  792.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    793. 

  793.         if (ret < 0) {
    794. 

  794.                 gf_log ("", GF_LOG_ERROR, "error");
    795. 

  795.                 goto out;
    796. 

  796.         }
    797. 

  797. 

  798.         gf_log ("cli", GF_LOG_INFO, "Received resp to create volume");
    799. 

  799. 

  800.         dict = local->dict;
    801. 

  801. 

  802.         ret = dict_get_str (dict, "volname", &volname);
    803. 

  803.         if (ret)
    804. 

  804.                 goto out;
    805. 

  805. 

  806.         if (global_state->mode & GLUSTER_MODE_XML) {
    807. 

  807.                 if (rsp.op_ret == 0) {
    808. 

  808.                         rsp_dict = dict_new ();
    809. 

  809.                         ret = dict_unserialize (rsp.dict.dict_val,
    810. 

  810.                                                 rsp.dict.dict_len,
    811. 

  811.                                                 &rsp_dict);
    812. 

  812.                         if (ret) {
    813. 

  813.                                 gf_log ("cli", GF_LOG_ERROR,
    814. 

  814.                                         "Failed rsp_dict unserialization");
    815. 

  815.                                 goto out;
    816. 

  816.                         }
    817. 

  817.                 }
    818. 

  818. 

  819.                 ret = cli_xml_output_vol_create (rsp_dict, rsp.op_ret,
    820. 

  820.                                                  rsp.op_errno, rsp.op_errstr);
    821. 

  821.                 if (ret)
    822. 

  822.                         gf_log ("cli", GF_LOG_ERROR,
    823. 

  823.                                 "Error outputting to xml");
    824. 

  824.                 goto out;
    825. 

  825.         }
    826. 

  826. 

  827.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    828. 

  828.                 cli_err ("volume create: %s: failed: %s", volname,
    829. 

  829.                          rsp.op_errstr);
    830. 

  830.         else if (rsp.op_ret)
    831. 

  831.                 cli_err ("volume create: %s: failed", volname);
    832. 

  832.         else
    833. 

  833.                 cli_out ("volume create: %s: success: "
    834. 

  834.                          "please start the volume to access data", volname);
    835. 

  835. 

  836.         ret = rsp.op_ret;
    837. 

  837. 

  838. out:
    839. 

  839.         cli_cmd_broadcast_response (ret);
    840. 

  840.         free (rsp.dict.dict_val);
    841. 

  841.         free (rsp.op_errstr);
    842. 

  842.         return ret;
    843. 

  843. }
    844. 

  844. 

  845. int
    846. 

  846. gf_cli_delete_volume_cbk (struct rpc_req *req, struct iovec *iov,
    847. 

  847.                              int count, void *myframe)
    848. 

  848. {
    849. 

  849.         gf_cli_rsp              rsp   = {0,};
    850. 

  850.         int                     ret   = -1;
    851. 

  851.         cli_local_t             *local = NULL;
    852. 

  852.         char                    *volname = NULL;
    853. 

  853.         call_frame_t            *frame = NULL;
    854. 

  854.         dict_t                  *dict = NULL;
    855. 

  855.         dict_t                  *rsp_dict = NULL;
    856. 

  856. 

  857.         if (-1 == req->rpc_status) {
    858. 

  858.                 goto out;
    859. 

  859.         }
    860. 

  860. 

  861.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    862. 

  862.         if (ret < 0) {
    863. 

  863.                 gf_log ("", GF_LOG_ERROR, "error");
    864. 

  864.                 goto out;
    865. 

  865.         }
    866. 

  866. 

  867.         frame = myframe;
    868. 

  868.         local = frame->local;
    869. 

  869. 

  870.         if (local)
    871. 

  871.                 dict = local->dict;
    872. 

  872.         ret = dict_get_str (dict, "volname", &volname);
    873. 

  873.         if (ret) {
    874. 

  874.                 gf_log (THIS->name, GF_LOG_ERROR,
    875. 

  875.                         "dict get failed");
    876. 

  876.                 goto out;
    877. 

  877.         }
    878. 

  878. 

  879.         gf_log ("cli", GF_LOG_INFO, "Received resp to delete volume");
    880. 

  880. 

  881.         if (global_state->mode & GLUSTER_MODE_XML) {
    882. 

  882.                 if (rsp.op_ret == 0) {
    883. 

  883.                         rsp_dict = dict_new ();
    884. 

  884.                         ret = dict_unserialize (rsp.dict.dict_val,
    885. 

  885.                                                 rsp.dict.dict_len,
    886. 

  886.                                                 &rsp_dict);
    887. 

  887.                         if (ret) {
    888. 

  888.                                 gf_log ("cli", GF_LOG_ERROR,
    889. 

  889.                                         "Failed rsp_dict unserialization");
    890. 

  890.                                 goto out;
    891. 

  891.                         }
    892. 

  892.                 }
    893. 

  893. 

  894.                 ret = cli_xml_output_generic_volume ("volDelete", rsp_dict,
    895. 

  895.                                                      rsp.op_ret, rsp.op_errno,
    896. 

  896.                                                      rsp.op_errstr);
    897. 

  897.                 if (ret)
    898. 

  898.                         gf_log ("cli", GF_LOG_ERROR,
    899. 

  899.                                 "Error outputting to xml");
    900. 

  900.                 goto out;
    901. 

  901.         }
    902. 

  902. 

  903.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    904. 

  904.                 cli_err ("volume delete: %s: failed: %s", volname,
    905. 

  905.                          rsp.op_errstr);
    906. 

  906.         else if (rsp.op_ret)
    907. 

  907.                 cli_err ("volume delete: %s: failed", volname);
    908. 

  908.         else
    909. 

  909.                 cli_out ("volume delete: %s: success", volname);
    910. 

  910. 

  911.         ret = rsp.op_ret;
    912. 

  912. 

  913. out:
    914. 

  914.         cli_cmd_broadcast_response (ret);
    915. 

  915.         free (rsp.dict.dict_val);
    916. 

  916. 

  917.         gf_log ("", GF_LOG_INFO, "Returning with %d", ret);
    918. 

  918.         return ret;
    919. 

  919. }
    920. 

  920. 

  921. int
    922. 

  922. gf_cli3_1_uuid_reset_cbk (struct rpc_req *req, struct iovec *iov,
    923. 

  923.                              int count, void *myframe)
    924. 

  924. {
    925. 

  925.         gf_cli_rsp              rsp   = {0,};
    926. 

  926.         int                     ret   = -1;
    927. 

  927.         cli_local_t             *local = NULL;
    928. 

  928.         call_frame_t            *frame = NULL;
    929. 

  929.         dict_t                  *dict = NULL;
    930. 

  930. 

  931.         if (-1 == req->rpc_status) {
    932. 

  932.                 goto out;
    933. 

  933.         }
    934. 

  934. 

  935.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    936. 

  936.         if (ret < 0) {
    937. 

  937.                 gf_log ("", GF_LOG_ERROR, "error");
    938. 

  938.                 goto out;
    939. 

  939.         }
    940. 

  940. 

  941.         frame = myframe;
    942. 

  942.         local = frame->local;
    943. 

  943.         frame->local = NULL;
    944. 

  944. 

  945.         gf_log ("cli", GF_LOG_INFO, "Received resp to uuid reset");
    946. 

  946. 

  947.         if (global_state->mode & GLUSTER_MODE_XML) {
    948. 

  948.                 ret = cli_xml_output_dict ("uuidReset", dict, rsp.op_ret,
    949. 

  949.                                            rsp.op_errno, rsp.op_errstr);
    950. 

  950.                 if (ret)
    951. 

  951.                         gf_log ("cli", GF_LOG_ERROR,
    952. 

  952.                                 "Error outputting to xml");
    953. 

  953.                 goto out;
    954. 

  954.         }
    955. 

  955. 

  956.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    957. 

  957.                 cli_err ("%s", rsp.op_errstr);
    958. 

  958.         else
    959. 

  959.                 cli_out ("resetting the peer uuid has been %s",
    960. 

  960.                          (rsp.op_ret) ? "unsuccessful": "successful");
    961. 

  961.         ret = rsp.op_ret;
    962. 

  962. 

  963. out:
    964. 

  964.         cli_cmd_broadcast_response (ret);
    965. 

  965.         cli_local_wipe (local);
    966. 

  966.         if (rsp.dict.dict_val)
    967. 

  967.                 free (rsp.dict.dict_val);
    968. 

  968.         if (dict)
    969. 

  969.                 dict_unref (dict);
    970. 

  970. 

  971.         gf_log ("", GF_LOG_INFO, "Returning with %d", ret);
    972. 

  972.         return ret;
    973. 

  973. }
    974. 

  974. 

  975. int
    976. 

  976. gf_cli_start_volume_cbk (struct rpc_req *req, struct iovec *iov,
    977. 

  977.                              int count, void *myframe)
    978. 

  978. {
    979. 

  979.         gf_cli_rsp              rsp   = {0,};
    980. 

  980.         int                     ret   = -1;
    981. 

  981.         cli_local_t             *local = NULL;
    982. 

  982.         char                    *volname = NULL;
    983. 

  983.         call_frame_t            *frame = NULL;
    984. 

  984.         dict_t                  *dict = NULL;
    985. 

  985.         dict_t                  *rsp_dict = NULL;
    986. 

  986. 

  987.         if (-1 == req->rpc_status) {
    988. 

  988.                 goto out;
    989. 

  989.         }
    990. 

  990. 

  991.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    992. 

  992.         if (ret < 0) {
    993. 

  993.                 gf_log ("", GF_LOG_ERROR, "error");
    994. 

  994.                 goto out;
    995. 

  995.         }
    996. 

  996. 

  997.         frame = myframe;
    998. 

  998. 

  999.         if (frame)
    1000. 

  1000.                 local = frame->local;
    1001. 

  1001. 

  1002.         if (local)
    1003. 

  1003.                 dict = local->dict;
    1004. 

  1004. 

  1005.         ret = dict_get_str (dict, "volname", &volname);
    1006. 

  1006.         if (ret) {
    1007. 

  1007.                 gf_log (THIS->name, GF_LOG_ERROR, "dict get failed");
    1008. 

  1008.                 goto out;
    1009. 

  1009.         }
    1010. 

  1010. 

  1011.         gf_log ("cli", GF_LOG_INFO, "Received resp to start volume");
    1012. 

  1012. 

  1013.         if (global_state->mode & GLUSTER_MODE_XML) {
    1014. 

  1014.                 if (rsp.op_ret == 0) {
    1015. 

  1015.                         rsp_dict = dict_new ();
    1016. 

  1016.                         ret = dict_unserialize (rsp.dict.dict_val,
    1017. 

  1017.                                                 rsp.dict.dict_len,
    1018. 

  1018.                                                 &rsp_dict);
    1019. 

  1019.                         if (ret) {
    1020. 

  1020.                                 gf_log ("cli", GF_LOG_ERROR,
    1021. 

  1021.                                         "Failed rsp_dict unserialization");
    1022. 

  1022.                                 goto out;
    1023. 

  1023.                         }
    1024. 

  1024.                 }
    1025. 

  1025. 

  1026.                 ret = cli_xml_output_generic_volume ("volStart", rsp_dict,
    1027. 

  1027.                                                      rsp.op_ret, rsp.op_errno,
    1028. 

  1028.                                                      rsp.op_errstr);
    1029. 

  1029.                 if (ret)
    1030. 

  1030.                         gf_log ("cli", GF_LOG_ERROR,
    1031. 

  1031.                                 "Error outputting to xml");
    1032. 

  1032.                 goto out;
    1033. 

  1033.         }
    1034. 

  1034. 

  1035.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    1036. 

  1036.                 cli_err ("volume start: %s: failed: %s", volname,
    1037. 

  1037.                          rsp.op_errstr);
    1038. 

  1038.         else if (rsp.op_ret)
    1039. 

  1039.                 cli_err ("volume start: %s: failed", volname);
    1040. 

  1040.         else
    1041. 

  1041.                 cli_out ("volume start: %s: success", volname);
    1042. 

  1042. 

  1043.         ret = rsp.op_ret;
    1044. 

  1044. 

  1045. out:
    1046. 

  1046.         cli_cmd_broadcast_response (ret);
    1047. 

  1047.         free (rsp.dict.dict_val);
    1048. 

  1048.         free (rsp.op_errstr);
    1049. 

  1049.         return ret;
    1050. 

  1050. }
    1051. 

  1051. 

  1052. int
    1053. 

  1053. gf_cli_stop_volume_cbk (struct rpc_req *req, struct iovec *iov,
    1054. 

  1054.                              int count, void *myframe)
    1055. 

  1055. {
    1056. 

  1056.         gf_cli_rsp            rsp   = {0,};
    1057. 

  1057.         int                   ret   = -1;
    1058. 

  1058.         cli_local_t           *local = NULL;
    1059. 

  1059.         char                  *volname = NULL;
    1060. 

  1060.         call_frame_t          *frame = NULL;
    1061. 

  1061.         dict_t                *dict = NULL;
    1062. 

  1062.         dict_t                *rsp_dict = NULL;
    1063. 

  1063. 

  1064.         if (-1 == req->rpc_status) {
    1065. 

  1065.                 goto out;
    1066. 

  1066.         }
    1067. 

  1067. 

  1068.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    1069. 

  1069.         if (ret < 0) {
    1070. 

  1070.                 gf_log ("", GF_LOG_ERROR, "error");
    1071. 

  1071.                 goto out;
    1072. 

  1072.         }
    1073. 

  1073. 

  1074.         frame = myframe;
    1075. 

  1075. 

  1076.         if (frame)
    1077. 

  1077.                 local = frame->local;
    1078. 

  1078. 

  1079.         if (local) {
    1080. 

  1080.                 dict = local->dict;
    1081. 

  1081.                 ret = dict_get_str (dict, "volname", &volname);
    1082. 

  1082.                 if (ret) {
    1083. 

  1083.                         gf_log (THIS->name, GF_LOG_ERROR,
    1084. 

  1084.                                 "Unable to get volname from dict");
    1085. 

  1085.                         goto out;
    1086. 

  1086.                 }
    1087. 

  1087.         }
    1088. 

  1088. 

  1089.         gf_log ("cli", GF_LOG_INFO, "Received resp to stop volume");
    1090. 

  1090. 

  1091.         if (global_state->mode & GLUSTER_MODE_XML) {
    1092. 

  1092.                 if (rsp.op_ret == 0) {
    1093. 

  1093.                         rsp_dict = dict_new ();
    1094. 

  1094.                         ret = dict_unserialize (rsp.dict.dict_val,
    1095. 

  1095.                                                 rsp.dict.dict_len,
    1096. 

  1096.                                                 &rsp_dict);
    1097. 

  1097.                         if (ret) {
    1098. 

  1098.                                 gf_log ("cli", GF_LOG_ERROR,
    1099. 

  1099.                                         "Failed rsp_dict unserialization");
    1100. 

  1100.                                 goto out;
    1101. 

  1101.                         }
    1102. 

  1102.                 }
    1103. 

  1103. 

  1104.                 ret = cli_xml_output_generic_volume ("volStop", rsp_dict,
    1105. 

  1105.                                                      rsp.op_ret, rsp.op_errno,
    1106. 

  1106.                                                      rsp.op_errstr);
    1107. 

  1107.                 if (ret)
    1108. 

  1108.                         gf_log ("cli", GF_LOG_ERROR,
    1109. 

  1109.                                 "Error outputting to xml");
    1110. 

  1110.                 goto out;
    1111. 

  1111.         }
    1112. 

  1112. 

  1113.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    1114. 

  1114.                 cli_err ("volume stop: %s: failed: %s", volname, rsp.op_errstr);
    1115. 

  1115.         else if (rsp.op_ret)
    1116. 

  1116.                 cli_err ("volume stop: %s: failed", volname);
    1117. 

  1117.         else
    1118. 

  1118.                 cli_out ("volume stop: %s: success", volname);
    1119. 

  1119. 

  1120.         ret = rsp.op_ret;
    1121. 

  1121. 

  1122. out:
    1123. 

  1123.         cli_cmd_broadcast_response (ret);
    1124. 

  1124.         free (rsp.op_errstr);
    1125. 

  1125.         free (rsp.dict.dict_val);
    1126. 

  1126. 

  1127.         return ret;
    1128. 

  1128. }
    1129. 

  1129. 

  1130. int
    1131. 

  1131. gf_cli_defrag_volume_cbk (struct rpc_req *req, struct iovec *iov,
    1132. 

  1132.                              int count, void *myframe)
    1133. 

  1133. {
    1134. 

  1134.         gf_cli_rsp               rsp     = {0,};
    1135. 

  1135.         cli_local_t             *local   = NULL;
    1136. 

  1136.         char                    *volname = NULL;
    1137. 

  1137.         call_frame_t            *frame   = NULL;
    1138. 

  1138.         char                    *status  = "unknown";
    1139. 

  1139.         int                      cmd     = 0;
    1140. 

  1140.         int                      ret     = -1;
    1141. 

  1141.         dict_t                  *dict    = NULL;
    1142. 

  1142.         dict_t                  *local_dict = NULL;
    1143. 

  1143.         uint64_t                 files   = 0;
    1144. 

  1144.         uint64_t                 size    = 0;
    1145. 

  1145.         uint64_t                 lookup  = 0;
    1146. 

  1146.         char                     msg[1024] = {0,};
    1147. 

  1147.         gf_defrag_status_t       status_rcd = GF_DEFRAG_STATUS_NOT_STARTED;
    1148. 

  1148.         int32_t                  counter = 0;
    1149. 

  1149.         char                    *node_uuid = NULL;
    1150. 

  1150.         char                     key[256] = {0,};
    1151. 

  1151.         int32_t                  i = 1;
    1152. 

  1152.         uint64_t                 failures = 0;
    1153. 

  1153.         double                   elapsed = 0;
    1154. 

  1154.         char                    *size_str = NULL;
    1155. 

  1155.         char                    *task_id_str = NULL;
    1156. 

  1156. 

  1157.         if (-1 == req->rpc_status) {
    1158. 

  1158.                 goto out;
    1159. 

  1159.         }
    1160. 

  1160. 

  1161.         ret = xdr_to_generic (*iov, &rsp,
    1162. 

  1162.                               (xdrproc_t)xdr_gf_cli_rsp);
    1163. 

  1163.         if (ret < 0) {
    1164. 

  1164.                 gf_log ("", GF_LOG_ERROR, "error");
    1165. 

  1165.                 goto out;
    1166. 

  1166.         }
    1167. 

  1167. 

  1168.         frame = myframe;
    1169. 

  1169. 

  1170.         if (frame)
    1171. 

  1171.                 local = frame->local;
    1172. 

  1172. 

  1173.         if (local)
    1174. 

  1174.                 local_dict = local->dict;
    1175. 

  1175. 

  1176.         ret = dict_get_str (local_dict, "volname", &volname);
    1177. 

  1177.         if (ret) {
    1178. 

  1178.                 gf_log (THIS->name, GF_LOG_ERROR,
    1179. 

  1179.                         "Failed to get volname");
    1180. 

  1180.                 goto out;
    1181. 

  1181.         }
    1182. 

  1182. 

  1183.         ret = dict_get_int32 (local_dict, "rebalance-command", (int32_t*)&cmd);
    1184. 

  1184.         if (ret) {
    1185. 

  1185.                 gf_log (THIS->name, GF_LOG_ERROR,
    1186. 

  1186.                         "Failed to get command");
    1187. 

  1187.                 goto out;
    1188. 

  1188.         }
    1189. 

  1189. 

  1190.         if (rsp.dict.dict_len) {
    1191. 

  1191.                 /* Unserialize the dictionary */
    1192. 

  1192.                 dict  = dict_new ();
    1193. 

  1193. 

  1194.                 ret = dict_unserialize (rsp.dict.dict_val,
    1195. 

  1195.                                         rsp.dict.dict_len,
    1196. 

  1196.                                         &dict);
    1197. 

  1197.                 if (ret < 0) {
    1198. 

  1198.                         gf_log ("glusterd", GF_LOG_ERROR,
    1199. 

  1199.                                 "failed to "
    1200. 

  1200.                                 "unserialize req-buffer to dictionary");
    1201. 

  1201.                         goto out;
    1202. 

  1202.                 }
    1203. 

  1203.         }
    1204. 

  1204. 

  1205.         if (!((cmd == GF_DEFRAG_CMD_STOP) || (cmd == GF_DEFRAG_CMD_STATUS)) &&
    1206. 

  1206.              !(global_state->mode & GLUSTER_MODE_XML)) {
    1207. 

  1207.                 /* All other possibilites are about starting a rebalance */
    1208. 

  1208.                 ret = dict_get_str (dict, GF_REBALANCE_TID_KEY, &task_id_str);
    1209. 

  1209.                 if (rsp.op_ret && strcmp (rsp.op_errstr, "")) {
    1210. 

  1210.                         snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    1211. 

  1211.                 } else {
    1212. 

  1212.                         if (!rsp.op_ret) {
    1213. 

  1213.                                 snprintf (msg, sizeof (msg),
    1214. 

  1214.                                           "Starting rebalance on volume %s has "
    1215. 

  1215.                                           "been successful.\nID: %s", volname,
    1216. 

  1216.                                           task_id_str);
    1217. 

  1217.                         } else {
    1218. 

  1218.                                 snprintf (msg, sizeof (msg),
    1219. 

  1219.                                           "Starting rebalance on volume %s has "
    1220. 

  1220.                                           "been unsuccessful.", volname);
    1221. 

  1221.                         }
    1222. 

  1222.                 }
    1223. 

  1223.                 goto done;
    1224. 

  1224.         }
    1225. 

  1225. 

  1226.         if (cmd == GF_DEFRAG_CMD_STOP) {
    1227. 

  1227.                 if (rsp.op_ret == -1) {
    1228. 

  1228.                         if (strcmp (rsp.op_errstr, ""))
    1229. 

  1229.                                 snprintf (msg, sizeof (msg),
    1230. 

  1230.                                           "%s", rsp.op_errstr);
    1231. 

  1231.                         else
    1232. 

  1232.                                 snprintf (msg, sizeof (msg),
    1233. 

  1233.                                           "rebalance volume %s stop failed",
    1234. 

  1234.                                           volname);
    1235. 

  1235.                         goto done;
    1236. 

  1236.                 } else {
    1237. 

  1237.                         snprintf (msg, sizeof (msg),
    1238. 

  1238.                                  "Stopped rebalance process on volume %s \n",
    1239. 

  1239.                                   volname);
    1240. 

  1240.                 }
    1241. 

  1241.         }
    1242. 

  1242.         if (cmd == GF_DEFRAG_CMD_STATUS) {
    1243. 

  1243.                 if (rsp.op_ret == -1) {
    1244. 

  1244.                         if (strcmp (rsp.op_errstr, ""))
    1245. 

  1245.                                 snprintf (msg, sizeof (msg),
    1246. 

  1246.                                           "%s", rsp.op_errstr);
    1247. 

  1247.                         else
    1248. 

  1248.                                 snprintf (msg, sizeof (msg),
    1249. 

  1249.                                           "Failed to get the status of "
    1250. 

  1250.                                           "rebalance process");
    1251. 

  1251.                         goto done;
    1252. 

  1252.                 }
    1253. 

  1253.         }
    1254. 

  1254. 

  1255.         if (global_state->mode & GLUSTER_MODE_XML) {
    1256. 

  1256.                 ret = cli_xml_output_vol_rebalance (cmd, dict, rsp.op_ret,
    1257. 

  1257.                                                     rsp.op_errno,
    1258. 

  1258.                                                     rsp.op_errstr);
    1259. 

  1259.                 goto out;
    1260. 

  1260.         }
    1261. 

  1261. 

  1262.         ret = dict_get_int32 (dict, "count", &counter);
    1263. 

  1263.         if (ret) {
    1264. 

  1264.                 gf_log (THIS->name, GF_LOG_ERROR, "count not set");
    1265. 

  1265.                 goto out;
    1266. 

  1266.         }
    1267. 

  1267. 

  1268.         cli_out ("%40s %16s %13s %13s %13s %14s %s", "Node", "Rebalanced-files",
    1269. 

  1269.                  "size", "scanned", "failures", "status", "run time in secs");
    1270. 

  1270.         cli_out ("%40s %16s %13s %13s %13s %14s %16s", "---------",
    1271. 

  1271.                  "-----------", "-----------", "-----------", "-----------",
    1272. 

  1272.                  "------------", "--------------");
    1273. 

  1273.         do {
    1274. 

  1274.                 snprintf (key, 256, "node-uuid-%d", i);
    1275. 

  1275.                 ret = dict_get_str (dict, key, &node_uuid);
    1276. 

  1276.                 if (ret)
    1277. 

  1277.                         gf_log (THIS->name, GF_LOG_TRACE,
    1278. 

  1278.                                 "failed to get node-uuid");
    1279. 

  1279. 

  1280.                 memset (key, 0, 256);
    1281. 

  1281.                 snprintf (key, 256, "files-%d", i);
    1282. 

  1282.                 ret = dict_get_uint64 (dict, key, &files);
    1283. 

  1283.                 if (ret)
    1284. 

  1284.                         gf_log (THIS->name, GF_LOG_TRACE,
    1285. 

  1285.                                 "failed to get file count");
    1286. 

  1286. 

  1287.                 memset (key, 0, 256);
    1288. 

  1288.                 snprintf (key, 256, "size-%d", i);
    1289. 

  1289.                 ret = dict_get_uint64 (dict, key, &size);
    1290. 

  1290.                 if (ret)
    1291. 

  1291.                         gf_log (THIS->name, GF_LOG_TRACE,
    1292. 

  1292.                                 "failed to get size of xfer");
    1293. 

  1293. 

  1294.                 memset (key, 0, 256);
    1295. 

  1295.                 snprintf (key, 256, "lookups-%d", i);
    1296. 

  1296.                 ret = dict_get_uint64 (dict, key, &lookup);
    1297. 

  1297.                 if (ret)
    1298. 

  1298.                         gf_log (THIS->name, GF_LOG_TRACE,
    1299. 

  1299.                                 "failed to get lookedup file count");
    1300. 

  1300. 

  1301.                 memset (key, 0, 256);
    1302. 

  1302.                 snprintf (key, 256, "status-%d", i);
    1303. 

  1303.                 ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
    1304. 

  1304.                 if (ret)
    1305. 

  1305.                         gf_log (THIS->name, GF_LOG_TRACE,
    1306. 

  1306.                                 "failed to get status");
    1307. 

  1307. 

  1308.                 memset (key, 0, 256);
    1309. 

  1309.                 snprintf (key, 256, "failures-%d", i);
    1310. 

  1310.                 ret = dict_get_uint64 (dict, key, &failures);
    1311. 

  1311.                 if (ret)
    1312. 

  1312.                         gf_log (THIS->name, GF_LOG_TRACE,
    1313. 

  1313.                                 "failed to get failures count");
    1314. 

  1314. 

  1315.                 memset (key, 0, 256);
    1316. 

  1316.                 snprintf (key, 256, "run-time-%d", i);
    1317. 

  1317.                 ret = dict_get_double (dict, key, &elapsed);
    1318. 

  1318.                 if (ret)
    1319. 

  1319.                         gf_log (THIS->name, GF_LOG_TRACE,
    1320. 

  1320.                                 "failed to get run-time");
    1321. 

  1321. 

  1322.                 switch (status_rcd) {
    1323. 

  1323.                 case GF_DEFRAG_STATUS_NOT_STARTED:
    1324. 

  1324.                         status = "not started";
    1325. 

  1325.                         break;
    1326. 

  1326.                 case GF_DEFRAG_STATUS_STARTED:
    1327. 

  1327.                         status = "in progress";
    1328. 

  1328.                         break;
    1329. 

  1329.                 case GF_DEFRAG_STATUS_STOPPED:
    1330. 

  1330.                         status = "stopped";
    1331. 

  1331.                         break;
    1332. 

  1332.                 case GF_DEFRAG_STATUS_COMPLETE:
    1333. 

  1333.                         status = "completed";
    1334. 

  1334.                         break;
    1335. 

  1335.                 case GF_DEFRAG_STATUS_FAILED:
    1336. 

  1336.                         status = "failed";
    1337. 

  1337.                         break;
    1338. 

  1338.                 }
    1339. 

  1339. 

  1340.                 size_str = gf_uint64_2human_readable(size);
    1341. 

  1341.                 cli_out ("%40s %16"PRIu64 " %13s" " %13"PRIu64 " %13"PRIu64
    1342. 

  1342.                          " %14s %16.2f", node_uuid, files, size_str, lookup,
    1343. 

  1343.                          failures, status, elapsed);
    1344. 

  1344.                 GF_FREE(size_str);
    1345. 

  1345. 

  1346.                 i++;
    1347. 

  1347.         } while (i <= counter);
    1348. 

  1348. 

  1349. 

  1350. done:
    1351. 

  1351.         if (rsp.op_ret)
    1352. 

  1352.                 cli_err ("volume rebalance: %s: failed: %s", volname, msg);
    1353. 

  1353.         else
    1354. 

  1354.                 cli_out ("volume rebalance: %s: success: %s", volname, msg);
    1355. 

  1355.         ret = rsp.op_ret;
    1356. 

  1356. 

  1357. out:
    1358. 

  1358.         free (rsp.op_errstr); //malloced by xdr
    1359. 

  1359.         free (rsp.dict.dict_val); //malloced by xdr
    1360. 

  1360.         if (dict)
    1361. 

  1361.                 dict_unref (dict);
    1362. 

  1362.         cli_cmd_broadcast_response (ret);
    1363. 

  1363.         return ret;
    1364. 

  1364. }
    1365. 

  1365. 

  1366. int
    1367. 

  1367. gf_cli_rename_volume_cbk (struct rpc_req *req, struct iovec *iov,
    1368. 

  1368.                              int count, void *myframe)
    1369. 

  1369. {
    1370. 

  1370.         gf_cli_rsp              rsp   = {0,};
    1371. 

  1371.         int                     ret   = -1;
    1372. 

  1372.         char                    msg[1024] = {0,};
    1373. 

  1373. 

  1374.         if (-1 == req->rpc_status) {
    1375. 

  1375.                 goto out;
    1376. 

  1376.         }
    1377. 

  1377. 

  1378.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    1379. 

  1379.         if (ret < 0) {
    1380. 

  1380.                 gf_log ("", GF_LOG_ERROR, "error");
    1381. 

  1381.                 goto out;
    1382. 

  1382.         }
    1383. 

  1383. 

  1384. 

  1385.         gf_log ("cli", GF_LOG_INFO, "Received resp to probe");
    1386. 

  1386.         snprintf (msg, sizeof (msg), "Rename volume %s",
    1387. 

  1387.                   (rsp.op_ret) ? "unsuccessful": "successful");
    1388. 

  1388. 

  1389.         if (global_state->mode & GLUSTER_MODE_XML) {
    1390. 

  1390.                 ret = cli_xml_output_str ("volRename", msg, rsp.op_ret,
    1391. 

  1391.                                           rsp.op_errno, rsp.op_errstr);
    1392. 

  1392.                 if (ret)
    1393. 

  1393.                         gf_log ("cli", GF_LOG_ERROR,
    1394. 

  1394.                                 "Error outputting to xml");
    1395. 

  1395.                 goto out;
    1396. 

  1396.         }
    1397. 

  1397. 

  1398.         if (rsp.op_ret)
    1399. 

  1399.                 cli_err ("volume rename: failed");
    1400. 

  1400.         else
    1401. 

  1401.                 cli_out ("volume rename: success");
    1402. 

  1402. 

  1403.         ret = rsp.op_ret;
    1404. 

  1404. 

  1405. out:
    1406. 

  1406.         cli_cmd_broadcast_response (ret);
    1407. 

  1407.         return ret;
    1408. 

  1408. }
    1409. 

  1409. 

  1410. int
    1411. 

  1411. gf_cli_reset_volume_cbk (struct rpc_req *req, struct iovec *iov,
    1412. 

  1412.                              int count, void *myframe)
    1413. 

  1413. {
    1414. 

  1414.         gf_cli_rsp           rsp   = {0,};
    1415. 

  1415.         int                  ret   = -1;
    1416. 

  1416.         char                 msg[1024] = {0,};
    1417. 

  1417. 

  1418.         if (-1 == req->rpc_status) {
    1419. 

  1419.                 goto out;
    1420. 

  1420.         }
    1421. 

  1421. 

  1422.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    1423. 

  1423.         if (ret < 0) {
    1424. 

  1424.                 gf_log ("", GF_LOG_ERROR, "error");
    1425. 

  1425.                 goto out;
    1426. 

  1426.         }
    1427. 

  1427. 

  1428.         gf_log ("cli", GF_LOG_INFO, "Received resp to reset");
    1429. 

  1429. 

  1430.         if (rsp.op_ret &&  strcmp (rsp.op_errstr, ""))
    1431. 

  1431.                 snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    1432. 

  1432.         else
    1433. 

  1433.                 snprintf (msg, sizeof (msg), "reset volume %s",
    1434. 

  1434.                           (rsp.op_ret) ? "unsuccessful": "successful");
    1435. 

  1435. 

  1436.         if (global_state->mode & GLUSTER_MODE_XML) {
    1437. 

  1437.                 ret = cli_xml_output_str ("volReset", msg, rsp.op_ret,
    1438. 

  1438.                                           rsp.op_errno, rsp.op_errstr);
    1439. 

  1439.                 if (ret)
    1440. 

  1440.                         gf_log ("cli", GF_LOG_ERROR,
    1441. 

  1441.                                 "Error outputting to xml");
    1442. 

  1442.                 goto out;
    1443. 

  1443.         }
    1444. 

  1444. 

  1445.         if (rsp.op_ret)
    1446. 

  1446.                 cli_err ("volume reset: failed: %s", msg);
    1447. 

  1447.         else
    1448. 

  1448.                 cli_out ("volume reset: success");
    1449. 

  1449. 

  1450.         ret = rsp.op_ret;
    1451. 

  1451. 

  1452. out:
    1453. 

  1453.         cli_cmd_broadcast_response (ret);
    1454. 

  1454.         return ret;
    1455. 

  1455. }
    1456. 

  1456. 

  1457. int
    1458. 

  1458. gf_cli_set_volume_cbk (struct rpc_req *req, struct iovec *iov,
    1459. 

  1459.                              int count, void *myframe)
    1460. 

  1460. {
    1461. 

  1461.         gf_cli_rsp           rsp   = {0,};
    1462. 

  1462.         int                  ret   = -1;
    1463. 

  1463.         dict_t               *dict = NULL;
    1464. 

  1464.         char                 *help_str = NULL;
    1465. 

  1465.         char                 msg[1024] = {0,};
    1466. 

  1466. 

  1467.         if (-1 == req->rpc_status) {
    1468. 

  1468.                 goto out;
    1469. 

  1469.         }
    1470. 

  1470. 

  1471.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    1472. 

  1472.         if (ret < 0) {
    1473. 

  1473.                 gf_log ("", GF_LOG_ERROR, "error");
    1474. 

  1474.                 goto out;
    1475. 

  1475.         }
    1476. 

  1476. 

  1477.         gf_log ("cli", GF_LOG_INFO, "Received resp to set");
    1478. 

  1478. 

  1479.         dict = dict_new ();
    1480. 

  1480. 

  1481.         if (!dict) {
    1482. 

  1482.                 ret = -1;
    1483. 

  1483.                 goto out;
    1484. 

  1484.         }
    1485. 

  1485. 

  1486.         ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
    1487. 

  1487. 

  1488.         if (dict_get_str (dict, "help-str", &help_str) && !msg[0])
    1489. 

  1489.                 snprintf (msg, sizeof (msg), "Set volume %s",
    1490. 

  1490.                           (rsp.op_ret) ? "unsuccessful": "successful");
    1491. 

  1491. 

  1492.         if ((global_state->mode & GLUSTER_MODE_XML) && (help_str == NULL)) {
    1493. 

  1493.                 ret = cli_xml_output_str ("volSet", msg, rsp.op_ret,
    1494. 

  1494.                                           rsp.op_errno, rsp.op_errstr);
    1495. 

  1495.                 if (ret)
    1496. 

  1496.                         gf_log ("cli", GF_LOG_ERROR,
    1497. 

  1497.                                 "Error outputting to xml");
    1498. 

  1498.                 goto out;
    1499. 

  1499.         }
    1500. 

  1500. 

  1501.         if (rsp.op_ret &&  strcmp (rsp.op_errstr, ""))
    1502. 

  1502.                 cli_err ("volume set: failed: %s", rsp.op_errstr);
    1503. 

  1503. 

  1504.         if (!rsp.op_ret) {
    1505. 

  1505.                 if (help_str == NULL)
    1506. 

  1506.                         cli_out ("volume set: success");
    1507. 

  1507.                 else
    1508. 

  1508.                         cli_out ("%s", help_str);
    1509. 

  1509.         } else {
    1510. 

  1510.                 cli_err ("volume set: failed");
    1511. 

  1511.         }
    1512. 

  1512. 

  1513.         ret = rsp.op_ret;
    1514. 

  1514. 

  1515. out:
    1516. 

  1516.         if (dict)
    1517. 

  1517.                 dict_unref (dict);
    1518. 

  1518.         cli_cmd_broadcast_response (ret);
    1519. 

  1519.         return ret;
    1520. 

  1520. }
    1521. 

  1521. 

  1522. int
    1523. 

  1523. gf_cli_add_brick_cbk (struct rpc_req *req, struct iovec *iov,
    1524. 

  1524.                              int count, void *myframe)
    1525. 

  1525. {
    1526. 

  1526.         gf_cli_rsp                  rsp   = {0,};
    1527. 

  1527.         int                         ret   = -1;
    1528. 

  1528.         char                        msg[1024] = {0,};
    1529. 

  1529. 

  1530.         if (-1 == req->rpc_status) {
    1531. 

  1531.                 goto out;
    1532. 

  1532.         }
    1533. 

  1533. 

  1534.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    1535. 

  1535.         if (ret < 0) {
    1536. 

  1536.                 gf_log ("", GF_LOG_ERROR, "error");
    1537. 

  1537.                 goto out;
    1538. 

  1538.         }
    1539. 

  1539. 

  1540. 

  1541.         gf_log ("cli", GF_LOG_INFO, "Received resp to add brick");
    1542. 

  1542. 

  1543.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    1544. 

  1544.                 snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    1545. 

  1545.         else
    1546. 

  1546.                 snprintf (msg, sizeof (msg), "Add Brick %s",
    1547. 

  1547.                           (rsp.op_ret) ? "unsuccessful": "successful");
    1548. 

  1548. 

  1549.         if (global_state->mode & GLUSTER_MODE_XML) {
    1550. 

  1550.                 ret = cli_xml_output_str ("volAddBrick", msg, rsp.op_ret,
    1551. 

  1551.                                           rsp.op_errno, rsp.op_errstr);
    1552. 

  1552.                 if (ret)
    1553. 

  1553.                         gf_log ("cli", GF_LOG_ERROR,
    1554. 

  1554.                                 "Error outputting to xml");
    1555. 

  1555.                 goto out;
    1556. 

  1556.         }
    1557. 

  1557. 

  1558.         if (rsp.op_ret)
    1559. 

  1559.                 cli_err ("volume add-brick: failed: %s", rsp.op_errstr);
    1560. 

  1560.         else
    1561. 

  1561.                 cli_out ("volume add-brick: success");
    1562. 

  1562.         ret = rsp.op_ret;
    1563. 

  1563. 

  1564. out:
    1565. 

  1565.         cli_cmd_broadcast_response (ret);
    1566. 

  1566.         free (rsp.dict.dict_val);
    1567. 

  1567.         free (rsp.op_errstr);
    1568. 

  1568.         return ret;
    1569. 

  1569. }
    1570. 

  1570. 

  1571. int
    1572. 

  1572. gf_cli3_remove_brick_status_cbk (struct rpc_req *req, struct iovec *iov,
    1573. 

  1573.                                  int count, void *myframe)
    1574. 

  1574. {
    1575. 

  1575.         gf_cli_rsp               rsp     = {0,};
    1576. 

  1576.         char                    *status  = "unknown";
    1577. 

  1577.         int                      ret     = -1;
    1578. 

  1578.         uint64_t                 files   = 0;
    1579. 

  1579.         uint64_t                 size    = 0;
    1580. 

  1580.         uint64_t                 lookup  = 0;
    1581. 

  1581.         dict_t                  *dict    = NULL;
    1582. 

  1582.         char                     msg[1024] = {0,};
    1583. 

  1583.         char                     key[256] = {0,};
    1584. 

  1584.         int32_t                  i       = 1;
    1585. 

  1585.         int32_t                  counter = 0;
    1586. 

  1586.         char                    *node_uuid = 0;
    1587. 

  1587.         gf_defrag_status_t       status_rcd = GF_DEFRAG_STATUS_NOT_STARTED;
    1588. 

  1588.         uint64_t                 failures = 0;
    1589. 

  1589.         double                   elapsed = 0;
    1590. 

  1590.         char                    *size_str = NULL;
    1591. 

  1591. 

  1592.         if (-1 == req->rpc_status) {
    1593. 

  1593.                 goto out;
    1594. 

  1594.         }
    1595. 

  1595. 

  1596.         ret = xdr_to_generic (*iov, &rsp,
    1597. 

  1597.                               (xdrproc_t)xdr_gf_cli_rsp);
    1598. 

  1598.         if (ret < 0) {
    1599. 

  1599.                 gf_log ("", GF_LOG_ERROR, "error");
    1600. 

  1600.                 goto out;
    1601. 

  1601.         }
    1602. 

  1602. 

  1603.         ret = rsp.op_ret;
    1604. 

  1604.         if (rsp.op_ret == -1) {
    1605. 

  1605.                 if (strcmp (rsp.op_errstr, ""))
    1606. 

  1606.                         snprintf (msg, sizeof (msg), "volume remove-brick: "
    1607. 

  1607.                                   "failed: %s", rsp.op_errstr);
    1608. 

  1608.                 else
    1609. 

  1609.                         snprintf (msg, sizeof (msg), "volume remove-brick: "
    1610. 

  1610.                                   "failed: status getting failed");
    1611. 

  1611. 

  1612.                 if (global_state->mode & GLUSTER_MODE_XML)
    1613. 

  1613.                         goto xml_output;
    1614. 

  1614. 

  1615.                 cli_err ("%s", msg);
    1616. 

  1616.                 goto out;
    1617. 

  1617.         }
    1618. 

  1618. 

  1619.         if (rsp.dict.dict_len) {
    1620. 

  1620.                 /* Unserialize the dictionary */
    1621. 

  1621.                 dict  = dict_new ();
    1622. 

  1622. 

  1623.                 ret = dict_unserialize (rsp.dict.dict_val,
    1624. 

  1624.                                         rsp.dict.dict_len,
    1625. 

  1625.                                         &dict);
    1626. 

  1626.                 if (ret < 0) {
    1627. 

  1627.                         strncpy (msg, "failed to unserialize req-buffer to "
    1628. 

  1628.                                  "dictionary", sizeof (msg));
    1629. 

  1629. 

  1630.                         if (global_state->mode & GLUSTER_MODE_XML) {
    1631. 

  1631.                                 rsp.op_ret = -1;
    1632. 

  1632.                                 goto xml_output;
    1633. 

  1633.                         }
    1634. 

  1634. 

  1635.                         gf_log ("cli", GF_LOG_ERROR, "%s", msg);
    1636. 

  1636.                         goto out;
    1637. 

  1637.                 }
    1638. 

  1638.         }
    1639. 

  1639. 

  1640. xml_output:
    1641. 

  1641.         if (global_state->mode & GLUSTER_MODE_XML) {
    1642. 

  1642.                 if (strcmp (rsp.op_errstr, "")) {
    1643. 

  1643.                         ret = cli_xml_output_vol_remove_brick (_gf_true, dict,
    1644. 

  1644.                                                                rsp.op_ret,
    1645. 

  1645.                                                                rsp.op_errno,
    1646. 

  1646.                                                                rsp.op_errstr);
    1647. 

  1647.                 } else {
    1648. 

  1648.                         ret = cli_xml_output_vol_remove_brick (_gf_true, dict,
    1649. 

  1649.                                                                rsp.op_ret,
    1650. 

  1650.                                                                rsp.op_errno,
    1651. 

  1651.                                                                msg);
    1652. 

  1652.                 }
    1653. 

  1653.                 goto out;
    1654. 

  1654.         }
    1655. 

  1655. 

  1656.         ret = dict_get_int32 (dict, "count", &counter);
    1657. 

  1657.         if (ret) {
    1658. 

  1658.                 gf_log (THIS->name, GF_LOG_ERROR, "count not set");
    1659. 

  1659.                 goto out;
    1660. 

  1660.         }
    1661. 

  1661. 

  1662. 

  1663.         cli_out ("%40s %16s %13s %13s %13s %14s %s", "Node", "Rebalanced-files",
    1664. 

  1664.                  "size", "scanned", "failures", "status", "run-time in secs");
    1665. 

  1665.         cli_out ("%40s %16s %13s %13s %13s %14s %16s", "---------",
    1666. 

  1666.                  "-----------", "-----------", "-----------", "-----------",
    1667. 

  1667.                  "------------", "--------------");
    1668. 

  1668. 

  1669.         do {
    1670. 

  1670.                 snprintf (key, 256, "node-uuid-%d", i);
    1671. 

  1671.                 ret = dict_get_str (dict, key, &node_uuid);
    1672. 

  1672.                 if (ret)
    1673. 

  1673.                         gf_log (THIS->name, GF_LOG_TRACE,
    1674. 

  1674.                                 "failed to get node-uuid");
    1675. 

  1675. 

  1676.                 memset (key, 0, 256);
    1677. 

  1677.                 snprintf (key, 256, "files-%d", i);
    1678. 

  1678.                 ret = dict_get_uint64 (dict, key, &files);
    1679. 

  1679.                 if (ret)
    1680. 

  1680.                         gf_log (THIS->name, GF_LOG_TRACE,
    1681. 

  1681.                                 "failed to get file count");
    1682. 

  1682. 

  1683.                 memset (key, 0, 256);
    1684. 

  1684.                 snprintf (key, 256, "size-%d", i);
    1685. 

  1685.                 ret = dict_get_uint64 (dict, key, &size);
    1686. 

  1686.                 if (ret)
    1687. 

  1687.                         gf_log (THIS->name, GF_LOG_TRACE,
    1688. 

  1688.                                 "failed to get size of xfer");
    1689. 

  1689. 

  1690.                 memset (key, 0, 256);
    1691. 

  1691.                 snprintf (key, 256, "lookups-%d", i);
    1692. 

  1692.                 ret = dict_get_uint64 (dict, key, &lookup);
    1693. 

  1693.                 if (ret)
    1694. 

  1694.                         gf_log (THIS->name, GF_LOG_TRACE,
    1695. 

  1695.                                 "failed to get lookedup file count");
    1696. 

  1696. 

  1697.                 memset (key, 0, 256);
    1698. 

  1698.                 snprintf (key, 256, "status-%d", i);
    1699. 

  1699.                 ret = dict_get_int32 (dict, key, (int32_t *)&status_rcd);
    1700. 

  1700.                 if (ret)
    1701. 

  1701.                         gf_log (THIS->name, GF_LOG_TRACE,
    1702. 

  1702.                                 "failed to get status");
    1703. 

  1703. 

  1704.                 snprintf (key, 256, "failures-%d", i);
    1705. 

  1705.                 ret = dict_get_uint64 (dict, key, &failures);
    1706. 

  1706.                 if (ret)
    1707. 

  1707.                         gf_log (THIS->name, GF_LOG_TRACE,
    1708. 

  1708.                                 "Failed to get failure on files");
    1709. 

  1709. 

  1710.                 memset (key, 0, 256);
    1711. 

  1711.                 snprintf (key, 256, "run-time-%d", i);
    1712. 

  1712.                 ret = dict_get_double (dict, key, &elapsed);
    1713. 

  1713.                 if (ret)
    1714. 

  1714.                         gf_log (THIS->name, GF_LOG_TRACE,
    1715. 

  1715.                                 "Failed to get run-time");
    1716. 

  1716. 

  1717.                 switch (status_rcd) {
    1718. 

  1718.                 case GF_DEFRAG_STATUS_NOT_STARTED:
    1719. 

  1719.                         status = "not started";
    1720. 

  1720.                         break;
    1721. 

  1721.                 case GF_DEFRAG_STATUS_STARTED:
    1722. 

  1722.                         status = "in progress";
    1723. 

  1723.                         break;
    1724. 

  1724.                 case GF_DEFRAG_STATUS_STOPPED:
    1725. 

  1725.                         status = "stopped";
    1726. 

  1726.                         break;
    1727. 

  1727.                 case GF_DEFRAG_STATUS_COMPLETE:
    1728. 

  1728.                         status = "completed";
    1729. 

  1729.                         break;
    1730. 

  1730.                 case GF_DEFRAG_STATUS_FAILED:
    1731. 

  1731.                         status = "failed";
    1732. 

  1732.                         break;
    1733. 

  1733.                 }
    1734. 

  1734. 

  1735.                 size_str = gf_uint64_2human_readable(size);
    1736. 

  1736.                 cli_out ("%40s %16"PRIu64 " %13s" " %13"PRIu64 " %13"PRIu64
    1737. 

  1737.                          " %14s %16.2f", node_uuid, files, size_str, lookup,
    1738. 

  1738.                          failures, status, elapsed);
    1739. 

  1739.                 GF_FREE(size_str);
    1740. 

  1740. 

  1741.                 i++;
    1742. 

  1742.         } while (i <= counter);
    1743. 

  1743. 

  1744. out:
    1745. 

  1745.         free (rsp.dict.dict_val); //malloced by xdr
    1746. 

  1746.         if (dict)
    1747. 

  1747.                 dict_unref (dict);
    1748. 

  1748.         cli_cmd_broadcast_response (ret);
    1749. 

  1749.         return ret;
    1750. 

  1750. }
    1751. 

  1751. 

  1752. 

  1753. int
    1754. 

  1754. gf_cli_remove_brick_cbk (struct rpc_req *req, struct iovec *iov,
    1755. 

  1755.                              int count, void *myframe)
    1756. 

  1756. {
    1757. 

  1757.         gf_cli_rsp                      rsp   = {0,};
    1758. 

  1758.         int                             ret   = -1;
    1759. 

  1759.         char                            msg[1024] = {0,};
    1760. 

  1760.         gf1_op_commands                 cmd = GF_OP_CMD_NONE;
    1761. 

  1761.         char                           *cmd_str = "unknown";
    1762. 

  1762.         cli_local_t                    *local = NULL;
    1763. 

  1763.         call_frame_t                   *frame = NULL;
    1764. 

  1764.         char                           *task_id_str = NULL;
    1765. 

  1765.         dict_t                         *rsp_dict = NULL;
    1766. 

  1766. 

  1767.         if (-1 == req->rpc_status) {
    1768. 

  1768.                 goto out;
    1769. 

  1769.         }
    1770. 

  1770. 

  1771.         frame = myframe;
    1772. 

  1772.         local = frame->local;
    1773. 

  1773. 

  1774.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    1775. 

  1775.         if (ret < 0) {
    1776. 

  1776.                 gf_log ("", GF_LOG_ERROR, "error");
    1777. 

  1777.                 goto out;
    1778. 

  1778.         }
    1779. 

  1779. 

  1780.         ret = dict_get_int32 (local->dict, "command", (int32_t *)&cmd);
    1781. 

  1781.         if (ret) {
    1782. 

  1782.                  gf_log ("", GF_LOG_ERROR, "failed to get command");
    1783. 

  1783.                  goto out;
    1784. 

  1784.         }
    1785. 

  1785. 

  1786.         if (rsp.dict.dict_len) {
    1787. 

  1787.                 rsp_dict = dict_new ();
    1788. 

  1788.                 if (!rsp_dict) {
    1789. 

  1789.                         ret = -1;
    1790. 

  1790.                         goto out;
    1791. 

  1791.                 }
    1792. 

  1792. 

  1793.                 ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len,
    1794. 

  1794.                                         &rsp_dict);
    1795. 

  1795.                 if (ret) {
    1796. 

  1796.                         gf_log ("cli", GF_LOG_ERROR,
    1797. 

  1797.                                 "Failed to unserialize rsp_dict");
    1798. 

  1798.                         goto out;
    1799. 

  1799.                 }
    1800. 

  1800.         }
    1801. 

  1801. 

  1802.         switch (cmd) {
    1803. 

  1803.         case GF_OP_CMD_START:
    1804. 

  1804.                 cmd_str = "start";
    1805. 

  1805. 

  1806.                 ret = dict_get_str (rsp_dict, GF_REMOVE_BRICK_TID_KEY, &task_id_str);
    1807. 

  1807.                 if (ret) {
    1808. 

  1808.                         gf_log ("cli", GF_LOG_ERROR,
    1809. 

  1809.                                 "remove-brick-id is not present in dict");
    1810. 

  1810.                         goto out;
    1811. 

  1811.                 }
    1812. 

  1812.                 break;
    1813. 

  1813.         case GF_OP_CMD_COMMIT:
    1814. 

  1814.                 cmd_str = "commit";
    1815. 

  1815.                 break;
    1816. 

  1816.         case GF_OP_CMD_COMMIT_FORCE:
    1817. 

  1817.                 cmd_str = "commit force";
    1818. 

  1818.                 break;
    1819. 

  1819.         default:
    1820. 

  1820.                 cmd_str = "unknown";
    1821. 

  1821.                 break;
    1822. 

  1822.         }
    1823. 

  1823. 

  1824.         gf_log ("cli", GF_LOG_INFO, "Received resp to remove brick");
    1825. 

  1825. 

  1826.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    1827. 

  1827.                 snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    1828. 

  1828.         else
    1829. 

  1829.                 snprintf (msg, sizeof (msg), "Remove Brick %s %s", cmd_str,
    1830. 

  1830.                           (rsp.op_ret) ? "unsuccessful": "successful");
    1831. 

  1831. 

  1832.         if (global_state->mode & GLUSTER_MODE_XML) {
    1833. 

  1833.                 ret = cli_xml_output_vol_remove_brick (_gf_false, rsp_dict,
    1834. 

  1834.                                                        rsp.op_ret, rsp.op_errno,
    1835. 

  1835.                                                        rsp.op_errstr);
    1836. 

  1836.                 if (ret)
    1837. 

  1837.                         gf_log ("cli", GF_LOG_ERROR,
    1838. 

  1838.                                 "Error outputting to xml");
    1839. 

  1839.                 goto out;
    1840. 

  1840.         }
    1841. 

  1841. 

  1842.         if (rsp.op_ret) {
    1843. 

  1843.                 cli_err ("volume remove-brick %s: failed: %s", cmd_str,
    1844. 

  1844.                          rsp.op_errstr);
    1845. 

  1845.         } else {
    1846. 

  1846.                 cli_out ("volume remove-brick %s: success", cmd_str);
    1847. 

  1847.                 if (GF_OP_CMD_START == cmd)
    1848. 

  1848.                         cli_out ("ID: %s", task_id_str);
    1849. 

  1849.         }
    1850. 

  1850. 

  1851.         ret = rsp.op_ret;
    1852. 

  1852. 

  1853. out:
    1854. 

  1854.         cli_cmd_broadcast_response (ret);
    1855. 

  1855.         free (rsp.dict.dict_val);
    1856. 

  1856.         free (rsp.op_errstr);
    1857. 

  1857. 

  1858.         return ret;
    1859. 

  1859. }
    1860. 

  1860. 

  1861. 

  1862. 

  1863. int
    1864. 

  1864. gf_cli_replace_brick_cbk (struct rpc_req *req, struct iovec *iov,
    1865. 

  1865.                              int count, void *myframe)
    1866. 

  1866. {
    1867. 

  1867.         gf_cli_rsp                       rsp              = {0,};
    1868. 

  1868.         int                              ret              = -1;
    1869. 

  1869.         cli_local_t                     *local            = NULL;
    1870. 

  1870.         call_frame_t                    *frame            = NULL;
    1871. 

  1871.         dict_t                          *dict             = NULL;
    1872. 

  1872.         char                            *src_brick        = NULL;
    1873. 

  1873.         char                            *dst_brick        = NULL;
    1874. 

  1874.         char                            *status_reply     = NULL;
    1875. 

  1875.         gf1_cli_replace_op               replace_op       = 0;
    1876. 

  1876.         char                            *rb_operation_str = NULL;
    1877. 

  1877.         dict_t                          *rsp_dict         = NULL;
    1878. 

  1878.         char                             msg[1024]        = {0,};
    1879. 

  1879.         char                            *task_id_str      = NULL;
    1880. 

  1880. 

  1881.         if (-1 == req->rpc_status) {
    1882. 

  1882.                 goto out;
    1883. 

  1883.         }
    1884. 

  1884. 

  1885.         frame = (call_frame_t *) myframe;
    1886. 

  1886. 

  1887.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    1888. 

  1888.         if (ret < 0) {
    1889. 

  1889.                 gf_log ("", GF_LOG_ERROR, "error");
    1890. 

  1890.                 goto out;
    1891. 

  1891.         }
    1892. 

  1892. 

  1893.         local = frame->local;
    1894. 

  1894.         GF_ASSERT (local);
    1895. 

  1895.         dict = local->dict;
    1896. 

  1896. 

  1897.         ret = dict_get_int32 (dict, "operation", (int32_t *)&replace_op);
    1898. 

  1898.         if (ret) {
    1899. 

  1899.                 gf_log ("", GF_LOG_DEBUG,
    1900. 

  1900.                         "dict_get on operation failed");
    1901. 

  1901.                 goto out;
    1902. 

  1902.         }
    1903. 

  1903. 

  1904.         if (rsp.dict.dict_len) {
    1905. 

  1905.                 /* Unserialize the dictionary */
    1906. 

  1906.                 rsp_dict  = dict_new ();
    1907. 

  1907. 

  1908.                 ret = dict_unserialize (rsp.dict.dict_val,
    1909. 

  1909.                                 rsp.dict.dict_len,
    1910. 

  1910.                                 &rsp_dict);
    1911. 

  1911.                 if (ret < 0) {
    1912. 

  1912.                         gf_log ("glusterd", GF_LOG_ERROR,
    1913. 

  1913.                                         "failed to "
    1914. 

  1914.                                         "unserialize rsp buffer to dictionary");
    1915. 

  1915.                         goto out;
    1916. 

  1916.                 }
    1917. 

  1917.         }
    1918. 

  1918. 

  1919.         switch (replace_op) {
    1920. 

  1920.         case GF_REPLACE_OP_START:
    1921. 

  1921.                 if (rsp.op_ret) {
    1922. 

  1922.                         rb_operation_str = gf_strdup ("replace-brick failed to"
    1923. 

  1923.                                                       " start");
    1924. 

  1924.                 } else {
    1925. 

  1925.                         ret = dict_get_str (rsp_dict, GF_REPLACE_BRICK_TID_KEY,
    1926. 

  1926.                                             &task_id_str);
    1927. 

  1927.                         if (ret) {
    1928. 

  1928.                                 gf_log ("cli", GF_LOG_ERROR, "Failed to get "
    1929. 

  1929.                                         "\"replace-brick-id\" from dict");
    1930. 

  1930.                                 goto out;
    1931. 

  1931.                         }
    1932. 

  1932.                         ret = gf_asprintf (&rb_operation_str,
    1933. 

  1933.                                            "replace-brick started successfully"
    1934. 

  1934.                                            "\nID: %s", task_id_str);
    1935. 

  1935.                         if (ret < 0)
    1936. 

  1936.                                 goto out;
    1937. 

  1937.                 }
    1938. 

  1938.                 break;
    1939. 

  1939. 

  1940.         case GF_REPLACE_OP_STATUS:
    1941. 

  1941. 

  1942.                 if (rsp.op_ret || ret) {
    1943. 

  1943.                         rb_operation_str = gf_strdup ("replace-brick status "
    1944. 

  1944.                                                       "unknown");
    1945. 

  1945.                 } else {
    1946. 

  1946.                         ret = dict_get_str (rsp_dict, "status-reply",
    1947. 

  1947.                                             &status_reply);
    1948. 

  1948.                         if (ret) {
    1949. 

  1949.                                 gf_log (THIS->name, GF_LOG_ERROR, "failed to"
    1950. 

  1950.                                         "get status");
    1951. 

  1951.                                 goto out;
    1952. 

  1952.                         }
    1953. 

  1953. 

  1954.                         rb_operation_str = gf_strdup (status_reply);
    1955. 

  1955.                 }
    1956. 

  1956. 

  1957.                 break;
    1958. 

  1958. 

  1959.         case GF_REPLACE_OP_PAUSE:
    1960. 

  1960.                 if (rsp.op_ret)
    1961. 

  1961.                         rb_operation_str = gf_strdup ("replace-brick pause "
    1962. 

  1962.                                                       "failed");
    1963. 

  1963.                 else
    1964. 

  1964.                         rb_operation_str = gf_strdup ("replace-brick paused "
    1965. 

  1965.                                                       "successfully");
    1966. 

  1966.                 break;
    1967. 

  1967. 

  1968.         case GF_REPLACE_OP_ABORT:
    1969. 

  1969.                 if (rsp.op_ret)
    1970. 

  1970.                         rb_operation_str = gf_strdup ("replace-brick abort "
    1971. 

  1971.                                                       "failed");
    1972. 

  1972.                 else
    1973. 

  1973.                         rb_operation_str = gf_strdup ("replace-brick aborted "
    1974. 

  1974.                                                       "successfully");
    1975. 

  1975.                 break;
    1976. 

  1976. 

  1977.         case GF_REPLACE_OP_COMMIT:
    1978. 

  1978.         case GF_REPLACE_OP_COMMIT_FORCE:
    1979. 

  1979.                 ret = dict_get_str (dict, "src-brick", &src_brick);
    1980. 

  1980.                 if (ret) {
    1981. 

  1981.                         gf_log ("", GF_LOG_DEBUG,
    1982. 

  1982.                                 "dict_get on src-brick failed");
    1983. 

  1983.                         goto out;
    1984. 

  1984.                 }
    1985. 

  1985. 

  1986.                 ret = dict_get_str (dict, "dst-brick", &dst_brick);
    1987. 

  1987.                 if (ret) {
    1988. 

  1988.                         gf_log ("", GF_LOG_DEBUG,
    1989. 

  1989.                                 "dict_get on dst-brick failed");
    1990. 

  1990.                         goto out;
    1991. 

  1991.                 }
    1992. 

  1992. 

  1993. 

  1994.                 if (rsp.op_ret || ret)
    1995. 

  1995.                         rb_operation_str = gf_strdup ("replace-brick commit "
    1996. 

  1996.                                                       "failed");
    1997. 

  1997.                 else
    1998. 

  1998.                         rb_operation_str = gf_strdup ("replace-brick commit "
    1999. 

  1999.                                                       "successful");
    2000. 

  2000. 

  2001.                 break;
    2002. 

  2002. 

  2003.         default:
    2004. 

  2004.                 gf_log ("", GF_LOG_DEBUG,
    2005. 

  2005.                         "Unknown operation");
    2006. 

  2006.                 break;
    2007. 

  2007.         }
    2008. 

  2008. 

  2009.         if (rsp.op_ret && (strcmp (rsp.op_errstr, ""))) {
    2010. 

  2010.                 rb_operation_str = gf_strdup (rsp.op_errstr);
    2011. 

  2011.         }
    2012. 

  2012. 

  2013.         gf_log ("cli", GF_LOG_INFO, "Received resp to replace brick");
    2014. 

  2014.         snprintf (msg, sizeof (msg), "%s",
    2015. 

  2015.                   rb_operation_str ? rb_operation_str : "Unknown operation");
    2016. 

  2016. 

  2017.         if (global_state->mode & GLUSTER_MODE_XML) {
    2018. 

  2018.                 ret = cli_xml_output_vol_replace_brick (replace_op, rsp_dict,
    2019. 

  2019.                                                         rsp.op_ret,
    2020. 

  2020.                                                         rsp.op_errno, msg);
    2021. 

  2021.                 if (ret)
    2022. 

  2022.                         gf_log ("cli", GF_LOG_ERROR,
    2023. 

  2023.                                 "Error outputting to xml");
    2024. 

  2024.                 goto out;
    2025. 

  2025.         }
    2026. 

  2026. 

  2027.         if (rsp.op_ret)
    2028. 

  2028.                 cli_err ("volume replace-brick: failed: %s", msg);
    2029. 

  2029.         else
    2030. 

  2030.                 cli_out ("volume replace-brick: success: %s", msg);
    2031. 

  2031.         ret = rsp.op_ret;
    2032. 

  2032. 

  2033. out:
    2034. 

  2034.         if (frame)
    2035. 

  2035.                 frame->local = NULL;
    2036. 

  2036. 

  2037.         if (local) {
    2038. 

  2038.                 dict_unref (local->dict);
    2039. 

  2039.                 cli_local_wipe (local);
    2040. 

  2040.         }
    2041. 

  2041. 

  2042.         if (rb_operation_str)
    2043. 

  2043.                 GF_FREE (rb_operation_str);
    2044. 

  2044. 

  2045.         cli_cmd_broadcast_response (ret);
    2046. 

  2046.         free (rsp.dict.dict_val);
    2047. 

  2047.         if (rsp_dict)
    2048. 

  2048.                 dict_unref (rsp_dict);
    2049. 

  2049. 

  2050.         return ret;
    2051. 

  2051. }
    2052. 

  2052. 

  2053. 

  2054. static int
    2055. 

  2055. gf_cli_log_rotate_cbk (struct rpc_req *req, struct iovec *iov,
    2056. 

  2056.                           int count, void *myframe)
    2057. 

  2057. {
    2058. 

  2058.         gf_cli_rsp             rsp   = {0,};
    2059. 

  2059.         int                    ret   = -1;
    2060. 

  2060.         char                   msg[1024] = {0,};
    2061. 

  2061. 

  2062.         if (-1 == req->rpc_status) {
    2063. 

  2063.                 goto out;
    2064. 

  2064.         }
    2065. 

  2065. 

  2066.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    2067. 

  2067.         if (ret < 0) {
    2068. 

  2068.                 gf_log ("", GF_LOG_ERROR, "error");
    2069. 

  2069.                 goto out;
    2070. 

  2070.         }
    2071. 

  2071. 

  2072.         gf_log ("cli", GF_LOG_DEBUG, "Received resp to log rotate");
    2073. 

  2073. 

  2074.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    2075. 

  2075.                 snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    2076. 

  2076.         else
    2077. 

  2077.                 snprintf (msg, sizeof (msg), "log rotate %s",
    2078. 

  2078.                           (rsp.op_ret) ? "unsuccessful": "successful");
    2079. 

  2079. 

  2080.         if (global_state->mode & GLUSTER_MODE_XML) {
    2081. 

  2081.                 ret = cli_xml_output_str ("volLogRotate", msg, rsp.op_ret,
    2082. 

  2082.                                           rsp.op_errno, rsp.op_errstr);
    2083. 

  2083.                 if (ret)
    2084. 

  2084.                         gf_log ("cli", GF_LOG_ERROR,
    2085. 

  2085.                                 "Error outputting to xml");
    2086. 

  2086.                 goto out;
    2087. 

  2087.         }
    2088. 

  2088. 

  2089.         if (rsp.op_ret)
    2090. 

  2090.                 cli_err ("volume log-rotate: failed: %s", msg);
    2091. 

  2091.         else
    2092. 

  2092.                 cli_out ("volume log-rotate: success");
    2093. 

  2093.         ret = rsp.op_ret;
    2094. 

  2094. 

  2095. out:
    2096. 

  2096.         cli_cmd_broadcast_response (ret);
    2097. 

  2097.         free (rsp.dict.dict_val);
    2098. 

  2098. 

  2099.         return ret;
    2100. 

  2100. }
    2101. 

  2101. 

  2102. static int
    2103. 

  2103. gf_cli_sync_volume_cbk (struct rpc_req *req, struct iovec *iov,
    2104. 

  2104.                            int count, void *myframe)
    2105. 

  2105. {
    2106. 

  2106.         gf_cli_rsp                     rsp   = {0,};
    2107. 

  2107.         int                            ret   = -1;
    2108. 

  2108.         char                           msg[1024] = {0,};
    2109. 

  2109. 

  2110.         if (-1 == req->rpc_status) {
    2111. 

  2111.                 goto out;
    2112. 

  2112.         }
    2113. 

  2113. 

  2114.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    2115. 

  2115.         if (ret < 0) {
    2116. 

  2116.                 gf_log ("", GF_LOG_ERROR, "error");
    2117. 

  2117.                 goto out;
    2118. 

  2118.         }
    2119. 

  2119. 

  2120.         gf_log ("cli", GF_LOG_DEBUG, "Received resp to sync");
    2121. 

  2121. 

  2122.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    2123. 

  2123.                 snprintf (msg, sizeof (msg), "volume sync: failed: %s",
    2124. 

  2124.                           rsp.op_errstr);
    2125. 

  2125.         else
    2126. 

  2126.                 snprintf (msg, sizeof (msg), "volume sync: %s",
    2127. 

  2127.                           (rsp.op_ret) ? "failed": "success");
    2128. 

  2128. 

  2129.         if (global_state->mode & GLUSTER_MODE_XML) {
    2130. 

  2130.                 ret = cli_xml_output_str ("volSync", msg, rsp.op_ret,
    2131. 

  2131.                                           rsp.op_errno, rsp.op_errstr);
    2132. 

  2132.                 if (ret)
    2133. 

  2133.                         gf_log ("cli", GF_LOG_ERROR,
    2134. 

  2134.                                 "Error outputting to xml");
    2135. 

  2135.                 goto out;
    2136. 

  2136.         }
    2137. 

  2137. 

  2138.         if (rsp.op_ret)
    2139. 

  2139.                 cli_err ("%s", msg);
    2140. 

  2140.         else
    2141. 

  2141.                 cli_out ("%s", msg);
    2142. 

  2142.         ret = rsp.op_ret;
    2143. 

  2143. 

  2144. out:
    2145. 

  2145.         cli_cmd_broadcast_response (ret);
    2146. 

  2146.         return ret;
    2147. 

  2147. }
    2148. 

  2148. 

  2149. int32_t
    2150. 

  2150. gf_cli_print_limit_list (char *volname, char *limit_list,
    2151. 

  2151.                             char *op_errstr)
    2152. 

  2152. {
    2153. 

  2153.         int64_t  size            = 0;
    2154. 

  2154.         int64_t  limit_value     = 0;
    2155. 

  2155.         int32_t  i, j;
    2156. 

  2156.         int32_t  len = 0, ret    = -1;
    2157. 

  2157.         char     *size_str       = NULL;
    2158. 

  2158.         char     path [PATH_MAX] = {0, };
    2159. 

  2159.         char     ret_str [1024]  = {0, };
    2160. 

  2160.         char     value [1024]    = {0, };
    2161. 

  2161.         char     mountdir []     = "/tmp/mntXXXXXX";
    2162. 

  2162.         char     abspath [PATH_MAX] = {0, };
    2163. 

  2163.         char     *colon_ptr      = NULL;
    2164. 

  2164.         runner_t runner          = {0,};
    2165. 

  2165. 

  2166.         GF_VALIDATE_OR_GOTO ("cli", volname, out);
    2167. 

  2167.         GF_VALIDATE_OR_GOTO ("cli", limit_list, out);
    2168. 

  2168. 

  2169.         if (!connected)
    2170. 

  2170.                 goto out;
    2171. 

  2171. 

  2172.         len = strlen (limit_list);
    2173. 

  2173.         if (len == 0) {
    2174. 

  2174.                 cli_err ("%s", op_errstr?op_errstr:"quota limit not set ");
    2175. 

  2175.                 goto out;
    2176. 

  2176.         }
    2177. 

  2177. 

  2178.         if (mkdtemp (mountdir) == NULL) {
    2179. 

  2179.                 gf_log ("cli", GF_LOG_WARNING, "failed to create a temporary "
    2180. 

  2180.                         "mount directory");
    2181. 

  2181.                 ret = -1;
    2182. 

  2182.                 goto out;
    2183. 

  2183.         }
    2184. 

  2184. 

  2185.         /* Mount a temporary client to fetch the disk usage
    2186. 

  2186.          * of the directory on which the limit is set.
    2187. 

  2187.          */
    2188. 

  2188.         ret = runcmd (SBIN_DIR"/glusterfs", "-s",
    2189. 

  2189.                       "localhost", "--volfile-id", volname, "-l",
    2190. 

  2190.                       DEFAULT_LOG_FILE_DIRECTORY"/quota-list.log",
    2191. 

  2191.                       mountdir, NULL);
    2192. 

  2192.         if (ret) {
    2193. 

  2193.                 gf_log ("cli", GF_LOG_WARNING, "failed to mount glusterfs client");
    2194. 

  2194.                 ret = -1;
    2195. 

  2195.                 goto rm_dir;
    2196. 

  2196.         }
    2197. 

  2197. 

  2198.         len = strlen (limit_list);
    2199. 

  2199.         if (len == 0) {
    2200. 

  2200.                 cli_err ("quota limit not set ");
    2201. 

  2201.                 goto unmount;
    2202. 

  2202.         }
    2203. 

  2203. 

  2204.         i = 0;
    2205. 

  2205. 

  2206.         cli_out ("\tpath\t\t  limit_set\t     size");
    2207. 

  2207.         cli_out ("-----------------------------------------------------------"
    2208. 

  2208.                  "-----------------------");
    2209. 

  2209.         while (i < len) {
    2210. 

  2210.                 j = 0;
    2211. 

  2211. 

  2212.                 while (limit_list [i] != ',' && limit_list [i] != '\0') {
    2213. 

  2213.                         path [j++] = limit_list[i++];
    2214. 

  2214.                 }
    2215. 

  2215.                 path [j] = '\0';
    2216. 

  2216.                 //here path[] contains both path and limit value
    2217. 

  2217. 

  2218.                 colon_ptr = strrchr (path, ':');
    2219. 

  2219.                 *colon_ptr = '\0';
    2220. 

  2220.                 strcpy (value, ++colon_ptr);
    2221. 

  2221. 

  2222.                 snprintf (abspath, sizeof (abspath), "%s/%s", mountdir, path);
    2223. 

  2223. 

  2224.                 ret = sys_lgetxattr (abspath, "trusted.limit.list", (void *) ret_str, 4096);
    2225. 

  2225.                 if (ret < 0) {
    2226. 

  2226.                         cli_out ("%-20s %10s", path, value);
    2227. 

  2227.                 } else {
    2228. 

  2228.                         sscanf (ret_str, "%"PRId64",%"PRId64, &size,
    2229. 

  2229.                                 &limit_value);
    2230. 

  2230.                         size_str = gf_uint64_2human_readable ((uint64_t) size);
    2231. 

  2231.                         if (size_str == NULL) {
    2232. 

  2232.                                 cli_out ("%-20s %10s %20"PRId64, path,
    2233. 

  2233.                                          value, size);
    2234. 

  2234.                         } else {
    2235. 

  2235.                                 cli_out ("%-20s %10s %20s", path,
    2236. 

  2236.                                          value, size_str);
    2237. 

  2237.                                 GF_FREE (size_str);
    2238. 

  2238.                         }
    2239. 

  2239.                 }
    2240. 

  2240.                 i++;
    2241. 

  2241.         }
    2242. 

  2242. 

  2243. unmount:
    2244. 

  2244. 

  2245.         runinit (&runner);
    2246. 

  2246.         runner_add_args (&runner, "umount",
    2247. 

  2247. #if GF_LINUX_HOST_OS
    2248. 

  2248.                          "-l",
    2249. 

  2249. #endif
    2250. 

  2250.                          mountdir, NULL);
    2251. 

  2251.         ret = runner_run_reuse (&runner);
    2252. 

  2252.         if (ret)
    2253. 

  2253.                 runner_log (&runner, "cli", GF_LOG_WARNING, "error executing");
    2254. 

  2254.         runner_end (&runner);
    2255. 

  2255. 

  2256. rm_dir:
    2257. 

  2257.         rmdir (mountdir);
    2258. 

  2258. out:
    2259. 

  2259.         return ret;
    2260. 

  2260. }
    2261. 

  2261. 

  2262. int
    2263. 

  2263. gf_cli_quota_cbk (struct rpc_req *req, struct iovec *iov,
    2264. 

  2264.                      int count, void *myframe)
    2265. 

  2265. {
    2266. 

  2266.         gf_cli_rsp         rsp        = {0,};
    2267. 

  2267.         int                ret        = -1;
    2268. 

  2268.         dict_t            *dict       = NULL;
    2269. 

  2269.         char              *volname    = NULL;
    2270. 

  2270.         char              *limit_list = NULL;
    2271. 

  2271.         int32_t            type       = 0;
    2272. 

  2272.         char               msg[1024] = {0,};
    2273. 

  2273. 

  2274.         if (-1 == req->rpc_status) {
    2275. 

  2275.                 goto out;
    2276. 

  2276.         }
    2277. 

  2277. 

  2278.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    2279. 

  2279.         if (ret < 0) {
    2280. 

  2280.                 gf_log ("", GF_LOG_ERROR, "error");
    2281. 

  2281.                 goto out;
    2282. 

  2282.         }
    2283. 

  2283. 

  2284.         if (rsp.op_ret &&
    2285. 

  2285.             strcmp (rsp.op_errstr, "") == 0) {
    2286. 

  2286.                 snprintf (msg, sizeof (msg), "command unsuccessful %s",
    2287. 

  2287.                           rsp.op_errstr);
    2288. 

  2288. 

  2289.                 if (global_state->mode & GLUSTER_MODE_XML)
    2290. 

  2290.                         goto xml_output;
    2291. 

  2291.                 goto out;
    2292. 

  2292.         }
    2293. 

  2293. 

  2294.         if (rsp.dict.dict_len) {
    2295. 

  2295.                 /* Unserialize the dictionary */
    2296. 

  2296.                 dict  = dict_new ();
    2297. 

  2297. 

  2298.                 ret = dict_unserialize (rsp.dict.dict_val,
    2299. 

  2299.                                         rsp.dict.dict_len,
    2300. 

  2300.                                         &dict);
    2301. 

  2301.                 if (ret < 0) {
    2302. 

  2302.                         gf_log ("glusterd", GF_LOG_ERROR,
    2303. 

  2303.                                 "failed to "
    2304. 

  2304.                                 "unserialize req-buffer to dictionary");
    2305. 

  2305.                         goto out;
    2306. 

  2306.                 }
    2307. 

  2307.         }
    2308. 

  2308. 

  2309.         ret = dict_get_str (dict, "volname", &volname);
    2310. 

  2310.         if (ret)
    2311. 

  2311.                 gf_log (THIS->name, GF_LOG_TRACE,
    2312. 

  2312.                         "failed to get volname");
    2313. 

  2313. 

  2314.         ret = dict_get_str (dict, "limit_list", &limit_list);
    2315. 

  2315.         if (ret)
    2316. 

  2316.                 gf_log (THIS->name, GF_LOG_TRACE,
    2317. 

  2317.                         "failed to get limit_list");
    2318. 

  2318. 

  2319.         ret = dict_get_int32 (dict, "type", &type);
    2320. 

  2320.         if (ret)
    2321. 

  2321.                 gf_log (THIS->name, GF_LOG_TRACE,
    2322. 

  2322.                         "failed to get type");
    2323. 

  2323. 

  2324.         if (type == GF_QUOTA_OPTION_TYPE_LIST) {
    2325. 

  2325.                 if (global_state->mode & GLUSTER_MODE_XML) {
    2326. 

  2326.                         ret = cli_xml_output_vol_quota_limit_list
    2327. 

  2327.                                 (volname, limit_list, rsp.op_ret,
    2328. 

  2328.                                  rsp.op_errno, rsp.op_errstr);
    2329. 

  2329.                         if (ret)
    2330. 

  2330.                                 gf_log ("cli", GF_LOG_ERROR,
    2331. 

  2331.                                         "Error outputting to xml");
    2332. 

  2332.                         goto out;
    2333. 

  2333. 

  2334.                 }
    2335. 

  2335. 

  2336.                 if (limit_list) {
    2337. 

  2337.                         gf_cli_print_limit_list (volname,
    2338. 

  2338.                                                     limit_list,
    2339. 

  2339.                                                     rsp.op_errstr);
    2340. 

  2340.                 } else {
    2341. 

  2341.                         gf_log ("cli", GF_LOG_INFO, "Received resp to quota "
    2342. 

  2342.                                 "command ");
    2343. 

  2343.                         if (rsp.op_errstr)
    2344. 

  2344.                                 snprintf (msg, sizeof (msg), "%s",
    2345. 

  2345.                                           rsp.op_errstr);
    2346. 

  2346.                 }
    2347. 

  2347.         } else {
    2348. 

  2348.                 gf_log ("cli", GF_LOG_INFO, "Received resp to quota command ");
    2349. 

  2349.                 if (rsp.op_errstr)
    2350. 

  2350.                         snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    2351. 

  2351.                 else
    2352. 

  2352.                         snprintf (msg, sizeof (msg), "successful");
    2353. 

  2353.         }
    2354. 

  2354. 

  2355. xml_output:
    2356. 

  2356.         if (global_state->mode & GLUSTER_MODE_XML) {
    2357. 

  2357.                 ret = cli_xml_output_str ("volQuota", msg, rsp.op_ret,
    2358. 

  2358.                                           rsp.op_errno, rsp.op_errstr);
    2359. 

  2359.                 if (ret)
    2360. 

  2360.                         gf_log ("cli", GF_LOG_ERROR,
    2361. 

  2361.                                 "Error outputting to xml");
    2362. 

  2362.                 goto out;
    2363. 

  2363.         }
    2364. 

  2364. 

  2365.         if (strlen (msg) > 0) {
    2366. 

  2366.                 if (rsp.op_ret)
    2367. 

  2367.                         cli_err ("%s", msg);
    2368. 

  2368.                 else
    2369. 

  2369.                         cli_out ("%s", msg);
    2370. 

  2370.         }
    2371. 

  2371. 

  2372.         ret = rsp.op_ret;
    2373. 

  2373. out:
    2374. 

  2374.         cli_cmd_broadcast_response (ret);
    2375. 

  2375.         if (dict)
    2376. 

  2376.                 dict_unref (dict);
    2377. 

  2377. 

  2378.         free (rsp.dict.dict_val);
    2379. 

  2379. 

  2380.         return ret;
    2381. 

  2381. }
    2382. 

  2382. 

  2383. int
    2384. 

  2384. gf_cli_getspec_cbk (struct rpc_req *req, struct iovec *iov,
    2385. 

  2385.                        int count, void *myframe)
    2386. 

  2386. {
    2387. 

  2387.         gf_getspec_rsp          rsp   = {0,};
    2388. 

  2388.         int                     ret   = -1;
    2389. 

  2389.         char                   *spec  = NULL;
    2390. 

  2390. 

  2391.         if (-1 == req->rpc_status) {
    2392. 

  2392.                 goto out;
    2393. 

  2393.         }
    2394. 

  2394. 

  2395.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp);
    2396. 

  2396.         if (ret < 0 || rsp.op_ret == -1) {
    2397. 

  2397.                 gf_log ("", GF_LOG_ERROR, "error");
    2398. 

  2398.                 goto out;
    2399. 

  2399.         }
    2400. 

  2400. 

  2401.         gf_log ("cli", GF_LOG_INFO, "Received resp to getspec");
    2402. 

  2402. 

  2403.         spec = GF_MALLOC (rsp.op_ret + 1, cli_mt_char);
    2404. 

  2404.         if (!spec) {
    2405. 

  2405.                 gf_log("", GF_LOG_ERROR, "out of memory");
    2406. 

  2406.                 goto out;
    2407. 

  2407.         }
    2408. 

  2408.         memcpy (spec, rsp.spec, rsp.op_ret);
    2409. 

  2409.         spec[rsp.op_ret] = '\0';
    2410. 

  2410.         cli_out ("%s", spec);
    2411. 

  2411.         GF_FREE (spec);
    2412. 

  2412. 

  2413.         ret = 0;
    2414. 

  2414. 

  2415. out:
    2416. 

  2416.         cli_cmd_broadcast_response (ret);
    2417. 

  2417.         return ret;
    2418. 

  2418. }
    2419. 

  2419. 

  2420. int
    2421. 

  2421. gf_cli_pmap_b2p_cbk (struct rpc_req *req, struct iovec *iov,
    2422. 

  2422.                         int count, void *myframe)
    2423. 

  2423. {
    2424. 

  2424.         pmap_port_by_brick_rsp rsp = {0,};
    2425. 

  2425.         int                     ret   = -1;
    2426. 

  2426.         char                   *spec  = NULL;
    2427. 

  2427. 

  2428.         if (-1 == req->rpc_status) {
    2429. 

  2429.                 goto out;
    2430. 

  2430.         }
    2431. 

  2431. 

  2432.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_port_by_brick_rsp);
    2433. 

  2433.         if (ret < 0 || rsp.op_ret == -1) {
    2434. 

  2434.                 gf_log ("", GF_LOG_ERROR, "error");
    2435. 

  2435.                 goto out;
    2436. 

  2436.         }
    2437. 

  2437. 

  2438.         gf_log ("cli", GF_LOG_INFO, "Received resp to pmap b2p");
    2439. 

  2439. 

  2440.         cli_out ("%d", rsp.port);
    2441. 

  2441.         GF_FREE (spec);
    2442. 

  2442. 

  2443.         ret = rsp.op_ret;
    2444. 

  2444. 

  2445. out:
    2446. 

  2446.         cli_cmd_broadcast_response (ret);
    2447. 

  2447.         return ret;
    2448. 

  2448. }
    2449. 

  2449. 

  2450. 

  2451. int32_t
    2452. 

  2452. gf_cli_probe (call_frame_t *frame, xlator_t *this,
    2453. 

  2453.                  void *data)
    2454. 

  2454. {
    2455. 

  2455.         gf1_cli_probe_req  req      = {0,};
    2456. 

  2456.         int                ret      = 0;
    2457. 

  2457.         dict_t            *dict     = NULL;
    2458. 

  2458.         char              *hostname = NULL;
    2459. 

  2459.         int                port     = 0;
    2460. 

  2460. 

  2461.         if (!frame || !this ||  !data) {
    2462. 

  2462.                 ret = -1;
    2463. 

  2463.                 goto out;
    2464. 

  2464.         }
    2465. 

  2465. 

  2466.         dict = data;
    2467. 

  2467.         ret = dict_get_str (dict, "hostname", &hostname);
    2468. 

  2468.         if (ret)
    2469. 

  2469.                 goto out;
    2470. 

  2470. 

  2471.         ret = dict_get_int32 (dict, "port", &port);
    2472. 

  2472.         if (ret)
    2473. 

  2473.                 port = CLI_GLUSTERD_PORT;
    2474. 

  2474. 

  2475.         req.hostname = hostname;
    2476. 

  2476.         req.port     = port;
    2477. 

  2477. 

  2478.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    2479. 

  2479.                               GLUSTER_CLI_PROBE, NULL,
    2480. 

  2480.                               this, gf_cli_probe_cbk,
    2481. 

  2481.                               (xdrproc_t)xdr_gf1_cli_probe_req);
    2482. 

  2482. 

  2483. out:
    2484. 

  2484.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2485. 

  2485.         return ret;
    2486. 

  2486. }
    2487. 

  2487. 

  2488. int32_t
    2489. 

  2489. gf_cli_deprobe (call_frame_t *frame, xlator_t *this,
    2490. 

  2490.                    void *data)
    2491. 

  2491. {
    2492. 

  2492.         gf1_cli_deprobe_req  req      = {0,};
    2493. 

  2493.         int                  ret      = 0;
    2494. 

  2494.         dict_t              *dict     = NULL;
    2495. 

  2495.         char                *hostname = NULL;
    2496. 

  2496.         int                  port     = 0;
    2497. 

  2497.         int                  flags    = 0;
    2498. 

  2498. 

  2499.         if (!frame || !this ||  !data) {
    2500. 

  2500.                 ret = -1;
    2501. 

  2501.                 goto out;
    2502. 

  2502.         }
    2503. 

  2503. 

  2504.         dict = data;
    2505. 

  2505.         ret = dict_get_str (dict, "hostname", &hostname);
    2506. 

  2506.         if (ret)
    2507. 

  2507.                 goto out;
    2508. 

  2508. 

  2509.         ret = dict_get_int32 (dict, "port", &port);
    2510. 

  2510.         if (ret)
    2511. 

  2511.                 port = CLI_GLUSTERD_PORT;
    2512. 

  2512. 

  2513.         ret = dict_get_int32 (dict, "flags", &flags);
    2514. 

  2514.         if (ret)
    2515. 

  2515.                 flags = 0;
    2516. 

  2516. 

  2517.         req.hostname = hostname;
    2518. 

  2518.         req.port     = port;
    2519. 

  2519.         req.flags    = flags;
    2520. 

  2520.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    2521. 

  2521.                               GLUSTER_CLI_DEPROBE, NULL,
    2522. 

  2522.                               this, gf_cli_deprobe_cbk,
    2523. 

  2523.                               (xdrproc_t)xdr_gf1_cli_deprobe_req);
    2524. 

  2524. 

  2525. out:
    2526. 

  2526.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2527. 

  2527.         return ret;
    2528. 

  2528. }
    2529. 

  2529. 

  2530. int32_t
    2531. 

  2531. gf_cli_list_friends (call_frame_t *frame, xlator_t *this,
    2532. 

  2532.                         void *data)
    2533. 

  2533. {
    2534. 

  2534.         gf1_cli_peer_list_req   req = {0,};
    2535. 

  2535.         int                     ret = 0;
    2536. 

  2536. 

  2537.         if (!frame || !this) {
    2538. 

  2538.                 ret = -1;
    2539. 

  2539.                 goto out;
    2540. 

  2540.         }
    2541. 

  2541. 

  2542.         req.flags = GF_CLI_LIST_ALL;
    2543. 

  2543. 

  2544.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    2545. 

  2545.                               GLUSTER_CLI_LIST_FRIENDS, NULL,
    2546. 

  2546.                               this, gf_cli_list_friends_cbk,
    2547. 

  2547.                               (xdrproc_t) xdr_gf1_cli_peer_list_req);
    2548. 

  2548. 

  2549. out:
    2550. 

  2550.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2551. 

  2551.         return ret;
    2552. 

  2552. }
    2553. 

  2553. 

  2554. int32_t
    2555. 

  2555. gf_cli_get_next_volume (call_frame_t *frame, xlator_t *this,
    2556. 

  2556.                            void *data)
    2557. 

  2557. {
    2558. 

  2558. 

  2559.         int                             ret = 0;
    2560. 

  2560.         cli_cmd_volume_get_ctx_t        *ctx = NULL;
    2561. 

  2561.         cli_local_t                     *local = NULL;
    2562. 

  2562. 

  2563.         if (!frame || !this || !data) {
    2564. 

  2564.                 ret = -1;
    2565. 

  2565.                 goto out;
    2566. 

  2566.         }
    2567. 

  2567. 

  2568.         ctx = data;
    2569. 

  2569.         local = frame->local;
    2570. 

  2570. 

  2571.         if (global_state->mode & GLUSTER_MODE_XML) {
    2572. 

  2572.                 ret = cli_xml_output_vol_info_begin (local, 0, 0, "");
    2573. 

  2573.                 if (ret) {
    2574. 

  2574.                         gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
    2575. 

  2575.                         goto out;
    2576. 

  2576.                 }
    2577. 

  2577.         }
    2578. 

  2578. 

  2579.         ret = gf_cli_get_volume (frame, this, data);
    2580. 

  2580. 

  2581. 

  2582.         if (!local || !local->get_vol.volname) {
    2583. 

  2583.                 if ((global_state->mode & GLUSTER_MODE_XML))
    2584. 

  2584.                         goto end_xml;
    2585. 

  2585. 

  2586.                 cli_err ("No volumes present");
    2587. 

  2587.                 goto out;
    2588. 

  2588.         }
    2589. 

  2589. 

  2590. 

  2591.         ctx->volname = local->get_vol.volname;
    2592. 

  2592. 

  2593.         while (ctx->volname) {
    2594. 

  2594.                 ret = gf_cli_get_volume (frame, this, ctx);
    2595. 

  2595.                 if (ret)
    2596. 

  2596.                         goto out;
    2597. 

  2597.                 ctx->volname = local->get_vol.volname;
    2598. 

  2598.         }
    2599. 

  2599. 

  2600. end_xml:
    2601. 

  2601.         if (global_state->mode & GLUSTER_MODE_XML) {
    2602. 

  2602.                 ret = cli_xml_output_vol_info_end (local);
    2603. 

  2603.                 if (ret)
    2604. 

  2604.                         gf_log ("cli", GF_LOG_ERROR, "Error outputting to xml");
    2605. 

  2605.         }
    2606. 

  2606. 

  2607. out:
    2608. 

  2608.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2609. 

  2609.         return ret;
    2610. 

  2610. }
    2611. 

  2611. 

  2612. int32_t
    2613. 

  2613. gf_cli_get_volume (call_frame_t *frame, xlator_t *this,
    2614. 

  2614.                       void *data)
    2615. 

  2615. {
    2616. 

  2616.         gf_cli_req                      req = {{0,}};
    2617. 

  2617.         int                             ret = 0;
    2618. 

  2618.         cli_cmd_volume_get_ctx_t        *ctx = NULL;
    2619. 

  2619.         dict_t                          *dict = NULL;
    2620. 

  2620.         int32_t                         flags = 0;
    2621. 

  2621. 

  2622.         if (!frame || !this || !data) {
    2623. 

  2623.                 ret = -1;
    2624. 

  2624.                 goto out;
    2625. 

  2625.         }
    2626. 

  2626. 

  2627.         ctx = data;
    2628. 

  2628. 

  2629.         dict = dict_new ();
    2630. 

  2630.         if (!dict)
    2631. 

  2631.                 goto out;
    2632. 

  2632. 

  2633.         if (ctx->volname) {
    2634. 

  2634.                 ret = dict_set_str (dict, "volname", ctx->volname);
    2635. 

  2635.                 if (ret)
    2636. 

  2636.                         goto out;
    2637. 

  2637.         }
    2638. 

  2638. 

  2639.         flags = ctx->flags;
    2640. 

  2640.         ret = dict_set_int32 (dict, "flags", flags);
    2641. 

  2641.         if (ret) {
    2642. 

  2642.                 gf_log (THIS->name, GF_LOG_ERROR, "failed to set flags");
    2643. 

  2643.                 goto out;
    2644. 

  2644.         }
    2645. 

  2645. 

  2646.         ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
    2647. 

  2647.                                            &req.dict.dict_len);
    2648. 

  2648. 

  2649.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    2650. 

  2650.                               GLUSTER_CLI_GET_VOLUME, NULL,
    2651. 

  2651.                               this, gf_cli_get_volume_cbk,
    2652. 

  2652.                               (xdrproc_t) xdr_gf_cli_req);
    2653. 

  2653. 

  2654. out:
    2655. 

  2655.         if (dict)
    2656. 

  2656.                 dict_unref (dict);
    2657. 

  2657. 

  2658.         GF_FREE (req.dict.dict_val);
    2659. 

  2659. 

  2660.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2661. 

  2661.         return ret;
    2662. 

  2662. }
    2663. 

  2663. 

  2664. int32_t
    2665. 

  2665. gf_cli3_1_uuid_reset (call_frame_t *frame, xlator_t *this,
    2666. 

  2666.                       void *data)
    2667. 

  2667. {
    2668. 

  2668.         gf_cli_req                      req = {{0,}};
    2669. 

  2669.         int                             ret = 0;
    2670. 

  2670.         dict_t                          *dict = NULL;
    2671. 

  2671. 

  2672.         if (!frame || !this || !data) {
    2673. 

  2673.                 ret = -1;
    2674. 

  2674.                 goto out;
    2675. 

  2675.         }
    2676. 

  2676. 

  2677.         dict = data;
    2678. 

  2678.         ret = cli_to_glusterd (&req, frame, gf_cli3_1_uuid_reset_cbk,
    2679. 

  2679.                                (xdrproc_t)xdr_gf_cli_req, dict,
    2680. 

  2680.                                GLUSTER_CLI_UUID_RESET, this, cli_rpc_prog,
    2681. 

  2681.                                NULL);
    2682. 

  2682. out:
    2683. 

  2683.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2684. 

  2684.         return ret;
    2685. 

  2685. }
    2686. 

  2686. 

  2687. #ifdef HAVE_BD_XLATOR
    2688. 

  2688. int
    2689. 

  2689. gf_cli_bd_op_cbk (struct rpc_req *req, struct iovec *iov,
    2690. 

  2690.                              int count, void *myframe)
    2691. 

  2691. {
    2692. 

  2692.         gf_cli_rsp              rsp         = {0,};
    2693. 

  2693.         int                     ret         = -1;
    2694. 

  2694.         cli_local_t             *local      = NULL;
    2695. 

  2695.         dict_t                  *dict       = NULL;
    2696. 

  2696.         dict_t                  *input_dict = NULL;
    2697. 

  2697.         gf_xl_bd_op_t           bd_op       = GF_BD_OP_INVALID;
    2698. 

  2698.         char                    *operation  = NULL;
    2699. 

  2699.         call_frame_t            *frame      = NULL;
    2700. 

  2700. 

  2701.         if (-1 == req->rpc_status)
    2702. 

  2702.                 goto out;
    2703. 

  2703. 

  2704.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    2705. 

  2705.         if (ret < 0) {
    2706. 

  2706.                 gf_log ("", GF_LOG_ERROR, "error");
    2707. 

  2707.                 goto out;
    2708. 

  2708.         }
    2709. 

  2709. 

  2710.         dict = dict_new ();
    2711. 

  2711.         if (!dict) {
    2712. 

  2712.                 ret = -1;
    2713. 

  2713.                 goto out;
    2714. 

  2714.         }
    2715. 

  2715. 

  2716.         frame = myframe;
    2717. 

  2717.         if (frame)
    2718. 

  2718.                 local = frame->local;
    2719. 

  2719. 

  2720.         if (local) {
    2721. 

  2721.                 input_dict = local->dict;
    2722. 

  2722.                 ret = dict_get_int32 (input_dict, "bd-op",
    2723. 

  2723.                                       (int32_t *)&bd_op);
    2724. 

  2724.         }
    2725. 

  2725. 

  2726.         switch (bd_op) {
    2727. 

  2727.         case GF_BD_OP_NEW_BD:
    2728. 

  2728.                 operation = gf_strdup ("create");
    2729. 

  2729.                 break;
    2730. 

  2730.         case GF_BD_OP_DELETE_BD:
    2731. 

  2731.                 operation = gf_strdup ("delete");
    2732. 

  2732.                 break;
    2733. 

  2733.         case GF_BD_OP_CLONE_BD:
    2734. 

  2734.                 operation = gf_strdup ("clone");
    2735. 

  2735.                 break;
    2736. 

  2736.         case GF_BD_OP_SNAPSHOT_BD:
    2737. 

  2737.                 operation = gf_strdup ("snapshot");
    2738. 

  2738.                 break;
    2739. 

  2739.         default:
    2740. 

  2740.                 break;
    2741. 

  2741.         }
    2742. 

  2742. 

  2743.         ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
    2744. 

  2744.         if (ret)
    2745. 

  2745.                 goto out;
    2746. 

  2746. 

  2747.         gf_log ("cli", GF_LOG_INFO, "Received resp to %s bd op", operation);
    2748. 

  2748. 

  2749.         if (global_state->mode & GLUSTER_MODE_XML) {
    2750. 

  2750.                 ret = cli_xml_output_dict ("BdOp", dict, rsp.op_ret,
    2751. 

  2751.                                            rsp.op_errno, rsp.op_errstr);
    2752. 

  2752.                 if (ret)
    2753. 

  2753.                         gf_log ("cli", GF_LOG_ERROR,
    2754. 

  2754.                                 "Error outputting to xml");
    2755. 

  2755.                 goto out;
    2756. 

  2756.         }
    2757. 

  2757. 

  2758.         if (rsp.op_ret && strcmp (rsp.op_errstr, ""))
    2759. 

  2759.                 cli_err ("%s", rsp.op_errstr);
    2760. 

  2760.         else
    2761. 

  2761.                 cli_out ("BD %s has been %s", operation,
    2762. 

  2762.                                 (rsp.op_ret) ? "unsuccessful":
    2763. 

  2763.                                 "successful.");
    2764. 

  2764.         ret = rsp.op_ret;
    2765. 

  2765. 

  2766. out:
    2767. 

  2767.         cli_cmd_broadcast_response (ret);
    2768. 

  2768. 

  2769.         if (dict)
    2770. 

  2770.                 dict_unref (dict);
    2771. 

  2771. 

  2772.         if (operation)
    2773. 

  2773.                 GF_FREE (operation);
    2774. 

  2774. 

  2775.         if (rsp.dict.dict_val)
    2776. 

  2776.                 free (rsp.dict.dict_val);
    2777. 

  2777.         if (rsp.op_errstr)
    2778. 

  2778.                 free (rsp.op_errstr);
    2779. 

  2779.         return ret;
    2780. 

  2780. }
    2781. 

  2781. 

  2782. int32_t
    2783. 

  2783. gf_cli_bd_op (call_frame_t *frame, xlator_t *this,
    2784. 

  2784.                       void *data)
    2785. 

  2785. {
    2786. 

  2786.         gf_cli_req      req    = { {0,} };
    2787. 

  2787.         int             ret    = 0;
    2788. 

  2788.         dict_t          *dict  = NULL;
    2789. 

  2789. 

  2790.         if (!frame || !this || !data) {
    2791. 

  2791.                 ret = -1;
    2792. 

  2792.                 goto out;
    2793. 

  2793.         }
    2794. 

  2794. 

  2795.         dict = dict_ref ((dict_t *)data);
    2796. 

  2796.         if (!dict)
    2797. 

  2797.                 goto out;
    2798. 

  2798. 

  2799.         ret = dict_allocate_and_serialize (dict,
    2800. 

  2800.                                            &req.dict.dict_val,
    2801. 

  2801.                                            &req.dict.dict_len);
    2802. 

  2802. 

  2803. 

  2804.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    2805. 

  2805.                               GLUSTER_CLI_BD_OP, NULL,
    2806. 

  2806.                               this, gf_cli_bd_op_cbk,
    2807. 

  2807.                               (xdrproc_t) xdr_gf_cli_req);
    2808. 

  2808. 

  2809. out:
    2810. 

  2810.         if (dict)
    2811. 

  2811.                 dict_unref (dict);
    2812. 

  2812. 

  2813.         if (req.dict.dict_val)
    2814. 

  2814.                 GF_FREE (req.dict.dict_val);
    2815. 

  2815. 

  2816.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2817. 

  2817.         return ret;
    2818. 

  2818. }
    2819. 

  2819. #endif
    2820. 

  2820. 

  2821. int32_t
    2822. 

  2822. gf_cli_create_volume (call_frame_t *frame, xlator_t *this,
    2823. 

  2823.                          void *data)
    2824. 

  2824. {
    2825. 

  2825.         gf_cli_req              req = {{0,}};
    2826. 

  2826.         int                     ret = 0;
    2827. 

  2827.         dict_t                  *dict = NULL;
    2828. 

  2828. 

  2829.         if (!frame || !this ||  !data) {
    2830. 

  2830.                 ret = -1;
    2831. 

  2831.                 goto out;
    2832. 

  2832.         }
    2833. 

  2833. 

  2834.         dict = data;
    2835. 

  2835. 

  2836.         ret = cli_to_glusterd (&req, frame, gf_cli_create_volume_cbk,
    2837. 

  2837.                                (xdrproc_t) xdr_gf_cli_req, dict,
    2838. 

  2838.                                GLUSTER_CLI_CREATE_VOLUME, this, cli_rpc_prog,
    2839. 

  2839.                                NULL);
    2840. 

  2840. 

  2841. out:
    2842. 

  2842.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2843. 

  2843. 

  2844.         GF_FREE (req.dict.dict_val);
    2845. 

  2845. 

  2846.         return ret;
    2847. 

  2847. }
    2848. 

  2848. 

  2849. int32_t
    2850. 

  2850. gf_cli_delete_volume (call_frame_t *frame, xlator_t *this,
    2851. 

  2851.                          void *data)
    2852. 

  2852. {
    2853. 

  2853.         gf_cli_req              req = {{0,}};
    2854. 

  2854.         int                     ret = 0;
    2855. 

  2855.         dict_t                  *dict = NULL;
    2856. 

  2856. 

  2857.         if (!frame || !this ||  !data) {
    2858. 

  2858.                 ret = -1;
    2859. 

  2859.                 goto out;
    2860. 

  2860.         }
    2861. 

  2861. 

  2862.         dict = data;
    2863. 

  2863. 

  2864.         ret = cli_to_glusterd (&req, frame, gf_cli_delete_volume_cbk,
    2865. 

  2865.                                (xdrproc_t) xdr_gf_cli_req, dict,
    2866. 

  2866.                                GLUSTER_CLI_DELETE_VOLUME, this, cli_rpc_prog,
    2867. 

  2867.                                NULL);
    2868. 

  2868. 

  2869. out:
    2870. 

  2870.         GF_FREE (req.dict.dict_val);
    2871. 

  2871.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2872. 

  2872. 

  2873.         return ret;
    2874. 

  2874. }
    2875. 

  2875. 

  2876. int32_t
    2877. 

  2877. gf_cli_start_volume (call_frame_t *frame, xlator_t *this,
    2878. 

  2878.                          void *data)
    2879. 

  2879. {
    2880. 

  2880.         gf_cli_req              req = {{0,}};
    2881. 

  2881.         int                     ret = 0;
    2882. 

  2882.         dict_t                  *dict = NULL;
    2883. 

  2883. 

  2884.         if (!frame || !this ||  !data) {
    2885. 

  2885.                 ret = -1;
    2886. 

  2886.                 goto out;
    2887. 

  2887.         }
    2888. 

  2888. 

  2889.         dict = data;
    2890. 

  2890. 

  2891.         ret = cli_to_glusterd (&req, frame, gf_cli_start_volume_cbk,
    2892. 

  2892.                                (xdrproc_t) xdr_gf_cli_req, dict,
    2893. 

  2893.                                GLUSTER_CLI_START_VOLUME, this, cli_rpc_prog,
    2894. 

  2894.                                NULL);
    2895. 

  2895. 

  2896. out:
    2897. 

  2897.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2898. 

  2898. 

  2899.         return ret;
    2900. 

  2900. }
    2901. 

  2901. 

  2902. int32_t
    2903. 

  2903. gf_cli_stop_volume (call_frame_t *frame, xlator_t *this,
    2904. 

  2904.                          void *data)
    2905. 

  2905. {
    2906. 

  2906.         gf_cli_req             req = {{0,}};
    2907. 

  2907.         int                    ret = 0;
    2908. 

  2908.         dict_t                 *dict = data;
    2909. 

  2909. 

  2910.         if (!frame || !this ||  !data) {
    2911. 

  2911.                 ret = -1;
    2912. 

  2912.                 goto out;
    2913. 

  2913.         }
    2914. 

  2914. 

  2915.         dict = data;
    2916. 

  2916. 

  2917.         ret = cli_to_glusterd (&req, frame, gf_cli_stop_volume_cbk,
    2918. 

  2918.                                (xdrproc_t) xdr_gf_cli_req, dict,
    2919. 

  2919.                                GLUSTER_CLI_STOP_VOLUME, this, cli_rpc_prog,
    2920. 

  2920.                                NULL);
    2921. 

  2921. 

  2922. out:
    2923. 

  2923.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2924. 

  2924. 

  2925.         return ret;
    2926. 

  2926. }
    2927. 

  2927. 

  2928. int32_t
    2929. 

  2929. gf_cli_defrag_volume (call_frame_t *frame, xlator_t *this,
    2930. 

  2930.                          void *data)
    2931. 

  2931. {
    2932. 

  2932.         gf_cli_req              req     =  {{0,}};
    2933. 

  2933.         int                     ret     = 0;
    2934. 

  2934.         dict_t                 *dict    = NULL;
    2935. 

  2935. 

  2936.         if (!frame || !this ||  !data) {
    2937. 

  2937.                 ret = -1;
    2938. 

  2938.                 goto out;
    2939. 

  2939.         }
    2940. 

  2940. 

  2941.         dict = data;
    2942. 

  2942. 

  2943.         ret = cli_to_glusterd (&req, frame, gf_cli_defrag_volume_cbk,
    2944. 

  2944.                                (xdrproc_t) xdr_gf_cli_req, dict,
    2945. 

  2945.                                GLUSTER_CLI_DEFRAG_VOLUME, this, cli_rpc_prog,
    2946. 

  2946.                                NULL);
    2947. 

  2947. 

  2948. out:
    2949. 

  2949.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2950. 

  2950. 

  2951.         return ret;
    2952. 

  2952. }
    2953. 

  2953. 

  2954. int32_t
    2955. 

  2955. gf_cli_rename_volume (call_frame_t *frame, xlator_t *this,
    2956. 

  2956.                          void *data)
    2957. 

  2957. {
    2958. 

  2958.         gf_cli_req              req = {{0,}};
    2959. 

  2959.         int                     ret = 0;
    2960. 

  2960.         dict_t                  *dict = NULL;
    2961. 

  2961. 

  2962.         if (!frame || !this ||  !data) {
    2963. 

  2963.                 ret = -1;
    2964. 

  2964.                 goto out;
    2965. 

  2965.         }
    2966. 

  2966. 

  2967.         dict = data;
    2968. 

  2968. 

  2969.         ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
    2970. 

  2970.                                            &req.dict.dict_len);
    2971. 

  2971.         if (ret < 0) {
    2972. 

  2972.                 gf_log (this->name, GF_LOG_ERROR,
    2973. 

  2973.                         "failed to serialize the data");
    2974. 

  2974. 

  2975.                 goto out;
    2976. 

  2976.         }
    2977. 

  2977. 

  2978. 

  2979.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    2980. 

  2980.                               GLUSTER_CLI_RENAME_VOLUME, NULL,
    2981. 

  2981.                               this, gf_cli_rename_volume_cbk,
    2982. 

  2982.                               (xdrproc_t) xdr_gf_cli_req);
    2983. 

  2983. 

  2984. out:
    2985. 

  2985.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    2986. 

  2986. 

  2987.         return ret;
    2988. 

  2988. }
    2989. 

  2989. 

  2990. int32_t
    2991. 

  2991. gf_cli_reset_volume (call_frame_t *frame, xlator_t *this,
    2992. 

  2992.                         void *data)
    2993. 

  2993. {
    2994. 

  2994.         gf_cli_req              req =  {{0,}};
    2995. 

  2995.         int                     ret = 0;
    2996. 

  2996.         dict_t                  *dict = NULL;
    2997. 

  2997. 

  2998.         if (!frame || !this ||  !data) {
    2999. 

  2999.                 ret = -1;
    3000. 

  3000.                 goto out;
    3001. 

  3001.         }
    3002. 

  3002. 

  3003.         dict = data;
    3004. 

  3004. 

  3005.         ret = cli_to_glusterd (&req, frame, gf_cli_reset_volume_cbk,
    3006. 

  3006.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3007. 

  3007.                                GLUSTER_CLI_RESET_VOLUME, this, cli_rpc_prog,
    3008. 

  3008.                                NULL);
    3009. 

  3009. 

  3010. out:
    3011. 

  3011.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3012. 

  3012.         return ret;
    3013. 

  3013. }
    3014. 

  3014. 

  3015. int32_t
    3016. 

  3016. gf_cli_set_volume (call_frame_t *frame, xlator_t *this,
    3017. 

  3017.                          void *data)
    3018. 

  3018. {
    3019. 

  3019.         gf_cli_req              req =  {{0,}};
    3020. 

  3020.         int                     ret = 0;
    3021. 

  3021.         dict_t                  *dict = NULL;
    3022. 

  3022. 

  3023.         if (!frame || !this ||  !data) {
    3024. 

  3024.                 ret = -1;
    3025. 

  3025.                 goto out;
    3026. 

  3026.         }
    3027. 

  3027. 

  3028.         dict = data;
    3029. 

  3029. 

  3030.         ret = cli_to_glusterd (&req, frame, gf_cli_set_volume_cbk,
    3031. 

  3031.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3032. 

  3032.                                GLUSTER_CLI_SET_VOLUME, this, cli_rpc_prog,
    3033. 

  3033.                                NULL);
    3034. 

  3034. 

  3035. out:
    3036. 

  3036.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3037. 

  3037. 

  3038.         return ret;
    3039. 

  3039. }
    3040. 

  3040. 

  3041. int32_t
    3042. 

  3042. gf_cli_add_brick (call_frame_t *frame, xlator_t *this,
    3043. 

  3043.                          void *data)
    3044. 

  3044. {
    3045. 

  3045.         gf_cli_req              req =  {{0,}};
    3046. 

  3046.         int                     ret = 0;
    3047. 

  3047.         dict_t                  *dict = NULL;
    3048. 

  3048.         char                    *volname = NULL;
    3049. 

  3049.         int32_t                 count = 0;
    3050. 

  3050. 

  3051.         if (!frame || !this ||  !data) {
    3052. 

  3052.                 ret = -1;
    3053. 

  3053.                 goto out;
    3054. 

  3054.         }
    3055. 

  3055. 

  3056.         dict = data;
    3057. 

  3057. 

  3058.         ret = dict_get_str (dict, "volname", &volname);
    3059. 

  3059. 

  3060.         if (ret)
    3061. 

  3061.                 goto out;
    3062. 

  3062. 

  3063.         ret = dict_get_int32 (dict, "count", &count);
    3064. 

  3064.         if (ret)
    3065. 

  3065.                 goto out;
    3066. 

  3066. 

  3067.         ret = cli_to_glusterd (&req, frame, gf_cli_add_brick_cbk,
    3068. 

  3068.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3069. 

  3069.                                GLUSTER_CLI_ADD_BRICK, this, cli_rpc_prog, NULL);
    3070. 

  3070. 

  3071. out:
    3072. 

  3072.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3073. 

  3073. 

  3074.         GF_FREE (req.dict.dict_val);
    3075. 

  3075. 

  3076.         return ret;
    3077. 

  3077. }
    3078. 

  3078. 

  3079. int32_t
    3080. 

  3080. gf_cli_remove_brick (call_frame_t *frame, xlator_t *this,
    3081. 

  3081.                          void *data)
    3082. 

  3082. {
    3083. 

  3083.         gf_cli_req                req =  {{0,}};;
    3084. 

  3084.         gf_cli_req                status_req =  {{0,}};;
    3085. 

  3085.         int                       ret = 0;
    3086. 

  3086.         dict_t                   *dict = NULL;
    3087. 

  3087.         int32_t                   command = 0;
    3088. 

  3088.         char                     *volname = NULL;
    3089. 

  3089.         dict_t                   *req_dict = NULL;
    3090. 

  3090.         int32_t                   cmd = 0;
    3091. 

  3091. 

  3092.         if (!frame || !this ||  !data) {
    3093. 

  3093.                 ret = -1;
    3094. 

  3094.                 goto out;
    3095. 

  3095.         }
    3096. 

  3096. 

  3097.         dict = data;
    3098. 

  3098. 

  3099.         ret = dict_get_str (dict, "volname", &volname);
    3100. 

  3100.         if (ret)
    3101. 

  3101.                 goto out;
    3102. 

  3102. 

  3103.         ret = dict_get_int32 (dict, "command", &command);
    3104. 

  3104.         if (ret)
    3105. 

  3105.                 goto out;
    3106. 

  3106. 

  3107.         if ((command != GF_OP_CMD_STATUS) &&
    3108. 

  3108.             (command != GF_OP_CMD_STOP)) {
    3109. 

  3109. 

  3110. 

  3111.                 ret = cli_to_glusterd (&req, frame, gf_cli_remove_brick_cbk,
    3112. 

  3112.                                        (xdrproc_t) xdr_gf_cli_req, dict,
    3113. 

  3113.                                        GLUSTER_CLI_REMOVE_BRICK, this,
    3114. 

  3114.                                        cli_rpc_prog, NULL);
    3115. 

  3115.         } else {
    3116. 

  3116.                 /* Need rebalance status to be sent :-) */
    3117. 

  3117.                 req_dict = dict_new ();
    3118. 

  3118.                 if (!req_dict) {
    3119. 

  3119.                         ret = -1;
    3120. 

  3120.                         goto out;
    3121. 

  3121.                 }
    3122. 

  3122. 

  3123.                 ret = dict_set_str (req_dict, "volname", volname);
    3124. 

  3124.                 if (ret) {
    3125. 

  3125.                         gf_log (THIS->name, GF_LOG_ERROR,
    3126. 

  3126.                                 "Failed to set dict");
    3127. 

  3127.                         goto out;
    3128. 

  3128.                 }
    3129. 

  3129. 

  3130.                 if (command == GF_OP_CMD_STATUS)
    3131. 

  3131.                         cmd |= GF_DEFRAG_CMD_STATUS;
    3132. 

  3132.                 else
    3133. 

  3133.                         cmd |= GF_DEFRAG_CMD_STOP;
    3134. 

  3134. 

  3135.                 ret = dict_set_int32 (req_dict, "rebalance-command", (int32_t) cmd);
    3136. 

  3136.                 if (ret) {
    3137. 

  3137.                         gf_log (THIS->name, GF_LOG_ERROR,
    3138. 

  3138.                                 "Failed to set dict");
    3139. 

  3139.                         goto out;
    3140. 

  3140.                 }
    3141. 

  3141. 

  3142.                 ret = cli_to_glusterd (&status_req, frame,
    3143. 

  3143.                                        gf_cli3_remove_brick_status_cbk,
    3144. 

  3144.                                        (xdrproc_t) xdr_gf_cli_req, req_dict,
    3145. 

  3145.                                        GLUSTER_CLI_DEFRAG_VOLUME, this,
    3146. 

  3146.                                        cli_rpc_prog, NULL);
    3147. 

  3147. 

  3148.                 }
    3149. 

  3149. 

  3150. out:
    3151. 

  3151.         if (req_dict)
    3152. 

  3152.                 dict_unref (req_dict);
    3153. 

  3153.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3154. 

  3154. 

  3155.         GF_FREE (req.dict.dict_val);
    3156. 

  3156. 

  3157.         GF_FREE (status_req.dict.dict_val);
    3158. 

  3158. 

  3159.         return ret;
    3160. 

  3160. }
    3161. 

  3161. 

  3162. int32_t
    3163. 

  3163. gf_cli_replace_brick (call_frame_t *frame, xlator_t *this,
    3164. 

  3164.                          void *data)
    3165. 

  3165. {
    3166. 

  3166.         gf_cli_req                  req        =  {{0,}};
    3167. 

  3167.         int                         ret        = 0;
    3168. 

  3168.         dict_t                     *dict       = NULL;
    3169. 

  3169.         char                       *src_brick  = NULL;
    3170. 

  3170.         char                       *dst_brick  = NULL;
    3171. 

  3171.         char                       *volname    = NULL;
    3172. 

  3172.         int32_t                     op         = 0;
    3173. 

  3173. 

  3174.         if (!frame || !this ||  !data) {
    3175. 

  3175.                 ret = -1;
    3176. 

  3176.                 goto out;
    3177. 

  3177.         }
    3178. 

  3178. 

  3179.         dict = data;
    3180. 

  3180. 

  3181.         ret = dict_get_int32 (dict, "operation", &op);
    3182. 

  3182.         if (ret) {
    3183. 

  3183.                 gf_log (this->name, GF_LOG_DEBUG,
    3184. 

  3184.                         "dict_get on operation failed");
    3185. 

  3185.                 goto out;
    3186. 

  3186.         }
    3187. 

  3187.         ret = dict_get_str (dict, "volname", &volname);
    3188. 

  3188.         if (ret) {
    3189. 

  3189.                 gf_log (this->name, GF_LOG_DEBUG,
    3190. 

  3190.                         "dict_get on volname failed");
    3191. 

  3191.                 goto out;
    3192. 

  3192.         }
    3193. 

  3193. 

  3194.         ret = dict_get_str (dict, "src-brick", &src_brick);
    3195. 

  3195.         if (ret) {
    3196. 

  3196.                 gf_log (this->name, GF_LOG_DEBUG,
    3197. 

  3197.                         "dict_get on src-brick failed");
    3198. 

  3198.                 goto out;
    3199. 

  3199.         }
    3200. 

  3200. 

  3201.         ret = dict_get_str (dict, "dst-brick", &dst_brick);
    3202. 

  3202.         if (ret) {
    3203. 

  3203.                 gf_log (this->name, GF_LOG_DEBUG,
    3204. 

  3204.                         "dict_get on dst-brick failed");
    3205. 

  3205.                 goto out;
    3206. 

  3206.         }
    3207. 

  3207. 

  3208.         gf_log (this->name, GF_LOG_DEBUG,
    3209. 

  3209.                 "Received command replace-brick %s with "
    3210. 

  3210.                 "%s with operation=%d", src_brick,
    3211. 

  3211.                 dst_brick, op);
    3212. 

  3212. 

  3213.         ret = cli_to_glusterd (&req, frame, gf_cli_replace_brick_cbk,
    3214. 

  3214.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3215. 

  3215.                                GLUSTER_CLI_REPLACE_BRICK, this, cli_rpc_prog,
    3216. 

  3216.                                NULL);
    3217. 

  3217. 

  3218. out:
    3219. 

  3219.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3220. 

  3220. 

  3221.         GF_FREE (req.dict.dict_val);
    3222. 

  3222. 

  3223.         return ret;
    3224. 

  3224. }
    3225. 

  3225. 

  3226. 

  3227. int32_t
    3228. 

  3228. gf_cli_log_rotate (call_frame_t *frame, xlator_t *this,
    3229. 

  3229.                       void *data)
    3230. 

  3230. {
    3231. 

  3231.         gf_cli_req                req = {{0,}};
    3232. 

  3232.         int                       ret = 0;
    3233. 

  3233.         dict_t                   *dict = NULL;
    3234. 

  3234. 

  3235.         if (!frame || !this ||  !data) {
    3236. 

  3236.                 ret = -1;
    3237. 

  3237.                 goto out;
    3238. 

  3238.         }
    3239. 

  3239. 

  3240.         dict = data;
    3241. 

  3241. 

  3242.         ret = cli_to_glusterd (&req, frame, gf_cli_log_rotate_cbk,
    3243. 

  3243.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3244. 

  3244.                                GLUSTER_CLI_LOG_ROTATE, this, cli_rpc_prog,
    3245. 

  3245.                                NULL);
    3246. 

  3246. 

  3247. out:
    3248. 

  3248.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3249. 

  3249. 

  3250.         GF_FREE (req.dict.dict_val);
    3251. 

  3251.         return ret;
    3252. 

  3252. }
    3253. 

  3253. 

  3254. int32_t
    3255. 

  3255. gf_cli_sync_volume (call_frame_t *frame, xlator_t *this,
    3256. 

  3256.                        void *data)
    3257. 

  3257. {
    3258. 

  3258.         int               ret = 0;
    3259. 

  3259.         gf_cli_req        req = {{0,}};
    3260. 

  3260.         dict_t            *dict = NULL;
    3261. 

  3261. 

  3262.         if (!frame || !this || !data) {
    3263. 

  3263.                 ret = -1;
    3264. 

  3264.                 goto out;
    3265. 

  3265.         }
    3266. 

  3266. 

  3267.         dict = data;
    3268. 

  3268. 

  3269.         ret = cli_to_glusterd (&req, frame, gf_cli_sync_volume_cbk,
    3270. 

  3270.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3271. 

  3271.                                GLUSTER_CLI_SYNC_VOLUME, this, cli_rpc_prog,
    3272. 

  3272.                                NULL);
    3273. 

  3273. 

  3274. out:
    3275. 

  3275.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3276. 

  3276.         GF_FREE (req.dict.dict_val);
    3277. 

  3277. 

  3278.         return ret;
    3279. 

  3279. }
    3280. 

  3280. 

  3281. int32_t
    3282. 

  3282. gf_cli_getspec (call_frame_t *frame, xlator_t *this,
    3283. 

  3283.                          void *data)
    3284. 

  3284. {
    3285. 

  3285.         gf_getspec_req          req = {0,};
    3286. 

  3286.         int                     ret = 0;
    3287. 

  3287.         dict_t                  *dict = NULL;
    3288. 

  3288. 

  3289.         if (!frame || !this ||  !data) {
    3290. 

  3290.                 ret = -1;
    3291. 

  3291.                 goto out;
    3292. 

  3292.         }
    3293. 

  3293. 

  3294.         dict = data;
    3295. 

  3295. 

  3296.         ret = dict_get_str (dict, "volid", &req.key);
    3297. 

  3297.         if (ret)
    3298. 

  3298.                 goto out;
    3299. 

  3299. 

  3300.         ret = cli_cmd_submit (&req, frame, &cli_handshake_prog,
    3301. 

  3301.                               GF_HNDSK_GETSPEC, NULL,
    3302. 

  3302.                               this, gf_cli_getspec_cbk,
    3303. 

  3303.                               (xdrproc_t) xdr_gf_getspec_req);
    3304. 

  3304. 

  3305. out:
    3306. 

  3306.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3307. 

  3307. 

  3308.         return ret;
    3309. 

  3309. }
    3310. 

  3310. 

  3311. int32_t
    3312. 

  3312. gf_cli_quota (call_frame_t *frame, xlator_t *this,
    3313. 

  3313.                  void *data)
    3314. 

  3314. {
    3315. 

  3315.         gf_cli_req          req = {{0,}};
    3316. 

  3316.         int                 ret = 0;
    3317. 

  3317.         dict_t             *dict = NULL;
    3318. 

  3318. 

  3319.         if (!frame || !this ||  !data) {
    3320. 

  3320.                 ret = -1;
    3321. 

  3321.                 goto out;
    3322. 

  3322.         }
    3323. 

  3323. 

  3324.         dict = data;
    3325. 

  3325. 

  3326.         ret = cli_to_glusterd (&req, frame, gf_cli_quota_cbk,
    3327. 

  3327.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3328. 

  3328.                                GLUSTER_CLI_QUOTA, this, cli_rpc_prog, NULL);
    3329. 

  3329. 

  3330. out:
    3331. 

  3331.         GF_FREE (req.dict.dict_val);
    3332. 

  3332. 

  3333.         return ret;
    3334. 

  3334. }
    3335. 

  3335. 

  3336. int32_t
    3337. 

  3337. gf_cli_pmap_b2p (call_frame_t *frame, xlator_t *this, void *data)
    3338. 

  3338. {
    3339. 

  3339.         pmap_port_by_brick_req  req = {0,};
    3340. 

  3340.         int                     ret = 0;
    3341. 

  3341.         dict_t                  *dict = NULL;
    3342. 

  3342. 

  3343.         if (!frame || !this ||  !data) {
    3344. 

  3344.                 ret = -1;
    3345. 

  3345.                 goto out;
    3346. 

  3346.         }
    3347. 

  3347. 

  3348.         dict = data;
    3349. 

  3349. 

  3350.         ret = dict_get_str (dict, "brick", &req.brick);
    3351. 

  3351.         if (ret)
    3352. 

  3352.                 goto out;
    3353. 

  3353. 

  3354.         ret = cli_cmd_submit (&req, frame, &cli_pmap_prog,
    3355. 

  3355.                               GF_PMAP_PORTBYBRICK, NULL,
    3356. 

  3356.                               this, gf_cli_pmap_b2p_cbk,
    3357. 

  3357.                               (xdrproc_t) xdr_pmap_port_by_brick_req);
    3358. 

  3358. 

  3359. out:
    3360. 

  3360.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3361. 

  3361. 

  3362.         return ret;
    3363. 

  3363. }
    3364. 

  3364. 

  3365. static int
    3366. 

  3366. gf_cli_fsm_log_cbk (struct rpc_req *req, struct iovec *iov,
    3367. 

  3367.                        int count, void *myframe)
    3368. 

  3368. {
    3369. 

  3369.         gf1_cli_fsm_log_rsp        rsp   = {0,};
    3370. 

  3370.         int                        ret   = -1;
    3371. 

  3371.         dict_t                     *dict = NULL;
    3372. 

  3372.         int                        tr_count = 0;
    3373. 

  3373.         char                       key[256] = {0};
    3374. 

  3374.         int                        i = 0;
    3375. 

  3375.         char                       *old_state = NULL;
    3376. 

  3376.         char                       *new_state = NULL;
    3377. 

  3377.         char                       *event = NULL;
    3378. 

  3378.         char                       *time = NULL;
    3379. 

  3379. 

  3380.         if (-1 == req->rpc_status) {
    3381. 

  3381.                 goto out;
    3382. 

  3382.         }
    3383. 

  3383. 

  3384.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_fsm_log_rsp);
    3385. 

  3385.         if (ret < 0) {
    3386. 

  3386.                 gf_log ("", GF_LOG_ERROR, "error");
    3387. 

  3387.                 goto out;
    3388. 

  3388.         }
    3389. 

  3389. 

  3390.         if (rsp.op_ret) {
    3391. 

  3391.                 if (strcmp (rsp.op_errstr, ""))
    3392. 

  3392.                         cli_err ("%s", rsp.op_errstr);
    3393. 

  3393.                 cli_err ("fsm log unsuccessful");
    3394. 

  3394.                 ret = rsp.op_ret;
    3395. 

  3395.                 goto out;
    3396. 

  3396.         }
    3397. 

  3397. 

  3398.         dict = dict_new ();
    3399. 

  3399.         if (!dict) {
    3400. 

  3400.                 ret = -1;
    3401. 

  3401.                 goto out;
    3402. 

  3402.         }
    3403. 

  3403. 

  3404.         ret = dict_unserialize (rsp.fsm_log.fsm_log_val,
    3405. 

  3405.                                 rsp.fsm_log.fsm_log_len,
    3406. 

  3406.                                 &dict);
    3407. 

  3407. 

  3408.         if (ret) {
    3409. 

  3409.                 cli_err ("bad response");
    3410. 

  3410.                 goto out;
    3411. 

  3411.         }
    3412. 

  3412. 

  3413.         ret = dict_get_int32 (dict, "count", &tr_count);
    3414. 

  3414.         if (tr_count)
    3415. 

  3415.                 cli_out("number of transitions: %d", tr_count);
    3416. 

  3416.         else
    3417. 

  3417.                 cli_err("No transitions");
    3418. 

  3418.         for (i = 0; i < tr_count; i++) {
    3419. 

  3419.                 memset (key, 0, sizeof (key));
    3420. 

  3420.                 snprintf (key, sizeof (key), "log%d-old-state", i);
    3421. 

  3421.                 ret = dict_get_str (dict, key, &old_state);
    3422. 

  3422.                 if (ret)
    3423. 

  3423.                         goto out;
    3424. 

  3424. 

  3425.                 memset (key, 0, sizeof (key));
    3426. 

  3426.                 snprintf (key, sizeof (key), "log%d-event", i);
    3427. 

  3427.                 ret = dict_get_str (dict, key, &event);
    3428. 

  3428.                 if (ret)
    3429. 

  3429.                         goto out;
    3430. 

  3430. 

  3431.                 memset (key, 0, sizeof (key));
    3432. 

  3432.                 snprintf (key, sizeof (key), "log%d-new-state", i);
    3433. 

  3433.                 ret = dict_get_str (dict, key, &new_state);
    3434. 

  3434.                 if (ret)
    3435. 

  3435.                         goto out;
    3436. 

  3436. 

  3437.                 memset (key, 0, sizeof (key));
    3438. 

  3438.                 snprintf (key, sizeof (key), "log%d-time", i);
    3439. 

  3439.                 ret = dict_get_str (dict, key, &time);
    3440. 

  3440.                 if (ret)
    3441. 

  3441.                         goto out;
    3442. 

  3442.                 cli_out ("Old State: [%s]\n"
    3443. 

  3443.                          "New State: [%s]\n"
    3444. 

  3444.                          "Event    : [%s]\n"
    3445. 

  3445.                          "timestamp: [%s]\n", old_state, new_state, event, time);
    3446. 

  3446.         }
    3447. 

  3447. 

  3448.         ret = rsp.op_ret;
    3449. 

  3449. 

  3450. out:
    3451. 

  3451.         cli_cmd_broadcast_response (ret);
    3452. 

  3452.         return ret;
    3453. 

  3453. }
    3454. 

  3454. 

  3455. int32_t
    3456. 

  3456. gf_cli_fsm_log (call_frame_t *frame, xlator_t *this, void *data)
    3457. 

  3457. {
    3458. 

  3458.         int                        ret = -1;
    3459. 

  3459.         gf1_cli_fsm_log_req        req = {0,};
    3460. 

  3460. 

  3461.         GF_ASSERT (frame);
    3462. 

  3462.         GF_ASSERT (this);
    3463. 

  3463.         GF_ASSERT (data);
    3464. 

  3464. 

  3465.         if (!frame || !this || !data)
    3466. 

  3466.                 goto out;
    3467. 

  3467.         req.name = data;
    3468. 

  3468.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    3469. 

  3469.                               GLUSTER_CLI_FSM_LOG, NULL,
    3470. 

  3470.                               this, gf_cli_fsm_log_cbk,
    3471. 

  3471.                               (xdrproc_t) xdr_gf1_cli_fsm_log_req);
    3472. 

  3472. 

  3473. out:
    3474. 

  3474.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    3475. 

  3475. 

  3476.         return ret;
    3477. 

  3477. }
    3478. 

  3478. 

  3479. int
    3480. 

  3480. gf_cli_gsync_config_command (dict_t *dict)
    3481. 

  3481. {
    3482. 

  3482.         runner_t runner     = {0,};
    3483. 

  3483.         char *subop         = NULL;
    3484. 

  3484.         char *gwd           = NULL;
    3485. 

  3485.         char *slave         = NULL;
    3486. 

  3486.         char *master        = NULL;
    3487. 

  3487.         char *op_name       = NULL;
    3488. 

  3488. 

  3489.         if (dict_get_str (dict, "subop", &subop) != 0)
    3490. 

  3490.                 return -1;
    3491. 

  3491. 

  3492.         if (strcmp (subop, "get") != 0 && strcmp (subop, "get-all") != 0) {
    3493. 

  3493.                 cli_out (GEOREP" config updated successfully");
    3494. 

  3494.                 return 0;
    3495. 

  3495.         }
    3496. 

  3496. 

  3497.         if (dict_get_str (dict, "glusterd_workdir", &gwd) != 0 ||
    3498. 

  3498.             dict_get_str (dict, "slave", &slave) != 0)
    3499. 

  3499.                 return -1;
    3500. 

  3500. 

  3501.         if (dict_get_str (dict, "master", &master) != 0)
    3502. 

  3502.                 master = NULL;
    3503. 

  3503.         if (dict_get_str (dict, "op_name", &op_name) != 0)
    3504. 

  3504.                 op_name = NULL;
    3505. 

  3505. 

  3506.         runinit (&runner);
    3507. 

  3507.         runner_add_args (&runner, GSYNCD_PREFIX"/gsyncd", "-c", NULL);
    3508. 

  3508.         runner_argprintf (&runner, "%s/"GSYNC_CONF, gwd);
    3509. 

  3509.         if (master)
    3510. 

  3510.                 runner_argprintf (&runner, ":%s", master);
    3511. 

  3511.         runner_add_arg (&runner, slave);
    3512. 

  3512.         runner_argprintf (&runner, "--config-%s", subop);
    3513. 

  3513.         if (op_name)
    3514. 

  3514.                 runner_add_arg (&runner, op_name);
    3515. 

  3515. 

  3516.         return runner_run (&runner);
    3517. 

  3517. }
    3518. 

  3518. 

  3519. int
    3520. 

  3520. gf_cli_gsync_out_status (dict_t *dict)
    3521. 

  3521. {
    3522. 

  3522.         int   gsync_count              = 0;
    3523. 

  3523.         int   i                        = 0;
    3524. 

  3524.         int   ret                      = 0;
    3525. 

  3525.         char             mst[PATH_MAX] = {0, };
    3526. 

  3526.         char             slv[PATH_MAX] = {0, };
    3527. 

  3527.         char             sts[PATH_MAX] = {0, };
    3528. 

  3528.         char             nds[PATH_MAX] = {0, };
    3529. 

  3529.         char             hyphens[100]  = {0, };
    3530. 

  3530.         char *mst_val                  = NULL;
    3531. 

  3531.         char *slv_val                  = NULL;
    3532. 

  3532.         char *sts_val                  = NULL;
    3533. 

  3533.         char *nds_val                  = NULL;
    3534. 

  3534. 

  3535.         cli_out ("%-20s %-20s %-50s %-10s", "NODE", "MASTER", "SLAVE", "STATUS");
    3536. 

  3536. 

  3537.         for (i=0; i<sizeof(hyphens)-1; i++)
    3538. 

  3538.                 hyphens[i] = '-';
    3539. 

  3539. 

  3540.         cli_out ("%s", hyphens);
    3541. 

  3541. 

  3542. 

  3543.         ret = dict_get_int32 (dict, "gsync-count", &gsync_count);
    3544. 

  3544.         if (ret) {
    3545. 

  3545.                 gf_log ("cli", GF_LOG_INFO, "No active geo-replication sessions"
    3546. 

  3546.                         "present for the selected");
    3547. 

  3547.                 ret = 0;
    3548. 

  3548.                 goto out;
    3549. 

  3549.         }
    3550. 

  3550. 

  3551.         for (i = 1; i <= gsync_count; i++) {
    3552. 

  3552.                 snprintf (nds, sizeof(nds), "node%d", i);
    3553. 

  3553.                 snprintf (mst, sizeof(mst), "master%d", i);
    3554. 

  3554.                 snprintf (slv, sizeof(slv), "slave%d", i);
    3555. 

  3555.                 snprintf (sts, sizeof(sts), "status%d", i);
    3556. 

  3556. 

  3557.                 ret = dict_get_str (dict, nds, &nds_val);
    3558. 

  3558.                 if (ret)
    3559. 

  3559.                         goto out;
    3560. 

  3560. 

  3561.                 ret = dict_get_str (dict, mst, &mst_val);
    3562. 

  3562.                 if (ret)
    3563. 

  3563.                         goto out;
    3564. 

  3564. 

  3565.                 ret = dict_get_str (dict, slv, &slv_val);
    3566. 

  3566.                 if (ret)
    3567. 

  3567.                         goto out;
    3568. 

  3568. 

  3569.                 ret = dict_get_str (dict, sts, &sts_val);
    3570. 

  3570.                 if (ret)
    3571. 

  3571.                         goto out;
    3572. 

  3572. 

  3573.                 cli_out ("%-20s %-20s %-50s %-10s", nds_val, mst_val,
    3574. 

  3574.                          slv_val, sts_val);
    3575. 

  3575. 

  3576.         }
    3577. 

  3577. 

  3578.  out:
    3579. 

  3579.         return ret;
    3580. 

  3580. 

  3581. }
    3582. 

  3582. 

  3583. int
    3584. 

  3584. gf_cli_gsync_set_cbk (struct rpc_req *req, struct iovec *iov,
    3585. 

  3585.                          int count, void *myframe)
    3586. 

  3586. {
    3587. 

  3587.         int                     ret     = -1;
    3588. 

  3588.         gf_cli_rsp              rsp     = {0, };
    3589. 

  3589.         dict_t                  *dict   = NULL;
    3590. 

  3590.         char                    *gsync_status = NULL;
    3591. 

  3591.         char                    *master = NULL;
    3592. 

  3592.         char                    *slave  = NULL;
    3593. 

  3593.         int32_t                  type    = 0;
    3594. 

  3594. 

  3595.         if (req->rpc_status == -1) {
    3596. 

  3596.                 ret = -1;
    3597. 

  3597.                 goto out;
    3598. 

  3598.         }
    3599. 

  3599. 

  3600.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    3601. 

  3601.         if (ret < 0) {
    3602. 

  3602.                 gf_log ("", GF_LOG_ERROR,
    3603. 

  3603.                         "Unable to get response structure");
    3604. 

  3604.                 goto out;
    3605. 

  3605.         }
    3606. 

  3606. 

  3607.         dict = dict_new ();
    3608. 

  3608. 

  3609.         if (!dict) {
    3610. 

  3610.                 ret = -1;
    3611. 

  3611.                 goto out;
    3612. 

  3612.         }
    3613. 

  3613. 

  3614.         ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
    3615. 

  3615. 

  3616.         if (ret)
    3617. 

  3617.                 goto out;
    3618. 

  3618. 

  3619.         if (global_state->mode & GLUSTER_MODE_XML) {
    3620. 

  3620.                 ret = cli_xml_output_vol_gsync (dict, rsp.op_ret, rsp.op_errno,
    3621. 

  3621.                                                 rsp.op_errstr);
    3622. 

  3622.                 if (ret)
    3623. 

  3623.                         gf_log ("cli", GF_LOG_ERROR,
    3624. 

  3624.                                 "Error outputting to xml");
    3625. 

  3625.                 goto out;
    3626. 

  3626.         }
    3627. 

  3627. 

  3628.         if (rsp.op_ret) {
    3629. 

  3629.                 cli_err ("%s", rsp.op_errstr ? rsp.op_errstr :
    3630. 

  3630.                          GEOREP" command unsuccessful");
    3631. 

  3631.                 ret = rsp.op_ret;
    3632. 

  3632.                 goto out;
    3633. 

  3633.         }
    3634. 

  3634. 

  3635.         ret = dict_get_str (dict, "gsync-status", &gsync_status);
    3636. 

  3636.         if (!ret)
    3637. 

  3637.                 cli_out ("%s", gsync_status);
    3638. 

  3638.         else
    3639. 

  3639.                 ret = 0;
    3640. 

  3640. 

  3641.         ret = dict_get_int32 (dict, "type", &type);
    3642. 

  3642.         if (ret) {
    3643. 

  3643.                 gf_log (THIS->name, GF_LOG_ERROR, "failed to get type");
    3644. 

  3644.                 goto out;
    3645. 

  3645.         }
    3646. 

  3646. 

  3647.         switch (type) {
    3648. 

  3648.                 case GF_GSYNC_OPTION_TYPE_START:
    3649. 

  3649.                 case GF_GSYNC_OPTION_TYPE_STOP:
    3650. 

  3650.                         if (dict_get_str (dict, "master", &master) != 0)
    3651. 

  3651.                                 master = "???";
    3652. 

  3652.                         if (dict_get_str (dict, "slave", &slave) != 0)
    3653. 

  3653.                                 slave = "???";
    3654. 

  3654. 

  3655.                         cli_out ("%s " GEOREP " session between %s & %s"
    3656. 

  3656.                                  " has been successful",
    3657. 

  3657.                                  type == GF_GSYNC_OPTION_TYPE_START ?
    3658. 

  3658.                                   "Starting" : "Stopping",
    3659. 

  3659.                                  master, slave);
    3660. 

  3660.                 break;
    3661. 

  3661. 

  3662.                 case GF_GSYNC_OPTION_TYPE_CONFIG:
    3663. 

  3663.                         ret = gf_cli_gsync_config_command (dict);
    3664. 

  3664.                 break;
    3665. 

  3665. 

  3666.                 case GF_GSYNC_OPTION_TYPE_STATUS:
    3667. 

  3667.                         ret = gf_cli_gsync_out_status (dict);
    3668. 

  3668.                         goto out;
    3669. 

  3669.                 default:
    3670. 

  3670.                         cli_out (GEOREP" command executed successfully");
    3671. 

  3671.         }
    3672. 

  3672. 

  3673. out:
    3674. 

  3674.         if (dict)
    3675. 

  3675.                 dict_unref (dict);
    3676. 

  3676.         cli_cmd_broadcast_response (ret);
    3677. 

  3677. 

  3678.         free (rsp.dict.dict_val);
    3679. 

  3679. 

  3680.         return ret;
    3681. 

  3681. }
    3682. 

  3682. 

  3683. int32_t
    3684. 

  3684. gf_cli_gsync_set (call_frame_t *frame, xlator_t *this,
    3685. 

  3685.                      void *data)
    3686. 

  3686. {
    3687. 

  3687.         int                      ret    = 0;
    3688. 

  3688.         dict_t                  *dict   = NULL;
    3689. 

  3689.         gf_cli_req               req = {{0,}};
    3690. 

  3690. 

  3691.         if (!frame || !this || !data) {
    3692. 

  3692.                 ret = -1;
    3693. 

  3693.                 goto out;
    3694. 

  3694.         }
    3695. 

  3695. 

  3696.         dict = data;
    3697. 

  3697. 

  3698.         ret = cli_to_glusterd (&req, frame, gf_cli_gsync_set_cbk,
    3699. 

  3699.                                (xdrproc_t) xdr_gf_cli_req, dict,
    3700. 

  3700.                                GLUSTER_CLI_GSYNC_SET, this, cli_rpc_prog,
    3701. 

  3701.                                NULL);
    3702. 

  3702. 

  3703. out:
    3704. 

  3704.         GF_FREE (req.dict.dict_val);
    3705. 

  3705. 

  3706.         return ret;
    3707. 

  3707. }
    3708. 

  3708. 

  3709. 

  3710. int
    3711. 

  3711. cli_profile_info_percentage_cmp (void *a, void *b)
    3712. 

  3712. {
    3713. 

  3713.         cli_profile_info_t *ia = NULL;
    3714. 

  3714.         cli_profile_info_t *ib = NULL;
    3715. 

  3715.         int                ret = 0;
    3716. 

  3716. 

  3717.         ia = a;
    3718. 

  3718.         ib = b;
    3719. 

  3719.         if (ia->percentage_avg_latency < ib->percentage_avg_latency)
    3720. 

  3720.                 ret = -1;
    3721. 

  3721.         else if (ia->percentage_avg_latency > ib->percentage_avg_latency)
    3722. 

  3722.                 ret = 1;
    3723. 

  3723.         else
    3724. 

  3724.                 ret = 0;
    3725. 

  3725.         return ret;
    3726. 

  3726. }
    3727. 

  3727. 

  3728. 

  3729. void
    3730. 

  3730. cmd_profile_volume_brick_out (dict_t *dict, int count, int interval)
    3731. 

  3731. {
    3732. 

  3732.         char                    key[256] = {0};
    3733. 

  3733.         int                     i = 0;
    3734. 

  3734.         uint64_t                sec = 0;
    3735. 

  3735.         uint64_t                r_count = 0;
    3736. 

  3736.         uint64_t                w_count = 0;
    3737. 

  3737.         uint64_t                rb_counts[32] = {0};
    3738. 

  3738.         uint64_t                wb_counts[32] = {0};
    3739. 

  3739.         cli_profile_info_t      profile_info[GF_FOP_MAXVALUE] = {{0}};
    3740. 

  3740.         char                    output[128] = {0};
    3741. 

  3741.         int                     per_line = 0;
    3742. 

  3742.         char                    read_blocks[128] = {0};
    3743. 

  3743.         char                    write_blocks[128] = {0};
    3744. 

  3744.         int                     index = 0;
    3745. 

  3745.         int                     is_header_printed = 0;
    3746. 

  3746.         int                     ret = 0;
    3747. 

  3747.         double                  total_percentage_latency = 0;
    3748. 

  3748. 

  3749.         for (i = 0; i < 32; i++) {
    3750. 

  3750.                 memset (key, 0, sizeof (key));
    3751. 

  3751.                 snprintf (key, sizeof (key), "%d-%d-read-%d", count,
    3752. 

  3752.                           interval, (1 << i));
    3753. 

  3753.                 ret = dict_get_uint64 (dict, key, &rb_counts[i]);
    3754. 

  3754.         }
    3755. 

  3755. 

  3756.         for (i = 0; i < 32; i++) {
    3757. 

  3757.                 memset (key, 0, sizeof (key));
    3758. 

  3758.                 snprintf (key, sizeof (key), "%d-%d-write-%d", count, interval,
    3759. 

  3759.                           (1<<i));
    3760. 

  3760.                 ret = dict_get_uint64 (dict, key, &wb_counts[i]);
    3761. 

  3761.         }
    3762. 

  3762. 

  3763.         for (i = 0; i < GF_FOP_MAXVALUE; i++) {
    3764. 

  3764.                 memset (key, 0, sizeof (key));
    3765. 

  3765.                 snprintf (key, sizeof (key), "%d-%d-%d-hits", count,
    3766. 

  3766.                           interval, i);
    3767. 

  3767.                 ret = dict_get_uint64 (dict, key, &profile_info[i].fop_hits);
    3768. 

  3768. 

  3769.                 memset (key, 0, sizeof (key));
    3770. 

  3770.                 snprintf (key, sizeof (key), "%d-%d-%d-avglatency", count,
    3771. 

  3771.                           interval, i);
    3772. 

  3772.                 ret = dict_get_double (dict, key, &profile_info[i].avg_latency);
    3773. 

  3773. 

  3774.                 memset (key, 0, sizeof (key));
    3775. 

  3775.                 snprintf (key, sizeof (key), "%d-%d-%d-minlatency", count,
    3776. 

  3776.                           interval, i);
    3777. 

  3777.                 ret = dict_get_double (dict, key, &profile_info[i].min_latency);
    3778. 

  3778. 

  3779.                 memset (key, 0, sizeof (key));
    3780. 

  3780.                 snprintf (key, sizeof (key), "%d-%d-%d-maxlatency", count,
    3781. 

  3781.                           interval, i);
    3782. 

  3782.                 ret = dict_get_double (dict, key, &profile_info[i].max_latency);
    3783. 

  3783.                 profile_info[i].fop_name = (char *)gf_fop_list[i];
    3784. 

  3784. 

  3785.                 total_percentage_latency +=
    3786. 

  3786.                        (profile_info[i].fop_hits * profile_info[i].avg_latency);
    3787. 

  3787.         }
    3788. 

  3788.         if (total_percentage_latency) {
    3789. 

  3789.                 for (i = 0; i < GF_FOP_MAXVALUE; i++) {
    3790. 

  3790.                         profile_info[i].percentage_avg_latency = 100 * (
    3791. 

  3791.                      (profile_info[i].avg_latency* profile_info[i].fop_hits) /
    3792. 

  3792.                                 total_percentage_latency);
    3793. 

  3793.                 }
    3794. 

  3794.                 gf_array_insertionsort (profile_info, 1, GF_FOP_MAXVALUE - 1,
    3795. 

  3795.                                     sizeof (cli_profile_info_t),
    3796. 

  3796.                                     cli_profile_info_percentage_cmp);
    3797. 

  3797.         }
    3798. 

  3798.         memset (key, 0, sizeof (key));
    3799. 

  3799.         snprintf (key, sizeof (key), "%d-%d-duration", count, interval);
    3800. 

  3800.         ret = dict_get_uint64 (dict, key, &sec);
    3801. 

  3801. 

  3802.         memset (key, 0, sizeof (key));
    3803. 

  3803.         snprintf (key, sizeof (key), "%d-%d-total-read", count, interval);
    3804. 

  3804.         ret = dict_get_uint64 (dict, key, &r_count);
    3805. 

  3805. 

  3806.         memset (key, 0, sizeof (key));
    3807. 

  3807.         snprintf (key, sizeof (key), "%d-%d-total-write", count, interval);
    3808. 

  3808.         ret = dict_get_uint64 (dict, key, &w_count);
    3809. 

  3809. 

  3810.         if (ret == 0) {
    3811. 

  3811.         }
    3812. 

  3812. 

  3813.         if (interval == -1)
    3814. 

  3814.                 cli_out ("Cumulative Stats:");
    3815. 

  3815.         else
    3816. 

  3816.                 cli_out ("Interval %d Stats:", interval);
    3817. 

  3817.         snprintf (output, sizeof (output), "%14s", "Block Size:");
    3818. 

  3818.         snprintf (read_blocks, sizeof (read_blocks), "%14s", "No. of Reads:");
    3819. 

  3819.         snprintf (write_blocks, sizeof (write_blocks), "%14s", "No. of Writes:");
    3820. 

  3820.         index = 14;
    3821. 

  3821.         for (i = 0; i < 32; i++) {
    3822. 

  3822.                 if ((rb_counts[i] == 0) && (wb_counts[i] == 0))
    3823. 

  3823.                         continue;
    3824. 

  3824.                 per_line++;
    3825. 

  3825.                 snprintf (output+index, sizeof (output)-index, "%19db+ ", (1<<i));
    3826. 

  3826.                 if (rb_counts[i]) {
    3827. 

  3827.                         snprintf (read_blocks+index, sizeof (read_blocks)-index,
    3828. 

  3828.                                   "%21"PRId64" ", rb_counts[i]);
    3829. 

  3829.                 } else {
    3830. 

  3830.                         snprintf (read_blocks+index, sizeof (read_blocks)-index,
    3831. 

  3831.                                   "%21s ", "0");
    3832. 

  3832.                 }
    3833. 

  3833.                 if (wb_counts[i]) {
    3834. 

  3834.                         snprintf (write_blocks+index, sizeof (write_blocks)-index,
    3835. 

  3835.                                   "%21"PRId64" ", wb_counts[i]);
    3836. 

  3836.                 } else {
    3837. 

  3837.                         snprintf (write_blocks+index, sizeof (write_blocks)-index,
    3838. 

  3838.                                   "%21s ", "0");
    3839. 

  3839.                 }
    3840. 

  3840.                 index += 22;
    3841. 

  3841.                 if (per_line == 3) {
    3842. 

  3842.                         cli_out ("%s", output);
    3843. 

  3843.                         cli_out ("%s", read_blocks);
    3844. 

  3844.                         cli_out ("%s", write_blocks);
    3845. 

  3845.                         cli_out (" ");
    3846. 

  3846.                         per_line = 0;
    3847. 

  3847.                         memset (output, 0, sizeof (output));
    3848. 

  3848.                         memset (read_blocks, 0, sizeof (read_blocks));
    3849. 

  3849.                         memset (write_blocks, 0, sizeof (write_blocks));
    3850. 

  3850.                         snprintf (output, sizeof (output), "%14s", "Block Size:");
    3851. 

  3851.                         snprintf (read_blocks, sizeof (read_blocks), "%14s",
    3852. 

  3852.                                   "No. of Reads:");
    3853. 

  3853.                         snprintf (write_blocks, sizeof (write_blocks), "%14s",
    3854. 

  3854.                                   "No. of Writes:");
    3855. 

  3855.                         index = 14;
    3856. 

  3856.                 }
    3857. 

  3857.         }
    3858. 

  3858. 

  3859.         if (per_line != 0) {
    3860. 

  3860.                 cli_out ("%s", output);
    3861. 

  3861.                 cli_out ("%s", read_blocks);
    3862. 

  3862.                 cli_out ("%s", write_blocks);
    3863. 

  3863.         }
    3864. 

  3864.         for (i = 0; i < GF_FOP_MAXVALUE; i++) {
    3865. 

  3865.                 if (profile_info[i].fop_hits == 0)
    3866. 

  3866.                         continue;
    3867. 

  3867.                 if (is_header_printed == 0) {
    3868. 

  3868.                         cli_out ("%10s %13s %13s %13s %14s %11s", "%-latency",
    3869. 

  3869.                                  "Avg-latency", "Min-Latency", "Max-Latency",
    3870. 

  3870.                                  "No. of calls", "Fop");
    3871. 

  3871.                         cli_out ("%10s %13s %13s %13s %14s %11s", "---------",
    3872. 

  3872.                                  "-----------", "-----------", "-----------",
    3873. 

  3873.                                  "------------", "----");
    3874. 

  3874.                         is_header_printed = 1;
    3875. 

  3875.                 }
    3876. 

  3876.                 if (profile_info[i].fop_hits) {
    3877. 

  3877.                         cli_out ("%10.2lf %10.2lf us %10.2lf us %10.2lf us"
    3878. 

  3878.                                  " %14"PRId64" %11s",
    3879. 

  3879.                                  profile_info[i].percentage_avg_latency,
    3880. 

  3880.                                  profile_info[i].avg_latency,
    3881. 

  3881.                                  profile_info[i].min_latency,
    3882. 

  3882.                                  profile_info[i].max_latency,
    3883. 

  3883.                                  profile_info[i].fop_hits,
    3884. 

  3884.                                  profile_info[i].fop_name);
    3885. 

  3885.                 }
    3886. 

  3886.         }
    3887. 

  3887.         cli_out (" ");
    3888. 

  3888.         cli_out ("%12s: %"PRId64" seconds", "Duration", sec);
    3889. 

  3889.         cli_out ("%12s: %"PRId64" bytes", "Data Read", r_count);
    3890. 

  3890.         cli_out ("%12s: %"PRId64" bytes", "Data Written", w_count);
    3891. 

  3891.         cli_out (" ");
    3892. 

  3892. }
    3893. 

  3893. 

  3894. int32_t
    3895. 

  3895. gf_cli_profile_volume_cbk (struct rpc_req *req, struct iovec *iov,
    3896. 

  3896.                               int count, void *myframe)
    3897. 

  3897. {
    3898. 

  3898.         gf_cli_rsp                        rsp   = {0,};
    3899. 

  3899.         int                               ret   = -1;
    3900. 

  3900.         dict_t                            *dict = NULL;
    3901. 

  3901.         gf1_cli_stats_op                  op = GF_CLI_STATS_NONE;
    3902. 

  3902.         char                              key[256] = {0};
    3903. 

  3903.         int                               interval = 0;
    3904. 

  3904.         int                               i = 1;
    3905. 

  3905.         int32_t                           brick_count = 0;
    3906. 

  3906.         char                              *volname = NULL;
    3907. 

  3907.         char                              *brick = NULL;
    3908. 

  3908.         char                              str[1024] = {0,};
    3909. 

  3909. 

  3910.         if (-1 == req->rpc_status) {
    3911. 

  3911.                 goto out;
    3912. 

  3912.         }
    3913. 

  3913. 

  3914.         gf_log ("cli", GF_LOG_DEBUG, "Received resp to profile");
    3915. 

  3915.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    3916. 

  3916.         if (ret < 0) {
    3917. 

  3917.                 gf_log ("", GF_LOG_ERROR, "error");
    3918. 

  3918.                 goto out;
    3919. 

  3919.         }
    3920. 

  3920. 

  3921.         dict = dict_new ();
    3922. 

  3922. 

  3923.         if (!dict) {
    3924. 

  3924.                 ret = -1;
    3925. 

  3925.                 goto out;
    3926. 

  3926.         }
    3927. 

  3927. 

  3928.         ret = dict_unserialize (rsp.dict.dict_val,
    3929. 

  3929.                                 rsp.dict.dict_len,
    3930. 

  3930.                                 &dict);
    3931. 

  3931. 

  3932.         if (ret) {
    3933. 

  3933.                 gf_log ("", GF_LOG_ERROR,
    3934. 

  3934.                                 "Unable to allocate memory");
    3935. 

  3935.                 goto out;
    3936. 

  3936.         } else {
    3937. 

  3937.                 dict->extra_stdfree = rsp.dict.dict_val;
    3938. 

  3938.         }
    3939. 

  3939. 

  3940.         if (global_state->mode & GLUSTER_MODE_XML) {
    3941. 

  3941.                 ret = cli_xml_output_vol_profile (dict, rsp.op_ret,
    3942. 

  3942.                                                   rsp.op_errno,
    3943. 

  3943.                                                   rsp.op_errstr);
    3944. 

  3944.                 if (ret)
    3945. 

  3945.                         gf_log ("cli", GF_LOG_ERROR,
    3946. 

  3946.                                 "Error outputting to xml");
    3947. 

  3947.                 goto out;
    3948. 

  3948.         }
    3949. 

  3949. 

  3950.         ret = dict_get_str (dict, "volname", &volname);
    3951. 

  3951.         if (ret)
    3952. 

  3952.                 goto out;
    3953. 

  3953. 

  3954.         ret = dict_get_int32 (dict, "op", (int32_t*)&op);
    3955. 

  3955.         if (ret)
    3956. 

  3956.                 goto out;
    3957. 

  3957. 

  3958.         if (rsp.op_ret && strcmp (rsp.op_errstr, "")) {
    3959. 

  3959.                 cli_err ("%s", rsp.op_errstr);
    3960. 

  3960.         } else {
    3961. 

  3961.                 switch (op) {
    3962. 

  3962.                 case GF_CLI_STATS_START:
    3963. 

  3963.                         cli_out ("Starting volume profile on %s has been %s ",
    3964. 

  3964.                                  volname,
    3965. 

  3965.                                  (rsp.op_ret) ? "unsuccessful": "successful");
    3966. 

  3966.                         break;
    3967. 

  3967.                 case GF_CLI_STATS_STOP:
    3968. 

  3968.                         cli_out ("Stopping volume profile on %s has been %s ",
    3969. 

  3969.                                  volname,
    3970. 

  3970.                                  (rsp.op_ret) ? "unsuccessful": "successful");
    3971. 

  3971.                         break;
    3972. 

  3972.                 case GF_CLI_STATS_INFO:
    3973. 

  3973.                         break;
    3974. 

  3974.                 default:
    3975. 

  3975.                         cli_out ("volume profile on %s has been %s ",
    3976. 

  3976.                                  volname,
    3977. 

  3977.                                  (rsp.op_ret) ? "unsuccessful": "successful");
    3978. 

  3978.                         break;
    3979. 

  3979.                 }
    3980. 

  3980.         }
    3981. 

  3981. 

  3982.         if (rsp.op_ret) {
    3983. 

  3983.                 ret = rsp.op_ret;
    3984. 

  3984.                 goto out;
    3985. 

  3985.         }
    3986. 

  3986. 

  3987.         if (op != GF_CLI_STATS_INFO) {
    3988. 

  3988.                 ret = 0;
    3989. 

  3989.                 goto out;
    3990. 

  3990.         }
    3991. 

  3991. 

  3992.         ret = dict_get_int32 (dict, "count", &brick_count);
    3993. 

  3993.         if (ret)
    3994. 

  3994.                 goto out;
    3995. 

  3995. 

  3996.         if (!brick_count) {
    3997. 

  3997.                 cli_err ("All bricks of volume %s are down.", volname);
    3998. 

  3998.                 goto out;
    3999. 

  3999.         }
    4000. 

  4000. 

  4001.         while (i <= brick_count) {
    4002. 

  4002.                 memset (key, 0, sizeof (key));
    4003. 

  4003.                 snprintf (key, sizeof (key), "%d-brick", i);
    4004. 

  4004.                 ret = dict_get_str (dict, key, &brick);
    4005. 

  4005.                 if (ret) {
    4006. 

  4006.                         gf_log ("cli", GF_LOG_ERROR, "Couldn't get brick name");
    4007. 

  4007.                         goto out;
    4008. 

  4008.                 }
    4009. 

  4009. 

  4010.                 ret = dict_get_str_boolean (dict, "nfs", _gf_false);
    4011. 

  4011.                 if (ret)
    4012. 

  4012.                         snprintf (str, sizeof (str), "NFS Server : %s", brick);
    4013. 

  4013.                 else
    4014. 

  4014.                         snprintf (str, sizeof (str), "Brick: %s", brick);
    4015. 

  4015.                 cli_out ("%s", str);
    4016. 

  4016.                 memset (str, '-', strlen (str));
    4017. 

  4017.                 cli_out ("%s", str);
    4018. 

  4018. 

  4019.                 snprintf (key, sizeof (key), "%d-cumulative", i);
    4020. 

  4020.                 ret = dict_get_int32 (dict, key, &interval);
    4021. 

  4021.                 if (ret == 0) {
    4022. 

  4022.                         cmd_profile_volume_brick_out (dict, i, interval);
    4023. 

  4023.                 }
    4024. 

  4024.                 snprintf (key, sizeof (key), "%d-interval", i);
    4025. 

  4025.                 ret = dict_get_int32 (dict, key, &interval);
    4026. 

  4026.                 if (ret == 0) {
    4027. 

  4027.                         cmd_profile_volume_brick_out (dict, i, interval);
    4028. 

  4028.                 }
    4029. 

  4029.                 i++;
    4030. 

  4030.         }
    4031. 

  4031.         ret = rsp.op_ret;
    4032. 

  4032. 

  4033. out:
    4034. 

  4034.         if (dict)
    4035. 

  4035.                 dict_unref (dict);
    4036. 

  4036.         free (rsp.op_errstr);
    4037. 

  4037.         cli_cmd_broadcast_response (ret);
    4038. 

  4038.         return ret;
    4039. 

  4039. }
    4040. 

  4040. 

  4041. int32_t
    4042. 

  4042. gf_cli_profile_volume (call_frame_t *frame, xlator_t *this, void *data)
    4043. 

  4043. {
    4044. 

  4044.         int                        ret   = -1;
    4045. 

  4045.         gf_cli_req                 req   = {{0,}};
    4046. 

  4046.         dict_t                     *dict = NULL;
    4047. 

  4047. 

  4048.         GF_ASSERT (frame);
    4049. 

  4049.         GF_ASSERT (this);
    4050. 

  4050.         GF_ASSERT (data);
    4051. 

  4051. 

  4052.         if (!frame || !this || !data)
    4053. 

  4053.                 goto out;
    4054. 

  4054.         dict = data;
    4055. 

  4055. 

  4056.         ret = cli_to_glusterd (&req, frame, gf_cli_profile_volume_cbk,
    4057. 

  4057.                                (xdrproc_t) xdr_gf_cli_req, dict,
    4058. 

  4058.                                GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog,
    4059. 

  4059.                                NULL);
    4060. 

  4060. 

  4061. out:
    4062. 

  4062.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    4063. 

  4063. 

  4064.         GF_FREE (req.dict.dict_val);
    4065. 

  4065.         return ret;
    4066. 

  4066. }
    4067. 

  4067. 

  4068. int32_t
    4069. 

  4069. gf_cli_top_volume_cbk (struct rpc_req *req, struct iovec *iov,
    4070. 

  4070.                               int count, void *myframe)
    4071. 

  4071. {
    4072. 

  4072.         gf_cli_rsp                        rsp   = {0,};
    4073. 

  4073.         int                               ret   = -1;
    4074. 

  4074.         dict_t                           *dict = NULL;
    4075. 

  4075.         gf1_cli_stats_op                  op = GF_CLI_STATS_NONE;
    4076. 

  4076.         char                              key[256] = {0};
    4077. 

  4077.         int                               i = 0;
    4078. 

  4078.         int32_t                           brick_count = 0;
    4079. 

  4079.         char                              brick[1024];
    4080. 

  4080.         int32_t                           members = 0;
    4081. 

  4081.         char                             *filename;
    4082. 

  4082.         char                             *bricks;
    4083. 

  4083.         uint64_t                          value = 0;
    4084. 

  4084.         int32_t                           j = 0;
    4085. 

  4085.         gf1_cli_top_op                    top_op = GF_CLI_TOP_NONE;
    4086. 

  4086.         uint64_t                          nr_open = 0;
    4087. 

  4087.         uint64_t                          max_nr_open = 0;
    4088. 

  4088.         double                            throughput = 0;
    4089. 

  4089.         double                            time = 0;
    4090. 

  4090.         int32_t                           time_sec = 0;
    4091. 

  4091.         long int                          time_usec = 0;
    4092. 

  4092.         char                              timestr[256] = {0, };
    4093. 

  4093.         char                             *openfd_str = NULL;
    4094. 

  4094.         gf_boolean_t                      nfs = _gf_false;
    4095. 

  4095.         gf_boolean_t                      clear_stats = _gf_false;
    4096. 

  4096.         int                               stats_cleared = 0;
    4097. 

  4097. 

  4098.         if (-1 == req->rpc_status) {
    4099. 

  4099.                 goto out;
    4100. 

  4100.         }
    4101. 

  4101. 

  4102.         gf_log ("cli", GF_LOG_DEBUG, "Received resp to top");
    4103. 

  4103.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    4104. 

  4104.         if (ret < 0) {
    4105. 

  4105.                 gf_log ("", GF_LOG_ERROR, "Unable to decode response");
    4106. 

  4106.                 goto out;
    4107. 

  4107.         }
    4108. 

  4108. 

  4109.         if (rsp.op_ret) {
    4110. 

  4110.                 if (strcmp (rsp.op_errstr, ""))
    4111. 

  4111.                         cli_err ("%s", rsp.op_errstr);
    4112. 

  4112.                 cli_err ("volume top unsuccessful");
    4113. 

  4113.                 ret = rsp.op_ret;
    4114. 

  4114.                 goto out;
    4115. 

  4115.         }
    4116. 

  4116. 

  4117.         dict = dict_new ();
    4118. 

  4118. 

  4119.         if (!dict) {
    4120. 

  4120.                 ret = -1;
    4121. 

  4121.                 goto out;
    4122. 

  4122.         }
    4123. 

  4123. 

  4124.         ret = dict_unserialize (rsp.dict.dict_val,
    4125. 

  4125.                                 rsp.dict.dict_len,
    4126. 

  4126.                                 &dict);
    4127. 

  4127. 

  4128.         if (ret) {
    4129. 

  4129.                 gf_log ("", GF_LOG_ERROR,
    4130. 

  4130.                                 "Unable to allocate memory");
    4131. 

  4131.                 goto out;
    4132. 

  4132.         }
    4133. 

  4133. 

  4134.         ret = dict_get_int32 (dict, "op", (int32_t*)&op);
    4135. 

  4135. 

  4136.         if (op != GF_CLI_STATS_TOP) {
    4137. 

  4137.                 ret = 0;
    4138. 

  4138.                 goto out;
    4139. 

  4139.         }
    4140. 

  4140. 

  4141.         if (global_state->mode & GLUSTER_MODE_XML) {
    4142. 

  4142.                 ret = cli_xml_output_vol_top (dict, rsp.op_ret,
    4143. 

  4143.                                               rsp.op_errno,
    4144. 

  4144.                                               rsp.op_errstr);
    4145. 

  4145.                 if (ret) {
    4146. 

  4146.                         gf_log ("cli", GF_LOG_ERROR,
    4147. 

  4147.                                 "Error outputting to xml");
    4148. 

  4148.                 }
    4149. 

  4149.                 goto out;
    4150. 

  4150.         }
    4151. 

  4151. 

  4152.         ret = dict_get_int32 (dict, "count", &brick_count);
    4153. 

  4153.         if (ret)
    4154. 

  4154.                 goto out;
    4155. 

  4155.         snprintf (key, sizeof (key), "%d-top-op", 1);
    4156. 

  4156.         ret = dict_get_int32 (dict, key, (int32_t*)&top_op);
    4157. 

  4157.         if (ret)
    4158. 

  4158.                 goto out;
    4159. 

  4159. 

  4160.         clear_stats = dict_get_str_boolean (dict, "clear-stats", _gf_false);
    4161. 

  4161. 

  4162.         while (i < brick_count) {
    4163. 

  4163.                 i++;
    4164. 

  4164.                 snprintf (brick, sizeof (brick), "%d-brick", i);
    4165. 

  4165.                 ret = dict_get_str (dict, brick, &bricks);
    4166. 

  4166.                 if (ret)
    4167. 

  4167.                         goto out;
    4168. 

  4168. 

  4169.                 nfs = dict_get_str_boolean (dict, "nfs", _gf_false);
    4170. 

  4170. 

  4171.                 if (clear_stats) {
    4172. 

  4172.                         memset (key, 0, sizeof (key));
    4173. 

  4173.                         snprintf (key, sizeof (key), "%d-stats-cleared", i);
    4174. 

  4174.                         ret = dict_get_int32 (dict, key, &stats_cleared);
    4175. 

  4175.                         if (ret)
    4176. 

  4176.                                 goto out;
    4177. 

  4177.                         cli_out (stats_cleared ? "Cleared stats for %s %s" :
    4178. 

  4178.                                  "Failed to clear stats for %s %s",
    4179. 

  4179.                                  nfs ? "NFS server on" : "brick", bricks);
    4180. 

  4180.                         continue;
    4181. 

  4181.                 }
    4182. 

  4182. 

  4183.                 if (nfs)
    4184. 

  4184.                         cli_out ("NFS Server : %s", bricks);
    4185. 

  4185.                 else
    4186. 

  4186.                         cli_out ("Brick: %s", bricks);
    4187. 

  4187. 

  4188.                 snprintf(key, sizeof (key), "%d-members", i);
    4189. 

  4189.                 ret = dict_get_int32 (dict, key, &members);
    4190. 

  4190. 

  4191.                 switch (top_op) {
    4192. 

  4192.                 case GF_CLI_TOP_OPEN:
    4193. 

  4193.                         snprintf (key, sizeof (key), "%d-current-open", i);
    4194. 

  4194.                         ret = dict_get_uint64 (dict, key, &nr_open);
    4195. 

  4195.                         if (ret)
    4196. 

  4196.                                 break;
    4197. 

  4197.                         snprintf (key, sizeof (key), "%d-max-open", i);
    4198. 

  4198.                         ret = dict_get_uint64 (dict, key, &max_nr_open);
    4199. 

  4199.                         if (ret)
    4200. 

  4200.                                 goto out;
    4201. 

  4201.                         snprintf (key, sizeof (key), "%d-max-openfd-time", i);
    4202. 

  4202.                         ret = dict_get_str (dict, key, &openfd_str);
    4203. 

  4203.                         if (ret)
    4204. 

  4204.                                 goto out;
    4205. 

  4205.                         cli_out ("Current open fds: %"PRIu64", Max open"
    4206. 

  4206.                                 " fds: %"PRIu64", Max openfd time: %s", nr_open,
    4207. 

  4207.                                  max_nr_open, openfd_str);
    4208. 

  4208.                 case GF_CLI_TOP_READ:
    4209. 

  4209.                 case GF_CLI_TOP_WRITE:
    4210. 

  4210.                 case GF_CLI_TOP_OPENDIR:
    4211. 

  4211.                 case GF_CLI_TOP_READDIR:
    4212. 

  4212.                         if (!members) {
    4213. 

  4213.                                 continue;
    4214. 

  4214.                         }
    4215. 

  4215.                         cli_out ("Count\t\tfilename\n=======================");
    4216. 

  4216.                         break;
    4217. 

  4217.                 case GF_CLI_TOP_READ_PERF:
    4218. 

  4218.                 case GF_CLI_TOP_WRITE_PERF:
    4219. 

  4219.                         snprintf (key, sizeof (key), "%d-throughput", i);
    4220. 

  4220.                         ret = dict_get_double (dict, key, &throughput);
    4221. 

  4221.                         if (!ret) {
    4222. 

  4222.                                 snprintf (key, sizeof (key), "%d-time", i);
    4223. 

  4223.                                 ret = dict_get_double (dict, key, &time);
    4224. 

  4224.                         }
    4225. 

  4225.                         if (!ret)
    4226. 

  4226.                                 cli_out ("Throughput %.2f MBps time %.4f secs", throughput,
    4227. 

  4227.                                           time / 1e6);
    4228. 

  4228. 

  4229.                         if (!members) {
    4230. 

  4230.                                 continue;
    4231. 

  4231.                         }
    4232. 

  4232.                         cli_out ("%*s %-*s %-*s",
    4233. 

  4233.                                  VOL_TOP_PERF_SPEED_WIDTH, "MBps",
    4234. 

  4234.                                  VOL_TOP_PERF_FILENAME_DEF_WIDTH, "Filename",
    4235. 

  4235.                                  VOL_TOP_PERF_TIME_WIDTH, "Time");
    4236. 

  4236.                         cli_out ("%*s %-*s %-*s",
    4237. 

  4237.                                  VOL_TOP_PERF_SPEED_WIDTH, "====",
    4238. 

  4238.                                  VOL_TOP_PERF_FILENAME_DEF_WIDTH, "========",
    4239. 

  4239.                                  VOL_TOP_PERF_TIME_WIDTH, "====");
    4240. 

  4240.                         break;
    4241. 

  4241.                 default:
    4242. 

  4242.                         goto out;
    4243. 

  4243.                 }
    4244. 

  4244. 

  4245.                 for (j = 1; j <= members; j++) {
    4246. 

  4246.                         snprintf (key, sizeof (key), "%d-filename-%d", i, j);
    4247. 

  4247.                         ret = dict_get_str (dict, key, &filename);
    4248. 

  4248.                         if (ret)
    4249. 

  4249.                                 break;
    4250. 

  4250.                         snprintf (key, sizeof (key), "%d-value-%d", i, j);
    4251. 

  4251.                         ret = dict_get_uint64 (dict, key, &value);
    4252. 

  4252.                         if (ret)
    4253. 

  4253.                                 goto out;
    4254. 

  4254.                         if ( top_op == GF_CLI_TOP_READ_PERF ||
    4255. 

  4255.                                 top_op == GF_CLI_TOP_WRITE_PERF) {
    4256. 

  4256.                                 snprintf (key, sizeof (key), "%d-time-sec-%d", i, j);
    4257. 

  4257.                                 ret = dict_get_int32 (dict, key, (int32_t *)&time_sec);
    4258. 

  4258.                                 if (ret)
    4259. 

  4259.                                         goto out;
    4260. 

  4260.                                 snprintf (key, sizeof (key), "%d-time-usec-%d", i, j);
    4261. 

  4261.                                 ret = dict_get_int32 (dict, key, (int32_t *)&time_usec);
    4262. 

  4262.                                 if (ret)
    4263. 

  4263.                                         goto out;
    4264. 

  4264.                                 gf_time_fmt (timestr, sizeof timestr,
    4265. 

  4265.                                              time_sec, gf_timefmt_FT);
    4266. 

  4266.                                 snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
    4267. 

  4267.                                   ".%"GF_PRI_SUSECONDS, time_usec);
    4268. 

  4268.                                 if (strlen (filename) < VOL_TOP_PERF_FILENAME_DEF_WIDTH)
    4269. 

  4269.                                         cli_out ("%*"PRIu64" %-*s %-*s",
    4270. 

  4270.                                                  VOL_TOP_PERF_SPEED_WIDTH,
    4271. 

  4271.                                                  value,
    4272. 

  4272.                                                  VOL_TOP_PERF_FILENAME_DEF_WIDTH,
    4273. 

  4273.                                                  filename,
    4274. 

  4274.                                                  VOL_TOP_PERF_TIME_WIDTH,
    4275. 

  4275.                                                  timestr);
    4276. 

  4276.                                 else
    4277. 

  4277.                                         cli_out ("%*"PRIu64" ...%-*s %-*s",
    4278. 

  4278.                                                  VOL_TOP_PERF_SPEED_WIDTH,
    4279. 

  4279.                                                  value,
    4280. 

  4280.                                                  VOL_TOP_PERF_FILENAME_ALT_WIDTH ,
    4281. 

  4281.                                                  filename + strlen (filename) -
    4282. 

  4282.                                                  VOL_TOP_PERF_FILENAME_ALT_WIDTH,
    4283. 

  4283.                                                  VOL_TOP_PERF_TIME_WIDTH,
    4284. 

  4284.                                                  timestr);
    4285. 

  4285.                         } else {
    4286. 

  4286.                                 cli_out ("%"PRIu64"\t\t%s", value, filename);
    4287. 

  4287.                         }
    4288. 

  4288.                 }
    4289. 

  4289.         }
    4290. 

  4290.         ret = rsp.op_ret;
    4291. 

  4291. 

  4292. out:
    4293. 

  4293.         cli_cmd_broadcast_response (ret);
    4294. 

  4294. 

  4295.         if (dict)
    4296. 

  4296.                 dict_unref (dict);
    4297. 

  4297. 

  4298.         free (rsp.dict.dict_val);
    4299. 

  4299.         return ret;
    4300. 

  4300. }
    4301. 

  4301. 

  4302. int32_t
    4303. 

  4303. gf_cli_top_volume (call_frame_t *frame, xlator_t *this, void *data)
    4304. 

  4304. {
    4305. 

  4305.         int                        ret   = -1;
    4306. 

  4306.         gf_cli_req                 req   = {{0,}};
    4307. 

  4307.         dict_t                     *dict = NULL;
    4308. 

  4308. 

  4309.         GF_ASSERT (frame);
    4310. 

  4310.         GF_ASSERT (this);
    4311. 

  4311.         GF_ASSERT (data);
    4312. 

  4312. 

  4313.         if (!frame || !this || !data)
    4314. 

  4314.                 goto out;
    4315. 

  4315.         dict = data;
    4316. 

  4316. 

  4317.         ret = cli_to_glusterd (&req, frame, gf_cli_top_volume_cbk,
    4318. 

  4318.                                (xdrproc_t) xdr_gf_cli_req, dict,
    4319. 

  4319.                                GLUSTER_CLI_PROFILE_VOLUME, this, cli_rpc_prog,
    4320. 

  4320.                                NULL);
    4321. 

  4321. 

  4322. out:
    4323. 

  4323.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    4324. 

  4324.         GF_FREE (req.dict.dict_val);
    4325. 

  4325.         return ret;
    4326. 

  4326. }
    4327. 

  4327. 

  4328. 

  4329. int
    4330. 

  4330. gf_cli_getwd_cbk (struct rpc_req *req, struct iovec *iov,
    4331. 

  4331.                        int count, void *myframe)
    4332. 

  4332. {
    4333. 

  4333.         gf1_cli_getwd_rsp rsp   = {0,};
    4334. 

  4334.         int               ret   = -1;
    4335. 

  4335. 

  4336.         if (-1 == req->rpc_status) {
    4337. 

  4337.                 goto out;
    4338. 

  4338.         }
    4339. 

  4339. 

  4340.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_getwd_rsp);
    4341. 

  4341.         if (ret < 0 || rsp.op_ret == -1) {
    4342. 

  4342.                 gf_log ("", GF_LOG_ERROR, "error");
    4343. 

  4343.                 goto out;
    4344. 

  4344.         }
    4345. 

  4345. 

  4346.         gf_log ("cli", GF_LOG_INFO, "Received resp to getwd");
    4347. 

  4347. 

  4348.         cli_out ("%s", rsp.wd);
    4349. 

  4349. 

  4350.         ret = 0;
    4351. 

  4351. 

  4352. out:
    4353. 

  4353.         cli_cmd_broadcast_response (ret);
    4354. 

  4354.         return ret;
    4355. 

  4355. }
    4356. 

  4356. 

  4357. int32_t
    4358. 

  4358. gf_cli_getwd (call_frame_t *frame, xlator_t *this, void *data)
    4359. 

  4359. {
    4360. 

  4360.         int                      ret = -1;
    4361. 

  4361.         gf1_cli_getwd_req        req = {0,};
    4362. 

  4362. 

  4363.         GF_ASSERT (frame);
    4364. 

  4364.         GF_ASSERT (this);
    4365. 

  4365. 

  4366.         if (!frame || !this)
    4367. 

  4367.                 goto out;
    4368. 

  4368. 

  4369.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    4370. 

  4370.                               GLUSTER_CLI_GETWD, NULL,
    4371. 

  4371.                               this, gf_cli_getwd_cbk,
    4372. 

  4372.                               (xdrproc_t) xdr_gf1_cli_getwd_req);
    4373. 

  4373. 

  4374. out:
    4375. 

  4375.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    4376. 

  4376. 

  4377.         return ret;
    4378. 

  4378. }
    4379. 

  4379. 

  4380. void
    4381. 

  4381. cli_print_volume_status_mempool (dict_t *dict, char *prefix)
    4382. 

  4382. {
    4383. 

  4383.         int             ret = -1;
    4384. 

  4384.         int32_t         mempool_count = 0;
    4385. 

  4385.         char            *name = NULL;
    4386. 

  4386.         int32_t         hotcount = 0;
    4387. 

  4387.         int32_t         coldcount = 0;
    4388. 

  4388.         uint64_t        paddedsizeof = 0;
    4389. 

  4389.         uint64_t        alloccount = 0;
    4390. 

  4390.         int32_t         maxalloc = 0;
    4391. 

  4391.         uint64_t        pool_misses = 0;
    4392. 

  4392.         int32_t         maxstdalloc = 0;
    4393. 

  4393.         char            key[1024] = {0,};
    4394. 

  4394.         int             i = 0;
    4395. 

  4395. 

  4396.         GF_ASSERT (dict);
    4397. 

  4397.         GF_ASSERT (prefix);
    4398. 

  4398. 

  4399.         memset (key, 0, sizeof (key));
    4400. 

  4400.         snprintf (key, sizeof (key), "%s.mempool-count",prefix);
    4401. 

  4401.         ret = dict_get_int32 (dict, key, &mempool_count);
    4402. 

  4402.         if (ret)
    4403. 

  4403.                 goto out;
    4404. 

  4404. 

  4405.         cli_out ("Mempool Stats\n-------------");
    4406. 

  4406.         cli_out ("%-30s %9s %9s %12s %10s %8s %8s %12s", "Name", "HotCount",
    4407. 

  4407.                  "ColdCount", "PaddedSizeof", "AllocCount", "MaxAlloc",
    4408. 

  4408.                  "Misses", "Max-StdAlloc");
    4409. 

  4409.         cli_out ("%-30s %9s %9s %12s %10s %8s %8s %12s", "----", "--------",
    4410. 

  4410.                  "---------", "------------", "----------",
    4411. 

  4411.                  "--------", "--------", "------------");
    4412. 

  4412. 

  4413.         for (i = 0; i < mempool_count; i++) {
    4414. 

  4414.                 memset (key, 0, sizeof (key));
    4415. 

  4415.                 snprintf (key, sizeof (key), "%s.pool%d.name", prefix, i);
    4416. 

  4416.                 ret = dict_get_str (dict, key, &name);
    4417. 

  4417.                 if (ret)
    4418. 

  4418.                         goto out;
    4419. 

  4419. 

  4420.                 memset (key, 0, sizeof (key));
    4421. 

  4421.                 snprintf (key, sizeof (key), "%s.pool%d.hotcount", prefix, i);
    4422. 

  4422.                 ret = dict_get_int32 (dict, key, &hotcount);
    4423. 

  4423.                 if (ret)
    4424. 

  4424.                         goto out;
    4425. 

  4425. 

  4426.                 memset (key, 0, sizeof (key));
    4427. 

  4427.                 snprintf (key, sizeof (key), "%s.pool%d.coldcount", prefix, i);
    4428. 

  4428.                 ret = dict_get_int32 (dict, key, &coldcount);
    4429. 

  4429.                 if (ret)
    4430. 

  4430.                         goto out;
    4431. 

  4431. 

  4432.                 memset (key, 0, sizeof (key));
    4433. 

  4433.                 snprintf (key, sizeof (key), "%s.pool%d.paddedsizeof",
    4434. 

  4434.                           prefix, i);
    4435. 

  4435.                 ret = dict_get_uint64 (dict, key, &paddedsizeof);
    4436. 

  4436.                 if (ret)
    4437. 

  4437.                         goto out;
    4438. 

  4438. 

  4439.                 memset (key, 0, sizeof (key));
    4440. 

  4440.                 snprintf (key, sizeof (key), "%s.pool%d.alloccount", prefix, i);
    4441. 

  4441.                 ret = dict_get_uint64 (dict, key, &alloccount);
    4442. 

  4442.                 if (ret)
    4443. 

  4443.                         goto out;
    4444. 

  4444. 

  4445.                 memset (key, 0, sizeof (key));
    4446. 

  4446.                 snprintf (key, sizeof (key), "%s.pool%d.max_alloc", prefix, i);
    4447. 

  4447.                 ret = dict_get_int32 (dict, key, &maxalloc);
    4448. 

  4448.                 if (ret)
    4449. 

  4449.                         goto out;
    4450. 

  4450. 

  4451.                 memset (key, 0, sizeof (key));
    4452. 

  4452.                 snprintf (key, sizeof (key), "%s.pool%d.max-stdalloc", prefix, i);
    4453. 

  4453.                 ret = dict_get_int32 (dict, key, &maxstdalloc);
    4454. 

  4454.                 if (ret)
    4455. 

  4455.                         goto out;
    4456. 

  4456. 

  4457.                 memset (key, 0, sizeof (key));
    4458. 

  4458.                 snprintf (key, sizeof (key), "%s.pool%d.pool-misses", prefix, i);
    4459. 

  4459.                 ret = dict_get_uint64 (dict, key, &pool_misses);
    4460. 

  4460.                 if (ret)
    4461. 

  4461.                         goto out;
    4462. 

  4462. 

  4463.                 cli_out ("%-30s %9d %9d %12"PRIu64" %10"PRIu64" %8d %8"PRIu64
    4464. 

  4464.                          " %12d", name, hotcount, coldcount, paddedsizeof,
    4465. 

  4465.                          alloccount, maxalloc, pool_misses, maxstdalloc);
    4466. 

  4466.         }
    4467. 

  4467. 

  4468. out:
    4469. 

  4469.         return;
    4470. 

  4470. 

  4471. }
    4472. 

  4472. 

  4473. void
    4474. 

  4474. cli_print_volume_status_mem (dict_t *dict, gf_boolean_t notbrick)
    4475. 

  4475. {
    4476. 

  4476.         int             ret = -1;
    4477. 

  4477.         char            *volname = NULL;
    4478. 

  4478.         char            *hostname = NULL;
    4479. 

  4479.         char            *path = NULL;
    4480. 

  4480.         int             online = -1;
    4481. 

  4481.         char            key[1024] = {0,};
    4482. 

  4482.         int             brick_index_max = -1;
    4483. 

  4483.         int             other_count = 0;
    4484. 

  4484.         int             index_max = 0;
    4485. 

  4485.         int             val = 0;
    4486. 

  4486.         int             i = 0;
    4487. 

  4487. 

  4488.         GF_ASSERT (dict);
    4489. 

  4489. 

  4490.         ret = dict_get_str (dict, "volname", &volname);
    4491. 

  4491.         if (ret)
    4492. 

  4492.                 goto out;
    4493. 

  4493.         cli_out ("Memory status for volume : %s", volname);
    4494. 

  4494. 

  4495.         ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
    4496. 

  4496.         if (ret)
    4497. 

  4497.                 goto out;
    4498. 

  4498.         ret = dict_get_int32 (dict, "other-count", &other_count);
    4499. 

  4499.         if (ret)
    4500. 

  4500.                 goto out;
    4501. 

  4501. 

  4502.         index_max = brick_index_max + other_count;
    4503. 

  4503. 

  4504.         for (i = 0; i <= index_max; i++) {
    4505. 

  4505.                 cli_out ("----------------------------------------------");
    4506. 

  4506. 

  4507.                 memset (key, 0, sizeof (key));
    4508. 

  4508.                 snprintf (key, sizeof (key), "brick%d.hostname", i);
    4509. 

  4509.                 ret = dict_get_str (dict, key, &hostname);
    4510. 

  4510.                 if (ret)
    4511. 

  4511.                         continue;
    4512. 

  4512.                 memset (key, 0, sizeof (key));
    4513. 

  4513.                 snprintf (key, sizeof (key), "brick%d.path", i);
    4514. 

  4514.                 ret = dict_get_str (dict, key, &path);
    4515. 

  4515.                 if (ret)
    4516. 

  4516.                         continue;
    4517. 

  4517.                 if (notbrick)
    4518. 

  4518.                         cli_out ("%s : %s", hostname, path);
    4519. 

  4519.                 else
    4520. 

  4520.                         cli_out ("Brick : %s:%s", hostname, path);
    4521. 

  4521. 

  4522.                 memset (key, 0, sizeof (key));
    4523. 

  4523.                 snprintf (key, sizeof (key), "brick%d.status", i);
    4524. 

  4524.                 ret = dict_get_int32 (dict, key, &online);
    4525. 

  4525.                 if (ret)
    4526. 

  4526.                         goto out;
    4527. 

  4527.                 if (!online) {
    4528. 

  4528.                         if (notbrick)
    4529. 

  4529.                                 cli_out ("%s is offline", hostname);
    4530. 

  4530.                         else
    4531. 

  4531.                                 cli_out ("Brick is offline");
    4532. 

  4532.                         continue;
    4533. 

  4533.                 }
    4534. 

  4534. 

  4535.                 cli_out ("Mallinfo\n--------");
    4536. 

  4536. 

  4537.                 memset (key, 0, sizeof (key));
    4538. 

  4538.                 snprintf (key, sizeof (key), "brick%d.mallinfo.arena", i);
    4539. 

  4539.                 ret = dict_get_int32 (dict, key, &val);
    4540. 

  4540.                 if (ret)
    4541. 

  4541.                         goto out;
    4542. 

  4542.                 cli_out ("%-8s : %d","Arena", val);
    4543. 

  4543. 

  4544.                 memset (key, 0, sizeof (key));
    4545. 

  4545.                 snprintf (key, sizeof (key), "brick%d.mallinfo.ordblks", i);
    4546. 

  4546.                 ret = dict_get_int32 (dict, key, &val);
    4547. 

  4547.                 if(ret)
    4548. 

  4548.                         goto out;
    4549. 

  4549.                 cli_out ("%-8s : %d","Ordblks", val);
    4550. 

  4550. 

  4551.                 memset (key, 0, sizeof (key));
    4552. 

  4552.                 snprintf (key, sizeof (key), "brick%d.mallinfo.smblks", i);
    4553. 

  4553.                 ret = dict_get_int32 (dict, key, &val);
    4554. 

  4554.                 if(ret)
    4555. 

  4555.                         goto out;
    4556. 

  4556.                 cli_out ("%-8s : %d","Smblks", val);
    4557. 

  4557. 

  4558.                 memset (key, 0, sizeof (key));
    4559. 

  4559.                 snprintf (key, sizeof (key), "brick%d.mallinfo.hblks", i);
    4560. 

  4560.                 ret = dict_get_int32 (dict, key, &val);
    4561. 

  4561.                 if(ret)
    4562. 

  4562.                         goto out;
    4563. 

  4563.                 cli_out ("%-8s : %d", "Hblks", val);
    4564. 

  4564. 

  4565.                 memset (key, 0, sizeof (key));
    4566. 

  4566.                 snprintf (key, sizeof (key), "brick%d.mallinfo.hblkhd", i);
    4567. 

  4567.                 ret = dict_get_int32 (dict, key, &val);
    4568. 

  4568.                 if (ret)
    4569. 

  4569.                         goto out;
    4570. 

  4570.                 cli_out ("%-8s : %d", "Hblkhd", val);
    4571. 

  4571. 

  4572.                 memset (key, 0, sizeof (key));
    4573. 

  4573.                 snprintf (key, sizeof (key), "brick%d.mallinfo.usmblks", i);
    4574. 

  4574.                 ret = dict_get_int32 (dict, key, &val);
    4575. 

  4575.                 if (ret)
    4576. 

  4576.                         goto out;
    4577. 

  4577.                 cli_out ("%-8s : %d", "Usmblks", val);
    4578. 

  4578. 

  4579.                 memset (key, 0, sizeof (key));
    4580. 

  4580.                 snprintf (key, sizeof (key), "brick%d.mallinfo.fsmblks", i);
    4581. 

  4581.                 ret = dict_get_int32 (dict, key, &val);
    4582. 

  4582.                 if (ret)
    4583. 

  4583.                         goto out;
    4584. 

  4584.                 cli_out ("%-8s : %d", "Fsmblks", val);
    4585. 

  4585. 

  4586.                 memset (key, 0, sizeof (key));
    4587. 

  4587.                 snprintf (key, sizeof (key), "brick%d.mallinfo.uordblks", i);
    4588. 

  4588.                 ret = dict_get_int32 (dict, key, &val);
    4589. 

  4589.                 if (ret)
    4590. 

  4590.                         goto out;
    4591. 

  4591.                 cli_out ("%-8s : %d", "Uordblks", val);
    4592. 

  4592. 

  4593.                 memset (key, 0, sizeof (key));
    4594. 

  4594.                 snprintf (key, sizeof (key), "brick%d.mallinfo.fordblks", i);
    4595. 

  4595.                 ret = dict_get_int32 (dict, key, &val);
    4596. 

  4596.                 if (ret)
    4597. 

  4597.                         goto out;
    4598. 

  4598.                 cli_out ("%-8s : %d", "Fordblks", val);
    4599. 

  4599. 

  4600.                 memset (key, 0, sizeof (key));
    4601. 

  4601.                 snprintf (key, sizeof (key), "brick%d.mallinfo.keepcost", i);
    4602. 

  4602.                 ret = dict_get_int32 (dict, key, &val);
    4603. 

  4603.                 if (ret)
    4604. 

  4604.                         goto out;
    4605. 

  4605.                 cli_out ("%-8s : %d", "Keepcost", val);
    4606. 

  4606. 

  4607.                 cli_out (" ");
    4608. 

  4608.                 memset (key, 0, sizeof (key));
    4609. 

  4609.                 snprintf (key, sizeof (key), "brick%d", i);
    4610. 

  4610.                 cli_print_volume_status_mempool (dict, key);
    4611. 

  4611.         }
    4612. 

  4612. out:
    4613. 

  4613.         cli_out ("----------------------------------------------\n");
    4614. 

  4614.         return;
    4615. 

  4615. }
    4616. 

  4616. 

  4617. void
    4618. 

  4618. cli_print_volume_status_clients (dict_t *dict, gf_boolean_t notbrick)
    4619. 

  4619. {
    4620. 

  4620.         int             ret = -1;
    4621. 

  4621.         char            *volname = NULL;
    4622. 

  4622.         int             brick_index_max = -1;
    4623. 

  4623.         int             other_count = 0;
    4624. 

  4624.         int             index_max = 0;
    4625. 

  4625.         char            *hostname = NULL;
    4626. 

  4626.         char            *path = NULL;
    4627. 

  4627.         int             online = -1;
    4628. 

  4628.         int             client_count = 0;
    4629. 

  4629.         char            *clientname = NULL;
    4630. 

  4630.         uint64_t        bytesread = 0;
    4631. 

  4631.         uint64_t        byteswrite = 0;
    4632. 

  4632.         char            key[1024] = {0,};
    4633. 

  4633.         int             i = 0;
    4634. 

  4634.         int             j = 0;
    4635. 

  4635. 

  4636.         GF_ASSERT (dict);
    4637. 

  4637. 

  4638.         ret = dict_get_str (dict, "volname", &volname);
    4639. 

  4639.         if (ret)
    4640. 

  4640.                 goto out;
    4641. 

  4641.         cli_out ("Client connections for volume %s", volname);
    4642. 

  4642. 

  4643.         ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
    4644. 

  4644.         if (ret)
    4645. 

  4645.                 goto out;
    4646. 

  4646.         ret = dict_get_int32 (dict, "other-count", &other_count);
    4647. 

  4647.         if (ret)
    4648. 

  4648.                 goto out;
    4649. 

  4649. 

  4650.         index_max = brick_index_max + other_count;
    4651. 

  4651. 

  4652.         for (i = 0; i <= index_max; i++) {
    4653. 

  4653.                 cli_out ("----------------------------------------------");
    4654. 

  4654. 

  4655.                 memset (key, 0, sizeof (key));
    4656. 

  4656.                 snprintf (key, sizeof (key), "brick%d.hostname", i);
    4657. 

  4657.                 ret = dict_get_str (dict, key, &hostname);
    4658. 

  4658.                 if (ret)
    4659. 

  4659.                         goto out;
    4660. 

  4660.                 memset (key, 0, sizeof (key));
    4661. 

  4661.                 snprintf (key, sizeof (key), "brick%d.path", i);
    4662. 

  4662.                 ret = dict_get_str (dict, key, &path);
    4663. 

  4663.                 if (ret)
    4664. 

  4664.                         goto out;
    4665. 

  4665. 

  4666.                 if (notbrick)
    4667. 

  4667.                         cli_out ("%s : %s", hostname, path);
    4668. 

  4668.                 else
    4669. 

  4669.                         cli_out ("Brick : %s:%s", hostname, path);
    4670. 

  4670. 

  4671.                 memset (key, 0, sizeof (key));
    4672. 

  4672.                 snprintf (key, sizeof (key), "brick%d.status", i);
    4673. 

  4673.                 ret = dict_get_int32 (dict, key, &online);
    4674. 

  4674.                 if (ret)
    4675. 

  4675.                         goto out;
    4676. 

  4676.                 if (!online) {
    4677. 

  4677.                         if (notbrick)
    4678. 

  4678.                                 cli_out ("%s is offline", hostname);
    4679. 

  4679.                         else
    4680. 

  4680.                                 cli_out ("Brick is offline");
    4681. 

  4681.                         continue;
    4682. 

  4682.                 }
    4683. 

  4683. 

  4684.                 memset (key, 0, sizeof (key));
    4685. 

  4685.                 snprintf (key, sizeof (key), "brick%d.clientcount", i);
    4686. 

  4686.                 ret = dict_get_int32 (dict, key, &client_count);
    4687. 

  4687.                 if (ret)
    4688. 

  4688.                         goto out;
    4689. 

  4689. 

  4690.                 cli_out ("Clients connected : %d", client_count);
    4691. 

  4691.                 if (client_count == 0)
    4692. 

  4692.                         continue;
    4693. 

  4693. 

  4694.                 cli_out ("%-48s %15s %15s", "Hostname", "BytesRead",
    4695. 

  4695.                          "BytesWritten");
    4696. 

  4696.                 cli_out ("%-48s %15s %15s", "--------", "---------",
    4697. 

  4697.                          "------------");
    4698. 

  4698.                 for (j =0; j < client_count; j++) {
    4699. 

  4699.                         memset (key, 0, sizeof (key));
    4700. 

  4700.                         snprintf (key, sizeof (key),
    4701. 

  4701.                                   "brick%d.client%d.hostname", i, j);
    4702. 

  4702.                         ret = dict_get_str (dict, key, &clientname);
    4703. 

  4703.                         if (ret)
    4704. 

  4704.                                 goto out;
    4705. 

  4705. 

  4706.                         memset (key, 0, sizeof (key));
    4707. 

  4707.                         snprintf (key, sizeof (key),
    4708. 

  4708.                                   "brick%d.client%d.bytesread", i, j);
    4709. 

  4709.                         ret = dict_get_uint64 (dict, key, &bytesread);
    4710. 

  4710.                         if (ret)
    4711. 

  4711.                                 goto out;
    4712. 

  4712. 

  4713.                         memset (key, 0, sizeof (key));
    4714. 

  4714.                         snprintf (key, sizeof (key),
    4715. 

  4715.                                  "brick%d.client%d.byteswrite", i, j);
    4716. 

  4716.                         ret = dict_get_uint64 (dict, key, &byteswrite);
    4717. 

  4717.                         if (ret)
    4718. 

  4718.                                 goto out;
    4719. 

  4719. 

  4720.                         cli_out ("%-48s %15"PRIu64" %15"PRIu64,
    4721. 

  4721.                                  clientname, bytesread, byteswrite);
    4722. 

  4722.                 }
    4723. 

  4723.         }
    4724. 

  4724. out:
    4725. 

  4725.         cli_out ("----------------------------------------------\n");
    4726. 

  4726.         return;
    4727. 

  4727. }
    4728. 

  4728. 

  4729. void
    4730. 

  4730. cli_print_volume_status_inode_entry (dict_t *dict, char *prefix)
    4731. 

  4731. {
    4732. 

  4732.         int             ret = -1;
    4733. 

  4733.         char            key[1024] = {0,};
    4734. 

  4734.         char            *gfid = NULL;
    4735. 

  4735.         uint64_t        nlookup = 0;
    4736. 

  4736.         uint32_t        ref = 0;
    4737. 

  4737.         int             ia_type = 0;
    4738. 

  4738.         char            inode_type;
    4739. 

  4739. 

  4740.         GF_ASSERT (dict);
    4741. 

  4741.         GF_ASSERT (prefix);
    4742. 

  4742. 

  4743.         memset (key, 0, sizeof (key));
    4744. 

  4744.         snprintf (key, sizeof (key), "%s.gfid", prefix);
    4745. 

  4745.         ret = dict_get_str (dict, key, &gfid);
    4746. 

  4746.         if (ret)
    4747. 

  4747.                 goto out;
    4748. 

  4748. 

  4749.         memset (key, 0, sizeof (key));
    4750. 

  4750.         snprintf (key, sizeof (key), "%s.nlookup", prefix);
    4751. 

  4751.         ret = dict_get_uint64 (dict, key, &nlookup);
    4752. 

  4752.         if (ret)
    4753. 

  4753.                 goto out;
    4754. 

  4754. 

  4755.         memset (key, 0, sizeof (key));
    4756. 

  4756.         snprintf (key, sizeof (key), "%s.ref", prefix);
    4757. 

  4757.         ret = dict_get_uint32 (dict, key, &ref);
    4758. 

  4758.         if (ret)
    4759. 

  4759.                 goto out;
    4760. 

  4760. 

  4761.         memset (key, 0, sizeof (key));
    4762. 

  4762.         snprintf (key, sizeof (key), "%s.ia_type", prefix);
    4763. 

  4763.         ret = dict_get_int32 (dict, key, &ia_type);
    4764. 

  4764.         if (ret)
    4765. 

  4765.                 goto out;
    4766. 

  4766. 

  4767.         switch (ia_type) {
    4768. 

  4768.         case IA_IFREG:
    4769. 

  4769.                 inode_type = 'R';
    4770. 

  4770.                 break;
    4771. 

  4771.         case IA_IFDIR:
    4772. 

  4772.                 inode_type = 'D';
    4773. 

  4773.                 break;
    4774. 

  4774.         case IA_IFLNK:
    4775. 

  4775.                 inode_type = 'L';
    4776. 

  4776.                 break;
    4777. 

  4777.         case IA_IFBLK:
    4778. 

  4778.                 inode_type = 'B';
    4779. 

  4779.                 break;
    4780. 

  4780.         case IA_IFCHR:
    4781. 

  4781.                 inode_type = 'C';
    4782. 

  4782.                 break;
    4783. 

  4783.         case IA_IFIFO:
    4784. 

  4784.                 inode_type = 'F';
    4785. 

  4785.                 break;
    4786. 

  4786.         case IA_IFSOCK:
    4787. 

  4787.                 inode_type = 'S';
    4788. 

  4788.                 break;
    4789. 

  4789.         default:
    4790. 

  4790.                 inode_type = 'I';
    4791. 

  4791.                 break;
    4792. 

  4792.         }
    4793. 

  4793. 

  4794.         cli_out ("%-40s %14"PRIu64" %14"PRIu32" %9c",
    4795. 

  4795.                  gfid, nlookup, ref, inode_type);
    4796. 

  4796. 

  4797. out:
    4798. 

  4798.         return;
    4799. 

  4799. 

  4800. }
    4801. 

  4801. 

  4802. void
    4803. 

  4803. cli_print_volume_status_itables (dict_t *dict, char *prefix)
    4804. 

  4804. {
    4805. 

  4805.         int             ret = -1;
    4806. 

  4806.         char            key[1024] = {0,};
    4807. 

  4807.         uint32_t        active_size = 0;
    4808. 

  4808.         uint32_t        lru_size = 0;
    4809. 

  4809.         uint32_t        purge_size = 0;
    4810. 

  4810.         int             i =0;
    4811. 

  4811. 

  4812.         GF_ASSERT (dict);
    4813. 

  4813.         GF_ASSERT (prefix);
    4814. 

  4814. 

  4815.         memset (key, 0, sizeof (key));
    4816. 

  4816.         snprintf (key, sizeof (key), "%s.active_size", prefix);
    4817. 

  4817.         ret = dict_get_uint32 (dict, key, &active_size);
    4818. 

  4818.         if (ret)
    4819. 

  4819.                 goto out;
    4820. 

  4820.         if (active_size != 0) {
    4821. 

  4821.                 cli_out ("Active inodes:");
    4822. 

  4822.                 cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
    4823. 

  4823.                          "IA type");
    4824. 

  4824.                 cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
    4825. 

  4825.                          "-------");
    4826. 

  4826.         }
    4827. 

  4827.         for (i = 0; i < active_size; i++) {
    4828. 

  4828.                 memset (key, 0, sizeof (key));
    4829. 

  4829.                 snprintf (key, sizeof (key), "%s.active%d", prefix, i);
    4830. 

  4830.                 cli_print_volume_status_inode_entry (dict, key);
    4831. 

  4831.         }
    4832. 

  4832.         cli_out (" ");
    4833. 

  4833. 

  4834.         memset (key, 0, sizeof (key));
    4835. 

  4835.         snprintf (key, sizeof (key), "%s.lru_size", prefix);
    4836. 

  4836.         ret = dict_get_uint32 (dict, key, &lru_size);
    4837. 

  4837.         if (ret)
    4838. 

  4838.                 goto out;
    4839. 

  4839.         if (lru_size != 0) {
    4840. 

  4840.                 cli_out ("LRU inodes:");
    4841. 

  4841.                 cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
    4842. 

  4842.                          "IA type");
    4843. 

  4843.                 cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
    4844. 

  4844.                          "-------");
    4845. 

  4845.         }
    4846. 

  4846.         for (i = 0; i < lru_size; i++) {
    4847. 

  4847.                 memset (key, 0, sizeof (key));
    4848. 

  4848.                 snprintf (key, sizeof (key), "%s.lru%d", prefix, i);
    4849. 

  4849.                 cli_print_volume_status_inode_entry (dict, key);
    4850. 

  4850.         }
    4851. 

  4851.         cli_out (" ");
    4852. 

  4852. 

  4853.         memset (key, 0, sizeof (key));
    4854. 

  4854.         snprintf (key, sizeof (key), "%s.purge_size", prefix);
    4855. 

  4855.         ret = dict_get_uint32 (dict, key, &purge_size);
    4856. 

  4856.         if (ret)
    4857. 

  4857.                 goto out;
    4858. 

  4858.         if (purge_size != 0) {
    4859. 

  4859.                 cli_out ("Purged inodes:");
    4860. 

  4860.                 cli_out ("%-40s %14s %14s %9s", "GFID", "Lookups", "Ref",
    4861. 

  4861.                          "IA type");
    4862. 

  4862.                 cli_out ("%-40s %14s %14s %9s", "----", "-------", "---",
    4863. 

  4863.                          "-------");
    4864. 

  4864.         }
    4865. 

  4865.         for (i = 0; i < purge_size; i++) {
    4866. 

  4866.                 memset (key, 0, sizeof (key));
    4867. 

  4867.                 snprintf (key, sizeof (key), "%s.purge%d", prefix, i);
    4868. 

  4868.                 cli_print_volume_status_inode_entry (dict, key);
    4869. 

  4869.         }
    4870. 

  4870. 

  4871. out:
    4872. 

  4872.         return;
    4873. 

  4873. }
    4874. 

  4874. 

  4875. void
    4876. 

  4876. cli_print_volume_status_inode (dict_t *dict, gf_boolean_t notbrick)
    4877. 

  4877. {
    4878. 

  4878.         int             ret = -1;
    4879. 

  4879.         char            *volname = NULL;
    4880. 

  4880.         int             brick_index_max = -1;
    4881. 

  4881.         int             other_count = 0;
    4882. 

  4882.         int             index_max = 0;
    4883. 

  4883.         char            *hostname = NULL;
    4884. 

  4884.         char            *path = NULL;
    4885. 

  4885.         int             online = -1;
    4886. 

  4886.         int             conn_count = 0;
    4887. 

  4887.         char            key[1024] = {0,};
    4888. 

  4888.         int             i = 0;
    4889. 

  4889.         int             j = 0;
    4890. 

  4890. 

  4891.         GF_ASSERT (dict);
    4892. 

  4892. 

  4893.         ret = dict_get_str (dict, "volname", &volname);
    4894. 

  4894.         if (ret)
    4895. 

  4895.                 goto out;
    4896. 

  4896.         cli_out ("Inode tables for volume %s", volname);
    4897. 

  4897. 

  4898.         ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
    4899. 

  4899.         if (ret)
    4900. 

  4900.                 goto out;
    4901. 

  4901.         ret = dict_get_int32 (dict, "other-count", &other_count);
    4902. 

  4902.         if (ret)
    4903. 

  4903.                 goto out;
    4904. 

  4904. 

  4905.         index_max = brick_index_max + other_count;
    4906. 

  4906. 

  4907.         for ( i = 0; i <= index_max; i++) {
    4908. 

  4908.                 cli_out ("----------------------------------------------");
    4909. 

  4909. 

  4910.                 memset (key, 0, sizeof (key));
    4911. 

  4911.                 snprintf (key, sizeof (key), "brick%d.hostname", i);
    4912. 

  4912.                 ret = dict_get_str (dict, key, &hostname);
    4913. 

  4913.                 if (ret)
    4914. 

  4914.                         goto out;
    4915. 

  4915.                 memset (key, 0, sizeof (key));
    4916. 

  4916.                 snprintf (key, sizeof (key), "brick%d.path", i);
    4917. 

  4917.                 ret = dict_get_str (dict, key, &path);
    4918. 

  4918.                 if (ret)
    4919. 

  4919.                         goto out;
    4920. 

  4920.                 if (notbrick)
    4921. 

  4921.                         cli_out ("%s : %s", hostname, path);
    4922. 

  4922.                 else
    4923. 

  4923.                         cli_out ("Brick : %s:%s", hostname, path);
    4924. 

  4924. 

  4925.                 memset (key, 0, sizeof (key));
    4926. 

  4926.                 snprintf (key, sizeof (key), "brick%d.status", i);
    4927. 

  4927.                 ret = dict_get_int32 (dict, key, &online);
    4928. 

  4928.                 if (ret)
    4929. 

  4929.                         goto out;
    4930. 

  4930.                 if (!online) {
    4931. 

  4931.                         if (notbrick)
    4932. 

  4932.                                 cli_out ("%s is offline", hostname);
    4933. 

  4933.                         else
    4934. 

  4934.                                 cli_out ("Brick is offline");
    4935. 

  4935.                         continue;
    4936. 

  4936.                 }
    4937. 

  4937. 

  4938.                 memset (key, 0, sizeof (key));
    4939. 

  4939.                 snprintf (key, sizeof (key), "brick%d.conncount", i);
    4940. 

  4940.                 ret = dict_get_int32 (dict, key, &conn_count);
    4941. 

  4941.                 if (ret)
    4942. 

  4942.                         goto out;
    4943. 

  4943. 

  4944.                 for (j = 0; j < conn_count; j++) {
    4945. 

  4945.                         if (conn_count > 1)
    4946. 

  4946.                                 cli_out ("Connection %d:", j+1);
    4947. 

  4947. 

  4948.                         memset (key, 0, sizeof (key));
    4949. 

  4949.                         snprintf (key, sizeof (key), "brick%d.conn%d.itable",
    4950. 

  4950.                                   i, j);
    4951. 

  4951.                         cli_print_volume_status_itables (dict, key);
    4952. 

  4952.                         cli_out (" ");
    4953. 

  4953.                 }
    4954. 

  4954.         }
    4955. 

  4955. out:
    4956. 

  4956.         cli_out ("----------------------------------------------");
    4957. 

  4957.         return;
    4958. 

  4958. }
    4959. 

  4959. 

  4960. void
    4961. 

  4961. cli_print_volume_status_fdtable (dict_t *dict, char *prefix)
    4962. 

  4962. {
    4963. 

  4963.         int             ret = -1;
    4964. 

  4964.         char            key[1024] = {0,};
    4965. 

  4965.         int             refcount = 0;
    4966. 

  4966.         uint32_t        maxfds = 0;
    4967. 

  4967.         int             firstfree = 0;
    4968. 

  4968.         int             openfds = 0;
    4969. 

  4969.         int             fd_pid = 0;
    4970. 

  4970.         int             fd_refcount = 0;
    4971. 

  4971.         int             fd_flags = 0;
    4972. 

  4972.         int             i = 0;
    4973. 

  4973. 

  4974.         GF_ASSERT (dict);
    4975. 

  4975.         GF_ASSERT (prefix);
    4976. 

  4976. 

  4977.         memset (key, 0, sizeof (key));
    4978. 

  4978.         snprintf (key, sizeof (key), "%s.refcount", prefix);
    4979. 

  4979.         ret = dict_get_int32 (dict, key, &refcount);
    4980. 

  4980.         if (ret)
    4981. 

  4981.                 goto out;
    4982. 

  4982. 

  4983.         memset (key, 0, sizeof (key));
    4984. 

  4984.         snprintf (key, sizeof (key), "%s.maxfds", prefix);
    4985. 

  4985.         ret = dict_get_uint32 (dict, key, &maxfds);
    4986. 

  4986.         if (ret)
    4987. 

  4987.                 goto out;
    4988. 

  4988. 

  4989.         memset (key, 0 ,sizeof (key));
    4990. 

  4990.         snprintf (key, sizeof (key), "%s.firstfree", prefix);
    4991. 

  4991.         ret = dict_get_int32 (dict, key, &firstfree);
    4992. 

  4992.         if (ret)
    4993. 

  4993.                 goto out;
    4994. 

  4994. 

  4995.         cli_out ("RefCount = %d  MaxFDs = %d  FirstFree = %d",
    4996. 

  4996.                  refcount, maxfds, firstfree);
    4997. 

  4997. 

  4998.         memset (key, 0, sizeof (key));
    4999. 

  4999.         snprintf (key, sizeof (key), "%s.openfds", prefix);
    5000. 

  5000.         ret = dict_get_int32 (dict, key, &openfds);
    5001. 

  5001.         if (ret)
    5002. 

  5002.                 goto out;
    5003. 

  5003.         if (0 == openfds) {
    5004. 

  5004.                 cli_err ("No open fds");
    5005. 

  5005.                 goto out;
    5006. 

  5006.         }
    5007. 

  5007. 

  5008.         cli_out ("%-19s %-19s %-19s %-19s", "FD Entry", "PID",
    5009. 

  5009.                  "RefCount", "Flags");
    5010. 

  5010.         cli_out ("%-19s %-19s %-19s %-19s", "--------", "---",
    5011. 

  5011.                  "--------", "-----");
    5012. 

  5012. 

  5013.         for (i = 0; i < maxfds ; i++) {
    5014. 

  5014.                 memset (key, 0, sizeof (key));
    5015. 

  5015.                 snprintf (key, sizeof (key), "%s.fdentry%d.pid", prefix, i);
    5016. 

  5016.                 ret = dict_get_int32 (dict, key, &fd_pid);
    5017. 

  5017.                 if (ret)
    5018. 

  5018.                         continue;
    5019. 

  5019. 

  5020.                 memset (key, 0, sizeof (key));
    5021. 

  5021.                 snprintf (key, sizeof (key), "%s.fdentry%d.refcount",
    5022. 

  5022.                           prefix, i);
    5023. 

  5023.                 ret = dict_get_int32 (dict, key, &fd_refcount);
    5024. 

  5024.                 if (ret)
    5025. 

  5025.                         continue;
    5026. 

  5026. 

  5027.                 memset (key, 0, sizeof (key));
    5028. 

  5028.                 snprintf (key, sizeof (key), "%s.fdentry%d.flags", prefix, i);
    5029. 

  5029.                 ret = dict_get_int32 (dict, key, &fd_flags);
    5030. 

  5030.                 if (ret)
    5031. 

  5031.                         continue;
    5032. 

  5032. 

  5033.                 cli_out ("%-19d %-19d %-19d %-19d", i, fd_pid, fd_refcount,
    5034. 

  5034.                          fd_flags);
    5035. 

  5035.         }
    5036. 

  5036. 

  5037. out:
    5038. 

  5038.         return;
    5039. 

  5039. }
    5040. 

  5040. 

  5041. void
    5042. 

  5042. cli_print_volume_status_fd (dict_t *dict, gf_boolean_t notbrick)
    5043. 

  5043. {
    5044. 

  5044.         int             ret = -1;
    5045. 

  5045.         char            *volname = NULL;
    5046. 

  5046.         int             brick_index_max = -1;
    5047. 

  5047.         int             other_count = 0;
    5048. 

  5048.         int             index_max = 0;
    5049. 

  5049.         char            *hostname = NULL;
    5050. 

  5050.         char            *path = NULL;
    5051. 

  5051.         int             online = -1;
    5052. 

  5052.         int             conn_count = 0;
    5053. 

  5053.         char            key[1024] = {0,};
    5054. 

  5054.         int             i = 0;
    5055. 

  5055.         int             j = 0;
    5056. 

  5056. 

  5057.         GF_ASSERT (dict);
    5058. 

  5058. 

  5059.         ret = dict_get_str (dict, "volname", &volname);
    5060. 

  5060.         if (ret)
    5061. 

  5061.                 goto out;
    5062. 

  5062.         cli_out ("FD tables for volume %s", volname);
    5063. 

  5063. 

  5064.         ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
    5065. 

  5065.         if (ret)
    5066. 

  5066.                 goto out;
    5067. 

  5067.         ret = dict_get_int32 (dict, "other-count", &other_count);
    5068. 

  5068.         if (ret)
    5069. 

  5069.                 goto out;
    5070. 

  5070. 

  5071.         index_max = brick_index_max + other_count;
    5072. 

  5072. 

  5073.         for (i = 0; i <= index_max; i++) {
    5074. 

  5074.                 cli_out ("----------------------------------------------");
    5075. 

  5075. 

  5076.                 memset (key, 0, sizeof (key));
    5077. 

  5077.                 snprintf (key, sizeof (key), "brick%d.hostname", i);
    5078. 

  5078.                 ret = dict_get_str (dict, key, &hostname);
    5079. 

  5079.                 if (ret)
    5080. 

  5080.                         goto out;
    5081. 

  5081.                 memset (key, 0, sizeof (key));
    5082. 

  5082.                 snprintf (key, sizeof (key), "brick%d.path", i);
    5083. 

  5083.                 ret = dict_get_str (dict, key, &path);
    5084. 

  5084.                 if (ret)
    5085. 

  5085.                         goto out;
    5086. 

  5086. 

  5087.                 if (notbrick)
    5088. 

  5088.                         cli_out ("%s : %s", hostname, path);
    5089. 

  5089.                 else
    5090. 

  5090.                         cli_out ("Brick : %s:%s", hostname, path);
    5091. 

  5091. 

  5092.                 memset (key, 0, sizeof (key));
    5093. 

  5093.                 snprintf (key, sizeof (key), "brick%d.status", i);
    5094. 

  5094.                 ret = dict_get_int32 (dict, key, &online);
    5095. 

  5095.                 if (ret)
    5096. 

  5096.                         goto out;
    5097. 

  5097.                 if (!online) {
    5098. 

  5098.                         if (notbrick)
    5099. 

  5099.                                 cli_out ("%s is offline", hostname);
    5100. 

  5100.                         else
    5101. 

  5101.                                 cli_out ("Brick is offline");
    5102. 

  5102.                         continue;
    5103. 

  5103.                 }
    5104. 

  5104. 

  5105.                 memset (key, 0, sizeof (key));
    5106. 

  5106.                 snprintf (key, sizeof (key), "brick%d.conncount", i);
    5107. 

  5107.                 ret = dict_get_int32 (dict, key, &conn_count);
    5108. 

  5108.                 if (ret)
    5109. 

  5109.                         goto out;
    5110. 

  5110. 

  5111.                 for (j = 0; j < conn_count; j++) {
    5112. 

  5112.                         cli_out ("Connection %d:", j+1);
    5113. 

  5113. 

  5114.                         memset (key, 0, sizeof (key));
    5115. 

  5115.                         snprintf (key, sizeof (key), "brick%d.conn%d.fdtable",
    5116. 

  5116.                                   i, j);
    5117. 

  5117.                         cli_print_volume_status_fdtable (dict, key);
    5118. 

  5118.                         cli_out (" ");
    5119. 

  5119.                 }
    5120. 

  5120.         }
    5121. 

  5121. out:
    5122. 

  5122.         cli_out ("----------------------------------------------");
    5123. 

  5123.         return;
    5124. 

  5124. }
    5125. 

  5125. 

  5126. void
    5127. 

  5127. cli_print_volume_status_call_frame (dict_t *dict, char *prefix)
    5128. 

  5128. {
    5129. 

  5129.         int             ret = -1;
    5130. 

  5130.         char            key[1024] = {0,};
    5131. 

  5131.         int             ref_count = 0;
    5132. 

  5132.         char            *translator = 0;
    5133. 

  5133.         int             complete = 0;
    5134. 

  5134.         char            *parent = NULL;
    5135. 

  5135.         char            *wind_from = NULL;
    5136. 

  5136.         char            *wind_to = NULL;
    5137. 

  5137.         char            *unwind_from = NULL;
    5138. 

  5138.         char            *unwind_to = NULL;
    5139. 

  5139. 

  5140.         if (!dict || !prefix)
    5141. 

  5141.                 return;
    5142. 

  5142. 

  5143.         memset (key, 0, sizeof (key));
    5144. 

  5144.         snprintf (key, sizeof (key), "%s.refcount", prefix);
    5145. 

  5145.         ret = dict_get_int32 (dict, key, &ref_count);
    5146. 

  5146.         if (ret)
    5147. 

  5147.                 return;
    5148. 

  5148. 

  5149.         memset (key, 0, sizeof (key));
    5150. 

  5150.         snprintf (key, sizeof (key), "%s.translator", prefix);
    5151. 

  5151.         ret = dict_get_str (dict, key, &translator);
    5152. 

  5152.         if (ret)
    5153. 

  5153.                 return;
    5154. 

  5154. 

  5155.         memset (key, 0, sizeof (key));
    5156. 

  5156.         snprintf (key, sizeof (key), "%s.complete", prefix);
    5157. 

  5157.         ret = dict_get_int32 (dict, key, &complete);
    5158. 

  5158.         if (ret)
    5159. 

  5159.                 return;
    5160. 

  5160. 

  5161.         cli_out ("  Ref Count   = %d", ref_count);
    5162. 

  5162.         cli_out ("  Translator  = %s", translator);
    5163. 

  5163.         cli_out ("  Completed   = %s", (complete ? "Yes" : "No"));
    5164. 

  5164. 

  5165.         memset (key, 0, sizeof (key));
    5166. 

  5166.         snprintf (key, sizeof (key), "%s.parent", prefix);
    5167. 

  5167.         ret = dict_get_str (dict, key, &parent);
    5168. 

  5168.         if (!ret)
    5169. 

  5169.                 cli_out ("  Parent      = %s", parent);
    5170. 

  5170. 

  5171.         memset (key, 0, sizeof (key));
    5172. 

  5172.         snprintf (key, sizeof (key), "%s.windfrom", prefix);
    5173. 

  5173.         ret = dict_get_str (dict, key, &wind_from);
    5174. 

  5174.         if (!ret)
    5175. 

  5175.                 cli_out ("  Wind From   = %s", wind_from);
    5176. 

  5176. 

  5177.         memset (key, 0, sizeof (key));
    5178. 

  5178.         snprintf (key, sizeof (key), "%s.windto", prefix);
    5179. 

  5179.         ret = dict_get_str (dict, key, &wind_to);
    5180. 

  5180.         if (!ret)
    5181. 

  5181.                 cli_out ("  Wind To     = %s", wind_to);
    5182. 

  5182. 

  5183.         memset (key, 0, sizeof (key));
    5184. 

  5184.         snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
    5185. 

  5185.         ret = dict_get_str (dict, key, &unwind_from);
    5186. 

  5186.         if (!ret)
    5187. 

  5187.                 cli_out ("  Unwind From = %s", unwind_from);
    5188. 

  5188. 

  5189.         memset (key, 0, sizeof (key));
    5190. 

  5190.         snprintf (key, sizeof (key), "%s.unwindto", prefix);
    5191. 

  5191.         ret = dict_get_str (dict, key, &unwind_to);
    5192. 

  5192.         if (!ret)
    5193. 

  5193.                 cli_out ("  Unwind To   = %s", unwind_to);
    5194. 

  5194. }
    5195. 

  5195. 

  5196. void
    5197. 

  5197. cli_print_volume_status_call_stack (dict_t *dict, char *prefix)
    5198. 

  5198. {
    5199. 

  5199.         int             ret = -1;
    5200. 

  5200.         char            key[1024] = {0,};
    5201. 

  5201.         int             uid = 0;
    5202. 

  5202.         int             gid = 0;
    5203. 

  5203.         int             pid = 0;
    5204. 

  5204.         uint64_t        unique = 0;
    5205. 

  5205.         //char            *op = NULL;
    5206. 

  5206.         int             count = 0;
    5207. 

  5207.         int             i = 0;
    5208. 

  5208. 

  5209.         if (!dict || !prefix)
    5210. 

  5210.                 return;
    5211. 

  5211. 

  5212.         memset (key, 0, sizeof (key));
    5213. 

  5213.         snprintf (key, sizeof (key), "%s.uid", prefix);
    5214. 

  5214.         ret = dict_get_int32 (dict, key, &uid);
    5215. 

  5215.         if (ret)
    5216. 

  5216.                 return;
    5217. 

  5217. 

  5218.         memset (key, 0, sizeof (key));
    5219. 

  5219.         snprintf (key, sizeof (key), "%s.gid", prefix);
    5220. 

  5220.         ret = dict_get_int32 (dict, key, &gid);
    5221. 

  5221.         if (ret)
    5222. 

  5222.                 return;
    5223. 

  5223. 

  5224.         memset (key, 0, sizeof (key));
    5225. 

  5225.         snprintf (key, sizeof (key), "%s.pid", prefix);
    5226. 

  5226.         ret = dict_get_int32 (dict, key, &pid);
    5227. 

  5227.         if (ret)
    5228. 

  5228.                 return;
    5229. 

  5229. 

  5230.         memset (key, 0, sizeof (key));
    5231. 

  5231.         snprintf (key, sizeof (key), "%s.unique", prefix);
    5232. 

  5232.         ret = dict_get_uint64 (dict, key, &unique);
    5233. 

  5233.         if (ret)
    5234. 

  5234.                 return;
    5235. 

  5235. 

  5236.         /*
    5237. 

  5237.         memset (key, 0, sizeof (key));
    5238. 

  5238.         snprintf (key, sizeof (key), "%s.op", prefix);
    5239. 

  5239.         ret = dict_get_str (dict, key, &op);
    5240. 

  5240.         if (ret)
    5241. 

  5241.                 return;
    5242. 

  5242.         */
    5243. 

  5243. 

  5244. 

  5245.         memset (key, 0, sizeof (key));
    5246. 

  5246.         snprintf (key, sizeof (key), "%s.count", prefix);
    5247. 

  5247.         ret = dict_get_int32 (dict, key, &count);
    5248. 

  5248.         if (ret)
    5249. 

  5249.                 return;
    5250. 

  5250. 

  5251.         cli_out (" UID    : %d", uid);
    5252. 

  5252.         cli_out (" GID    : %d", gid);
    5253. 

  5253.         cli_out (" PID    : %d", pid);
    5254. 

  5254.         cli_out (" Unique : %"PRIu64, unique);
    5255. 

  5255.         //cli_out ("\tOp     : %s", op);
    5256. 

  5256.         cli_out (" Frames : %d", count);
    5257. 

  5257. 

  5258.         for (i = 0; i < count; i++) {
    5259. 

  5259.                 cli_out (" Frame %d", i+1);
    5260. 

  5260. 

  5261.                 memset (key, 0, sizeof (key));
    5262. 

  5262.                 snprintf (key, sizeof (key), "%s.frame%d", prefix, i);
    5263. 

  5263.                 cli_print_volume_status_call_frame (dict, key);
    5264. 

  5264.         }
    5265. 

  5265. 

  5266.         cli_out (" ");
    5267. 

  5267. }
    5268. 

  5268. 

  5269. void
    5270. 

  5270. cli_print_volume_status_callpool (dict_t *dict, gf_boolean_t notbrick)
    5271. 

  5271. {
    5272. 

  5272.         int             ret = -1;
    5273. 

  5273.         char            *volname = NULL;
    5274. 

  5274.         int             brick_index_max = -1;
    5275. 

  5275.         int             other_count = 0;
    5276. 

  5276.         int             index_max = 0;
    5277. 

  5277.         char            *hostname = NULL;
    5278. 

  5278.         char            *path = NULL;
    5279. 

  5279.         int             online = -1;
    5280. 

  5280.         int             call_count = 0;
    5281. 

  5281.         char            key[1024] = {0,};
    5282. 

  5282.         int             i = 0;
    5283. 

  5283.         int             j = 0;
    5284. 

  5284. 

  5285.         GF_ASSERT (dict);
    5286. 

  5286. 

  5287.         ret = dict_get_str (dict, "volname", &volname);
    5288. 

  5288.         if (ret)
    5289. 

  5289.                 goto out;
    5290. 

  5290.         cli_out ("Pending calls for volume %s", volname);
    5291. 

  5291. 

  5292.         ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
    5293. 

  5293.         if (ret)
    5294. 

  5294.                 goto out;
    5295. 

  5295.         ret = dict_get_int32 (dict, "other-count", &other_count);
    5296. 

  5296.         if (ret)
    5297. 

  5297.                 goto out;
    5298. 

  5298. 

  5299.         index_max = brick_index_max + other_count;
    5300. 

  5300. 

  5301.         for (i = 0; i <= index_max; i++) {
    5302. 

  5302.                 cli_out ("----------------------------------------------");
    5303. 

  5303. 

  5304.                 memset (key, 0, sizeof (key));
    5305. 

  5305.                 snprintf (key, sizeof (key), "brick%d.hostname", i);
    5306. 

  5306.                 ret = dict_get_str (dict, key, &hostname);
    5307. 

  5307.                 if (ret)
    5308. 

  5308.                         goto out;
    5309. 

  5309.                 memset (key, 0, sizeof (key));
    5310. 

  5310.                 snprintf (key, sizeof (key), "brick%d.path", i);
    5311. 

  5311.                 ret = dict_get_str (dict, key, &path);
    5312. 

  5312.                 if (ret)
    5313. 

  5313.                         goto out;
    5314. 

  5314. 

  5315.                 if (notbrick)
    5316. 

  5316.                         cli_out ("%s : %s", hostname, path);
    5317. 

  5317.                 else
    5318. 

  5318.                         cli_out ("Brick : %s:%s", hostname, path);
    5319. 

  5319. 

  5320.                 memset (key, 0, sizeof (key));
    5321. 

  5321.                 snprintf (key, sizeof (key), "brick%d.status", i);
    5322. 

  5322.                 ret = dict_get_int32 (dict, key, &online);
    5323. 

  5323.                 if (ret)
    5324. 

  5324.                         goto out;
    5325. 

  5325.                 if (!online) {
    5326. 

  5326.                         if (notbrick)
    5327. 

  5327.                                 cli_out ("%s is offline", hostname);
    5328. 

  5328.                         else
    5329. 

  5329.                                 cli_out ("Brick is offline");
    5330. 

  5330.                         continue;
    5331. 

  5331.                 }
    5332. 

  5332. 

  5333.                 memset (key, 0, sizeof (key));
    5334. 

  5334.                 snprintf (key, sizeof (key), "brick%d.callpool.count", i);
    5335. 

  5335.                 ret = dict_get_int32 (dict, key, &call_count);
    5336. 

  5336.                 if (ret)
    5337. 

  5337.                         goto out;
    5338. 

  5338.                 cli_out ("Pending calls: %d", call_count);
    5339. 

  5339. 

  5340.                 if (0 == call_count)
    5341. 

  5341.                         continue;
    5342. 

  5342. 

  5343.                 for (j = 0; j < call_count; j++) {
    5344. 

  5344.                         cli_out ("Call Stack%d", j+1);
    5345. 

  5345. 

  5346.                         memset (key, 0, sizeof (key));
    5347. 

  5347.                         snprintf (key, sizeof (key),
    5348. 

  5348.                                   "brick%d.callpool.stack%d", i, j);
    5349. 

  5349.                         cli_print_volume_status_call_stack (dict, key);
    5350. 

  5350.                 }
    5351. 

  5351.         }
    5352. 

  5352. 

  5353. out:
    5354. 

  5354.         cli_out ("----------------------------------------------");
    5355. 

  5355.         return;
    5356. 

  5356. }
    5357. 

  5357. 

  5358. 

  5359. static void
    5360. 

  5360. cli_print_volume_tasks (dict_t *dict) {
    5361. 

  5361.         int             ret = -1;
    5362. 

  5362.         int             tasks = 0;
    5363. 

  5363.         char            *op = 0;
    5364. 

  5364.         char            *task_id_str = NULL;
    5365. 

  5365.         int             status = 0;
    5366. 

  5366.         char            key[1024] = {0,};
    5367. 

  5367.         int             i = 0;
    5368. 

  5368. 

  5369.         ret = dict_get_int32 (dict, "tasks", &tasks);
    5370. 

  5370.         if (ret) {
    5371. 

  5371.                 gf_log ("cli", GF_LOG_ERROR,
    5372. 

  5372.                         "Failed to get tasks count");
    5373. 

  5373.                 return;
    5374. 

  5374.         }
    5375. 

  5375. 

  5376.         if (tasks == 0) {
    5377. 

  5377.                 cli_out ("There are no active volume tasks");
    5378. 

  5378.                 return;
    5379. 

  5379.         }
    5380. 

  5380. 

  5381.         cli_out ("%15s%40s%15s", "Task", "ID", "Status");
    5382. 

  5382.         cli_out ("%15s%40s%15s", "----", "--", "------");
    5383. 

  5383.         for (i = 0; i < tasks; i++) {
    5384. 

  5384.                 memset (key, 0, sizeof (key));
    5385. 

  5385.                 snprintf (key, sizeof (key), "task%d.type", i);
    5386. 

  5386.                 ret = dict_get_str(dict, key, &op);
    5387. 

  5387.                 if (ret)
    5388. 

  5388.                         return;
    5389. 

  5389. 

  5390.                 memset (key, 0, sizeof (key));
    5391. 

  5391.                 snprintf (key, sizeof (key), "task%d.id", i);
    5392. 

  5392.                 ret = dict_get_str (dict, key, &task_id_str);
    5393. 

  5393.                 if (ret)
    5394. 

  5394.                         return;
    5395. 

  5395. 

  5396.                 memset (key, 0, sizeof (key));
    5397. 

  5397.                 snprintf (key, sizeof (key), "task%d.status", i);
    5398. 

  5398.                 ret = dict_get_int32 (dict, key, &status);
    5399. 

  5399.                 if (ret)
    5400. 

  5400.                         return;
    5401. 

  5401. 

  5402.                 cli_out ("%15s%40s%15d", op, task_id_str, status);
    5403. 

  5403.         }
    5404. 

  5404. 

  5405. }
    5406. 

  5406. 

  5407. static int
    5408. 

  5408. gf_cli_status_cbk (struct rpc_req *req, struct iovec *iov,
    5409. 

  5409.                       int count, void *myframe)
    5410. 

  5410. {
    5411. 

  5411.         int                             ret             = -1;
    5412. 

  5412.         int                             brick_index_max = -1;
    5413. 

  5413.         int                             other_count     = 0;
    5414. 

  5414.         int                             index_max       = 0;
    5415. 

  5415.         int                             i               = 0;
    5416. 

  5416.         int                             pid             = -1;
    5417. 

  5417.         uint32_t                        cmd             = 0;
    5418. 

  5418.         gf_boolean_t                    notbrick        = _gf_false;
    5419. 

  5419.         char                            key[1024]       = {0,};
    5420. 

  5420.         char                           *hostname        = NULL;
    5421. 

  5421.         char                           *path            = NULL;
    5422. 

  5422.         char                           *volname         = NULL;
    5423. 

  5423.         dict_t                         *dict            = NULL;
    5424. 

  5424.         gf_cli_rsp                      rsp             = {0,};
    5425. 

  5425.         cli_volume_status_t             status          = {0};
    5426. 

  5426.         cli_local_t                    *local           = NULL;
    5427. 

  5427.         gf_boolean_t                    wipe_local      = _gf_false;
    5428. 

  5428.         char                            msg[1024]       = {0,};
    5429. 

  5429. 

  5430.         if (req->rpc_status == -1)
    5431. 

  5431.                 goto out;
    5432. 

  5432. 

  5433.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    5434. 

  5434.         if (ret < 0) {
    5435. 

  5435.                 gf_log ("cli", GF_LOG_ERROR, "Volume status response error");
    5436. 

  5436.                 goto out;
    5437. 

  5437.         }
    5438. 

  5438. 

  5439.         gf_log ("cli", GF_LOG_DEBUG, "Received response to status cmd");
    5440. 

  5440. 

  5441.         local = ((call_frame_t *)myframe)->local;
    5442. 

  5442.         if (!local) {
    5443. 

  5443.                 local = cli_local_get ();
    5444. 

  5444.                 if (!local) {
    5445. 

  5445.                         ret = -1;
    5446. 

  5446.                         gf_log ("cli", GF_LOG_ERROR, "Failed to get local");
    5447. 

  5447.                         goto out;
    5448. 

  5448.                 }
    5449. 

  5449.                 wipe_local = _gf_true;
    5450. 

  5450.         }
    5451. 

  5451. 

  5452.         if (rsp.op_ret) {
    5453. 

  5453.                 if (strcmp (rsp.op_errstr, ""))
    5454. 

  5454.                         snprintf (msg, sizeof (msg), "%s", rsp.op_errstr);
    5455. 

  5455.                 else
    5456. 

  5456.                         snprintf (msg, sizeof (msg), "Unable to obtain volume "
    5457. 

  5457.                                   "status information.");
    5458. 

  5458. 

  5459.                 if (global_state->mode & GLUSTER_MODE_XML) {
    5460. 

  5460.                        cli_xml_output_str ("volStatus", msg, rsp.op_ret,
    5461. 

  5461.                                            rsp.op_errno, rsp.op_errstr);
    5462. 

  5462.                        ret = 0;
    5463. 

  5463.                        goto out;
    5464. 

  5464.                 }
    5465. 

  5465. 

  5466.                 cli_err ("%s", msg);
    5467. 

  5467.                 if (local && local->all) {
    5468. 

  5468.                         ret = 0;
    5469. 

  5469.                         cli_out (" ");
    5470. 

  5470.                 } else
    5471. 

  5471.                         ret = -1;
    5472. 

  5472. 

  5473.                 goto out;
    5474. 

  5474.         }
    5475. 

  5475. 

  5476.         dict = dict_new ();
    5477. 

  5477.         if (!dict)
    5478. 

  5478.                 goto out;
    5479. 

  5479. 

  5480.         ret = dict_unserialize (rsp.dict.dict_val,
    5481. 

  5481.                                 rsp.dict.dict_len,
    5482. 

  5482.                                 &dict);
    5483. 

  5483.         if (ret)
    5484. 

  5484.                 goto out;
    5485. 

  5485. 

  5486.         ret = dict_get_uint32 (dict, "cmd", &cmd);
    5487. 

  5487.         if (ret)
    5488. 

  5488.                 goto out;
    5489. 

  5489. 

  5490.         if ((cmd & GF_CLI_STATUS_ALL)) {
    5491. 

  5491.                 if (local && local->dict) {
    5492. 

  5492.                         dict_ref (dict);
    5493. 

  5493.                         ret = dict_set_static_ptr (local->dict, "rsp-dict", dict);
    5494. 

  5494.                         ret = 0;
    5495. 

  5495.                 } else {
    5496. 

  5496.                         gf_log ("cli", GF_LOG_ERROR, "local not found");
    5497. 

  5497.                         ret = -1;
    5498. 

  5498.                 }
    5499. 

  5499.                 goto out;
    5500. 

  5500.         }
    5501. 

  5501. 

  5502.         if ((cmd & GF_CLI_STATUS_NFS) || (cmd & GF_CLI_STATUS_SHD))
    5503. 

  5503.                 notbrick = _gf_true;
    5504. 

  5504. 

  5505.         ret = dict_get_int32 (dict, "count", &count);
    5506. 

  5506.         if (ret)
    5507. 

  5507.                 goto out;
    5508. 

  5508.         if (count == 0) {
    5509. 

  5509.                 ret = -1;
    5510. 

  5510.                 goto out;
    5511. 

  5511.         }
    5512. 

  5512. 

  5513.         ret = dict_get_int32 (dict, "brick-index-max", &brick_index_max);
    5514. 

  5514.         if (ret)
    5515. 

  5515.                 goto out;
    5516. 

  5516.         ret = dict_get_int32 (dict, "other-count", &other_count);
    5517. 

  5517.         if (ret)
    5518. 

  5518.                 goto out;
    5519. 

  5519. 

  5520.         index_max = brick_index_max + other_count;
    5521. 

  5521. 

  5522.         if (global_state->mode & GLUSTER_MODE_XML) {
    5523. 

  5523.                 if (!local->all) {
    5524. 

  5524.                         ret = cli_xml_output_vol_status_begin (local,
    5525. 

  5525.                                                                rsp.op_ret,
    5526. 

  5526.                                                                rsp.op_errno,
    5527. 

  5527.                                                                rsp.op_errstr);
    5528. 

  5528.                         if (ret) {
    5529. 

  5529.                                 gf_log ("cli", GF_LOG_ERROR,
    5530. 

  5530.                                         "Error outputting to xml");
    5531. 

  5531.                                 goto out;
    5532. 

  5532.                         }
    5533. 

  5533.                 }
    5534. 

  5534.                 ret = cli_xml_output_vol_status (local, dict);
    5535. 

  5535.                 if (ret) {
    5536. 

  5536.                         gf_log ("cli", GF_LOG_ERROR,
    5537. 

  5537.                                 "Error outputting to xml");
    5538. 

  5538.                         goto out;
    5539. 

  5539.                 }
    5540. 

  5540. 

  5541.                 if (!local->all) {
    5542. 

  5542.                         ret = cli_xml_output_vol_status_end (local);
    5543. 

  5543.                         if (ret) {
    5544. 

  5544.                                 gf_log ("cli", GF_LOG_ERROR,
    5545. 

  5545.                                         "Error outputting to xml");
    5546. 

  5546.                         }
    5547. 

  5547.                 }
    5548. 

  5548.                 goto out;
    5549. 

  5549.         }
    5550. 

  5550. 

  5551.         status.brick = GF_CALLOC (1, PATH_MAX + 256, gf_common_mt_strdup);
    5552. 

  5552. 

  5553.         switch (cmd & GF_CLI_STATUS_MASK) {
    5554. 

  5554.                 case GF_CLI_STATUS_MEM:
    5555. 

  5555.                         cli_print_volume_status_mem (dict, notbrick);
    5556. 

  5556.                         goto cont;
    5557. 

  5557.                         break;
    5558. 

  5558.                 case GF_CLI_STATUS_CLIENTS:
    5559. 

  5559.                         cli_print_volume_status_clients (dict, notbrick);
    5560. 

  5560.                         goto cont;
    5561. 

  5561.                         break;
    5562. 

  5562.                 case GF_CLI_STATUS_INODE:
    5563. 

  5563.                         cli_print_volume_status_inode (dict, notbrick);
    5564. 

  5564.                         goto cont;
    5565. 

  5565.                         break;
    5566. 

  5566.                 case GF_CLI_STATUS_FD:
    5567. 

  5567.                         cli_print_volume_status_fd (dict, notbrick);
    5568. 

  5568.                         goto cont;
    5569. 

  5569.                         break;
    5570. 

  5570.                 case GF_CLI_STATUS_CALLPOOL:
    5571. 

  5571.                         cli_print_volume_status_callpool (dict, notbrick);
    5572. 

  5572.                         goto cont;
    5573. 

  5573.                         break;
    5574. 

  5574.                 default:
    5575. 

  5575.                         break;
    5576. 

  5576.         }
    5577. 

  5577. 

  5578.         ret = dict_get_str (dict, "volname", &volname);
    5579. 

  5579.         if (ret)
    5580. 

  5580.                 goto out;
    5581. 

  5581. 

  5582.         cli_out ("Status of volume: %s", volname);
    5583. 

  5583. 

  5584.         if ((cmd & GF_CLI_STATUS_DETAIL) == 0) {
    5585. 

  5585.                 cli_out ("Gluster process\t\t\t\t\t\tPort\tOnline\tPid");
    5586. 

  5586.                 cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
    5587. 

  5587.         }
    5588. 

  5588. 

  5589.         for (i = 0; i <= index_max; i++) {
    5590. 

  5590. 

  5591. 

  5592.                 memset (key, 0, sizeof (key));
    5593. 

  5593.                 snprintf (key, sizeof (key), "brick%d.hostname", i);
    5594. 

  5594.                 ret = dict_get_str (dict, key, &hostname);
    5595. 

  5595.                 if (ret)
    5596. 

  5596.                         continue;
    5597. 

  5597. 

  5598.                 memset (key, 0, sizeof (key));
    5599. 

  5599.                 snprintf (key, sizeof (key), "brick%d.path", i);
    5600. 

  5600.                 ret = dict_get_str (dict, key, &path);
    5601. 

  5601.                 if (ret)
    5602. 

  5602.                         continue;
    5603. 

  5603. 

  5604.                 /* Brick/not-brick is handled seperately here as all
    5605. 

  5605.                  * types of nodes are contained in the default output
    5606. 

  5606.                  */
    5607. 

  5607.                 memset (status.brick, 0, PATH_MAX + 255);
    5608. 

  5608.                 if (!strcmp (hostname, "NFS Server") ||
    5609. 

  5609.                     !strcmp (hostname, "Self-heal Daemon"))
    5610. 

  5610.                         snprintf (status.brick, PATH_MAX + 255, "%s on %s",
    5611. 

  5611.                                   hostname, path);
    5612. 

  5612.                 else
    5613. 

  5613.                         snprintf (status.brick, PATH_MAX + 255, "Brick %s:%s",
    5614. 

  5614.                                   hostname, path);
    5615. 

  5615. 

  5616.                 memset (key, 0, sizeof (key));
    5617. 

  5617.                 snprintf (key, sizeof (key), "brick%d.port", i);
    5618. 

  5618.                 ret = dict_get_int32 (dict, key, &(status.port));
    5619. 

  5619.                 if (ret)
    5620. 

  5620.                         continue;
    5621. 

  5621. 

  5622.                 memset (key, 0, sizeof (key));
    5623. 

  5623.                 snprintf (key, sizeof (key), "brick%d.status", i);
    5624. 

  5624.                 ret = dict_get_int32 (dict, key, &(status.online));
    5625. 

  5625.                 if (ret)
    5626. 

  5626.                         continue;
    5627. 

  5627. 

  5628.                 memset (key, 0, sizeof (key));
    5629. 

  5629.                 snprintf (key, sizeof (key), "brick%d.pid", i);
    5630. 

  5630.                 ret = dict_get_int32 (dict, key, &pid);
    5631. 

  5631.                 if (ret)
    5632. 

  5632.                         continue;
    5633. 

  5633.                 if (pid == -1)
    5634. 

  5634.                         ret = gf_asprintf (&(status.pid_str), "%s", "N/A");
    5635. 

  5635.                 else
    5636. 

  5636.                         ret = gf_asprintf (&(status.pid_str), "%d", pid);
    5637. 

  5637. 

  5638.                 if (ret == -1)
    5639. 

  5639.                         goto out;
    5640. 

  5640. 

  5641.                 if ((cmd & GF_CLI_STATUS_DETAIL)) {
    5642. 

  5642.                         ret = cli_get_detail_status (dict, i, &status);
    5643. 

  5643.                         if (ret)
    5644. 

  5644.                                 goto out;
    5645. 

  5645.                         cli_print_line (CLI_BRICK_STATUS_LINE_LEN);
    5646. 

  5646.                         cli_print_detailed_status (&status);
    5647. 

  5647. 

  5648.                 } else {
    5649. 

  5649.                         cli_print_brick_status (&status);
    5650. 

  5650.                 }
    5651. 

  5651.         }
    5652. 

  5652.         cli_out (" ");
    5653. 

  5653. 

  5654.         if ((cmd & GF_CLI_STATUS_MASK) == GF_CLI_STATUS_NONE)
    5655. 

  5655.                 cli_print_volume_tasks (dict);
    5656. 

  5656. cont:
    5657. 

  5657.         ret = rsp.op_ret;
    5658. 

  5658. 

  5659. out:
    5660. 

  5660.         if (dict)
    5661. 

  5661.                 dict_unref (dict);
    5662. 

  5662.         GF_FREE (status.brick);
    5663. 

  5663.         if (local && wipe_local) {
    5664. 

  5664.                 cli_local_wipe (local);
    5665. 

  5665.         }
    5666. 

  5666. 

  5667.         cli_cmd_broadcast_response (ret);
    5668. 

  5668.         return ret;
    5669. 

  5669. }
    5670. 

  5670. 

  5671. int32_t
    5672. 

  5672. gf_cli_status_volume (call_frame_t *frame, xlator_t *this,
    5673. 

  5673.                          void *data)
    5674. 

  5674. {
    5675. 

  5675.         gf_cli_req                      req  = {{0,}};
    5676. 

  5676.         int                             ret  = -1;
    5677. 

  5677.         dict_t                         *dict = NULL;
    5678. 

  5678. 

  5679.         if (!frame || !this || !data)
    5680. 

  5680.                 goto out;
    5681. 

  5681. 

  5682.         dict = data;
    5683. 

  5683. 

  5684.         ret = cli_to_glusterd (&req, frame, gf_cli_status_cbk,
    5685. 

  5685.                                (xdrproc_t) xdr_gf_cli_req, dict,
    5686. 

  5686.                                GLUSTER_CLI_STATUS_VOLUME, this, cli_rpc_prog,
    5687. 

  5687.                                NULL);
    5688. 

  5688.  out:
    5689. 

  5689.         gf_log ("cli", GF_LOG_DEBUG, "Returning: %d", ret);
    5690. 

  5690.         return ret;
    5691. 

  5691. }
    5692. 

  5692. 

  5693. int
    5694. 

  5694. gf_cli_status_volume_all (call_frame_t *frame, xlator_t *this, void *data)
    5695. 

  5695. {
    5696. 

  5696.         int              i            = 0;
    5697. 

  5697.         int              ret          = -1;
    5698. 

  5698.         int              vol_count    = -1;
    5699. 

  5699.         uint32_t         cmd          = 0;
    5700. 

  5700.         char             key[1024]    = {0};
    5701. 

  5701.         char            *volname      = NULL;
    5702. 

  5702.         void            *vol_dict     = NULL;
    5703. 

  5703.         dict_t          *dict         = NULL;
    5704. 

  5704.         cli_local_t     *local        = NULL;
    5705. 

  5705. 

  5706.         if (frame->local) {
    5707. 

  5707.                 local = frame->local;
    5708. 

  5708.                 local->all = _gf_true;
    5709. 

  5709.         } else
    5710. 

  5710.                 goto out;
    5711. 

  5711. 

  5712.         ret = dict_get_uint32 (local->dict, "cmd", &cmd);
    5713. 

  5713.         if (ret)
    5714. 

  5714.                 goto out;
    5715. 

  5715. 

  5716. 

  5717.         ret = gf_cli_status_volume (frame, this, data);
    5718. 

  5718.         if (ret)
    5719. 

  5719.                 goto out;
    5720. 

  5720. 

  5721.         ret = dict_get_ptr (local->dict, "rsp-dict", &vol_dict);
    5722. 

  5722.         if (ret)
    5723. 

  5723.                 goto out;
    5724. 

  5724. 

  5725.         ret = dict_get_int32 ((dict_t *)vol_dict, "vol_count", &vol_count);
    5726. 

  5726.         if (ret) {
    5727. 

  5727.                 cli_err ("Failed to get names of volumes");
    5728. 

  5728.                 goto out;
    5729. 

  5729.         }
    5730. 

  5730. 

  5731.         if (vol_count == 0) {
    5732. 

  5732.                 cli_err ("No volumes present");
    5733. 

  5733.                 ret = 0;
    5734. 

  5734.                 goto out;
    5735. 

  5735.         }
    5736. 

  5736. 

  5737.         /* remove the "all" flag in cmd */
    5738. 

  5738.         cmd &= ~GF_CLI_STATUS_ALL;
    5739. 

  5739.         cmd |= GF_CLI_STATUS_VOL;
    5740. 

  5740. 

  5741.         if (global_state->mode & GLUSTER_MODE_XML) {
    5742. 

  5742.                 //TODO: Pass proper op_* values
    5743. 

  5743.                 ret = cli_xml_output_vol_status_begin (local, 0,0, NULL);
    5744. 

  5744.                 if (ret) {
    5745. 

  5745.                         gf_log ("cli", GF_LOG_ERROR,
    5746. 

  5746.                                 "Error outputting to xml");
    5747. 

  5747.                         goto out;
    5748. 

  5748.                 }
    5749. 

  5749.         }
    5750. 

  5750. 

  5751.         for (i = 0; i < vol_count; i++) {
    5752. 

  5752. 

  5753.                 dict = dict_new ();
    5754. 

  5754.                 if (!dict)
    5755. 

  5755.                         goto out;
    5756. 

  5756. 

  5757.                 memset (key, 0, sizeof (key));
    5758. 

  5758.                 snprintf (key, sizeof (key), "vol%d", i);
    5759. 

  5759.                 ret = dict_get_str (vol_dict, key, &volname);
    5760. 

  5760.                 if (ret)
    5761. 

  5761.                         goto out;
    5762. 

  5762. 

  5763.                 ret = dict_set_str (dict, "volname", volname);
    5764. 

  5764.                 if (ret)
    5765. 

  5765.                         goto out;
    5766. 

  5766. 

  5767.                 ret = dict_set_uint32 (dict, "cmd", cmd);
    5768. 

  5768.                 if (ret)
    5769. 

  5769.                         goto out;
    5770. 

  5770. 

  5771.                 ret = gf_cli_status_volume (frame, this, dict);
    5772. 

  5772.                 if (ret)
    5773. 

  5773.                         goto out;
    5774. 

  5774. 

  5775.                 dict_unref (dict);
    5776. 

  5776.         }
    5777. 

  5777. 

  5778.         if (global_state->mode & GLUSTER_MODE_XML) {
    5779. 

  5779.                 ret = cli_xml_output_vol_status_end (local);
    5780. 

  5780.         }
    5781. 

  5781. 

  5782.  out:
    5783. 

  5783.         if (ret)
    5784. 

  5784.                 gf_log ("cli", GF_LOG_ERROR, "status all failed");
    5785. 

  5785. 

  5786.         if (vol_dict)
    5787. 

  5787.                 dict_unref (vol_dict);
    5788. 

  5788. 

  5789.         if (ret && dict)
    5790. 

  5790.                 dict_unref (dict);
    5791. 

  5791. 

  5792.         if (local)
    5793. 

  5793.                 cli_local_wipe (local);
    5794. 

  5794. 

  5795.         if (frame)
    5796. 

  5796.                 frame->local = NULL;
    5797. 

  5797. 

  5798.         return ret;
    5799. 

  5799. }
    5800. 

  5800. 

  5801. static int
    5802. 

  5802. gf_cli_mount_cbk (struct rpc_req *req, struct iovec *iov,
    5803. 

  5803.                   int count, void *myframe)
    5804. 

  5804. {
    5805. 

  5805.         gf1_cli_mount_rsp rsp   = {0,};
    5806. 

  5806.         int               ret   = -1;
    5807. 

  5807. 

  5808.         if (-1 == req->rpc_status) {
    5809. 

  5809.                 goto out;
    5810. 

  5810.         }
    5811. 

  5811. 

  5812.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_mount_rsp);
    5813. 

  5813.         if (ret < 0) {
    5814. 

  5814.                 gf_log ("", GF_LOG_ERROR, "error");
    5815. 

  5815.                 goto out;
    5816. 

  5816.         }
    5817. 

  5817. 

  5818.         gf_log ("cli", GF_LOG_INFO, "Received resp to mount");
    5819. 

  5819. 

  5820.         if (rsp.op_ret == 0) {
    5821. 

  5821.                 ret = 0;
    5822. 

  5822.                 cli_out ("%s", rsp.path);
    5823. 

  5823.         } else {
    5824. 

  5824.                 /* weird sounding but easy to parse... */
    5825. 

  5825.                 cli_err ("%d : failed with this errno (%s)",
    5826. 

  5826.                          rsp.op_errno, strerror (rsp.op_errno));
    5827. 

  5827.                 ret = -1;
    5828. 

  5828.         }
    5829. 

  5829. 

  5830. out:
    5831. 

  5831.         cli_cmd_broadcast_response (ret);
    5832. 

  5832.         return ret;
    5833. 

  5833. }
    5834. 

  5834. 

  5835. int32_t
    5836. 

  5836. gf_cli_mount (call_frame_t *frame, xlator_t *this, void *data)
    5837. 

  5837. {
    5838. 

  5838.         gf1_cli_mount_req  req  = {0,};
    5839. 

  5839.         int                ret  = -1;
    5840. 

  5840.         void            **dataa = data;
    5841. 

  5841.         char             *label = NULL;
    5842. 

  5842.         dict_t            *dict = NULL;
    5843. 

  5843. 

  5844.         if (!frame || !this || !data)
    5845. 

  5845.                 goto out;
    5846. 

  5846. 

  5847.         label = dataa[0];
    5848. 

  5848.         dict  = dataa[1];
    5849. 

  5849. 

  5850.         req.label = label;
    5851. 

  5851.         ret = dict_allocate_and_serialize (dict, &req.dict.dict_val,
    5852. 

  5852.                                            &req.dict.dict_len);
    5853. 

  5853.         if (ret) {
    5854. 

  5854.                 ret = -1;
    5855. 

  5855.                 goto out;
    5856. 

  5856.         }
    5857. 

  5857. 

  5858.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    5859. 

  5859.                               GLUSTER_CLI_MOUNT, NULL,
    5860. 

  5860.                               this, gf_cli_mount_cbk,
    5861. 

  5861.                               (xdrproc_t)xdr_gf1_cli_mount_req);
    5862. 

  5862. 

  5863. out:
    5864. 

  5864.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    5865. 

  5865.         return ret;
    5866. 

  5866. }
    5867. 

  5867. 

  5868. static int
    5869. 

  5869. gf_cli_umount_cbk (struct rpc_req *req, struct iovec *iov,
    5870. 

  5870.                    int count, void *myframe)
    5871. 

  5871. {
    5872. 

  5872.         gf1_cli_umount_rsp rsp   = {0,};
    5873. 

  5873.         int               ret   = -1;
    5874. 

  5874. 

  5875.         if (-1 == req->rpc_status) {
    5876. 

  5876.                 goto out;
    5877. 

  5877.         }
    5878. 

  5878. 

  5879.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf1_cli_umount_rsp);
    5880. 

  5880.         if (ret < 0) {
    5881. 

  5881.                 gf_log ("", GF_LOG_ERROR, "error");
    5882. 

  5882.                 goto out;
    5883. 

  5883.         }
    5884. 

  5884. 

  5885.         gf_log ("cli", GF_LOG_INFO, "Received resp to mount");
    5886. 

  5886. 

  5887.         if (rsp.op_ret == 0)
    5888. 

  5888.                 ret = 0;
    5889. 

  5889.         else {
    5890. 

  5890.                 cli_err ("umount failed");
    5891. 

  5891.                 ret = -1;
    5892. 

  5892.         }
    5893. 

  5893. 

  5894. out:
    5895. 

  5895.         cli_cmd_broadcast_response (ret);
    5896. 

  5896.         return ret;
    5897. 

  5897. }
    5898. 

  5898. 

  5899. int32_t
    5900. 

  5900. gf_cli_umount (call_frame_t *frame, xlator_t *this, void *data)
    5901. 

  5901. {
    5902. 

  5902.         gf1_cli_umount_req  req  = {0,};
    5903. 

  5903.         int                ret  = -1;
    5904. 

  5904.         dict_t            *dict = NULL;
    5905. 

  5905. 

  5906.         if (!frame || !this || !data)
    5907. 

  5907.                 goto out;
    5908. 

  5908. 

  5909.         dict = data;
    5910. 

  5910. 

  5911.         ret = dict_get_str (dict, "path", &req.path);
    5912. 

  5912.         if (ret == 0)
    5913. 

  5913.                 ret = dict_get_int32 (dict, "lazy", &req.lazy);
    5914. 

  5914. 

  5915.         if (ret) {
    5916. 

  5916.                 ret = -1;
    5917. 

  5917.                 goto out;
    5918. 

  5918.         }
    5919. 

  5919. 

  5920.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    5921. 

  5921.                               GLUSTER_CLI_UMOUNT, NULL,
    5922. 

  5922.                               this, gf_cli_umount_cbk,
    5923. 

  5923.                               (xdrproc_t)xdr_gf1_cli_umount_req);
    5924. 

  5924. 

  5925.  out:
    5926. 

  5926.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    5927. 

  5927.         return ret;
    5928. 

  5928. }
    5929. 

  5929. 

  5930. void
    5931. 

  5931. cmd_heal_volume_brick_out (dict_t *dict, int brick)
    5932. 

  5932. {
    5933. 

  5933.         uint64_t        num_entries = 0;
    5934. 

  5934.         int             ret = 0;
    5935. 

  5935.         char            key[256] = {0};
    5936. 

  5936.         char           *hostname = NULL;
    5937. 

  5937.         char           *path = NULL;
    5938. 

  5938.         char           *status = NULL;
    5939. 

  5939.         uint64_t        i = 0;
    5940. 

  5940.         uint32_t        time = 0;
    5941. 

  5941.         char            timestr[32] = {0};
    5942. 

  5942. 

  5943.         snprintf (key, sizeof key, "%d-hostname", brick);
    5944. 

  5944.         ret = dict_get_str (dict, key, &hostname);
    5945. 

  5945.         if (ret)
    5946. 

  5946.                 goto out;
    5947. 

  5947.         snprintf (key, sizeof key, "%d-path", brick);
    5948. 

  5948.         ret = dict_get_str (dict, key, &path);
    5949. 

  5949.         if (ret)
    5950. 

  5950.                 goto out;
    5951. 

  5951.         cli_out ("\nBrick %s:%s", hostname, path);
    5952. 

  5952.         snprintf (key, sizeof key, "%d-count", brick);
    5953. 

  5953.         ret = dict_get_uint64 (dict, key, &num_entries);
    5954. 

  5954.         cli_out ("Number of entries: %"PRIu64, num_entries);
    5955. 

  5955.         snprintf (key, sizeof key, "%d-status", brick);
    5956. 

  5956.         ret = dict_get_str (dict, key, &status);
    5957. 

  5957.         if (status && strlen (status))
    5958. 

  5958.                 cli_out ("Status: %s", status);
    5959. 

  5959.         for (i = 0; i < num_entries; i++) {
    5960. 

  5960.                 snprintf (key, sizeof key, "%d-%"PRIu64, brick, i);
    5961. 

  5961.                 ret = dict_get_str (dict, key, &path);
    5962. 

  5962.                 if (ret)
    5963. 

  5963.                         continue;
    5964. 

  5964.                 time = 0;
    5965. 

  5965.                 snprintf (key, sizeof key, "%d-%"PRIu64"-time", brick, i);
    5966. 

  5966.                 ret = dict_get_uint32 (dict, key, &time);
    5967. 

  5967.                 if (!time) {
    5968. 

  5968.                         cli_out ("%s", path);
    5969. 

  5969.                 } else {
    5970. 

  5970.                         gf_time_fmt (timestr, sizeof timestr,
    5971. 

  5971.                                      time, gf_timefmt_FT);
    5972. 

  5972.                         if (i == 0) {
    5973. 

  5973.                                 cli_out ("at                    path on brick");
    5974. 

  5974.                                 cli_out ("-----------------------------------");
    5975. 

  5975.                         }
    5976. 

  5976.                         cli_out ("%s %s", timestr, path);
    5977. 

  5977.                 }
    5978. 

  5978.         }
    5979. 

  5979. out:
    5980. 

  5980.         return;
    5981. 

  5981. }
    5982. 

  5982. 

  5983. int
    5984. 

  5984. gf_cli_heal_volume_cbk (struct rpc_req *req, struct iovec *iov,
    5985. 

  5985.                              int count, void *myframe)
    5986. 

  5986. {
    5987. 

  5987.         gf_cli_rsp              rsp   = {0,};
    5988. 

  5988.         int                     ret   = -1;
    5989. 

  5989.         cli_local_t             *local = NULL;
    5990. 

  5990.         char                    *volname = NULL;
    5991. 

  5991.         call_frame_t            *frame = NULL;
    5992. 

  5992.         dict_t                  *input_dict = NULL;
    5993. 

  5993.         dict_t                  *dict = NULL;
    5994. 

  5994.         int                     brick_count = 0;
    5995. 

  5995.         int                     i = 0;
    5996. 

  5996.         gf_xl_afr_op_t          heal_op = GF_AFR_OP_INVALID;
    5997. 

  5997.         char                    *operation = NULL;
    5998. 

  5998.         char                    *substr = NULL;
    5999. 

  5999. 

  6000.         if (-1 == req->rpc_status) {
    6001. 

  6001.                 goto out;
    6002. 

  6002.         }
    6003. 

  6003. 

  6004.         ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);
    6005. 

  6005.         if (ret < 0) {
    6006. 

  6006.                 gf_log ("", GF_LOG_ERROR, "error");
    6007. 

  6007.                 goto out;
    6008. 

  6008.         }
    6009. 

  6009. 

  6010.         frame = myframe;
    6011. 

  6011. 

  6012.         if (frame)
    6013. 

  6013.                 local = frame->local;
    6014. 

  6014. 

  6015.         if (local) {
    6016. 

  6016.                 input_dict = local->dict;
    6017. 

  6017.                 ret = dict_get_int32 (input_dict, "heal-op",
    6018. 

  6018.                                       (int32_t*)&heal_op);
    6019. 

  6019.         }
    6020. 

  6020. //TODO: Proper XML output
    6021. 

  6021. //#if (HAVE_LIB_XML)
    6022. 

  6022. //        if (global_state->mode & GLUSTER_MODE_XML) {
    6023. 

  6023. //                ret = cli_xml_output_dict ("volHeal", dict, rsp.op_ret,
    6024. 

  6024. //                                           rsp.op_errno, rsp.op_errstr);
    6025. 

  6025. //                if (ret)
    6026. 

  6026. //                        gf_log ("cli", GF_LOG_ERROR,
    6027. 

  6027. //                                "Error outputting to xml");
    6028. 

  6028. //                goto out;
    6029. 

  6029. //        }
    6030. 

  6030. //#endif
    6031. 

  6031. 

  6032.         ret = dict_get_str (input_dict, "volname", &volname);
    6033. 

  6033.         if (ret) {
    6034. 

  6034.                 gf_log (THIS->name, GF_LOG_ERROR, "failed to get volname");
    6035. 

  6035.                 goto out;
    6036. 

  6036.         }
    6037. 

  6037. 

  6038.         gf_log ("cli", GF_LOG_INFO, "Received resp to heal volume");
    6039. 

  6039. 

  6040.         if ((heal_op == GF_AFR_OP_HEAL_FULL) ||
    6041. 

  6041.             (heal_op == GF_AFR_OP_HEAL_INDEX)) {
    6042. 

  6042.                 operation = "Launching Heal operation";
    6043. 

  6043.                 substr = "\nUse heal info commands to check status";
    6044. 

  6044.         } else {
    6045. 

  6045.                 operation = "Gathering Heal info";
    6046. 

  6046.                 substr = "";
    6047. 

  6047.         }
    6048. 

  6048. 

  6049.         if (rsp.op_ret) {
    6050. 

  6050.                 if (strcmp (rsp.op_errstr, "")) {
    6051. 

  6051.                         cli_err ("%s", rsp.op_errstr);
    6052. 

  6052.                 } else {
    6053. 

  6053.                         cli_err ("%s on volume %s has been unsuccessful",
    6054. 

  6054.                                  operation, volname);
    6055. 

  6055.                 }
    6056. 

  6056. 

  6057.                 ret = rsp.op_ret;
    6058. 

  6058.                 goto out;
    6059. 

  6059.         } else {
    6060. 

  6060.                 cli_out ("%s on volume %s has been successful%s", operation,
    6061. 

  6061.                          volname, substr);
    6062. 

  6062.         }
    6063. 

  6063. 

  6064.         ret = rsp.op_ret;
    6065. 

  6065.         if ((heal_op == GF_AFR_OP_HEAL_FULL) ||
    6066. 

  6066.             (heal_op == GF_AFR_OP_HEAL_INDEX))
    6067. 

  6067.                 goto out;
    6068. 

  6068. 

  6069.         dict = dict_new ();
    6070. 

  6070.         if (!dict) {
    6071. 

  6071.                 ret = -1;
    6072. 

  6072.                 goto out;
    6073. 

  6073.         }
    6074. 

  6074. 

  6075.         ret = dict_unserialize (rsp.dict.dict_val,
    6076. 

  6076.                                 rsp.dict.dict_len,
    6077. 

  6077.                                 &dict);
    6078. 

  6078. 

  6079.         if (ret) {
    6080. 

  6080.                 gf_log ("", GF_LOG_ERROR,
    6081. 

  6081.                                 "Unable to allocate memory");
    6082. 

  6082.                 goto out;
    6083. 

  6083.         } else {
    6084. 

  6084.                 dict->extra_stdfree = rsp.dict.dict_val;
    6085. 

  6085.         }
    6086. 

  6086.         ret = dict_get_int32 (dict, "count", &brick_count);
    6087. 

  6087.         if (ret)
    6088. 

  6088.                 goto out;
    6089. 

  6089. 

  6090.         if (!brick_count) {
    6091. 

  6091.                 cli_err ("All bricks of volume %s are down.", volname);
    6092. 

  6092.                 goto out;
    6093. 

  6093.         }
    6094. 

  6094. 

  6095.         for (i = 0; i < brick_count; i++)
    6096. 

  6096.                 cmd_heal_volume_brick_out (dict, i);
    6097. 

  6097.         ret = rsp.op_ret;
    6098. 

  6098. 

  6099. out:
    6100. 

  6100.         cli_cmd_broadcast_response (ret);
    6101. 

  6101.         free (rsp.op_errstr);
    6102. 

  6102.         if (dict)
    6103. 

  6103.                 dict_unref (dict);
    6104. 

  6104.         return ret;
    6105. 

  6105. }
    6106. 

  6106. 

  6107. int32_t
    6108. 

  6108. gf_cli_heal_volume (call_frame_t *frame, xlator_t *this,
    6109. 

  6109.                          void *data)
    6110. 

  6110. {
    6111. 

  6111.         gf_cli_req              req = {{0,}};
    6112. 

  6112.         int                     ret = 0;
    6113. 

  6113.         dict_t                  *dict = NULL;
    6114. 

  6114. 

  6115.         if (!frame || !this ||  !data) {
    6116. 

  6116.                 ret = -1;
    6117. 

  6117.                 goto out;
    6118. 

  6118.         }
    6119. 

  6119. 

  6120.         dict = data;
    6121. 

  6121. 

  6122.         ret = cli_to_glusterd (&req, frame, gf_cli_heal_volume_cbk,
    6123. 

  6123.                                (xdrproc_t) xdr_gf_cli_req, dict,
    6124. 

  6124.                                GLUSTER_CLI_HEAL_VOLUME, this, cli_rpc_prog,
    6125. 

  6125.                                NULL);
    6126. 

  6126. 

  6127. out:
    6128. 

  6128.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    6129. 

  6129. 

  6130.         GF_FREE (req.dict.dict_val);
    6131. 

  6131. 

  6132.         return ret;
    6133. 

  6133. }
    6134. 

  6134. 

  6135. int32_t
    6136. 

  6136. gf_cli_statedump_volume_cbk (struct rpc_req *req, struct iovec *iov,
    6137. 

  6137.                                 int count, void *myframe)
    6138. 

  6138. {
    6139. 

  6139.         gf_cli_rsp                      rsp = {0,};
    6140. 

  6140.         int                             ret = -1;
    6141. 

  6141.         char                            msg[1024] = {0,};
    6142. 

  6142. 

  6143.         if (-1 == req->rpc_status)
    6144. 

  6144.                 goto out;
    6145. 

  6145.         ret = xdr_to_generic (*iov, &rsp,
    6146. 

  6146.                               (xdrproc_t)xdr_gf_cli_rsp);
    6147. 

  6147.         if (ret < 0) {
    6148. 

  6148.                 gf_log (THIS->name, GF_LOG_ERROR, "XDR decoding failed");
    6149. 

  6149.                 goto out;
    6150. 

  6150.         }
    6151. 

  6151.         gf_log ("cli", GF_LOG_DEBUG, "Received response to statedump");
    6152. 

  6152.         if (rsp.op_ret)
    6153. 

  6153.                 snprintf (msg, sizeof(msg), "%s", rsp.op_errstr);
    6154. 

  6154.         else
    6155. 

  6155.                 snprintf (msg, sizeof (msg), "Volume statedump successful");
    6156. 

  6156. 

  6157.         if (global_state->mode & GLUSTER_MODE_XML) {
    6158. 

  6158.                 ret = cli_xml_output_str ("volStatedump", msg, rsp.op_ret,
    6159. 

  6159.                                           rsp.op_errno, rsp.op_errstr);
    6160. 

  6160.                 if (ret)
    6161. 

  6161.                         gf_log ("cli", GF_LOG_ERROR,
    6162. 

  6162.                                 "Error outputting to xml");
    6163. 

  6163.                 goto out;
    6164. 

  6164.         }
    6165. 

  6165. 

  6166.         if (rsp.op_ret)
    6167. 

  6167.                 cli_err ("volume statedump: failed: %s", msg);
    6168. 

  6168.         else
    6169. 

  6169.                 cli_out ("volume statedump: success");
    6170. 

  6170.         ret = rsp.op_ret;
    6171. 

  6171. 

  6172. out:
    6173. 

  6173.         cli_cmd_broadcast_response (ret);
    6174. 

  6174.         return ret;
    6175. 

  6175. }
    6176. 

  6176. 

  6177. int32_t
    6178. 

  6178. gf_cli_statedump_volume (call_frame_t *frame, xlator_t *this,
    6179. 

  6179.                             void *data)
    6180. 

  6180. {
    6181. 

  6181.         gf_cli_req                      req = {{0,}};
    6182. 

  6182.         dict_t                          *options = NULL;
    6183. 

  6183.         int                             ret = -1;
    6184. 

  6184. 

  6185.         if (!frame || !this || !data)
    6186. 

  6186.                 goto out;
    6187. 

  6187. 

  6188.         options = data;
    6189. 

  6189. 

  6190.         ret = cli_to_glusterd (&req, frame, gf_cli_statedump_volume_cbk,
    6191. 

  6191.                                (xdrproc_t) xdr_gf_cli_req, options,
    6192. 

  6192.                                GLUSTER_CLI_STATEDUMP_VOLUME, this, cli_rpc_prog,
    6193. 

  6193.                                NULL);
    6194. 

  6194. 

  6195. out:
    6196. 

  6196.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    6197. 

  6197. 

  6198.         GF_FREE (req.dict.dict_val);
    6199. 

  6199.         return ret;
    6200. 

  6200. }
    6201. 

  6201. 

  6202. int32_t
    6203. 

  6203. gf_cli_list_volume_cbk (struct rpc_req *req, struct iovec *iov,
    6204. 

  6204.                                 int count, void *myframe)
    6205. 

  6205. {
    6206. 

  6206.         int             ret = -1;
    6207. 

  6207.         gf_cli_rsp      rsp = {0,};
    6208. 

  6208.         dict_t          *dict = NULL;
    6209. 

  6209.         int             vol_count = 0;;
    6210. 

  6210.         char            *volname = NULL;
    6211. 

  6211.         char            key[1024] = {0,};
    6212. 

  6212.         int             i = 0;
    6213. 

  6213. 

  6214.         if (-1 == req->rpc_status)
    6215. 

  6215.                 goto out;
    6216. 

  6216.         ret = xdr_to_generic (*iov, &rsp,
    6217. 

  6217.                               (xdrproc_t)xdr_gf_cli_rsp);
    6218. 

  6218.         if (ret < 0) {
    6219. 

  6219.                 gf_log (THIS->name, GF_LOG_ERROR, "XDR decoding failed");
    6220. 

  6220.                 goto out;
    6221. 

  6221.         }
    6222. 

  6222. 

  6223.         dict = dict_new ();
    6224. 

  6224.         if (!dict) {
    6225. 

  6225.                 ret = -1;
    6226. 

  6226.                 goto out;
    6227. 

  6227.         }
    6228. 

  6228. 

  6229.         ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);
    6230. 

  6230.         if (ret) {
    6231. 

  6231.                 gf_log ("cli", GF_LOG_ERROR, "Unable to allocate memory");
    6232. 

  6232.                 goto out;
    6233. 

  6233.         }
    6234. 

  6234. 

  6235.         if (global_state->mode & GLUSTER_MODE_XML) {
    6236. 

  6236.                 ret = cli_xml_output_vol_list (dict, rsp.op_ret, rsp.op_errno,
    6237. 

  6237.                                                rsp.op_errstr);
    6238. 

  6238.                 if (ret)
    6239. 

  6239.                         gf_log ("cli", GF_LOG_ERROR,
    6240. 

  6240.                                 "Error outputting to xml");
    6241. 

  6241.                 goto out;
    6242. 

  6242.         }
    6243. 

  6243. 

  6244.         if (rsp.op_ret)
    6245. 

  6245.                 cli_err ("%s", rsp.op_errstr);
    6246. 

  6246.         else {
    6247. 

  6247.                 ret = dict_get_int32 (dict, "count", &vol_count);
    6248. 

  6248.                 if (ret)
    6249. 

  6249.                         goto out;
    6250. 

  6250. 

  6251.                 if (vol_count == 0) {
    6252. 

  6252.                         cli_err ("No volumes present in cluster");
    6253. 

  6253.                         goto out;
    6254. 

  6254.                 }
    6255. 

  6255.                 for (i = 0; i < vol_count; i++) {
    6256. 

  6256.                         memset (key, 0, sizeof (key));
    6257. 

  6257.                         snprintf (key, sizeof (key), "volume%d", i);
    6258. 

  6258.                         ret = dict_get_str (dict, key, &volname);
    6259. 

  6259.                         if (ret)
    6260. 

  6260.                                 goto out;
    6261. 

  6261.                         cli_out ("%s", volname);
    6262. 

  6262.                 }
    6263. 

  6263.         }
    6264. 

  6264. 

  6265.         ret = rsp.op_ret;
    6266. 

  6266. 

  6267. out:
    6268. 

  6268.         cli_cmd_broadcast_response (ret);
    6269. 

  6269.         return ret;
    6270. 

  6270. }
    6271. 

  6271. 

  6272. int32_t
    6273. 

  6273. gf_cli_list_volume (call_frame_t *frame, xlator_t *this, void *data)
    6274. 

  6274. {
    6275. 

  6275.         int             ret = -1;
    6276. 

  6276.         gf_cli_req      req = {{0,}};
    6277. 

  6277. 

  6278.         if (!frame || !this)
    6279. 

  6279.                 goto out;
    6280. 

  6280. 

  6281.         ret = cli_cmd_submit (&req, frame, cli_rpc_prog,
    6282. 

  6282.                               GLUSTER_CLI_LIST_VOLUME, NULL,
    6283. 

  6283.                               this, gf_cli_list_volume_cbk,
    6284. 

  6284.                               (xdrproc_t)xdr_gf_cli_req);
    6285. 

  6285. 

  6286. out:
    6287. 

  6287.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    6288. 

  6288.         return ret;
    6289. 

  6289. }
    6290. 

  6290. 

  6291. int32_t
    6292. 

  6292. gf_cli_clearlocks_volume_cbk (struct rpc_req *req, struct iovec *iov,
    6293. 

  6293.                                   int count, void *myframe)
    6294. 

  6294. {
    6295. 

  6295.         gf_cli_rsp                      rsp = {0,};
    6296. 

  6296.         int                             ret = -1;
    6297. 

  6297.         char                            *lk_summary = NULL;
    6298. 

  6298.         char                            *volname = NULL;
    6299. 

  6299.         dict_t                          *dict = NULL;
    6300. 

  6300. 

  6301.         if (-1 == req->rpc_status)
    6302. 

  6302.                 goto out;
    6303. 

  6303.         ret = xdr_to_generic (*iov, &rsp,
    6304. 

  6304.                               (xdrproc_t)xdr_gf_cli_rsp);
    6305. 

  6305.         if (ret < 0) {
    6306. 

  6306. 

  6307.                 gf_log ("cli", GF_LOG_ERROR, "XDR decoding failed");
    6308. 

  6308.                 goto out;
    6309. 

  6309.         }
    6310. 

  6310.         gf_log ("cli", GF_LOG_DEBUG, "Received response to clear-locks");
    6311. 

  6311. 

  6312.         if (rsp.op_ret) {
    6313. 

  6313.                 cli_err ("Volume clear-locks unsuccessful");
    6314. 

  6314.                 cli_err ("%s", rsp.op_errstr);
    6315. 

  6315. 

  6316.         } else {
    6317. 

  6317.                 if (!rsp.dict.dict_len) {
    6318. 

  6318.                         cli_err ("Possibly no locks cleared");
    6319. 

  6319.                         ret = 0;
    6320. 

  6320.                         goto out;
    6321. 

  6321.                 }
    6322. 

  6322. 

  6323.                 dict = dict_new ();
    6324. 

  6324. 

  6325.                 if (!dict) {
    6326. 

  6326.                         ret = -1;
    6327. 

  6327.                         goto out;
    6328. 

  6328.                 }
    6329. 

  6329. 

  6330.                 ret = dict_unserialize (rsp.dict.dict_val,
    6331. 

  6331.                                         rsp.dict.dict_len,
    6332. 

  6332.                                         &dict);
    6333. 

  6333. 

  6334.                 if (ret) {
    6335. 

  6335.                         gf_log ("cli", GF_LOG_ERROR,
    6336. 

  6336.                                 "Unable to serialize response dictionary");
    6337. 

  6337.                         goto out;
    6338. 

  6338.                 }
    6339. 

  6339. 

  6340.                 ret = dict_get_str (dict, "volname", &volname);
    6341. 

  6341.                 if (ret) {
    6342. 

  6342.                         gf_log ("cli", GF_LOG_ERROR, "Unable to get volname "
    6343. 

  6343.                                 "from dictionary");
    6344. 

  6344.                         goto out;
    6345. 

  6345.                 }
    6346. 

  6346. 

  6347.                 ret = dict_get_str (dict, "lk-summary", &lk_summary);
    6348. 

  6348.                 if (ret) {
    6349. 

  6349.                         gf_log ("cli", GF_LOG_ERROR, "Unable to get lock "
    6350. 

  6350.                                 "summary from dictionary");
    6351. 

  6351.                         goto out;
    6352. 

  6352.                 }
    6353. 

  6353.                 cli_out ("Volume clear-locks successful");
    6354. 

  6354.                 cli_out ("%s", lk_summary);
    6355. 

  6355. 

  6356.         }
    6357. 

  6357. 

  6358.         ret = rsp.op_ret;
    6359. 

  6359. 

  6360. out:
    6361. 

  6361.         if (dict)
    6362. 

  6362.                 dict_unref (dict);
    6363. 

  6363.         cli_cmd_broadcast_response (ret);
    6364. 

  6364.         return ret;
    6365. 

  6365. }
    6366. 

  6366. 

  6367. int32_t
    6368. 

  6368. gf_cli_clearlocks_volume (call_frame_t *frame, xlator_t *this,
    6369. 

  6369.                              void *data)
    6370. 

  6370. {
    6371. 

  6371.         gf_cli_req                      req = {{0,}};
    6372. 

  6372.         dict_t                          *options = NULL;
    6373. 

  6373.         int                             ret = -1;
    6374. 

  6374. 

  6375.         if (!frame || !this || !data)
    6376. 

  6376.                 goto out;
    6377. 

  6377. 

  6378.         options = data;
    6379. 

  6379. 

  6380.         ret = cli_to_glusterd (&req, frame, gf_cli_clearlocks_volume_cbk,
    6381. 

  6381.                                (xdrproc_t) xdr_gf_cli_req, options,
    6382. 

  6382.                                GLUSTER_CLI_CLRLOCKS_VOLUME, this, cli_rpc_prog,
    6383. 

  6383.                                NULL);
    6384. 

  6384. out:
    6385. 

  6385.         gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);
    6386. 

  6386. 

  6387.         GF_FREE (req.dict.dict_val);
    6388. 

  6388.         return ret;
    6389. 

  6389. }
    6390. 

  6390. 

  6391. int
    6392. 

  6392. cli_to_glusterd (gf_cli_req *req, call_frame_t *frame,
    6393. 

  6393.                  fop_cbk_fn_t cbkfn, xdrproc_t xdrproc, dict_t *dict,
    6394. 

  6394.                  int procnum, xlator_t *this, rpc_clnt_prog_t *prog,
    6395. 

  6395.                  struct iobref *iobref)
    6396. 

  6396. {
    6397. 

  6397.         int                ret = 0;
    6398. 

  6398.         size_t             len = 0;
    6399. 

  6399.         char               *cmd = NULL;
    6400. 

  6400.         int                i = 0;
    6401. 

  6401.         const char         **words = NULL;
    6402. 

  6402.         cli_local_t        *local = NULL;
    6403. 

  6403. 

  6404.         if (!this || !frame || !dict) {
    6405. 

  6405.                 ret = -1;
    6406. 

  6406.                 goto out;
    6407. 

  6407.         }
    6408. 

  6408. 

  6409.         if (!frame->local) {
    6410. 

  6410.                 ret = -1;
    6411. 

  6411.                 goto out;
    6412. 

  6412.         }
    6413. 

  6413. 

  6414.         local = frame->local;
    6415. 

  6415. 

  6416.         if (!local->words) {
    6417. 

  6417.                 ret = -1;
    6418. 

  6418.                 goto out;
    6419. 

  6419.         }
    6420. 

  6420. 

  6421.         words = local->words;
    6422. 

  6422. 

  6423.         while (words[i])
    6424. 

  6424.                 len += strlen (words[i++]) + 1;
    6425. 

  6425. 

  6426.         cmd = GF_CALLOC (1, len, gf_common_mt_char);
    6427. 

  6427. 

  6428.         if (!cmd) {
    6429. 

  6429.                 ret = -1;
    6430. 

  6430.                 goto out;
    6431. 

  6431.         }
    6432. 

  6432. 

  6433.         for (i = 0; words[i]; i++) {
    6434. 

  6434.                 strncat (cmd, words[i], strlen (words[i]));
    6435. 

  6435.                 if (words[i+1] != NULL)
    6436. 

  6436.                         strncat (cmd, " ", strlen (" "));
    6437. 

  6437.         }
    6438. 

  6438. 

  6439.         cmd [len - 1] = '\0';
    6440. 

  6440. 

  6441.         ret = dict_set_dynstr (dict, "cmd-str", cmd);
    6442. 

  6442.         if (ret)
    6443. 

  6443.                 goto out;
    6444. 

  6444. 

  6445.         ret = dict_allocate_and_serialize (dict, &(req->dict).dict_val,
    6446. 

  6446.                                            &(req->dict).dict_len);
    6447. 

  6447. 

  6448.         if (ret < 0) {
    6449. 

  6449.                 gf_log (this->name, GF_LOG_DEBUG,
    6450. 

  6450.                         "failed to get serialized length of dict");
    6451. 

  6451.                 goto out;
    6452. 

  6452.         }
    6453. 

  6453. 

  6454.         ret = cli_cmd_submit (req, frame, prog, procnum, iobref, this,
    6455. 

  6455.                               cbkfn, (xdrproc_t) xdrproc);
    6456. 

  6456. 

  6457. out:
    6458. 

  6458.         return ret;
    6459. 

  6459. 

  6460. }
    6461. 

  6461. 

  6462. struct rpc_clnt_procedure gluster_cli_actors[GLUSTER_CLI_MAXVALUE] = {
    6463. 

  6463.         [GLUSTER_CLI_NULL]             = {"NULL", NULL },
    6464. 

  6464.         [GLUSTER_CLI_PROBE]            = {"PROBE_QUERY", gf_cli_probe},
    6465. 

  6465.         [GLUSTER_CLI_DEPROBE]          = {"DEPROBE_QUERY", gf_cli_deprobe},
    6466. 

  6466.         [GLUSTER_CLI_LIST_FRIENDS]     = {"LIST_FRIENDS", gf_cli_list_friends},
    6467. 

  6467.         [GLUSTER_CLI_UUID_RESET]       = {"UUID_RESET", gf_cli3_1_uuid_reset},
    6468. 

  6468.         [GLUSTER_CLI_CREATE_VOLUME]    = {"CREATE_VOLUME", gf_cli_create_volume},
    6469. 

  6469.         [GLUSTER_CLI_DELETE_VOLUME]    = {"DELETE_VOLUME", gf_cli_delete_volume},
    6470. 

  6470.         [GLUSTER_CLI_START_VOLUME]     = {"START_VOLUME", gf_cli_start_volume},
    6471. 

  6471.         [GLUSTER_CLI_STOP_VOLUME]      = {"STOP_VOLUME", gf_cli_stop_volume},
    6472. 

  6472.         [GLUSTER_CLI_RENAME_VOLUME]    = {"RENAME_VOLUME", gf_cli_rename_volume},
    6473. 

  6473.         [GLUSTER_CLI_DEFRAG_VOLUME]    = {"DEFRAG_VOLUME", gf_cli_defrag_volume},
    6474. 

  6474.         [GLUSTER_CLI_GET_VOLUME]       = {"GET_VOLUME", gf_cli_get_volume},
    6475. 

  6475.         [GLUSTER_CLI_GET_NEXT_VOLUME]  = {"GET_NEXT_VOLUME", gf_cli_get_next_volume},
    6476. 

  6476.         [GLUSTER_CLI_SET_VOLUME]       = {"SET_VOLUME", gf_cli_set_volume},
    6477. 

  6477.         [GLUSTER_CLI_ADD_BRICK]        = {"ADD_BRICK", gf_cli_add_brick},
    6478. 

  6478.         [GLUSTER_CLI_REMOVE_BRICK]     = {"REMOVE_BRICK", gf_cli_remove_brick},
    6479. 

  6479.         [GLUSTER_CLI_REPLACE_BRICK]    = {"REPLACE_BRICK", gf_cli_replace_brick},
    6480. 

  6480.         [GLUSTER_CLI_LOG_ROTATE]       = {"LOG ROTATE", gf_cli_log_rotate},
    6481. 

  6481.         [GLUSTER_CLI_GETSPEC]          = {"GETSPEC", gf_cli_getspec},
    6482. 

  6482.         [GLUSTER_CLI_PMAP_PORTBYBRICK] = {"PMAP PORTBYBRICK", gf_cli_pmap_b2p},
    6483. 

  6483.         [GLUSTER_CLI_SYNC_VOLUME]      = {"SYNC_VOLUME", gf_cli_sync_volume},
    6484. 

  6484.         [GLUSTER_CLI_RESET_VOLUME]     = {"RESET_VOLUME", gf_cli_reset_volume},
    6485. 

  6485.         [GLUSTER_CLI_FSM_LOG]          = {"FSM_LOG", gf_cli_fsm_log},
    6486. 

  6486.         [GLUSTER_CLI_GSYNC_SET]        = {"GSYNC_SET", gf_cli_gsync_set},
    6487. 

  6487.         [GLUSTER_CLI_PROFILE_VOLUME]   = {"PROFILE_VOLUME", gf_cli_profile_volume},
    6488. 

  6488.         [GLUSTER_CLI_QUOTA]            = {"QUOTA", gf_cli_quota},
    6489. 

  6489.         [GLUSTER_CLI_TOP_VOLUME]       = {"TOP_VOLUME", gf_cli_top_volume},
    6490. 

  6490.         [GLUSTER_CLI_GETWD]            = {"GETWD", gf_cli_getwd},
    6491. 

  6491.         [GLUSTER_CLI_STATUS_VOLUME]    = {"STATUS_VOLUME", gf_cli_status_volume},
    6492. 

  6492.         [GLUSTER_CLI_STATUS_ALL]       = {"STATUS_ALL", gf_cli_status_volume_all},
    6493. 

  6493.         [GLUSTER_CLI_MOUNT]            = {"MOUNT", gf_cli_mount},
    6494. 

  6494.         [GLUSTER_CLI_UMOUNT]           = {"UMOUNT", gf_cli_umount},
    6495. 

  6495.         [GLUSTER_CLI_HEAL_VOLUME]      = {"HEAL_VOLUME", gf_cli_heal_volume},
    6496. 

  6496.         [GLUSTER_CLI_STATEDUMP_VOLUME] = {"STATEDUMP_VOLUME", gf_cli_statedump_volume},
    6497. 

  6497.         [GLUSTER_CLI_LIST_VOLUME]      = {"LIST_VOLUME", gf_cli_list_volume},
    6498. 

  6498.         [GLUSTER_CLI_CLRLOCKS_VOLUME]  = {"CLEARLOCKS_VOLUME", gf_cli_clearlocks_volume},
    6499. 

  6499. #ifdef HAVE_BD_XLATOR
    6500. 

  6500.         [GLUSTER_CLI_BD_OP]            = {"BD_OP", gf_cli_bd_op},
    6501. 

  6501. #endif
    6502. 

  6502. };
    6503. 

  6503. 

  6504. struct rpc_clnt_program cli_prog = {
    6505. 

  6505.         .progname  = "Gluster CLI",
    6506. 

  6506.         .prognum   = GLUSTER_CLI_PROGRAM,
    6507. 

  6507.         .progver   = GLUSTER_CLI_VERSION,
    6508. 

  6508.         .numproc   = GLUSTER_CLI_MAXVALUE,
    6509. 

  6509.         .proctable = gluster_cli_actors,
    6510. 

  6510. };
    6511. 

  6511.