File: | xlators/mgmt/glusterd/src/glusterd-volume-ops.c |
Location: | line 868, column 16 |
Description: | Access to field 'private' results in a dereference of a null pointer (loaded from variable 'this') |
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 | ||||
33 | int | |||
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 | ||||
175 | out: | |||
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 | ||||
194 | int | |||
195 | glusterd_handle_create_volume (rpcsvc_request_t *req) | |||
196 | { | |||
197 | return glusterd_big_locked_handler (req, | |||
198 | __glusterd_handle_create_volume); | |||
199 | } | |||
200 | ||||
201 | int | |||
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 | ||||
254 | out: | |||
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 | ||||
267 | int | |||
268 | glusterd_handle_cli_start_volume (rpcsvc_request_t *req) | |||
269 | { | |||
270 | return glusterd_big_locked_handler (req, | |||
271 | __glusterd_handle_cli_start_volume); | |||
272 | } | |||
273 | ||||
274 | int | |||
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 | ||||
328 | out: | |||
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 | ||||
342 | int | |||
343 | glusterd_handle_cli_stop_volume (rpcsvc_request_t *req) | |||
344 | { | |||
345 | return glusterd_big_locked_handler (req, | |||
346 | __glusterd_handle_cli_stop_volume); | |||
347 | } | |||
348 | ||||
349 | int | |||
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 | ||||
405 | out: | |||
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 | ||||
419 | int | |||
420 | glusterd_handle_cli_delete_volume (rpcsvc_request_t *req) | |||
421 | { | |||
422 | return glusterd_big_locked_handler (req, | |||
423 | __glusterd_handle_cli_delete_volume); | |||
424 | } | |||
425 | ||||
426 | int | |||
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 | ||||
498 | out: | |||
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 | ||||
510 | int | |||
511 | glusterd_handle_cli_heal_volume (rpcsvc_request_t *req) | |||
512 | { | |||
513 | return glusterd_big_locked_handler (req, | |||
514 | __glusterd_handle_cli_heal_volume); | |||
515 | } | |||
516 | ||||
517 | int | |||
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 | ||||
586 | out: | |||
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 | ||||
599 | int | |||
600 | glusterd_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 | |||
607 | int | |||
608 | glusterd_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; | |||
627 | out: | |||
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 */ | |||
637 | int | |||
638 | glusterd_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 | } | |||
778 | out: | |||
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 | ||||
792 | int | |||
793 | glusterd_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 | } | |||
815 | out: | |||
816 | return ret; | |||
817 | } | |||
818 | ||||
819 | int | |||
820 | glusterd_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 | ||||
846 | out: | |||
847 | return ret; | |||
848 | } | |||
849 | ||||
850 | int | |||
851 | glusterd_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; | |||
948 | out: | |||
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 | ||||
956 | int | |||
957 | glusterd_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 | ||||
1047 | out: | |||
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 | ||||
1055 | int | |||
1056 | glusterd_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 | ||||
1103 | out: | |||
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 | ||||
1113 | int | |||
1114 | glusterd_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; | |||
1209 | out: | |||
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 | ||||
1215 | int | |||
1216 | glusterd_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 | ||||
1254 | out: | |||
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 | ||||
1259 | int | |||
1260 | glusterd_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; | |||
1324 | out: | |||
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 | |||
1330 | int | |||
1331 | glusterd_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; | |||
1426 | out: | |||
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 | ||||
1432 | int | |||
1433 | glusterd_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); | |||
1659 | out: | |||
1660 | GF_FREE(free_ptr)__gf_free (free_ptr); | |||
1661 | if (!vol_added && volinfo) | |||
1662 | glusterd_volinfo_delete (volinfo); | |||
1663 | return ret; | |||
1664 | } | |||
1665 | ||||
1666 | int | |||
1667 | glusterd_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 | ||||
1704 | out: | |||
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 | ||||
1710 | int | |||
1711 | glusterd_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()); | |||
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); | |||
1722 | ||||
1723 | ret = glusterd_op_stop_volume_args_get (dict, &volname, &flags); | |||
1724 | if (ret) | |||
1725 | goto out; | |||
1726 | ||||
1727 | ret = glusterd_volinfo_find (volname, &volinfo); | |||
1728 | if (ret) { | |||
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) | |||
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); | |||
1747 | out: | |||
1748 | return ret; | |||
1749 | } | |||
1750 | ||||
1751 | int | |||
1752 | glusterd_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); | |||
1779 | out: | |||
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 | ||||
1784 | int | |||
1785 | glusterd_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 | ||||
1793 | int | |||
1794 | glusterd_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 | ||||
1833 | out: | |||
1834 | return ret; | |||
1835 | } | |||
1836 | ||||
1837 | int | |||
1838 | glusterd_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; | |||
1858 | out: | |||
1859 | return ret; | |||
1860 | } | |||
1861 | ||||
1862 | int | |||
1863 | glusterd_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; | |||
1877 | out: | |||
1878 | return ret; | |||
1879 | } | |||
1880 | ||||
1881 | void | |||
1882 | glusterd_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 | ||||
1910 | int | |||
1911 | glusterd_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; | |||
1931 | out: | |||
1932 | return ret; | |||
1933 | } | |||
1934 | ||||
1935 | int | |||
1936 | glusterd_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 | ||||
1983 | out: | |||
1984 | return ret; | |||
1985 | } | |||
1986 | ||||
1987 | int | |||
1988 | glusterd_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; | |||
2033 | out: | |||
2034 | return ret; | |||
2035 | } | |||
2036 | ||||
2037 | int | |||
2038 | glusterd_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 | ||||
2149 | umount: | |||
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 | ||||
2156 | out: | |||
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 | } |