Bug Summary

File:xlators/mgmt/glusterd/src/glusterd-volume-ops.c
Location:line 1729, column 17
Description:Access to field 'name' results in a dereference of a null pointer (loaded from variable 'this')

Annotated Source Code

1/*
2 Copyright (c) 2011-2012 Red Hat, Inc. <http://www.redhat.com>
3 This file is part of GlusterFS.
4
5 This file is licensed to you under your choice of the GNU Lesser
6 General Public License, version 3 or any later version (LGPLv3 or
7 later), or the GNU General Public License, version 2 (GPLv2), in all
8 cases as published by the Free Software Foundation.
9*/
10#ifndef _CONFIG_H
11#define _CONFIG_H
12#include "config.h"
13#endif
14
15#ifdef HAVE_BD_XLATOR
16#include <lvm2app.h>
17#endif
18
19#include "common-utils.h"
20#include "syscall.h"
21#include "cli1-xdr.h"
22#include "xdr-generic.h"
23#include "glusterd.h"
24#include "glusterd-op-sm.h"
25#include "glusterd-store.h"
26#include "glusterd-utils.h"
27#include "glusterd-volgen.h"
28#include "run.h"
29
30#define glusterd_op_start_volume_args_get(dict, volname, flags)glusterd_op_stop_volume_args_get (dict, volname, flags) \
31 glusterd_op_stop_volume_args_get (dict, volname, flags)
32
33int
34__glusterd_handle_create_volume (rpcsvc_request_t *req)
35{
36 int32_t ret = -1;
37 gf_cli_req cli_req = {{0,}};
38 dict_t *dict = NULL((void*)0);
39 char *bricks = NULL((void*)0);
40 char *volname = NULL((void*)0);
41 int brick_count = 0;
42 void *cli_rsp = NULL((void*)0);
43 char err_str[2048] = {0,};
44 gf_cli_rsp rsp = {0,};
45 xlator_t *this = NULL((void*)0);
46 char *free_ptr = NULL((void*)0);
47 char *trans_type = NULL((void*)0);
48 uuid_t volume_id = {0,};
49 uuid_t tmp_uuid = {0};
50 int32_t type = 0;
51 char *username = NULL((void*)0);
52 char *password = NULL((void*)0);
53
54 GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: "
"req"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 54, GF_LOG_ERROR, "Assertion failed: " "req")
; } while (0); } } while (0)
;
55
56 this = THIS(*__glusterfs_this_location());
57 GF_ASSERT(this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 57, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
58
59 ret = -1;
60 ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req);
61 if (ret < 0) {
62 req->rpc_err = GARBAGE_ARGS;
63 snprintf (err_str, sizeof (err_str), "Failed to decode request "
64 "received from cli");
65 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 65, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
66 goto out;
67 }
68
69 gf_log (this->name, GF_LOG_DEBUG, "Received create volume req")do { do { if (0) printf ("Received create volume req"); } while
(0); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 69, GF_LOG_DEBUG, "Received create volume req"); } while (0
)
;
70
71 if (cli_req.dict.dict_len) {
72 /* Unserialize the dictionary */
73 dict = dict_new ();
74
75 ret = dict_unserialize (cli_req.dict.dict_val,
76 cli_req.dict.dict_len,
77 &dict);
78 if (ret < 0) {
79 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 81, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
80 "failed to "do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 81, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
81 "unserialize req-buffer to dictionary")do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 81, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
;
82 snprintf (err_str, sizeof (err_str), "Unable to decode "
83 "the command");
84 goto out;
85 } else {
86 dict->extra_stdfree = cli_req.dict.dict_val;
87 }
88 }
89
90 ret = dict_get_str (dict, "volname", &volname);
91
92 if (ret) {
93 snprintf (err_str, sizeof (err_str), "Unable to get volume "
94 "name");
95 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 95, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
96 goto out;
97 }
98
99 if ((ret = glusterd_check_volume_exists (volname))) {
100 snprintf (err_str, sizeof (err_str), "Volume %s already exists",
101 volname);
102 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 102, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
103 goto out;
104 }
105
106 ret = dict_get_int32 (dict, "count", &brick_count);
107 if (ret) {
108 snprintf (err_str, sizeof (err_str), "Unable to get brick count"
109 " for volume %s", volname);
110 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 110, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
111 goto out;
112 }
113
114 ret = dict_get_int32 (dict, "type", &type);
115 if (ret) {
116 snprintf (err_str, sizeof (err_str), "Unable to get type of "
117 "volume %s", volname);
118 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 118, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
119 goto out;
120 }
121
122 ret = dict_get_str (dict, "transport", &trans_type);
123 if (ret) {
124 snprintf (err_str, sizeof (err_str), "Unable to get "
125 "transport-type of volume %s", volname);
126 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 126, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
127 goto out;
128 }
129 ret = dict_get_str (dict, "bricks", &bricks);
130 if (ret) {
131 snprintf (err_str, sizeof (err_str), "Unable to get bricks for "
132 "volume %s", volname);
133 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 133, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
134 goto out;
135 }
136
137 if (!dict_get (dict, "force")) {
138 gf_log (this->name, GF_LOG_ERROR, "Failed to get 'force' flag")do { do { if (0) printf ("Failed to get 'force' flag"); } while
(0); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 138, GF_LOG_ERROR, "Failed to get 'force' flag"); } while (
0)
;
139 goto out;
140 }
141
142 uuid_generate (volume_id);
143 free_ptr = gf_strdup (uuid_utoa (volume_id));
144 ret = dict_set_dynstr (dict, "volume-id", free_ptr);
145 if (ret) {
146 snprintf (err_str, sizeof (err_str), "Unable to set volume "
147 "id of volume %s", volname);
148 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 148, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
149 goto out;
150 }
151 free_ptr = NULL((void*)0);
152
153 /* generate internal username and password */
154
155 uuid_generate (tmp_uuid);
156 username = gf_strdup (uuid_utoa (tmp_uuid));
157 ret = dict_set_dynstr (dict, "internal-username", username);
158 if (ret) {
159 gf_log (this->name, GF_LOG_ERROR, "Failed to set username for "do { do { if (0) printf ("Failed to set username for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 160, GF_LOG_ERROR, "Failed to set username for "
"volume %s", volname); } while (0)
160 "volume %s", volname)do { do { if (0) printf ("Failed to set username for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 160, GF_LOG_ERROR, "Failed to set username for "
"volume %s", volname); } while (0)
;
161 goto out;
162 }
163
164 uuid_generate (tmp_uuid);
165 password = gf_strdup (uuid_utoa (tmp_uuid));
166 ret = dict_set_dynstr (dict, "internal-password", password);
167 if (ret) {
168 gf_log (this->name, GF_LOG_ERROR, "Failed to set password for "do { do { if (0) printf ("Failed to set password for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 169, GF_LOG_ERROR, "Failed to set password for "
"volume %s", volname); } while (0)
169 "volume %s", volname)do { do { if (0) printf ("Failed to set password for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 169, GF_LOG_ERROR, "Failed to set password for "
"volume %s", volname); } while (0)
;
170 goto out;
171 }
172
173 ret = glusterd_op_begin_synctask (req, GD_OP_CREATE_VOLUME, dict);
174
175out:
176 if (ret) {
177 rsp.op_ret = -1;
178 rsp.op_errno = 0;
179 if (err_str[0] == '\0')
180 snprintf (err_str, sizeof (err_str),
181 "Operation failed");
182 rsp.op_errstr = err_str;
183 cli_rsp = &rsp;
184 glusterd_to_cli (req, cli_rsp, NULL((void*)0), 0, NULL((void*)0),
185 (xdrproc_t)xdr_gf_cli_rsp, dict);
186 ret = 0; //Client response sent, prevent second response
187 }
188
189 GF_FREE(free_ptr)__gf_free (free_ptr);
190
191 return ret;
192}
193
194int
195glusterd_handle_create_volume (rpcsvc_request_t *req)
196{
197 return glusterd_big_locked_handler (req,
198 __glusterd_handle_create_volume);
199}
200
201int
202__glusterd_handle_cli_start_volume (rpcsvc_request_t *req)
203{
204 int32_t ret = -1;
205 gf_cli_req cli_req = {{0,}};
206 char *volname = NULL((void*)0);
207 dict_t *dict = NULL((void*)0);
208 glusterd_op_t cli_op = GD_OP_START_VOLUME;
209 char errstr[2048] = {0,};
210 xlator_t *this = NULL((void*)0);
211
212 this = THIS(*__glusterfs_this_location());
213 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 213, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
214 GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: "
"req"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 214, GF_LOG_ERROR, "Assertion failed: " "req"
); } while (0); } } while (0)
;
215
216 ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req);
217 if (ret < 0) {
218 snprintf (errstr, sizeof (errstr), "Failed to decode message "
219 "received from cli");
220 req->rpc_err = GARBAGE_ARGS;
221 gf_log (this->name, sizeof (errstr), "%s", errstr)do { do { if (0) printf ("%s", errstr); } while (0); _gf_log (
this->name, "glusterd-volume-ops.c", __FUNCTION__, 221, sizeof
(errstr), "%s", errstr); } while (0)
;
222 goto out;
223 }
224
225 if (cli_req.dict.dict_len) {
226 /* Unserialize the dictionary */
227 dict = dict_new ();
228
229 ret = dict_unserialize (cli_req.dict.dict_val,
230 cli_req.dict.dict_len,
231 &dict);
232 if (ret < 0) {
233 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 235, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
234 "failed to "do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 235, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
235 "unserialize req-buffer to dictionary")do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 235, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
;
236 snprintf (errstr, sizeof (errstr), "Unable to decode "
237 "the command");
238 goto out;
239 }
240 }
241
242 ret = dict_get_str (dict, "volname", &volname);
243 if (ret) {
244 snprintf (errstr, sizeof (errstr), "Unable to get volume name");
245 gf_log (this->name, GF_LOG_ERROR, "%s", errstr)do { do { if (0) printf ("%s", errstr); } while (0); _gf_log (
this->name, "glusterd-volume-ops.c", __FUNCTION__, 245, GF_LOG_ERROR
, "%s", errstr); } while (0)
;
246 goto out;
247 }
248
249 gf_log (this->name, GF_LOG_DEBUG, "Received start vol req"do { do { if (0) printf ("Received start vol req" " for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 250, GF_LOG_DEBUG, "Received start vol req" " for volume %s"
, volname); } while (0)
250 " for volume %s", volname)do { do { if (0) printf ("Received start vol req" " for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 250, GF_LOG_DEBUG, "Received start vol req" " for volume %s"
, volname); } while (0)
;
251
252 ret = glusterd_op_begin_synctask (req, GD_OP_START_VOLUME, dict);
253
254out:
255 free (cli_req.dict.dict_val); //its malloced by xdr
256
257 if (ret) {
258 if(errstr[0] == '\0')
259 snprintf (errstr, sizeof (errstr), "Operation failed");
260 ret = glusterd_op_send_cli_response (cli_op, ret, 0, req,
261 dict, errstr);
262 }
263
264 return ret;
265}
266
267int
268glusterd_handle_cli_start_volume (rpcsvc_request_t *req)
269{
270 return glusterd_big_locked_handler (req,
271 __glusterd_handle_cli_start_volume);
272}
273
274int
275__glusterd_handle_cli_stop_volume (rpcsvc_request_t *req)
276{
277 int32_t ret = -1;
278 gf_cli_req cli_req = {{0,}};
279 char *dup_volname = NULL((void*)0);
280 dict_t *dict = NULL((void*)0);
281 glusterd_op_t cli_op = GD_OP_STOP_VOLUME;
282 xlator_t *this = NULL((void*)0);
283 char err_str[2048] = {0,};
284
285 this = THIS(*__glusterfs_this_location());
286 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 286, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
287 GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: "
"req"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 287, GF_LOG_ERROR, "Assertion failed: " "req"
); } while (0); } } while (0)
;
288
289 ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req);
290 if (ret < 0) {
291 snprintf (err_str, sizeof (err_str), "Failed to decode message "
292 "received from cli");
293 req->rpc_err = GARBAGE_ARGS;
294 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 294, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
295 goto out;
296 }
297 if (cli_req.dict.dict_len) {
298 /* Unserialize the dictionary */
299 dict = dict_new ();
300
301 ret = dict_unserialize (cli_req.dict.dict_val,
302 cli_req.dict.dict_len,
303 &dict);
304 if (ret < 0) {
305 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 307, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
306 "failed to "do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 307, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
307 "unserialize req-buffer to dictionary")do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 307, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
;
308 snprintf (err_str, sizeof (err_str), "Unable to decode "
309 "the command");
310 goto out;
311 }
312 }
313
314 ret = dict_get_str (dict, "volname", &dup_volname);
315
316 if (ret) {
317 snprintf (err_str, sizeof (err_str), "Failed to get volume "
318 "name");
319 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 319, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
320 goto out;
321 }
322
323 gf_log (this->name, GF_LOG_DEBUG, "Received stop vol req "do { do { if (0) printf ("Received stop vol req " "for volume %s"
, dup_volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 324, GF_LOG_DEBUG, "Received stop vol req " "for volume %s"
, dup_volname); } while (0)
324 "for volume %s", dup_volname)do { do { if (0) printf ("Received stop vol req " "for volume %s"
, dup_volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 324, GF_LOG_DEBUG, "Received stop vol req " "for volume %s"
, dup_volname); } while (0)
;
325
326 ret = glusterd_op_begin_synctask (req, GD_OP_STOP_VOLUME, dict);
327
328out:
329 free (cli_req.dict.dict_val); //its malloced by xdr
330
331 if (ret) {
332 if (err_str[0] == '\0')
333 snprintf (err_str, sizeof (err_str),
334 "Operation failed");
335 ret = glusterd_op_send_cli_response (cli_op, ret, 0, req,
336 dict, err_str);
337 }
338
339 return ret;
340}
341
342int
343glusterd_handle_cli_stop_volume (rpcsvc_request_t *req)
344{
345 return glusterd_big_locked_handler (req,
346 __glusterd_handle_cli_stop_volume);
347}
348
349int
350__glusterd_handle_cli_delete_volume (rpcsvc_request_t *req)
351{
352 int32_t ret = -1;
353 gf_cli_req cli_req = {{0,},};
354 glusterd_op_t cli_op = GD_OP_DELETE_VOLUME;
355 dict_t *dict = NULL((void*)0);
356 char *volname = NULL((void*)0);
357 char err_str[2048]= {0,};
358 xlator_t *this = NULL((void*)0);
359
360 this = THIS(*__glusterfs_this_location());
361 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 361, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
362
363 GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: "
"req"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 363, GF_LOG_ERROR, "Assertion failed: " "req"
); } while (0); } } while (0)
;
364
365 ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req);
366 if (ret < 0) {
367 snprintf (err_str, sizeof (err_str), "Failed to decode request "
368 "received from cli");
369 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 369, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
370 req->rpc_err = GARBAGE_ARGS;
371 goto out;
372 }
373
374 if (cli_req.dict.dict_len) {
375 /* Unserialize the dictionary */
376 dict = dict_new ();
377
378 ret = dict_unserialize (cli_req.dict.dict_val,
379 cli_req.dict.dict_len,
380 &dict);
381 if (ret < 0) {
382 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 384, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
383 "failed to "do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 384, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
384 "unserialize req-buffer to dictionary")do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 384, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
;
385 snprintf (err_str, sizeof (err_str), "Unable to decode "
386 "the command");
387 goto out;
388 }
389 }
390
391 ret = dict_get_str (dict, "volname", &volname);
392 if (ret) {
393 snprintf (err_str, sizeof (err_str), "Failed to get volume "
394 "name");
395 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 395, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
396 req->rpc_err = GARBAGE_ARGS;
397 goto out;
398 }
399
400 gf_log (this->name, GF_LOG_DEBUG, "Received delete vol req"do { do { if (0) printf ("Received delete vol req" "for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 401, GF_LOG_DEBUG, "Received delete vol req" "for volume %s"
, volname); } while (0)
401 "for volume %s", volname)do { do { if (0) printf ("Received delete vol req" "for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 401, GF_LOG_DEBUG, "Received delete vol req" "for volume %s"
, volname); } while (0)
;
402
403 ret = glusterd_op_begin_synctask (req, GD_OP_DELETE_VOLUME, dict);
404
405out:
406 free (cli_req.dict.dict_val); //its malloced by xdr
407
408 if (ret) {
409 if (err_str[0] == '\0')
410 snprintf (err_str, sizeof (err_str),
411 "Operation failed");
412 ret = glusterd_op_send_cli_response (cli_op, ret, 0, req,
413 dict, err_str);
414 }
415
416 return ret;
417}
418
419int
420glusterd_handle_cli_delete_volume (rpcsvc_request_t *req)
421{
422 return glusterd_big_locked_handler (req,
423 __glusterd_handle_cli_delete_volume);
424}
425
426int
427__glusterd_handle_cli_heal_volume (rpcsvc_request_t *req)
428{
429 int32_t ret = -1;
430 gf_cli_req cli_req = {{0,}};
431 dict_t *dict = NULL((void*)0);
432 glusterd_op_t cli_op = GD_OP_HEAL_VOLUME;
433 char *volname = NULL((void*)0);
434 glusterd_volinfo_t *volinfo = NULL((void*)0);
435 xlator_t *this = NULL((void*)0);
436 char op_errstr[2048] = {0,};
437
438 GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: "
"req"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 438, GF_LOG_ERROR, "Assertion failed: " "req"
); } while (0); } } while (0)
;
439
440 ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req);
441 if (ret < 0) {
442 //failed to decode msg;
443 req->rpc_err = GARBAGE_ARGS;
444 goto out;
445 }
446
447 this = THIS(*__glusterfs_this_location());
448 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 448, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
449
450 if (cli_req.dict.dict_len) {
451 /* Unserialize the dictionary */
452 dict = dict_new ();
453
454 ret = dict_unserialize (cli_req.dict.dict_val,
455 cli_req.dict.dict_len,
456 &dict);
457 if (ret < 0) {
458 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 460, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
459 "failed to "do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 460, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
460 "unserialize req-buffer to dictionary")do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 460, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
;
461 snprintf (op_errstr, sizeof (op_errstr),
462 "Unable to decode the command");
463 goto out;
464 } else {
465 dict->extra_stdfree = cli_req.dict.dict_val;
466 }
467 }
468
469 ret = dict_get_str (dict, "volname", &volname);
470 if (ret) {
471 snprintf (op_errstr, sizeof (op_errstr), "Unable to find "
472 "volume name");
473 gf_log (this->name, GF_LOG_ERROR, "%s", op_errstr)do { do { if (0) printf ("%s", op_errstr); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 473, GF_LOG_ERROR
, "%s", op_errstr); } while (0)
;
474 goto out;
475 }
476
477 gf_log (this->name, GF_LOG_INFO, "Received heal vol req "do { do { if (0) printf ("Received heal vol req " "for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 478, GF_LOG_INFO, "Received heal vol req " "for volume %s"
, volname); } while (0)
478 "for volume %s", volname)do { do { if (0) printf ("Received heal vol req " "for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 478, GF_LOG_INFO, "Received heal vol req " "for volume %s"
, volname); } while (0)
;
479
480 ret = glusterd_volinfo_find (volname, &volinfo);
481 if (ret) {
482 snprintf (op_errstr, sizeof (op_errstr),
483 "Volume %s does not exist", volname);
484 gf_log (this->name, GF_LOG_ERROR, "%s", op_errstr)do { do { if (0) printf ("%s", op_errstr); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 484, GF_LOG_ERROR
, "%s", op_errstr); } while (0)
;
485 goto out;
486 }
487
488 ret = glusterd_add_bricks_hname_path_to_dict (dict, volinfo);
489 if (ret)
490 goto out;
491
492 ret = dict_set_int32 (dict, "count", volinfo->brick_count);
493 if (ret)
494 goto out;
495
496 ret = glusterd_op_begin_synctask (req, GD_OP_HEAL_VOLUME, dict);
497
498out:
499 if (ret) {
500 if (op_errstr[0] == '\0')
501 snprintf (op_errstr, sizeof (op_errstr),
502 "operation failed");
503 ret = glusterd_op_send_cli_response (cli_op, ret, 0, req,
504 dict, op_errstr);
505 }
506
507 return ret;
508}
509
510int
511glusterd_handle_cli_heal_volume (rpcsvc_request_t *req)
512{
513 return glusterd_big_locked_handler (req,
514 __glusterd_handle_cli_heal_volume);
515}
516
517int
518__glusterd_handle_cli_statedump_volume (rpcsvc_request_t *req)
519{
520 int32_t ret = -1;
521 gf_cli_req cli_req = {{0,}};
522 char *volname = NULL((void*)0);
523 char *options = NULL((void*)0);
524 dict_t *dict = NULL((void*)0);
525 int32_t option_cnt = 0;
526 glusterd_op_t cli_op = GD_OP_STATEDUMP_VOLUME;
527 char err_str[2048] = {0,};
528 xlator_t *this = NULL((void*)0);
529
530 this = THIS(*__glusterfs_this_location());
531 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 531, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
532
533 GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: "
"req"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 533, GF_LOG_ERROR, "Assertion failed: " "req"
); } while (0); } } while (0)
;
534
535 ret = -1;
536 ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req);
537 if (ret < 0) {
538 req->rpc_err = GARBAGE_ARGS;
539 goto out;
540 }
541 if (cli_req.dict.dict_len) {
542 /* Unserialize the dictionary */
543 dict = dict_new ();
544
545 ret = dict_unserialize (cli_req.dict.dict_val,
546 cli_req.dict.dict_len,
547 &dict);
548 if (ret < 0) {
549 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 551, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
550 "failed to "do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 551, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
551 "unserialize req-buffer to dictionary")do { do { if (0) printf ("failed to " "unserialize req-buffer to dictionary"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 551, GF_LOG_ERROR, "failed to " "unserialize req-buffer to dictionary"
); } while (0)
;
552 snprintf (err_str, sizeof (err_str), "Unable to "
553 "decode the command");
554 goto out;
555 }
556 }
557 ret = dict_get_str (dict, "volname", &volname);
558 if (ret) {
559 snprintf (err_str, sizeof (err_str), "Unable to get the volume "
560 "name");
561 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 561, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
562 goto out;
563 }
564
565 ret = dict_get_str (dict, "options", &options);
566 if (ret) {
567 snprintf (err_str, sizeof (err_str), "Unable to get options");
568 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 568, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
569 goto out;
570 }
571
572 ret = dict_get_int32 (dict, "option_cnt", &option_cnt);
573 if (ret) {
574 snprintf (err_str , sizeof (err_str), "Unable to get option "
575 "count");
576 gf_log (this->name, GF_LOG_ERROR, "%s", err_str)do { do { if (0) printf ("%s", err_str); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 576, GF_LOG_ERROR
, "%s", err_str); } while (0)
;
577 goto out;
578 }
579
580
581 gf_log (this->name, GF_LOG_INFO, "Received statedump request for "do { do { if (0) printf ("Received statedump request for " "volume %s with options %s"
, volname, options); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 582, GF_LOG_INFO, "Received statedump request for "
"volume %s with options %s", volname, options); } while (0)
582 "volume %s with options %s", volname, options)do { do { if (0) printf ("Received statedump request for " "volume %s with options %s"
, volname, options); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 582, GF_LOG_INFO, "Received statedump request for "
"volume %s with options %s", volname, options); } while (0)
;
583
584 ret = glusterd_op_begin_synctask (req, GD_OP_STATEDUMP_VOLUME, dict);
585
586out:
587 if (ret) {
588 if (err_str[0] == '\0')
589 snprintf (err_str, sizeof (err_str),
590 "Operation failed");
591 ret = glusterd_op_send_cli_response (cli_op, ret, 0, req,
592 dict, err_str);
593 }
594 free (cli_req.dict.dict_val);
595
596 return ret;
597}
598
599int
600glusterd_handle_cli_statedump_volume (rpcsvc_request_t *req)
601{
602 return glusterd_big_locked_handler (req,
603 __glusterd_handle_cli_statedump_volume);
604}
605
606#ifdef HAVE_BD_XLATOR
607int
608glusterd_is_valid_vg (const char *name)
609{
610 lvm_t handle = NULL((void*)0);
611 vg_t vg = NULL((void*)0);
612 char *vg_name = NULL((void*)0);
613 int retval = -1;
614
615 handle = lvm_init (NULL((void*)0));
616 if (!handle) {
617 gf_log ("", GF_LOG_ERROR, "lvm_init failed")do { do { if (0) printf ("lvm_init failed"); } while (0); _gf_log
("", "glusterd-volume-ops.c", __FUNCTION__, 617, GF_LOG_ERROR
, "lvm_init failed"); } while (0)
;
618 return -1;
619 }
620 vg_name = gf_strdup (name);
621 vg = lvm_vg_open (handle, basename__xpg_basename (vg_name), "r", 0);
622 if (!vg) {
623 gf_log ("", GF_LOG_ERROR, "no such vg: %s", vg_name)do { do { if (0) printf ("no such vg: %s", vg_name); } while (
0); _gf_log ("", "glusterd-volume-ops.c", __FUNCTION__, 623, GF_LOG_ERROR
, "no such vg: %s", vg_name); } while (0)
;
624 goto out;
625 }
626 retval = 0;
627out:
628 if (vg)
629 lvm_vg_close (vg);
630 lvm_quit (handle);
631 GF_FREE (vg_name)__gf_free (vg_name);
632 return retval;
633}
634#endif
635
636/* op-sm */
637int
638glusterd_op_stage_create_volume (dict_t *dict, char **op_errstr)
639{
640 int ret = 0;
641 char *volname = NULL((void*)0);
642 gf_boolean_t exists = _gf_false;
643 char *bricks = NULL((void*)0);
644 char *brick_list = NULL((void*)0);
645 char *free_ptr = NULL((void*)0);
646 glusterd_brickinfo_t *brick_info = NULL((void*)0);
647 int32_t brick_count = 0;
648 int32_t i = 0;
649 char *brick = NULL((void*)0);
650 char *tmpptr = NULL((void*)0);
651 xlator_t *this = NULL((void*)0);
652 glusterd_conf_t *priv = NULL((void*)0);
653 char msg[2048] = {0};
654 uuid_t volume_uuid;
655 char *volume_uuid_str;
656#ifdef HAVE_BD_XLATOR
657 char *dev_type = NULL((void*)0);
658#endif
659 gf_boolean_t is_force = _gf_false;
660
661 this = THIS(*__glusterfs_this_location());
662 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 662, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
663 priv = this->private;
664 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 664, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0)
;
665
666 ret = dict_get_str (dict, "volname", &volname);
667 if (ret) {
668 gf_log (this->name, GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while
(0); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 668, GF_LOG_ERROR, "Unable to get volume name"); } while (0
)
;
669 goto out;
670 }
671
672 exists = glusterd_check_volume_exists (volname);
673 if (exists) {
674 snprintf (msg, sizeof (msg), "Volume %s already exists",
675 volname);
676 ret = -1;
677 goto out;
678 } else {
679 ret = 0;
680 }
681
682 ret = dict_get_int32 (dict, "count", &brick_count);
683 if (ret) {
684 gf_log (this->name, GF_LOG_ERROR, "Unable to get brick count "do { do { if (0) printf ("Unable to get brick count " "for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 685, GF_LOG_ERROR, "Unable to get brick count "
"for volume %s", volname); } while (0)
685 "for volume %s", volname)do { do { if (0) printf ("Unable to get brick count " "for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 685, GF_LOG_ERROR, "Unable to get brick count "
"for volume %s", volname); } while (0)
;
686 goto out;
687 }
688
689 ret = dict_get_str (dict, "volume-id", &volume_uuid_str);
690 if (ret) {
691 gf_log (this->name, GF_LOG_ERROR, "Unable to get volume id of "do { do { if (0) printf ("Unable to get volume id of " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 692, GF_LOG_ERROR, "Unable to get volume id of "
"volume %s", volname); } while (0)
692 "volume %s", volname)do { do { if (0) printf ("Unable to get volume id of " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 692, GF_LOG_ERROR, "Unable to get volume id of "
"volume %s", volname); } while (0)
;
693 goto out;
694 }
695
696 ret = uuid_parse (volume_uuid_str, volume_uuid);
697 if (ret) {
698 gf_log (this->name, GF_LOG_ERROR, "Unable to parse volume id of"do { do { if (0) printf ("Unable to parse volume id of" " volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 699, GF_LOG_ERROR, "Unable to parse volume id of"
" volume %s", volname); } while (0)
699 " volume %s", volname)do { do { if (0) printf ("Unable to parse volume id of" " volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 699, GF_LOG_ERROR, "Unable to parse volume id of"
" volume %s", volname); } while (0)
;
700 goto out;
701 }
702
703#ifdef HAVE_BD_XLATOR
704 ret = dict_get_str (dict, "device", &dev_type);
705#endif
706
707 ret = dict_get_str (dict, "bricks", &bricks);
708 if (ret) {
709 gf_log (this->name, GF_LOG_ERROR, "Unable to get bricks for "do { do { if (0) printf ("Unable to get bricks for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 710, GF_LOG_ERROR, "Unable to get bricks for "
"volume %s", volname); } while (0)
710 "volume %s", volname)do { do { if (0) printf ("Unable to get bricks for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 710, GF_LOG_ERROR, "Unable to get bricks for "
"volume %s", volname); } while (0)
;
711 goto out;
712 }
713
714 is_force = dict_get_str_boolean (dict, "force", _gf_false);
715
716 if (bricks) {
717 brick_list = gf_strdup (bricks);
718 if (!brick_list) {
719 ret = -1;
720 goto out;
721 } else {
722 free_ptr = brick_list;
723 }
724 }
725
726 while ( i < brick_count) {
727 i++;
728 brick= strtok_r (brick_list, " \n", &tmpptr);
729 brick_list = tmpptr;
730
731 if (!glusterd_store_is_valid_brickpath (volname, brick) ||
732 !glusterd_is_valid_volfpath (volname, brick)) {
733 snprintf (msg, sizeof (msg), "brick path %s is too "
734 "long.", brick);
735 ret = -1;
736 goto out;
737 }
738
739 ret = glusterd_brickinfo_new_from_brick (brick, &brick_info);
740 if (ret)
741 goto out;
742
743 ret = glusterd_new_brick_validate (brick, brick_info, msg,
744 sizeof (msg));
745 if (ret)
746 goto out;
747
748 ret = glusterd_resolve_brick (brick_info);
749 if (ret) {
750 gf_log (this->name, GF_LOG_ERROR, FMTSTR_RESOLVE_BRICK,do { do { if (0) printf ("Could not find peer on which brick %s:%s resides"
, brick_info->hostname, brick_info->path); } while (0);
_gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 751, GF_LOG_ERROR, "Could not find peer on which brick %s:%s resides"
, brick_info->hostname, brick_info->path); } while (0)
751 brick_info->hostname, brick_info->path)do { do { if (0) printf ("Could not find peer on which brick %s:%s resides"
, brick_info->hostname, brick_info->path); } while (0);
_gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 751, GF_LOG_ERROR, "Could not find peer on which brick %s:%s resides"
, brick_info->hostname, brick_info->path); } while (0)
;
752 goto out;
753 }
754
755#ifdef HAVE_BD_XLATOR
756 if (dev_type) {
757 ret = glusterd_is_valid_vg (brick_info->path);
758 if (ret) {
759 snprintf (msg, sizeof(msg), "invalid vg %s",
760 brick_info->path);
761 goto out;
762 }
763
764 break;
765 } else
766#endif
767 if (!uuid_compare (brick_info->uuid, MY_UUID(__glusterd_uuid()))) {
768 ret = glusterd_validate_and_create_brickpath (brick_info,
769 volume_uuid, op_errstr,
770 is_force);
771 if (ret)
772 goto out;
773 brick_list = tmpptr;
774 }
775 glusterd_brickinfo_delete (brick_info);
776 brick_info = NULL((void*)0);
777 }
778out:
779 GF_FREE (free_ptr)__gf_free (free_ptr);
780 if (brick_info)
781 glusterd_brickinfo_delete (brick_info);
782
783 if (msg[0] != '\0') {
784 gf_log (this->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 784, GF_LOG_ERROR
, "%s", msg); } while (0)
;
785 *op_errstr = gf_strdup (msg);
786 }
787 gf_log (this->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 787, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
788
789 return ret;
790}
791
792int
793glusterd_op_stop_volume_args_get (dict_t *dict, char** volname, int *flags)
794{
795 int ret = -1;
796 xlator_t *this = NULL((void*)0);
797
798 this = THIS(*__glusterfs_this_location());
799 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 799, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
800
801 if (!dict || !volname || !flags)
802 goto out;
803
804 ret = dict_get_str (dict, "volname", volname);
805 if (ret) {
806 gf_log (this->name, GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while
(0); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 806, GF_LOG_ERROR, "Unable to get volume name"); } while (0
)
;
807 goto out;
808 }
809
810 ret = dict_get_int32 (dict, "flags", flags);
811 if (ret) {
812 gf_log (this->name, GF_LOG_ERROR, "Unable to get flags")do { do { if (0) printf ("Unable to get flags"); } while (0);
_gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 812, GF_LOG_ERROR, "Unable to get flags"); } while (0)
;
813 goto out;
814 }
815out:
816 return ret;
817}
818
819int
820glusterd_op_statedump_volume_args_get (dict_t *dict, char **volname,
821 char **options, int *option_cnt)
822{
823 int ret = -1;
824
825 if (!dict || !volname || !options || !option_cnt)
826 goto out;
827
828 ret = dict_get_str (dict, "volname", volname);
829 if (ret) {
830 gf_log ("", GF_LOG_ERROR, "Unable to get volname")do { do { if (0) printf ("Unable to get volname"); } while (0
); _gf_log ("", "glusterd-volume-ops.c", __FUNCTION__, 830, GF_LOG_ERROR
, "Unable to get volname"); } while (0)
;
831 goto out;
832 }
833
834 ret = dict_get_str (dict, "options", options);
835 if (ret) {
836 gf_log ("", GF_LOG_ERROR, "Unable to get options")do { do { if (0) printf ("Unable to get options"); } while (0
); _gf_log ("", "glusterd-volume-ops.c", __FUNCTION__, 836, GF_LOG_ERROR
, "Unable to get options"); } while (0)
;
837 goto out;
838 }
839
840 ret = dict_get_int32 (dict, "option_cnt", option_cnt);
841 if (ret) {
842 gf_log ("", GF_LOG_ERROR, "Unable to get option count")do { do { if (0) printf ("Unable to get option count"); } while
(0); _gf_log ("", "glusterd-volume-ops.c", __FUNCTION__, 842
, GF_LOG_ERROR, "Unable to get option count"); } while (0)
;
843 goto out;
844 }
845
846out:
847 return ret;
848}
849
850int
851glusterd_op_stage_start_volume (dict_t *dict, char **op_errstr)
852{
853 int ret = 0;
854 char *volname = NULL((void*)0);
855 int flags = 0;
856 gf_boolean_t exists = _gf_false;
857 glusterd_volinfo_t *volinfo = NULL((void*)0);
858 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
859 char msg[2048];
860 glusterd_conf_t *priv = NULL((void*)0);
861 xlator_t *this = NULL((void*)0);
862 uuid_t volume_id = {0,};
863 char volid[50] = {0,};
864 char xattr_volid[50] = {0,};
865
866 this = THIS(*__glusterfs_this_location());
867 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 867, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
868 priv = this->private;
869 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 869, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0)
;
870
871 ret = glusterd_op_start_volume_args_get (dict, &volname, &flags)glusterd_op_stop_volume_args_get (dict, &volname, &flags
)
;
872 if (ret)
873 goto out;
874
875 exists = glusterd_check_volume_exists (volname);
876
877 if (!exists) {
878 snprintf (msg, sizeof (msg), FMTSTR_CHECK_VOL_EXISTS"Volume %s does not exist", volname);
879 ret = -1;
880 goto out;
881 }
882
883 ret = glusterd_volinfo_find (volname, &volinfo);
884 if (ret) {
885 gf_log (this->name, GF_LOG_ERROR, FMTSTR_CHECK_VOL_EXISTS,do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 886, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
886 volname)do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 886, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
;
887 goto out;
888 }
889
890 ret = glusterd_validate_volume_id (dict, volinfo);
891 if (ret)
892 goto out;
893
894 if (!(flags & GF_CLI_FLAG_OP_FORCE)) {
895 if (glusterd_is_volume_started (volinfo)) {
896 snprintf (msg, sizeof (msg), "Volume %s already "
897 "started", volname);
898 ret = -1;
899 goto out;
900 }
901 }
902
903 list_for_each_entry (brickinfo, &volinfo->bricks, brick_list)for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo
->bricks)->next)-(unsigned long)(&((typeof(*brickinfo
) *)0)->brick_list))); &brickinfo->brick_list != (&
volinfo->bricks); brickinfo = ((typeof(*brickinfo) *)((char
*)(brickinfo->brick_list.next)-(unsigned long)(&((typeof
(*brickinfo) *)0)->brick_list))))
{
904 ret = glusterd_resolve_brick (brickinfo);
905 if (ret) {
906 gf_log (this->name, GF_LOG_ERROR, FMTSTR_RESOLVE_BRICK,do { do { if (0) printf ("Could not find peer on which brick %s:%s resides"
, brickinfo->hostname, brickinfo->path); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 907, GF_LOG_ERROR
, "Could not find peer on which brick %s:%s resides", brickinfo
->hostname, brickinfo->path); } while (0)
907 brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Could not find peer on which brick %s:%s resides"
, brickinfo->hostname, brickinfo->path); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 907, GF_LOG_ERROR
, "Could not find peer on which brick %s:%s resides", brickinfo
->hostname, brickinfo->path); } while (0)
;
908 goto out;
909 }
910
911 if (uuid_compare (brickinfo->uuid, MY_UUID(__glusterd_uuid())))
912 continue;
913
914 if (volinfo->backend == GD_VOL_BK_BD)
915 continue;
916
917 ret = gf_lstat_dir (brickinfo->path, NULL((void*)0));
918 if (ret) {
919 snprintf (msg, sizeof (msg), "Failed to find "
920 "brick directory %s for volume %s. "
921 "Reason : %s", brickinfo->path,
922 volname, strerror (errno(*__errno_location ())));
923 goto out;
924 }
925 ret = sys_lgetxattr (brickinfo->path, GF_XATTR_VOL_ID_KEY"trusted.glusterfs.volume-id",
926 volume_id, 16);
927 if (ret < 0) {
928 snprintf (msg, sizeof (msg), "Failed to get "
929 "extended attribute %s for brick dir %s. "
930 "Reason : %s", GF_XATTR_VOL_ID_KEY"trusted.glusterfs.volume-id",
931 brickinfo->path, strerror (errno(*__errno_location ())));
932 ret = -1;
933 goto out;
934 }
935 if (uuid_compare (volinfo->volume_id, volume_id)) {
936 snprintf (msg, sizeof (msg), "Volume id mismatch for "
937 "brick %s:%s. Expected volume id %s, "
938 "volume id %s found", brickinfo->hostname,
939 brickinfo->path,
940 uuid_utoa_r (volinfo->volume_id, volid),
941 uuid_utoa_r (volume_id, xattr_volid));
942 ret = -1;
943 goto out;
944 }
945 }
946
947 ret = 0;
948out:
949 if (ret && (msg[0] != '\0')) {
950 gf_log (this->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 950, GF_LOG_ERROR
, "%s", msg); } while (0)
;
951 *op_errstr = gf_strdup (msg);
952 }
953 return ret;
954}
955
956int
957glusterd_op_stage_stop_volume (dict_t *dict, char **op_errstr)
958{
959 int ret = -1;
960 char *volname = NULL((void*)0);
961 int flags = 0;
962 gf_boolean_t exists = _gf_false;
963 gf_boolean_t is_run = _gf_false;
964 glusterd_volinfo_t *volinfo = NULL((void*)0);
965 char msg[2048] = {0};
966 xlator_t *this = NULL((void*)0);
967
968 this = THIS(*__glusterfs_this_location());
969 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 969, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
970
971 ret = glusterd_op_stop_volume_args_get (dict, &volname, &flags);
972 if (ret)
973 goto out;
974
975 exists = glusterd_check_volume_exists (volname);
976
977 if (!exists) {
978 snprintf (msg, sizeof (msg), FMTSTR_CHECK_VOL_EXISTS"Volume %s does not exist", volname);
979 gf_log (this->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 979, GF_LOG_ERROR
, "%s", msg); } while (0)
;
980 ret = -1;
981 goto out;
982 }
983
984 ret = glusterd_volinfo_find (volname, &volinfo);
985 if (ret) {
986 snprintf (msg, sizeof (msg), FMTSTR_CHECK_VOL_EXISTS"Volume %s does not exist", volname);
987 gf_log (this->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 987, GF_LOG_ERROR
, "%s", msg); } while (0)
;
988 goto out;
989 }
990
991 ret = glusterd_validate_volume_id (dict, volinfo);
992 if (ret)
993 goto out;
994
995 /* If 'force' flag is given, no check is required */
996 if (flags & GF_CLI_FLAG_OP_FORCE)
997 goto out;
998
999 if (_gf_false == glusterd_is_volume_started (volinfo)) {
1000 snprintf (msg, sizeof(msg), "Volume %s "
1001 "is not in the started state", volname);
1002 gf_log (this->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 1002, GF_LOG_ERROR
, "%s", msg); } while (0)
;
1003 ret = -1;
1004 goto out;
1005 }
1006 ret = glusterd_check_gsync_running (volinfo, &is_run);
1007 if (ret && (is_run == _gf_false))
1008 gf_log (this->name, GF_LOG_WARNING, "Unable to get the status"do { do { if (0) printf ("Unable to get the status" " of active "
"geo-replication"" session"); } while (0); _gf_log (this->
name, "glusterd-volume-ops.c", __FUNCTION__, 1009, GF_LOG_WARNING
, "Unable to get the status" " of active ""geo-replication"" session"
); } while (0)
1009 " of active "GEOREP" session")do { do { if (0) printf ("Unable to get the status" " of active "
"geo-replication"" session"); } while (0); _gf_log (this->
name, "glusterd-volume-ops.c", __FUNCTION__, 1009, GF_LOG_WARNING
, "Unable to get the status" " of active ""geo-replication"" session"
); } while (0)
;
1010 if (is_run) {
1011 gf_log (this->name, GF_LOG_WARNING, GEOREP" sessions active"do { do { if (0) printf ("geo-replication"" sessions active" "for the volume %s "
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1012, GF_LOG_WARNING, "geo-replication"" sessions active"
"for the volume %s ", volname); } while (0)
1012 "for the volume %s ", volname)do { do { if (0) printf ("geo-replication"" sessions active" "for the volume %s "
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1012, GF_LOG_WARNING, "geo-replication"" sessions active"
"for the volume %s ", volname); } while (0)
;
1013 snprintf (msg, sizeof(msg), GEOREP"geo-replication"" sessions are active "
1014 "for the volume '%s'.\nUse 'volume "GEOREP"geo-replication"" "
1015 "status' command for more info. Use 'force' "
1016 "option to ignore and stop the volume.",
1017 volname);
1018 ret = -1;
1019 goto out;
1020 }
1021
1022 if (glusterd_is_rb_ongoing (volinfo)) {
1023 snprintf (msg, sizeof (msg), "Replace brick is in progress on "
1024 "volume %s. Please retry after replace-brick "
1025 "operation is committed or aborted", volname);
1026 gf_log (this->name, GF_LOG_WARNING, "replace-brick in progress "do { do { if (0) printf ("replace-brick in progress " "on volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1027, GF_LOG_WARNING, "replace-brick in progress "
"on volume %s", volname); } while (0)
1027 "on volume %s", volname)do { do { if (0) printf ("replace-brick in progress " "on volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1027, GF_LOG_WARNING, "replace-brick in progress "
"on volume %s", volname); } while (0)
;
1028 ret = -1;
1029 goto out;
1030 }
1031
1032 if (glusterd_is_defrag_on (volinfo)) {
1033 snprintf (msg, sizeof(msg), "rebalance session is "
1034 "in progress for the volume '%s'", volname);
1035 gf_log (this->name, GF_LOG_WARNING, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 1035, GF_LOG_WARNING
, "%s", msg); } while (0)
;
1036 ret = -1;
1037 goto out;
1038 }
1039 if (volinfo->rep_brick.rb_status != GF_RB_STATUS_NONE) {
1040 snprintf (msg, sizeof(msg), "replace-brick session is "
1041 "in progress for the volume '%s'", volname);
1042 gf_log (this->name, GF_LOG_WARNING, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 1042, GF_LOG_WARNING
, "%s", msg); } while (0)
;
1043 ret = -1;
1044 goto out;
1045 }
1046
1047out:
1048 if (msg[0] != 0)
1049 *op_errstr = gf_strdup (msg);
1050 gf_log (this->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1050,
GF_LOG_DEBUG, "Returning %d", ret); } while (0)
;
1051
1052 return ret;
1053}
1054
1055int
1056glusterd_op_stage_delete_volume (dict_t *dict, char **op_errstr)
1057{
1058 int ret = 0;
1059 char *volname = NULL((void*)0);
1060 gf_boolean_t exists = _gf_false;
1061 glusterd_volinfo_t *volinfo = NULL((void*)0);
1062 char msg[2048] = {0};
1063 xlator_t *this = NULL((void*)0);
1064
1065 this = THIS(*__glusterfs_this_location());
1066 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1066, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
1067
1068 ret = dict_get_str (dict, "volname", &volname);
1069 if (ret) {
1070 gf_log (this->name, GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while
(0); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 1070, GF_LOG_ERROR, "Unable to get volume name"); } while (
0)
;
1071 goto out;
1072 }
1073
1074 exists = glusterd_check_volume_exists (volname);
1075 if (!exists) {
1076 snprintf (msg, sizeof (msg), FMTSTR_CHECK_VOL_EXISTS"Volume %s does not exist", volname);
1077 ret = -1;
1078 goto out;
1079 } else {
1080 ret = 0;
1081 }
1082
1083 ret = glusterd_volinfo_find (volname, &volinfo);
1084 if (ret) {
1085 snprintf (msg, sizeof (msg), FMTSTR_CHECK_VOL_EXISTS"Volume %s does not exist", volname);
1086 goto out;
1087 }
1088
1089 ret = glusterd_validate_volume_id (dict, volinfo);
1090 if (ret)
1091 goto out;
1092
1093 if (glusterd_is_volume_started (volinfo)) {
1094 snprintf (msg, sizeof (msg), "Volume %s has been started."
1095 "Volume needs to be stopped before deletion.",
1096 volname);
1097 ret = -1;
1098 goto out;
1099 }
1100
1101 ret = 0;
1102
1103out:
1104 if (msg[0] != '\0') {
1105 gf_log (this->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 1105, GF_LOG_ERROR
, "%s", msg); } while (0)
;
1106 *op_errstr = gf_strdup (msg);
1107 }
1108 gf_log (this->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1108,
GF_LOG_DEBUG, "Returning %d", ret); } while (0)
;
1109
1110 return ret;
1111}
1112
1113int
1114glusterd_op_stage_heal_volume (dict_t *dict, char **op_errstr)
1115{
1116 int ret = 0;
1117 char *volname = NULL((void*)0);
1118 gf_boolean_t enabled = _gf_false;
1119 glusterd_volinfo_t *volinfo = NULL((void*)0);
1120 char msg[2048];
1121 glusterd_conf_t *priv = NULL((void*)0);
1122 dict_t *opt_dict = NULL((void*)0);
1123 gf_xl_afr_op_t heal_op = GF_AFR_OP_INVALID;
1124 xlator_t *this = NULL((void*)0);
1125
1126 this = THIS(*__glusterfs_this_location());
1127 priv = this->private;
1128 if (!priv) {
1129 ret = -1;
1130 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("priv is NULL"); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1131,
GF_LOG_ERROR, "priv is NULL"); } while (0)
1131 "priv is NULL")do { do { if (0) printf ("priv is NULL"); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1131,
GF_LOG_ERROR, "priv is NULL"); } while (0)
;
1132 goto out;
1133 }
1134
1135 ret = dict_get_str (dict, "volname", &volname);
1136 if (ret) {
1137 gf_log ("", GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while
(0); _gf_log ("", "glusterd-volume-ops.c", __FUNCTION__, 1137
, GF_LOG_ERROR, "Unable to get volume name"); } while (0)
;
1138 goto out;
1139 }
1140
1141 ret = glusterd_volinfo_find (volname, &volinfo);
1142 if (ret) {
1143 ret = -1;
1144 snprintf (msg, sizeof (msg), "Volume %s does not exist", volname);
1145 gf_log (this->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 1145, GF_LOG_ERROR
, "%s", msg); } while (0)
;
1146 *op_errstr = gf_strdup (msg);
1147 goto out;
1148 }
1149
1150 ret = glusterd_validate_volume_id (dict, volinfo);
1151 if (ret)
1152 goto out;
1153
1154 if (!glusterd_is_volume_replicate (volinfo)) {
1155 ret = -1;
1156 snprintf (msg, sizeof (msg), "Volume %s is not of type "
1157 "replicate", volname);
1158 *op_errstr = gf_strdup (msg);
1159 gf_log (this->name, GF_LOG_WARNING, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 1159, GF_LOG_WARNING
, "%s", msg); } while (0)
;
1160 goto out;
1161 }
1162
1163 if (!glusterd_is_volume_started (volinfo)) {
1164 ret = -1;
1165 snprintf (msg, sizeof (msg), "Volume %s is not started.",
1166 volname);
1167 gf_log (THIS->name, GF_LOG_WARNING, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1167, GF_LOG_WARNING, "%s", msg); } while (0)
;
1168 *op_errstr = gf_strdup (msg);
1169 goto out;
1170 }
1171
1172 opt_dict = volinfo->dict;
1173 if (!opt_dict) {
1174 ret = 0;
1175 goto out;
1176 }
1177
1178 enabled = dict_get_str_boolean (opt_dict, "cluster.self-heal-daemon",
1179 1);
1180 if (!enabled) {
1181 ret = -1;
1182 snprintf (msg, sizeof (msg), "Self-heal-daemon is "
1183 "disabled. Heal will not be triggered on volume %s",
1184 volname);
1185 gf_log (this->name, GF_LOG_WARNING, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (this
->name, "glusterd-volume-ops.c", __FUNCTION__, 1185, GF_LOG_WARNING
, "%s", msg); } while (0)
;
1186 *op_errstr = gf_strdup (msg);
1187 goto out;
1188 }
1189
1190 ret = dict_get_int32 (dict, "heal-op", (int32_t*)&heal_op);
1191 if (ret || (heal_op == GF_AFR_OP_INVALID)) {
1192 ret = -1;
1193 *op_errstr = gf_strdup("Invalid heal-op");
1194 gf_log (this->name, GF_LOG_WARNING, "%s", "Invalid heal-op")do { do { if (0) printf ("%s", "Invalid heal-op"); } while (0
); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 1194, GF_LOG_WARNING, "%s", "Invalid heal-op"); } while (0)
;
1195 goto out;
1196 }
1197
1198 if ((heal_op != GF_AFR_OP_INDEX_SUMMARY) &&
1199 !glusterd_is_nodesvc_online ("glustershd")) {
1200 ret = -1;
1201 *op_errstr = gf_strdup ("Self-heal daemon is not running."
1202 " Check self-heal daemon log file.");
1203 gf_log (this->name, GF_LOG_WARNING, "%s", "Self-heal daemon is "do { do { if (0) printf ("%s", "Self-heal daemon is " "not running. Check self-heal daemon log file."
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1204, GF_LOG_WARNING, "%s", "Self-heal daemon is "
"not running. Check self-heal daemon log file."); } while (0
)
1204 "not running. Check self-heal daemon log file.")do { do { if (0) printf ("%s", "Self-heal daemon is " "not running. Check self-heal daemon log file."
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1204, GF_LOG_WARNING, "%s", "Self-heal daemon is "
"not running. Check self-heal daemon log file."); } while (0
)
;
1205 goto out;
1206 }
1207
1208 ret = 0;
1209out:
1210 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-volume-ops.c", __FUNCTION__, 1210, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1211
1212 return ret;
1213}
1214
1215int
1216glusterd_op_stage_statedump_volume (dict_t *dict, char **op_errstr)
1217{
1218 int ret = -1;
1219 char *volname = NULL((void*)0);
1220 char *options = NULL((void*)0);
1221 int option_cnt = 0;
1222 gf_boolean_t is_running = _gf_false;
1223 glusterd_volinfo_t *volinfo = NULL((void*)0);
1224 char msg[2408] = {0,};
1225
1226 ret = glusterd_op_statedump_volume_args_get (dict, &volname, &options,
1227 &option_cnt);
1228 if (ret)
1229 goto out;
1230
1231 ret = glusterd_volinfo_find (volname, &volinfo);
1232 if (ret) {
1233 snprintf (msg, sizeof(msg), "Volume %s does not exist",
1234 volname);
1235 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1235, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1236 *op_errstr = gf_strdup (msg);
1237 goto out;
1238 }
1239
1240 ret = glusterd_validate_volume_id (dict, volinfo);
1241 if (ret)
1242 goto out;
1243
1244 is_running = glusterd_is_volume_started (volinfo);
1245 if (!is_running) {
1246 snprintf (msg, sizeof(msg), "Volume %s is not in a started"
1247 " state", volname);
1248 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1248, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1249 *op_errstr = gf_strdup (msg);
1250 ret = -1;
1251 goto out;
1252 }
1253
1254out:
1255 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-volume-ops.c", __FUNCTION__, 1255, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1256 return ret;
1257}
1258
1259int
1260glusterd_op_stage_clearlocks_volume (dict_t *dict, char **op_errstr)
1261{
1262 int ret = -1;
1263 char *volname = NULL((void*)0);
1264 char *path = NULL((void*)0);
1265 char *type = NULL((void*)0);
1266 char *kind = NULL((void*)0);
1267 glusterd_volinfo_t *volinfo = NULL((void*)0);
1268 char msg[2048] = {0,};
1269
1270 ret = dict_get_str (dict, "volname", &volname);
1271 if (ret) {
1272 snprintf (msg, sizeof(msg), "Failed to get volume name");
1273 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1273, GF_LOG_ERROR, "%s", msg); } while (0)
;
1274 *op_errstr = gf_strdup (msg);
1275 goto out;
1276 }
1277
1278 ret = dict_get_str (dict, "path", &path);
1279 if (ret) {
1280 snprintf (msg, sizeof(msg), "Failed to get path");
1281 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1281, GF_LOG_ERROR, "%s", msg); } while (0)
;
1282 *op_errstr = gf_strdup (msg);
1283 goto out;
1284 }
1285
1286 ret = dict_get_str (dict, "kind", &kind);
1287 if (ret) {
1288 snprintf (msg, sizeof(msg), "Failed to get kind");
1289 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1289, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1290 *op_errstr = gf_strdup (msg);
1291 goto out;
1292 }
1293
1294 ret = dict_get_str (dict, "type", &type);
1295 if (ret) {
1296 snprintf (msg, sizeof(msg), "Failed to get type");
1297 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1297, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1298 *op_errstr = gf_strdup (msg);
1299 goto out;
1300 }
1301
1302 ret = glusterd_volinfo_find (volname, &volinfo);
1303 if (ret) {
1304 snprintf (msg, sizeof(msg), "Volume %s does not exist",
1305 volname);
1306 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1306, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1307 *op_errstr = gf_strdup (msg);
1308 goto out;
1309 }
1310
1311 ret = glusterd_validate_volume_id (dict, volinfo);
1312 if (ret)
1313 goto out;
1314
1315 if (!glusterd_is_volume_started (volinfo)) {
1316 snprintf (msg, sizeof(msg), "Volume %s is not started",
1317 volname);
1318 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1318, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1319 *op_errstr = gf_strdup (msg);
1320 goto out;
1321 }
1322
1323 ret = 0;
1324out:
1325 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-volume-ops.c", __FUNCTION__, 1325, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1326 return ret;
1327}
1328
1329#ifdef HAVE_BD_XLATOR
1330int
1331glusterd_op_stage_bd (dict_t *dict, char **op_errstr)
1332{
1333 int ret = -1;
1334 char *volname = NULL((void*)0);
1335 char *path = NULL((void*)0);
1336 char *size = NULL((void*)0);
1337 glusterd_volinfo_t *volinfo = NULL((void*)0);
1338 char msg[2048] = {0,};
1339 gf_xl_bd_op_t bd_op = GF_BD_OP_INVALID;
1340 uint64_t bytes = 0;
1341
1342 ret = dict_get_str (dict, "volname", &volname);
1343 if (ret) {
1344 snprintf (msg, sizeof(msg), "Failed to get volume name");
1345 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1345, GF_LOG_ERROR, "%s", msg); } while (0)
;
1346 *op_errstr = gf_strdup (msg);
1347 goto out;
1348 }
1349
1350 ret = dict_get_int32 (dict, "bd-op", (int32_t *)&bd_op);
1351 if (ret) {
1352 snprintf (msg, sizeof(msg), "Failed to get bd-op");
1353 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1353, GF_LOG_ERROR, "%s", msg); } while (0)
;
1354 *op_errstr = gf_strdup (msg);
1355 goto out;
1356 }
1357
1358 ret = dict_get_str (dict, "path", &path);
1359 if (ret) {
1360 snprintf (msg, sizeof(msg), "Failed to get path");
1361 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1361, GF_LOG_ERROR, "%s", msg); } while (0)
;
1362 *op_errstr = gf_strdup (msg);
1363 goto out;
1364 }
1365
1366 if (bd_op == GF_BD_OP_NEW_BD) {
1367 ret = dict_get_str (dict, "size", &size);
1368 if (ret) {
1369 snprintf (msg, sizeof(msg), "Failed to get size");
1370 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1370, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1371 *op_errstr = gf_strdup (msg);
1372 goto out;
1373 }
1374 if (gf_string2bytesize (size, &bytes) < 0) {
1375 snprintf (msg, sizeof(msg),
1376 "Invalid size %s, suffix with KB, MB etc",
1377 size);
1378 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1378, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1379 *op_errstr = gf_strdup (msg);
1380 ret = -1;
1381 goto out;
1382 }
1383 } else if (bd_op == GF_BD_OP_SNAPSHOT_BD) {
1384 ret = dict_get_str (dict, "size", &size);
1385 if (ret) {
1386 snprintf (msg, sizeof(msg), "Failed to get size");
1387 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1387, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1388 *op_errstr = gf_strdup (msg);
1389 goto out;
1390 }
1391
1392 if (gf_string2bytesize (size, &bytes) < 0) {
1393 ret = -1;
1394 snprintf (msg, sizeof(msg),
1395 "Invalid size %s, suffix with KB, MB etc",
1396 size);
1397 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1397, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1398 *op_errstr = gf_strdup (msg);
1399 goto out;
1400 }
1401 }
1402
1403 ret = glusterd_volinfo_find (volname, &volinfo);
1404 if (ret) {
1405 snprintf (msg, sizeof(msg), "Volume %s does not exist",
1406 volname);
1407 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1407, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1408 *op_errstr = gf_strdup (msg);
1409 goto out;
1410 }
1411
1412 ret = glusterd_validate_volume_id (dict, volinfo);
1413 if (ret)
1414 goto out;
1415
1416 if (!glusterd_is_volume_started (volinfo)) {
1417 snprintf (msg, sizeof(msg), "Volume %s is not started",
1418 volname);
1419 gf_log ("", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log (""
, "glusterd-volume-ops.c", __FUNCTION__, 1419, GF_LOG_ERROR, "%s"
, msg); } while (0)
;
1420 *op_errstr = gf_strdup (msg);
1421 ret = -1;
1422 goto out;
1423 }
1424
1425 ret = 0;
1426out:
1427 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-volume-ops.c", __FUNCTION__, 1427, GF_LOG_DEBUG
, "Returning %d", ret); } while (0)
;
1428 return ret;
1429}
1430#endif
1431
1432int
1433glusterd_op_create_volume (dict_t *dict, char **op_errstr)
1434{
1435 int ret = 0;
1436 char *volname = NULL((void*)0);
1437 glusterd_conf_t *priv = NULL((void*)0);
1438 glusterd_volinfo_t *volinfo = NULL((void*)0);
1439 gf_boolean_t vol_added = _gf_false;
1440 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
1441 xlator_t *this = NULL((void*)0);
1442 char *brick = NULL((void*)0);
1443 int32_t count = 0;
1444 int32_t i = 1;
1445 char *bricks = NULL((void*)0);
1446 char *brick_list = NULL((void*)0);
1447 char *free_ptr = NULL((void*)0);
1448 char *saveptr = NULL((void*)0);
1449 char *trans_type = NULL((void*)0);
1450 char *str = NULL((void*)0);
1451 char *username = NULL((void*)0);
1452 char *password = NULL((void*)0);
1453#ifdef HAVE_BD_XLATOR
1454 char *device = NULL((void*)0);
1455#endif
1456
1457 this = THIS(*__glusterfs_this_location());
1458 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1458, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
1459
1460 priv = this->private;
1461 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1461, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0)
;
1462
1463 ret = glusterd_volinfo_new (&volinfo);
1464
1465 if (ret) {
1466 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Unable to allocate memory for volinfo"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1467, GF_LOG_ERROR, "Unable to allocate memory for volinfo"
); } while (0)
1467 "Unable to allocate memory for volinfo")do { do { if (0) printf ("Unable to allocate memory for volinfo"
); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1467, GF_LOG_ERROR, "Unable to allocate memory for volinfo"
); } while (0)
;
1468 goto out;
1469 }
1470
1471 ret = dict_get_str (dict, "volname", &volname);
1472
1473 if (ret) {
1474 gf_log (this->name, GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while
(0); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 1474, GF_LOG_ERROR, "Unable to get volume name"); } while (
0)
;
1475 goto out;
1476 }
1477
1478 strncpy (volinfo->volname, volname, GLUSTERD_MAX_VOLUME_NAME1000);
1479 GF_ASSERT (volinfo->volname)do { if (!(volinfo->volname)) { do { do { if (0) printf ("Assertion failed: "
"volinfo->volname"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1479, GF_LOG_ERROR, "Assertion failed: " "volinfo->volname"
); } while (0); } } while (0)
;
1480
1481 ret = dict_get_int32 (dict, "type", &volinfo->type);
1482 if (ret) {
1483 gf_log (this->name, GF_LOG_ERROR, "Unable to get type of volume"do { do { if (0) printf ("Unable to get type of volume" " %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1484, GF_LOG_ERROR, "Unable to get type of volume"
" %s", volname); } while (0)
1484 " %s", volname)do { do { if (0) printf ("Unable to get type of volume" " %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1484, GF_LOG_ERROR, "Unable to get type of volume"
" %s", volname); } while (0)
;
1485 goto out;
1486 }
1487
1488 ret = dict_get_int32 (dict, "count", &volinfo->brick_count);
1489 if (ret) {
1490 gf_log (this->name, GF_LOG_ERROR, "Unable to get brick count of"do { do { if (0) printf ("Unable to get brick count of" " volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1491, GF_LOG_ERROR, "Unable to get brick count of"
" volume %s", volname); } while (0)
1491 " volume %s", volname)do { do { if (0) printf ("Unable to get brick count of" " volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1491, GF_LOG_ERROR, "Unable to get brick count of"
" volume %s", volname); } while (0)
;
1492 goto out;
1493 }
1494
1495 ret = dict_get_int32 (dict, "port", &volinfo->port);
1496 if (ret) {
1497 gf_log (this->name, GF_LOG_ERROR, "Unable to get port")do { do { if (0) printf ("Unable to get port"); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1497,
GF_LOG_ERROR, "Unable to get port"); } while (0)
;
1498 goto out;
1499 }
1500
1501 count = volinfo->brick_count;
1502
1503 ret = dict_get_str (dict, "bricks", &bricks);
1504 if (ret) {
1505 gf_log (this->name, GF_LOG_ERROR, "Unable to get bricks for "do { do { if (0) printf ("Unable to get bricks for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1506, GF_LOG_ERROR, "Unable to get bricks for "
"volume %s", volname); } while (0)
1506 "volume %s", volname)do { do { if (0) printf ("Unable to get bricks for " "volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1506, GF_LOG_ERROR, "Unable to get bricks for "
"volume %s", volname); } while (0)
;
1507 goto out;
1508 }
1509
1510#ifdef HAVE_BD_XLATOR
1511 ret = dict_get_str (dict, "device", &device);
1512 if (!ret)
1513 volinfo->backend = GD_VOL_BK_BD;
1514#endif
1515
1516 /* replica-count 1 means, no replication, file is in one brick only */
1517 volinfo->replica_count = 1;
1518 /* stripe-count 1 means, no striping, file is present as a whole */
1519 volinfo->stripe_count = 1;
1520
1521 if (GF_CLUSTER_TYPE_REPLICATE == volinfo->type) {
1522 ret = dict_get_int32 (dict, "replica-count",
1523 &volinfo->replica_count);
1524 if (ret) {
1525 gf_log (this->name, GF_LOG_ERROR, "Failed to get "do { do { if (0) printf ("Failed to get " "replica count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1526, GF_LOG_ERROR, "Failed to get " "replica count for volume %s"
, volname); } while (0)
1526 "replica count for volume %s", volname)do { do { if (0) printf ("Failed to get " "replica count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1526, GF_LOG_ERROR, "Failed to get " "replica count for volume %s"
, volname); } while (0)
;
1527 goto out;
1528 }
1529 } else if (GF_CLUSTER_TYPE_STRIPE == volinfo->type) {
1530 ret = dict_get_int32 (dict, "stripe-count",
1531 &volinfo->stripe_count);
1532 if (ret) {
1533 gf_log (this->name, GF_LOG_ERROR, "Failed to get stripe"do { do { if (0) printf ("Failed to get stripe" " count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1534, GF_LOG_ERROR, "Failed to get stripe" " count for volume %s"
, volname); } while (0)
1534 " count for volume %s", volname)do { do { if (0) printf ("Failed to get stripe" " count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1534, GF_LOG_ERROR, "Failed to get stripe" " count for volume %s"
, volname); } while (0)
;
1535 goto out;
1536 }
1537 } else if (GF_CLUSTER_TYPE_STRIPE_REPLICATE == volinfo->type) {
1538 ret = dict_get_int32 (dict, "stripe-count",
1539 &volinfo->stripe_count);
1540 if (ret) {
1541 gf_log (this->name, GF_LOG_ERROR, "Failed to get stripe"do { do { if (0) printf ("Failed to get stripe" " count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1542, GF_LOG_ERROR, "Failed to get stripe" " count for volume %s"
, volname); } while (0)
1542 " count for volume %s", volname)do { do { if (0) printf ("Failed to get stripe" " count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1542, GF_LOG_ERROR, "Failed to get stripe" " count for volume %s"
, volname); } while (0)
;
1543 goto out;
1544 }
1545 ret = dict_get_int32 (dict, "replica-count",
1546 &volinfo->replica_count);
1547 if (ret) {
1548 gf_log (this->name, GF_LOG_ERROR, "Failed to get "do { do { if (0) printf ("Failed to get " "replica count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1549, GF_LOG_ERROR, "Failed to get " "replica count for volume %s"
, volname); } while (0)
1549 "replica count for volume %s", volname)do { do { if (0) printf ("Failed to get " "replica count for volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1549, GF_LOG_ERROR, "Failed to get " "replica count for volume %s"
, volname); } while (0)
;
1550 goto out;
1551 }
1552 }
1553
1554 /* dist-leaf-count is the count of brick nodes for a given
1555 subvolume of distribute */
1556 volinfo->dist_leaf_count = glusterd_get_dist_leaf_count (volinfo);
1557
1558 /* subvol_count is the count of number of subvolumes present
1559 for a given distribute volume */
1560 volinfo->subvol_count = (volinfo->brick_count /
1561 volinfo->dist_leaf_count);
1562
1563 /* Keep sub-count same as earlier, for the sake of backward
1564 compatibility */
1565 if (volinfo->dist_leaf_count > 1)
1566 volinfo->sub_count = volinfo->dist_leaf_count;
1567
1568 ret = dict_get_str (dict, "transport", &trans_type);
1569 if (ret) {
1570 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Unable to get transport type of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1571, GF_LOG_ERROR, "Unable to get transport type of volume %s"
, volname); } while (0)
1571 "Unable to get transport type of volume %s", volname)do { do { if (0) printf ("Unable to get transport type of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1571, GF_LOG_ERROR, "Unable to get transport type of volume %s"
, volname); } while (0)
;
1572 goto out;
1573 }
1574
1575 ret = dict_get_str (dict, "volume-id", &str);
1576 if (ret) {
1577 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Unable to get volume-id of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1578, GF_LOG_ERROR, "Unable to get volume-id of volume %s"
, volname); } while (0)
1578 "Unable to get volume-id of volume %s", volname)do { do { if (0) printf ("Unable to get volume-id of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1578, GF_LOG_ERROR, "Unable to get volume-id of volume %s"
, volname); } while (0)
;
1579 goto out;
1580 }
1581 ret = uuid_parse (str, volinfo->volume_id);
1582 if (ret) {
1583 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("unable to parse uuid %s of volume %s"
, str, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1584, GF_LOG_ERROR, "unable to parse uuid %s of volume %s"
, str, volname); } while (0)
1584 "unable to parse uuid %s of volume %s", str, volname)do { do { if (0) printf ("unable to parse uuid %s of volume %s"
, str, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1584, GF_LOG_ERROR, "unable to parse uuid %s of volume %s"
, str, volname); } while (0)
;
1585 goto out;
1586 }
1587
1588 ret = dict_get_str (dict, "internal-username", &username);
1589 if (ret) {
1590 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("unable to get internal username of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1592, GF_LOG_ERROR, "unable to get internal username of volume %s"
, volname); } while (0)
1591 "unable to get internal username of volume %s",do { do { if (0) printf ("unable to get internal username of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1592, GF_LOG_ERROR, "unable to get internal username of volume %s"
, volname); } while (0)
1592 volname)do { do { if (0) printf ("unable to get internal username of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1592, GF_LOG_ERROR, "unable to get internal username of volume %s"
, volname); } while (0)
;
1593 goto out;
1594 }
1595 glusterd_auth_set_username (volinfo, username);
1596
1597 ret = dict_get_str (dict, "internal-password", &password);
1598 if (ret) {
1599 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("unable to get internal password of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1601, GF_LOG_ERROR, "unable to get internal password of volume %s"
, volname); } while (0)
1600 "unable to get internal password of volume %s",do { do { if (0) printf ("unable to get internal password of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1601, GF_LOG_ERROR, "unable to get internal password of volume %s"
, volname); } while (0)
1601 volname)do { do { if (0) printf ("unable to get internal password of volume %s"
, volname); } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1601, GF_LOG_ERROR, "unable to get internal password of volume %s"
, volname); } while (0)
;
1602 goto out;
1603 }
1604 glusterd_auth_set_password (volinfo, password);
1605
1606 if (strcasecmp (trans_type, "rdma") == 0) {
1607 volinfo->transport_type = GF_TRANSPORT_RDMA;
1608 volinfo->nfs_transport_type = GF_TRANSPORT_RDMA;
1609 } else if (strcasecmp (trans_type, "tcp") == 0) {
1610 volinfo->transport_type = GF_TRANSPORT_TCP;
1611 volinfo->nfs_transport_type = GF_TRANSPORT_TCP;
1612 } else {
1613 volinfo->transport_type = GF_TRANSPORT_BOTH_TCP_RDMA;
1614 volinfo->nfs_transport_type = GF_DEFAULT_NFS_TRANSPORTGF_TRANSPORT_RDMA;
1615 }
1616
1617 if (bricks) {
1618 brick_list = gf_strdup (bricks);
1619 free_ptr = brick_list;
1620 }
1621
1622 if (count)
1623 brick = strtok_r (brick_list+1, " \n", &saveptr);
1624
1625 while ( i <= count) {
1626 ret = glusterd_brickinfo_new_from_brick (brick, &brickinfo);
1627 if (ret)
1628 goto out;
1629
1630 ret = glusterd_resolve_brick (brickinfo);
1631 if (ret) {
1632 gf_log (this->name, GF_LOG_ERROR, FMTSTR_RESOLVE_BRICK,do { do { if (0) printf ("Could not find peer on which brick %s:%s resides"
, brickinfo->hostname, brickinfo->path); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1633,
GF_LOG_ERROR, "Could not find peer on which brick %s:%s resides"
, brickinfo->hostname, brickinfo->path); } while (0)
1633 brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Could not find peer on which brick %s:%s resides"
, brickinfo->hostname, brickinfo->path); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1633,
GF_LOG_ERROR, "Could not find peer on which brick %s:%s resides"
, brickinfo->hostname, brickinfo->path); } while (0)
;
1634 goto out;
1635 }
1636 list_add_tail (&brickinfo->brick_list, &volinfo->bricks);
1637 brick = strtok_r (NULL((void*)0), " \n", &saveptr);
1638 i++;
1639 }
1640
1641 ret = glusterd_store_volinfo (volinfo, GLUSTERD_VOLINFO_VER_AC_INCREMENT);
1642 if (ret) {
1643 glusterd_store_delete_volume (volinfo);
1644 *op_errstr = gf_strdup ("Failed to store the Volume information");
1645 goto out;
1646 }
1647
1648 ret = glusterd_create_volfiles_and_notify_services (volinfo);
1649 if (ret) {
1650 *op_errstr = gf_strdup ("Failed to create volume files");
1651 goto out;
1652 }
1653
1654 volinfo->rebal.defrag_status = 0;
1655 list_add_tail (&volinfo->vol_list, &priv->volumes);
1656 vol_added = _gf_true;
1657
1658 gd_update_volume_op_versions (volinfo);
1659out:
1660 GF_FREE(free_ptr)__gf_free (free_ptr);
1661 if (!vol_added && volinfo)
1662 glusterd_volinfo_delete (volinfo);
1663 return ret;
1664}
1665
1666int
1667glusterd_op_start_volume (dict_t *dict, char **op_errstr)
1668{
1669 int ret = 0;
1670 char *volname = NULL((void*)0);
1671 int flags = 0;
1672 glusterd_volinfo_t *volinfo = NULL((void*)0);
1673 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
1674 xlator_t *this = NULL((void*)0);
1675
1676 this = THIS(*__glusterfs_this_location());
1677 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1677, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
1678
1679 ret = glusterd_op_start_volume_args_get (dict, &volname, &flags)glusterd_op_stop_volume_args_get (dict, &volname, &flags
)
;
1680 if (ret)
1681 goto out;
1682
1683 ret = glusterd_volinfo_find (volname, &volinfo);
1684 if (ret) {
1685 gf_log (this->name, GF_LOG_ERROR, FMTSTR_CHECK_VOL_EXISTS,do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1686, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
1686 volname)do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1686, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
;
1687 goto out;
1688 }
1689
1690 list_for_each_entry (brickinfo, &volinfo->bricks, brick_list)for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo
->bricks)->next)-(unsigned long)(&((typeof(*brickinfo
) *)0)->brick_list))); &brickinfo->brick_list != (&
volinfo->bricks); brickinfo = ((typeof(*brickinfo) *)((char
*)(brickinfo->brick_list.next)-(unsigned long)(&((typeof
(*brickinfo) *)0)->brick_list))))
{
1691 ret = glusterd_brick_start (volinfo, brickinfo, _gf_true);
1692 if (ret)
1693 goto out;
1694 }
1695
1696 glusterd_set_volume_status (volinfo, GLUSTERD_STATUS_STARTED);
1697
1698 ret = glusterd_store_volinfo (volinfo, GLUSTERD_VOLINFO_VER_AC_INCREMENT);
1699 if (ret)
1700 goto out;
1701
1702 ret = glusterd_nodesvcs_handle_graph_change (volinfo);
1703
1704out:
1705 gf_log (this->name, GF_LOG_DEBUG, "returning %d ", ret)do { do { if (0) printf ("returning %d ", ret); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1705,
GF_LOG_DEBUG, "returning %d ", ret); } while (0)
;
1706 return ret;
1707}
1708
1709
1710int
1711glusterd_op_stop_volume (dict_t *dict)
1712{
1713 int ret = 0;
1714 int flags = 0;
1715 char *volname = NULL((void*)0);
1716 glusterd_volinfo_t *volinfo = NULL((void*)0);
1717 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
1718 xlator_t *this = NULL((void*)0);
1719
1720 this = THIS(*__glusterfs_this_location());
1
Value assigned to 'this'
1721 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1721, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
2
Within the expansion of the macro 'GF_ASSERT':
a
Assuming 'this' is null
1722
1723 ret = glusterd_op_stop_volume_args_get (dict, &volname, &flags);
1724 if (ret)
3
Taking false branch
1725 goto out;
1726
1727 ret = glusterd_volinfo_find (volname, &volinfo);
1728 if (ret) {
4
Assuming 'ret' is not equal to 0
5
Taking true branch
1729 gf_log (this->name, GF_LOG_ERROR, FMTSTR_CHECK_VOL_EXISTS,do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1730, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
6
Within the expansion of the macro 'gf_log':
a
Access to field 'name' results in a dereference of a null pointer (loaded from variable 'this')
1730 volname)do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1730, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
;
1731 goto out;
1732 }
1733
1734 list_for_each_entry (brickinfo, &volinfo->bricks, brick_list)for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo
->bricks)->next)-(unsigned long)(&((typeof(*brickinfo
) *)0)->brick_list))); &brickinfo->brick_list != (&
volinfo->bricks); brickinfo = ((typeof(*brickinfo) *)((char
*)(brickinfo->brick_list.next)-(unsigned long)(&((typeof
(*brickinfo) *)0)->brick_list))))
{
1735 ret = glusterd_brick_stop (volinfo, brickinfo, _gf_false);
1736 if (ret)
1737 goto out;
1738 }
1739
1740 glusterd_set_volume_status (volinfo, GLUSTERD_STATUS_STOPPED);
1741
1742 ret = glusterd_store_volinfo (volinfo, GLUSTERD_VOLINFO_VER_AC_INCREMENT);
1743 if (ret)
1744 goto out;
1745
1746 ret = glusterd_nodesvcs_handle_graph_change (volinfo);
1747out:
1748 return ret;
1749}
1750
1751int
1752glusterd_op_delete_volume (dict_t *dict)
1753{
1754 int ret = 0;
1755 char *volname = NULL((void*)0);
1756 glusterd_conf_t *priv = NULL((void*)0);
1757 glusterd_volinfo_t *volinfo = NULL((void*)0);
1758 xlator_t *this = NULL((void*)0);
1759
1760 this = THIS(*__glusterfs_this_location());
1761 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1761, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0)
;
1762 priv = this->private;
1763 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1763, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0)
;
1764
1765 ret = dict_get_str (dict, "volname", &volname);
1766 if (ret) {
1767 gf_log (this->name, GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while
(0); _gf_log (this->name, "glusterd-volume-ops.c", __FUNCTION__
, 1767, GF_LOG_ERROR, "Unable to get volume name"); } while (
0)
;
1768 goto out;
1769 }
1770
1771 ret = glusterd_volinfo_find (volname, &volinfo);
1772 if (ret) {
1773 gf_log (this->name, GF_LOG_ERROR, FMTSTR_CHECK_VOL_EXISTS,do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1774, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
1774 volname)do { do { if (0) printf ("Volume %s does not exist", volname)
; } while (0); _gf_log (this->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1774, GF_LOG_ERROR, "Volume %s does not exist"
, volname); } while (0)
;
1775 goto out;
1776 }
1777
1778 ret = glusterd_delete_volume (volinfo);
1779out:
1780 gf_log (this->name, GF_LOG_DEBUG, "returning %d", ret)do { do { if (0) printf ("returning %d", ret); } while (0); _gf_log
(this->name, "glusterd-volume-ops.c", __FUNCTION__, 1780,
GF_LOG_DEBUG, "returning %d", ret); } while (0)
;
1781 return ret;
1782}
1783
1784int
1785glusterd_op_heal_volume (dict_t *dict, char **op_errstr)
1786{
1787 int ret = 0;
1788 /* Necessary subtasks of heal are completed in brick op */
1789
1790 return ret;
1791}
1792
1793int
1794glusterd_op_statedump_volume (dict_t *dict, char **op_errstr)
1795{
1796 int ret = 0;
1797 char *volname = NULL((void*)0);
1798 char *options = NULL((void*)0);
1799 int option_cnt = 0;
1800 glusterd_volinfo_t *volinfo = NULL((void*)0);
1801 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
1802
1803 ret = glusterd_op_statedump_volume_args_get (dict, &volname, &options,
1804 &option_cnt);
1805 if (ret)
1806 goto out;
1807
1808 ret = glusterd_volinfo_find (volname, &volinfo);
1809 if (ret)
1810 goto out;
1811 gf_log ("", GF_LOG_DEBUG, "Performing statedump on volume %s", volname)do { do { if (0) printf ("Performing statedump on volume %s",
volname); } while (0); _gf_log ("", "glusterd-volume-ops.c",
__FUNCTION__, 1811, GF_LOG_DEBUG, "Performing statedump on volume %s"
, volname); } while (0)
;
1812 if (strstr (options, "nfs") != NULL((void*)0)) {
1813 ret = glusterd_nfs_statedump (options, option_cnt, op_errstr);
1814 if (ret)
1815 goto out;
1816 } else {
1817 list_for_each_entry (brickinfo, &volinfo->bricks,for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo
->bricks)->next)-(unsigned long)(&((typeof(*brickinfo
) *)0)->brick_list))); &brickinfo->brick_list != (&
volinfo->bricks); brickinfo = ((typeof(*brickinfo) *)((char
*)(brickinfo->brick_list.next)-(unsigned long)(&((typeof
(*brickinfo) *)0)->brick_list))))
1818 brick_list)for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo
->bricks)->next)-(unsigned long)(&((typeof(*brickinfo
) *)0)->brick_list))); &brickinfo->brick_list != (&
volinfo->bricks); brickinfo = ((typeof(*brickinfo) *)((char
*)(brickinfo->brick_list.next)-(unsigned long)(&((typeof
(*brickinfo) *)0)->brick_list))))
{
1819 ret = glusterd_brick_statedump (volinfo, brickinfo,
1820 options, option_cnt,
1821 op_errstr);
1822 /* Let us take the statedump of other bricks instead of
1823 * exiting, if statedump of this brick fails.
1824 */
1825 if (ret)
1826 gf_log (THIS->name, GF_LOG_WARNING, "could not "do { do { if (0) printf ("could not " "take the statedump of the brick %s:%s."
" Proceeding to other bricks", brickinfo->hostname, brickinfo
->path); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-volume-ops.c", __FUNCTION__, 1829, GF_LOG_WARNING
, "could not " "take the statedump of the brick %s:%s." " Proceeding to other bricks"
, brickinfo->hostname, brickinfo->path); } while (0)
1827 "take the statedump of the brick %s:%s."do { do { if (0) printf ("could not " "take the statedump of the brick %s:%s."
" Proceeding to other bricks", brickinfo->hostname, brickinfo
->path); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-volume-ops.c", __FUNCTION__, 1829, GF_LOG_WARNING
, "could not " "take the statedump of the brick %s:%s." " Proceeding to other bricks"
, brickinfo->hostname, brickinfo->path); } while (0)
1828 " Proceeding to other bricks",do { do { if (0) printf ("could not " "take the statedump of the brick %s:%s."
" Proceeding to other bricks", brickinfo->hostname, brickinfo
->path); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-volume-ops.c", __FUNCTION__, 1829, GF_LOG_WARNING
, "could not " "take the statedump of the brick %s:%s." " Proceeding to other bricks"
, brickinfo->hostname, brickinfo->path); } while (0)
1829 brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("could not " "take the statedump of the brick %s:%s."
" Proceeding to other bricks", brickinfo->hostname, brickinfo
->path); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-volume-ops.c", __FUNCTION__, 1829, GF_LOG_WARNING
, "could not " "take the statedump of the brick %s:%s." " Proceeding to other bricks"
, brickinfo->hostname, brickinfo->path); } while (0)
;
1830 }
1831 }
1832
1833out:
1834 return ret;
1835}
1836
1837int
1838glusterd_clearlocks_send_cmd (glusterd_volinfo_t *volinfo, char *cmd,
1839 char *path, char *result, char *errstr,
1840 int err_len, char *mntpt)
1841{
1842 int ret = -1;
1843 glusterd_conf_t *priv = NULL((void*)0);
1844 char abspath[PATH_MAX4096] = {0, };
1845
1846 priv = THIS(*__glusterfs_this_location())->private;
1847
1848 snprintf (abspath, sizeof (abspath), "%s/%s", mntpt, path);
1849 ret = sys_lgetxattr (abspath, cmd, result, PATH_MAX4096);
1850 if (ret < 0) {
1851 snprintf (errstr, err_len, "clear-locks getxattr command "
1852 "failed. Reason: %s", strerror (errno(*__errno_location ())));
1853 gf_log (THIS->name, GF_LOG_DEBUG, "%s", errstr)do { do { if (0) printf ("%s", errstr); } while (0); _gf_log (
(*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1853, GF_LOG_DEBUG, "%s", errstr); } while (0
)
;
1854 goto out;
1855 }
1856
1857 ret = 0;
1858out:
1859 return ret;
1860}
1861
1862int
1863glusterd_clearlocks_rmdir_mount (glusterd_volinfo_t *volinfo, char *mntpt)
1864{
1865 int ret = -1;
1866 glusterd_conf_t *priv = NULL((void*)0);
1867
1868 priv = THIS(*__glusterfs_this_location())->private;
1869
1870 ret = rmdir (mntpt);
1871 if (ret) {
1872 gf_log (THIS->name, GF_LOG_DEBUG, "rmdir failed")do { do { if (0) printf ("rmdir failed"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1872, GF_LOG_DEBUG, "rmdir failed"); } while (
0)
;
1873 goto out;
1874 }
1875
1876 ret = 0;
1877out:
1878 return ret;
1879}
1880
1881void
1882glusterd_clearlocks_unmount (glusterd_volinfo_t *volinfo, char *mntpt)
1883{
1884 glusterd_conf_t *priv = NULL((void*)0);
1885 runner_t runner = {0,};
1886 int ret = 0;
1887
1888 priv = THIS(*__glusterfs_this_location())->private;
1889
1890 /*umount failures are ignored. Using stat we could have avoided
1891 * attempting to unmount a non-existent filesystem. But a failure of
1892 * stat() on mount can be due to network failures.*/
1893
1894 runinit (&runner);
1895 runner_add_args (&runner, "/bin/umount", "-f", NULL((void*)0));
1896 runner_argprintf (&runner, "%s", mntpt);
1897
1898 synclock_unlock (&priv->big_lock);
1899 ret = runner_run (&runner);
1900 synclock_lock (&priv->big_lock);
1901 if (ret) {
1902 ret = 0;
1903 gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("umount failed on maintenance client"
); } while (0); _gf_log ("", "glusterd-volume-ops.c", __FUNCTION__
, 1904, GF_LOG_DEBUG, "umount failed on maintenance client");
} while (0)
1904 "umount failed on maintenance client")do { do { if (0) printf ("umount failed on maintenance client"
); } while (0); _gf_log ("", "glusterd-volume-ops.c", __FUNCTION__
, 1904, GF_LOG_DEBUG, "umount failed on maintenance client");
} while (0)
;
1905 }
1906
1907 return;
1908}
1909
1910int
1911glusterd_clearlocks_create_mount (glusterd_volinfo_t *volinfo, char **mntpt)
1912{
1913 int ret = -1;
1914 glusterd_conf_t *priv = NULL((void*)0);
1915 char template[PATH_MAX4096] = {0,};
1916 char *tmpl = NULL((void*)0);
1917
1918 priv = THIS(*__glusterfs_this_location())->private;
1919
1920 snprintf (template, sizeof (template), "/tmp/%s.XXXXXX",
1921 volinfo->volname);
1922 tmpl = mkdtemp (template);
1923 if (!tmpl) {
1924 gf_log (THIS->name, GF_LOG_DEBUG, "Couldn't create temporary "do { do { if (0) printf ("Couldn't create temporary " "mount directory. Reason %s"
, strerror ((*__errno_location ()))); } while (0); _gf_log ((
*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1925, GF_LOG_DEBUG, "Couldn't create temporary "
"mount directory. Reason %s", strerror ((*__errno_location (
)))); } while (0)
1925 "mount directory. Reason %s", strerror (errno))do { do { if (0) printf ("Couldn't create temporary " "mount directory. Reason %s"
, strerror ((*__errno_location ()))); } while (0); _gf_log ((
*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1925, GF_LOG_DEBUG, "Couldn't create temporary "
"mount directory. Reason %s", strerror ((*__errno_location (
)))); } while (0)
;
1926 goto out;
1927 }
1928
1929 *mntpt = gf_strdup (tmpl);
1930 ret = 0;
1931out:
1932 return ret;
1933}
1934
1935int
1936glusterd_clearlocks_mount (glusterd_volinfo_t *volinfo, char **xl_opts,
1937 char *mntpt)
1938{
1939 int ret = -1;
1940 int i = 0;
1941 glusterd_conf_t *priv = NULL((void*)0);
1942 runner_t runner = {0,};
1943 char client_volfpath[PATH_MAX4096] = {0,};
1944 char self_heal_opts[3][1024] = {"*replicate*.data-self-heal=off",
1945 "*replicate*.metadata-self-heal=off",
1946 "*replicate*.entry-self-heal=off"};
1947
1948 priv = THIS(*__glusterfs_this_location())->private;
1949
1950 runinit (&runner);
1951 glusterd_get_trusted_client_filepath (client_volfpath, volinfo,
1952 volinfo->transport_type);
1953 runner_add_args (&runner, SBIN_DIR"/usr/local/sbin""/glusterfs", "-f", NULL((void*)0));
1954 runner_argprintf (&runner, "%s", client_volfpath);
1955 runner_add_arg (&runner, "-l");
1956 runner_argprintf (&runner, DEFAULT_LOG_FILE_DIRECTORY"/usr/local/var" "/log/glusterfs"
1957 "/%s-clearlocks-mnt.log", volinfo->volname);
1958 if (volinfo->memory_accounting)
1959 runner_add_arg (&runner, "--mem-accounting");
1960
1961 for (i = 0; i < volinfo->brick_count && xl_opts[i]; i++) {
1962 runner_add_arg (&runner, "--xlator-option");
1963 runner_argprintf (&runner, "%s", xl_opts[i]);
1964 }
1965
1966 for (i = 0; i < 3; i++) {
1967 runner_add_args (&runner, "--xlator-option",
1968 self_heal_opts[i], NULL((void*)0));
1969 }
1970
1971 runner_argprintf (&runner, "%s", mntpt);
1972 synclock_unlock (&priv->big_lock);
1973 ret = runner_run (&runner);
1974 synclock_lock (&priv->big_lock);
1975 if (ret) {
1976 gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("Could not start glusterfs"); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1977, GF_LOG_DEBUG, "Could not start glusterfs"
); } while (0)
1977 "Could not start glusterfs")do { do { if (0) printf ("Could not start glusterfs"); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 1977, GF_LOG_DEBUG, "Could not start glusterfs"
); } while (0)
;
1978 goto out;
1979 }
1980 gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("Started glusterfs successfully"); }
while (0); _gf_log ((*__glusterfs_this_location())->name,
"glusterd-volume-ops.c", __FUNCTION__, 1981, GF_LOG_DEBUG, "Started glusterfs successfully"
); } while (0)
1981 "Started glusterfs successfully")do { do { if (0) printf ("Started glusterfs successfully"); }
while (0); _gf_log ((*__glusterfs_this_location())->name,
"glusterd-volume-ops.c", __FUNCTION__, 1981, GF_LOG_DEBUG, "Started glusterfs successfully"
); } while (0)
;
1982
1983out:
1984 return ret;
1985}
1986
1987int
1988glusterd_clearlocks_get_local_client_ports (glusterd_volinfo_t *volinfo,
1989 char **xl_opts)
1990{
1991 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
1992 glusterd_conf_t *priv = NULL((void*)0);
1993 int index = 0;
1994 int ret = -1;
1995 int i = 0;
1996 int port = 0;
1997
1998 GF_ASSERT (xl_opts)do { if (!(xl_opts)) { do { do { if (0) printf ("Assertion failed: "
"xl_opts"); } while (0); _gf_log_callingfn ("", "glusterd-volume-ops.c"
, __FUNCTION__, 1998, GF_LOG_ERROR, "Assertion failed: " "xl_opts"
); } while (0); } } while (0)
;
1999 if (!xl_opts) {
2000 gf_log (THIS->name, GF_LOG_DEBUG, "Should pass non-NULL "do { do { if (0) printf ("Should pass non-NULL " "xl_opts"); }
while (0); _gf_log ((*__glusterfs_this_location())->name,
"glusterd-volume-ops.c", __FUNCTION__, 2001, GF_LOG_DEBUG, "Should pass non-NULL "
"xl_opts"); } while (0)
2001 "xl_opts")do { do { if (0) printf ("Should pass non-NULL " "xl_opts"); }
while (0); _gf_log ((*__glusterfs_this_location())->name,
"glusterd-volume-ops.c", __FUNCTION__, 2001, GF_LOG_DEBUG, "Should pass non-NULL "
"xl_opts"); } while (0)
;
2002 goto out;
2003 }
2004
2005 priv = THIS(*__glusterfs_this_location())->private;
2006
2007 index = -1;
2008 list_for_each_entry (brickinfo, &volinfo->bricks, brick_list)for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo
->bricks)->next)-(unsigned long)(&((typeof(*brickinfo
) *)0)->brick_list))); &brickinfo->brick_list != (&
volinfo->bricks); brickinfo = ((typeof(*brickinfo) *)((char
*)(brickinfo->brick_list.next)-(unsigned long)(&((typeof
(*brickinfo) *)0)->brick_list))))
{
2009 index++;
2010 if (uuid_compare (brickinfo->uuid, MY_UUID(__glusterd_uuid())))
2011 continue;
2012
2013 port = pmap_registry_search (THIS(*__glusterfs_this_location()), brickinfo->path,
2014 GF_PMAP_PORT_BRICKSERVER);
2015 if (!port) {
2016 ret = -1;
2017 gf_log (THIS->name, GF_LOG_DEBUG, "Couldn't get port "do { do { if (0) printf ("Couldn't get port " " for brick %s:%s"
, brickinfo->hostname, brickinfo->path); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2019, GF_LOG_DEBUG, "Couldn't get port " " for brick %s:%s"
, brickinfo->hostname, brickinfo->path); } while (0)
2018 " for brick %s:%s", brickinfo->hostname,do { do { if (0) printf ("Couldn't get port " " for brick %s:%s"
, brickinfo->hostname, brickinfo->path); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2019, GF_LOG_DEBUG, "Couldn't get port " " for brick %s:%s"
, brickinfo->hostname, brickinfo->path); } while (0)
2019 brickinfo->path)do { do { if (0) printf ("Couldn't get port " " for brick %s:%s"
, brickinfo->hostname, brickinfo->path); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2019, GF_LOG_DEBUG, "Couldn't get port " " for brick %s:%s"
, brickinfo->hostname, brickinfo->path); } while (0)
;
2020 goto out;
2021 }
2022
2023 ret = gf_asprintf (&xl_opts[i], "%s-client-%d.remote-port=%d",
2024 volinfo->volname, index, port);
2025 if (ret == -1) {
2026 xl_opts[i] = NULL((void*)0);
2027 goto out;
2028 }
2029 i++;
2030 }
2031
2032 ret = 0;
2033out:
2034 return ret;
2035}
2036
2037int
2038glusterd_op_clearlocks_volume (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
2039{
2040 int32_t ret = -1;
2041 int i = 0;
2042 char *volname = NULL((void*)0);
2043 char *path = NULL((void*)0);
2044 char *kind = NULL((void*)0);
2045 char *type = NULL((void*)0);
2046 char *opts = NULL((void*)0);
2047 char *cmd_str = NULL((void*)0);
2048 char *free_ptr = NULL((void*)0);
2049 char msg[PATH_MAX4096] = {0,};
2050 char result[PATH_MAX4096] = {0,};
2051 char *mntpt = NULL((void*)0);
2052 char **xl_opts = NULL((void*)0);
2053 glusterd_volinfo_t *volinfo = NULL((void*)0);
2054
2055 ret = dict_get_str (dict, "volname", &volname);
2056 if (ret) {
2057 gf_log (THIS->name, GF_LOG_ERROR, "Failed to get volume name")do { do { if (0) printf ("Failed to get volume name"); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2057, GF_LOG_ERROR, "Failed to get volume name"
); } while (0)
;
2058 goto out;
2059 }
2060 gf_log ("", GF_LOG_DEBUG, "Performing clearlocks on volume %s", volname)do { do { if (0) printf ("Performing clearlocks on volume %s"
, volname); } while (0); _gf_log ("", "glusterd-volume-ops.c"
, __FUNCTION__, 2060, GF_LOG_DEBUG, "Performing clearlocks on volume %s"
, volname); } while (0)
;
2061
2062 ret = dict_get_str (dict, "path", &path);
2063 if (ret) {
2064 gf_log (THIS->name, GF_LOG_ERROR, "Failed to get path")do { do { if (0) printf ("Failed to get path"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2064, GF_LOG_ERROR, "Failed to get path"); } while
(0)
;
2065 goto out;
2066 }
2067
2068 ret = dict_get_str (dict, "kind", &kind);
2069 if (ret) {
2070 gf_log (THIS->name, GF_LOG_ERROR, "Failed to get kind")do { do { if (0) printf ("Failed to get kind"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2070, GF_LOG_ERROR, "Failed to get kind"); } while
(0)
;
2071 goto out;
2072 }
2073
2074 ret = dict_get_str (dict, "type", &type);
2075 if (ret) {
2076 gf_log (THIS->name, GF_LOG_ERROR, "Failed to get type")do { do { if (0) printf ("Failed to get type"); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2076, GF_LOG_ERROR, "Failed to get type"); } while
(0)
;
2077 goto out;
2078 }
2079
2080 ret = dict_get_str (dict, "opts", &opts);
2081 if (ret)
2082 ret = 0;
2083
2084 gf_log (THIS->name, GF_LOG_INFO, "Received clear-locks request for "do { do { if (0) printf ("Received clear-locks request for " "volume %s with kind %s type %s and options %s"
, volname, kind, type, opts); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-volume-ops.c", __FUNCTION__, 2086, GF_LOG_INFO
, "Received clear-locks request for " "volume %s with kind %s type %s and options %s"
, volname, kind, type, opts); } while (0)
2085 "volume %s with kind %s type %s and options %s", volname,do { do { if (0) printf ("Received clear-locks request for " "volume %s with kind %s type %s and options %s"
, volname, kind, type, opts); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-volume-ops.c", __FUNCTION__, 2086, GF_LOG_INFO
, "Received clear-locks request for " "volume %s with kind %s type %s and options %s"
, volname, kind, type, opts); } while (0)
2086 kind, type, opts)do { do { if (0) printf ("Received clear-locks request for " "volume %s with kind %s type %s and options %s"
, volname, kind, type, opts); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-volume-ops.c", __FUNCTION__, 2086, GF_LOG_INFO
, "Received clear-locks request for " "volume %s with kind %s type %s and options %s"
, volname, kind, type, opts); } while (0)
;
2087
2088 if (opts)
2089 ret = gf_asprintf (&cmd_str, GF_XATTR_CLRLK_CMD"glusterfs.clrlk"".t%s.k%s.%s",
2090 type, kind, opts);
2091 else
2092 ret = gf_asprintf (&cmd_str, GF_XATTR_CLRLK_CMD"glusterfs.clrlk"".t%s.k%s",
2093 type, kind);
2094 if (ret == -1)
2095 goto out;
2096
2097 ret = glusterd_volinfo_find (volname, &volinfo);
2098 if (ret) {
2099 snprintf (msg, sizeof (msg), "Volume %s doesn't exist.",
2100 volname);
2101 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2101, GF_LOG_ERROR, "%s", msg); } while (0)
;
2102 goto out;
2103 }
2104
2105 xl_opts = GF_CALLOC (volinfo->brick_count+1, sizeof (char*),__gf_calloc (volinfo->brick_count+1, sizeof (char*), gf_gld_mt_charptr
)
2106 gf_gld_mt_charptr)__gf_calloc (volinfo->brick_count+1, sizeof (char*), gf_gld_mt_charptr
)
;
2107 if (!xl_opts)
2108 goto out;
2109
2110 ret = glusterd_clearlocks_get_local_client_ports (volinfo, xl_opts);
2111 if (ret) {
2112 snprintf (msg, sizeof (msg), "Couldn't get port numbers of "
2113 "local bricks");
2114 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2114, GF_LOG_ERROR, "%s", msg); } while (0)
;
2115 goto out;
2116 }
2117
2118 ret = glusterd_clearlocks_create_mount (volinfo, &mntpt);
2119 if (ret) {
2120 snprintf (msg, sizeof (msg), "Creating mount directory "
2121 "for clear-locks failed.");
2122 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2122, GF_LOG_ERROR, "%s", msg); } while (0)
;
2123 goto out;
2124 }
2125
2126 ret = glusterd_clearlocks_mount (volinfo, xl_opts, mntpt);
2127 if (ret) {
2128 snprintf (msg, sizeof (msg), "Failed to mount clear-locks "
2129 "maintenance client.");
2130 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2130, GF_LOG_ERROR, "%s", msg); } while (0)
;
2131 goto out;
2132 }
2133
2134 ret = glusterd_clearlocks_send_cmd (volinfo, cmd_str, path, result,
2135 msg, sizeof (msg), mntpt);
2136 if (ret) {
2137 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2137, GF_LOG_ERROR, "%s", msg); } while (0)
;
2138 goto umount;
2139 }
2140
2141 free_ptr = gf_strdup(result);
2142 if (dict_set_dynstr (rsp_dict, "lk-summary", free_ptr)) {
2143 GF_FREE (free_ptr)__gf_free (free_ptr);
2144 snprintf (msg, sizeof (msg), "Failed to set clear-locks "
2145 "result");
2146 gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "glusterd-volume-ops.c"
, __FUNCTION__, 2146, GF_LOG_ERROR, "%s", msg); } while (0)
;
2147 }
2148
2149umount:
2150 glusterd_clearlocks_unmount (volinfo, mntpt);
2151
2152 if (glusterd_clearlocks_rmdir_mount (volinfo, mntpt))
2153 gf_log (THIS->name, GF_LOG_WARNING, "Couldn't unmount "do { do { if (0) printf ("Couldn't unmount " "clear-locks mount point"
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-volume-ops.c", __FUNCTION__, 2154, GF_LOG_WARNING
, "Couldn't unmount " "clear-locks mount point"); } while (0)
2154 "clear-locks mount point")do { do { if (0) printf ("Couldn't unmount " "clear-locks mount point"
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-volume-ops.c", __FUNCTION__, 2154, GF_LOG_WARNING
, "Couldn't unmount " "clear-locks mount point"); } while (0)
;
2155
2156out:
2157 if (ret)
2158 *op_errstr = gf_strdup (msg);
2159
2160 if (xl_opts) {
2161 for (i = 0; i < volinfo->brick_count && xl_opts[i]; i++)
2162 GF_FREE (xl_opts[i])__gf_free (xl_opts[i]);
2163 GF_FREE (xl_opts)__gf_free (xl_opts);
2164 }
2165
2166 GF_FREE (cmd_str)__gf_free (cmd_str);
2167
2168 GF_FREE (mntpt)__gf_free (mntpt);
2169
2170 return ret;
2171}