Bug Summary

File:xlators/mgmt/glusterd/src/glusterd-store.c
Location:line 2925, column 17
Description:Value stored to 'ret' is never read

Annotated Source Code

1/*
2 Copyright (c) 2007-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
11#ifndef _CONFIG_H
12#define _CONFIG_H
13#include "config.h"
14#endif
15
16#include "glusterd-op-sm.h"
17#include <inttypes.h>
18
19
20#include "globals.h"
21#include "glusterfs.h"
22#include "compat.h"
23#include "dict.h"
24#include "protocol-common.h"
25#include "xlator.h"
26#include "logging.h"
27#include "timer.h"
28#include "defaults.h"
29#include "compat.h"
30#include "compat-errno.h"
31#include "statedump.h"
32#include "glusterd-mem-types.h"
33#include "glusterd.h"
34#include "glusterd-sm.h"
35#include "glusterd-op-sm.h"
36#include "glusterd-utils.h"
37#include "glusterd-hooks.h"
38#include "glusterd-store.h"
39
40#include "rpc-clnt.h"
41#include "common-utils.h"
42
43#include <sys/resource.h>
44#include <inttypes.h>
45#include <dirent.h>
46
47static int32_t
48glusterd_store_mkdir (char *path)
49{
50 int32_t ret = -1;
51
52 ret = mkdir (path, 0777);
53
54 if ((-1 == ret) && (EEXIST17 != errno(*__errno_location ()))) {
55 gf_log (THIS->name, GF_LOG_ERROR, "mkdir() failed on path %s,"do { do { if (0) printf ("mkdir() failed on path %s," "errno: %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 56, GF_LOG_ERROR, "mkdir() failed on path %s,"
"errno: %s", path, strerror ((*__errno_location ()))); } while
(0)
56 "errno: %s", path, strerror (errno))do { do { if (0) printf ("mkdir() failed on path %s," "errno: %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 56, GF_LOG_ERROR, "mkdir() failed on path %s,"
"errno: %s", path, strerror ((*__errno_location ()))); } while
(0);
57 } else {
58 ret = 0;
59 }
60
61 return ret;
62}
63
64int32_t
65glusterd_store_handle_create_on_absence (glusterd_store_handle_t **shandle,
66 char *path)
67{
68 GF_ASSERT (shandle)do { if (!(shandle)) { do { do { if (0) printf ("Assertion failed: "
"shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 68, GF_LOG_ERROR, "Assertion failed: " "shandle"
); } while (0); } } while (0);
69 int32_t ret = 0;
70
71 if (*shandle == NULL((void*)0)) {
72 ret = glusterd_store_handle_new (path, shandle);
73
74 if (ret) {
75 gf_log (THIS->name, GF_LOG_ERROR, "Unable to create "do { do { if (0) printf ("Unable to create " "store handle for path: %s"
, path); } while (0); _gf_log ((*__glusterfs_this_location())
->name, "glusterd-store.c", __FUNCTION__, 76, GF_LOG_ERROR
, "Unable to create " "store handle for path: %s", path); } while
(0)
76 "store handle for path: %s", path)do { do { if (0) printf ("Unable to create " "store handle for path: %s"
, path); } while (0); _gf_log ((*__glusterfs_this_location())
->name, "glusterd-store.c", __FUNCTION__, 76, GF_LOG_ERROR
, "Unable to create " "store handle for path: %s", path); } while
(0);
77 }
78 }
79 return ret;
80}
81
82int32_t
83glusterd_store_mkstemp (glusterd_store_handle_t *shandle)
84{
85 int fd = -1;
86 char tmppath[PATH_MAX4096] = {0,};
87
88 GF_ASSERT (shandle)do { if (!(shandle)) { do { do { if (0) printf ("Assertion failed: "
"shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 88, GF_LOG_ERROR, "Assertion failed: " "shandle"
); } while (0); } } while (0);
89 GF_ASSERT (shandle->path)do { if (!(shandle->path)) { do { do { if (0) printf ("Assertion failed: "
"shandle->path"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 89, GF_LOG_ERROR, "Assertion failed: " "shandle->path"
); } while (0); } } while (0);
90
91 snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
92 fd = open (tmppath, O_RDWR02 | O_CREAT0100 | O_TRUNC01000 | O_SYNC04010000, 0600);
93 if (fd <= 0) {
94 gf_log (THIS->name, GF_LOG_ERROR, "Failed to open %s, "do { do { if (0) printf ("Failed to open %s, " "error: %s", tmppath
, strerror ((*__errno_location ()))); } while (0); _gf_log ((
*__glusterfs_this_location())->name, "glusterd-store.c", __FUNCTION__
, 95, GF_LOG_ERROR, "Failed to open %s, " "error: %s", tmppath
, strerror ((*__errno_location ()))); } while (0)
95 "error: %s", tmppath, strerror (errno))do { do { if (0) printf ("Failed to open %s, " "error: %s", tmppath
, strerror ((*__errno_location ()))); } while (0); _gf_log ((
*__glusterfs_this_location())->name, "glusterd-store.c", __FUNCTION__
, 95, GF_LOG_ERROR, "Failed to open %s, " "error: %s", tmppath
, strerror ((*__errno_location ()))); } while (0);
96 }
97
98 return fd;
99}
100
101int
102glusterd_store_sync_direntry (char *path)
103{
104 int ret = -1;
105 int dirfd = -1;
106 char *dir = NULL((void*)0);
107 char *pdir = NULL((void*)0);
108 xlator_t *this = NULL((void*)0);
109
110 this = THIS(*__glusterfs_this_location());
111
112 dir = gf_strdup (path);
113 if (!dir)
114 goto out;
115
116 pdir = dirname (dir);
117 dirfd = open (pdir, O_RDONLY00);
118 if (dirfd == -1) {
119 gf_log (this->name, GF_LOG_ERROR, "Failed to open directory "do { do { if (0) printf ("Failed to open directory " "%s, due to %s"
, pdir, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 120, GF_LOG_ERROR
, "Failed to open directory " "%s, due to %s", pdir, strerror
((*__errno_location ()))); } while (0)
120 "%s, due to %s", pdir, strerror (errno))do { do { if (0) printf ("Failed to open directory " "%s, due to %s"
, pdir, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 120, GF_LOG_ERROR
, "Failed to open directory " "%s, due to %s", pdir, strerror
((*__errno_location ()))); } while (0);
121 goto out;
122 }
123
124 ret = fsync (dirfd);
125 if (ret) {
126 gf_log (this->name, GF_LOG_ERROR, "Failed to fsync %s, due to "do { do { if (0) printf ("Failed to fsync %s, due to " "%s", pdir
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 127, GF_LOG_ERROR
, "Failed to fsync %s, due to " "%s", pdir, strerror ((*__errno_location
()))); } while (0)
127 "%s", pdir, strerror (errno))do { do { if (0) printf ("Failed to fsync %s, due to " "%s", pdir
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 127, GF_LOG_ERROR
, "Failed to fsync %s, due to " "%s", pdir, strerror ((*__errno_location
()))); } while (0);
128 goto out;
129 }
130
131 ret = 0;
132out:
133 if (dirfd >= 0) {
134 ret = close (dirfd);
135 if (ret) {
136 gf_log (this->name, GF_LOG_ERROR, "Failed to close "do { do { if (0) printf ("Failed to close " "%s, due to %s", pdir
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 137, GF_LOG_ERROR
, "Failed to close " "%s, due to %s", pdir, strerror ((*__errno_location
()))); } while (0)
137 "%s, due to %s", pdir, strerror (errno))do { do { if (0) printf ("Failed to close " "%s, due to %s", pdir
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 137, GF_LOG_ERROR
, "Failed to close " "%s, due to %s", pdir, strerror ((*__errno_location
()))); } while (0);
138 }
139 }
140
141 if (dir)
142 GF_FREE (dir)__gf_free (dir);
143
144 return ret;
145}
146
147int32_t
148glusterd_store_rename_tmppath (glusterd_store_handle_t *shandle)
149{
150 int32_t ret = -1;
151 char tmppath[PATH_MAX4096] = {0,};
152
153 GF_ASSERT (shandle)do { if (!(shandle)) { do { do { if (0) printf ("Assertion failed: "
"shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 153, GF_LOG_ERROR, "Assertion failed: " "shandle"
); } while (0); } } while (0);
154 GF_ASSERT (shandle->path)do { if (!(shandle->path)) { do { do { if (0) printf ("Assertion failed: "
"shandle->path"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 154, GF_LOG_ERROR, "Assertion failed: " "shandle->path"
); } while (0); } } while (0);
155
156 snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
157 ret = rename (tmppath, shandle->path);
158 if (ret) {
159 gf_log (THIS->name, GF_LOG_ERROR, "Failed to rename %s to %s, "do { do { if (0) printf ("Failed to rename %s to %s, " "error: %s"
, tmppath, shandle->path, strerror ((*__errno_location ())
)); } while (0); _gf_log ((*__glusterfs_this_location())->
name, "glusterd-store.c", __FUNCTION__, 160, GF_LOG_ERROR, "Failed to rename %s to %s, "
"error: %s", tmppath, shandle->path, strerror ((*__errno_location
()))); } while (0)
160 "error: %s", tmppath, shandle->path, strerror (errno))do { do { if (0) printf ("Failed to rename %s to %s, " "error: %s"
, tmppath, shandle->path, strerror ((*__errno_location ())
)); } while (0); _gf_log ((*__glusterfs_this_location())->
name, "glusterd-store.c", __FUNCTION__, 160, GF_LOG_ERROR, "Failed to rename %s to %s, "
"error: %s", tmppath, shandle->path, strerror ((*__errno_location
()))); } while (0);
161 goto out;
162 }
163
164 ret = glusterd_store_sync_direntry (tmppath);
165out:
166 return ret;
167}
168
169int32_t
170glusterd_store_unlink_tmppath (glusterd_store_handle_t *shandle)
171{
172 int32_t ret = -1;
173 char tmppath[PATH_MAX4096] = {0,};
174
175 GF_ASSERT (shandle)do { if (!(shandle)) { do { do { if (0) printf ("Assertion failed: "
"shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 175, GF_LOG_ERROR, "Assertion failed: " "shandle"
); } while (0); } } while (0);
176 GF_ASSERT (shandle->path)do { if (!(shandle->path)) { do { do { if (0) printf ("Assertion failed: "
"shandle->path"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 176, GF_LOG_ERROR, "Assertion failed: " "shandle->path"
); } while (0); } } while (0);
177
178 snprintf (tmppath, sizeof (tmppath), "%s.tmp", shandle->path);
179 ret = unlink (tmppath);
180 if (ret && (errno(*__errno_location ()) != ENOENT2)) {
181 gf_log (THIS->name, GF_LOG_ERROR, "Failed to mv %s to %s, "do { do { if (0) printf ("Failed to mv %s to %s, " "error: %s"
, tmppath, shandle->path, strerror ((*__errno_location ())
)); } while (0); _gf_log ((*__glusterfs_this_location())->
name, "glusterd-store.c", __FUNCTION__, 182, GF_LOG_ERROR, "Failed to mv %s to %s, "
"error: %s", tmppath, shandle->path, strerror ((*__errno_location
()))); } while (0)
182 "error: %s", tmppath, shandle->path, strerror (errno))do { do { if (0) printf ("Failed to mv %s to %s, " "error: %s"
, tmppath, shandle->path, strerror ((*__errno_location ())
)); } while (0); _gf_log ((*__glusterfs_this_location())->
name, "glusterd-store.c", __FUNCTION__, 182, GF_LOG_ERROR, "Failed to mv %s to %s, "
"error: %s", tmppath, shandle->path, strerror ((*__errno_location
()))); } while (0);
183 } else {
184 ret = 0;
185 }
186
187 return ret;
188}
189
190static void
191glusterd_replace_slash_with_hipen (char *str)
192{
193 char *ptr = NULL((void*)0);
194
195 ptr = strchr (str, '/');
196
197 while (ptr) {
198 *ptr = '-';
199 ptr = strchr (str, '/');
200 }
201}
202
203int32_t
204glusterd_store_create_brick_dir (glusterd_volinfo_t *volinfo)
205{
206 int32_t ret = -1;
207 char brickdirpath[PATH_MAX4096] = {0,};
208 glusterd_conf_t *priv = NULL((void*)0);
209
210 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 210, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
211
212 priv = THIS(*__glusterfs_this_location())->private;
213 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 213, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
214
215 GLUSTERD_GET_BRICK_DIR (brickdirpath, volinfo, priv)snprintf (brickdirpath, 4096, "%s/%s/%s/%s", priv->workdir
, "vols", volinfo->volname, "bricks");;
216 ret = glusterd_store_mkdir (brickdirpath);
217
218 return ret;
219}
220
221static void
222glusterd_store_key_vol_brick_set (glusterd_brickinfo_t *brickinfo,
223 char *key_vol_brick, size_t len)
224{
225 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 225, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
226 GF_ASSERT (key_vol_brick)do { if (!(key_vol_brick)) { do { do { if (0) printf ("Assertion failed: "
"key_vol_brick"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 226, GF_LOG_ERROR, "Assertion failed: " "key_vol_brick"
); } while (0); } } while (0);
227 GF_ASSERT (len >= PATH_MAX)do { if (!(len >= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len >= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 227, GF_LOG_ERROR, "Assertion failed: " "len >= PATH_MAX"
); } while (0); } } while (0);
228
229 snprintf (key_vol_brick, len, "%s", brickinfo->path);
230 glusterd_replace_slash_with_hipen (key_vol_brick);
231}
232
233static void
234glusterd_store_brickinfofname_set (glusterd_brickinfo_t *brickinfo,
235 char *brickfname, size_t len)
236{
237 char key_vol_brick[PATH_MAX4096] = {0};
238
239 GF_ASSERT (brickfname)do { if (!(brickfname)) { do { do { if (0) printf ("Assertion failed: "
"brickfname"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 239, GF_LOG_ERROR, "Assertion failed: " "brickfname"
); } while (0); } } while (0);
240 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 240, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
241 GF_ASSERT (len >= PATH_MAX)do { if (!(len >= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len >= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 241, GF_LOG_ERROR, "Assertion failed: " "len >= PATH_MAX"
); } while (0); } } while (0);
242
243 glusterd_store_key_vol_brick_set (brickinfo, key_vol_brick,
244 sizeof (key_vol_brick));
245 snprintf (brickfname, len, "%s:%s", brickinfo->hostname, key_vol_brick);
246}
247
248static void
249glusterd_store_brickinfopath_set (glusterd_volinfo_t *volinfo,
250 glusterd_brickinfo_t *brickinfo,
251 char *brickpath, size_t len)
252{
253 char brickfname[PATH_MAX4096] = {0};
254 char brickdirpath[PATH_MAX4096] = {0,};
255 glusterd_conf_t *priv = NULL((void*)0);
256
257 GF_ASSERT (brickpath)do { if (!(brickpath)) { do { do { if (0) printf ("Assertion failed: "
"brickpath"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 257, GF_LOG_ERROR, "Assertion failed: " "brickpath"
); } while (0); } } while (0);
258 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 258, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
259 GF_ASSERT (len >= PATH_MAX)do { if (!(len >= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len >= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 259, GF_LOG_ERROR, "Assertion failed: " "len >= PATH_MAX"
); } while (0); } } while (0);
260
261 priv = THIS(*__glusterfs_this_location())->private;
262 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 262, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
263
264 GLUSTERD_GET_BRICK_DIR (brickdirpath, volinfo, priv)snprintf (brickdirpath, 4096, "%s/%s/%s/%s", priv->workdir
, "vols", volinfo->volname, "bricks");;
265 glusterd_store_brickinfofname_set (brickinfo, brickfname,
266 sizeof (brickfname));
267 snprintf (brickpath, len, "%s/%s", brickdirpath, brickfname);
268}
269
270gf_boolean_t
271glusterd_store_is_valid_brickpath (char *volname, char *brick)
272{
273 char brickpath[PATH_MAX4096] = {0};
274 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
275 glusterd_volinfo_t *volinfo = NULL((void*)0);
276 int32_t ret = 0;
277 size_t volname_len = strlen (volname);
278 xlator_t *this = NULL((void*)0);
279
280 this = THIS(*__glusterfs_this_location());
281 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 281, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
282
283 ret = glusterd_brickinfo_new_from_brick (brick, &brickinfo);
284 if (ret) {
285 gf_log (this->name, GF_LOG_WARNING, "Failed to create brick "do { do { if (0) printf ("Failed to create brick " "info for brick %s"
, brick); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 286, GF_LOG_WARNING, "Failed to create brick "
"info for brick %s", brick); } while (0)
286 "info for brick %s", brick)do { do { if (0) printf ("Failed to create brick " "info for brick %s"
, brick); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 286, GF_LOG_WARNING, "Failed to create brick "
"info for brick %s", brick); } while (0);
287 ret = 0;
288 goto out;
289 }
290 ret = glusterd_volinfo_new (&volinfo);
291 if (ret) {
292 gf_log (this->name, GF_LOG_WARNING, "Failed to create volinfo")do { do { if (0) printf ("Failed to create volinfo"); } while
(0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 292, GF_LOG_WARNING, "Failed to create volinfo"); } while (
0);
293 ret = 0;
294 goto out;
295 }
296 if (volname_len >= sizeof (volinfo->volname)) {
297 gf_log (this->name, GF_LOG_WARNING, "volume name too long")do { do { if (0) printf ("volume name too long"); } while (0)
; _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 297
, GF_LOG_WARNING, "volume name too long"); } while (0);
298 ret = 0;
299 goto out;
300 }
301 memcpy (volinfo->volname, volname, volname_len+1);
302 glusterd_store_brickinfopath_set (volinfo, brickinfo, brickpath,
303 sizeof (brickpath));
304
305 ret = (strlen (brickpath) < _POSIX_PATH_MAX256);
306
307out:
308 if (brickinfo)
309 glusterd_brickinfo_delete (brickinfo);
310 if (volinfo)
311 glusterd_volinfo_delete (volinfo);
312
313 return ret;
314}
315
316int32_t
317glusterd_store_volinfo_brick_fname_write (int vol_fd,
318 glusterd_brickinfo_t *brickinfo,
319 int32_t brick_count)
320{
321 char key[PATH_MAX4096] = {0,};
322 char brickfname[PATH_MAX4096] = {0,};
323 int32_t ret = -1;
324
325 snprintf (key, sizeof (key), "%s-%d", GLUSTERD_STORE_KEY_VOL_BRICK"brick",
326 brick_count);
327 glusterd_store_brickinfofname_set (brickinfo, brickfname,
328 sizeof (brickfname));
329 ret = glusterd_store_save_value (vol_fd, key, brickfname);
330 if (ret)
331 goto out;
332
333out:
334 return ret;
335}
336
337int32_t
338glusterd_store_create_brick_shandle_on_absence (glusterd_volinfo_t *volinfo,
339 glusterd_brickinfo_t *brickinfo)
340{
341 char brickpath[PATH_MAX4096] = {0,};
342 int32_t ret = 0;
343
344 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 344, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
345 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 345, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
346
347 glusterd_store_brickinfopath_set (volinfo, brickinfo, brickpath,
348 sizeof (brickpath));
349 ret = glusterd_store_handle_create_on_absence (&brickinfo->shandle,
350 brickpath);
351 return ret;
352}
353
354int32_t
355glusterd_store_brickinfo_write (int fd, glusterd_brickinfo_t *brickinfo)
356{
357 char value[256] = {0,};
358 int32_t ret = 0;
359
360 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 360, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
361 GF_ASSERT (fd > 0)do { if (!(fd > 0)) { do { do { if (0) printf ("Assertion failed: "
"fd > 0"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 361, GF_LOG_ERROR, "Assertion failed: " "fd > 0"
); } while (0); } } while (0);
362
363 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_BRICK_HOSTNAME"hostname",
364 brickinfo->hostname);
365 if (ret)
366 goto out;
367
368 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_BRICK_PATH"path",
369 brickinfo->path);
370 if (ret)
371 goto out;
372
373 snprintf (value, sizeof(value), "%d", brickinfo->port);
374 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_BRICK_PORT"listen-port",
375 value);
376
377 snprintf (value, sizeof(value), "%d", brickinfo->rdma_port);
378 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_BRICK_RDMA_PORT"rdma.listen-port",
379 value);
380
381 snprintf (value, sizeof(value), "%d", brickinfo->decommissioned);
382 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_BRICK_DECOMMISSIONED"decommissioned",
383 value);
384 if (ret)
385 goto out;
386
387out:
388 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 388, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
389 return ret;
390}
391
392int32_t
393glusterd_store_perform_brick_store (glusterd_brickinfo_t *brickinfo)
394{
395 int fd = -1;
396 int32_t ret = -1;
397 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 397, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
398
399 fd = glusterd_store_mkstemp (brickinfo->shandle);
400 if (fd <= 0) {
401 ret = -1;
402 goto out;
403 }
404
405 ret = glusterd_store_brickinfo_write (fd, brickinfo);
406 if (ret)
407 goto out;
408
409out:
410 if (ret && (fd > 0))
411 glusterd_store_unlink_tmppath (brickinfo->shandle);
412 if (fd > 0)
413 close (fd);
414 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 414, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
415 return ret;
416}
417
418int32_t
419glusterd_store_brickinfo (glusterd_volinfo_t *volinfo,
420 glusterd_brickinfo_t *brickinfo, int32_t brick_count,
421 int vol_fd)
422{
423 int32_t ret = -1;
424
425 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 425, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
426 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 426, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
427
428 ret = glusterd_store_volinfo_brick_fname_write (vol_fd, brickinfo,
429 brick_count);
430 if (ret)
431 goto out;
432
433 ret = glusterd_store_create_brick_dir (volinfo);
434 if (ret)
435 goto out;
436
437 ret = glusterd_store_create_brick_shandle_on_absence (volinfo,
438 brickinfo);
439 if (ret)
440 goto out;
441
442 ret = glusterd_store_perform_brick_store (brickinfo);
443out:
444 gf_log (THIS->name, GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 444, GF_LOG_DEBUG, "Returning with %d", ret);
} while (0);
445 return ret;
446}
447
448int32_t
449glusterd_store_delete_brick (glusterd_brickinfo_t *brickinfo, char *delete_path)
450{
451 int32_t ret = -1;
452 glusterd_conf_t *priv = NULL((void*)0);
453 char brickpath[PATH_MAX4096] = {0,};
454 char *ptr = NULL((void*)0);
455 char *tmppath = NULL((void*)0);
456 xlator_t *this = NULL((void*)0);
457
458 this = THIS(*__glusterfs_this_location());
459 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 459, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
460 GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: "
"brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 460, GF_LOG_ERROR, "Assertion failed: " "brickinfo"
); } while (0); } } while (0);
461
462 priv = this->private;
463 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 463, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
464
465 tmppath = gf_strdup (brickinfo->path);
466
467 ptr = strchr (tmppath, '/');
468
469 while (ptr) {
470 *ptr = '-';
471 ptr = strchr (tmppath, '/');
472 }
473
474 snprintf (brickpath, sizeof (brickpath),
475 "%s/"GLUSTERD_BRICK_INFO_DIR"bricks""/%s:%s", delete_path,
476 brickinfo->hostname, tmppath);
477
478 GF_FREE (tmppath)__gf_free (tmppath);
479
480 ret = unlink (brickpath);
481
482 if ((ret < 0) && (errno(*__errno_location ()) != ENOENT2)) {
483 gf_log (this->name, GF_LOG_DEBUG, "Unlink failed on %s, "do { do { if (0) printf ("Unlink failed on %s, " "reason: %s"
, brickpath, strerror((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 484, GF_LOG_DEBUG
, "Unlink failed on %s, " "reason: %s", brickpath, strerror((
*__errno_location ()))); } while (0)
484 "reason: %s", brickpath, strerror(errno))do { do { if (0) printf ("Unlink failed on %s, " "reason: %s"
, brickpath, strerror((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 484, GF_LOG_DEBUG
, "Unlink failed on %s, " "reason: %s", brickpath, strerror((
*__errno_location ()))); } while (0);
485 ret = -1;
486 goto out;
487 } else {
488 ret = 0;
489 }
490
491out:
492 if (brickinfo->shandle) {
493 glusterd_store_handle_destroy (brickinfo->shandle);
494 brickinfo->shandle = NULL((void*)0);
495 }
496 gf_log (this->name, GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__,
496, GF_LOG_DEBUG, "Returning with %d", ret); } while (0);
497 return ret;
498}
499
500int32_t
501glusterd_store_remove_bricks (glusterd_volinfo_t *volinfo, char *delete_path)
502{
503 int32_t ret = 0;
504 glusterd_brickinfo_t *tmp = NULL((void*)0);
505 glusterd_conf_t *priv = NULL((void*)0);
506 char brickdir [PATH_MAX4096] = {0,};
507 DIR *dir = NULL((void*)0);
508 struct dirent *entry = NULL((void*)0);
509 char path[PATH_MAX4096] = {0,};
510 xlator_t *this = NULL((void*)0);
511
512 this = THIS(*__glusterfs_this_location());
513 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 513, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
514
515 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 515, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
516
517 list_for_each_entry (tmp, &volinfo->bricks, brick_list)for (tmp = ((typeof(*tmp) *)((char *)((&volinfo->bricks
)->next)-(unsigned long)(&((typeof(*tmp) *)0)->brick_list
))); &tmp->brick_list != (&volinfo->bricks); tmp
= ((typeof(*tmp) *)((char *)(tmp->brick_list.next)-(unsigned
long)(&((typeof(*tmp) *)0)->brick_list)))) {
518 ret = glusterd_store_delete_brick (tmp, delete_path);
519 if (ret)
520 goto out;
521 }
522
523 priv = this->private;
524 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 524, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
525
526 snprintf (brickdir, sizeof (brickdir), "%s/%s", delete_path,
527 GLUSTERD_BRICK_INFO_DIR"bricks");
528
529 dir = opendir (brickdir);
530
531 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
532
533 while (entry) {
534 snprintf (path, sizeof (path), "%s/%s",
535 brickdir, entry->d_name);
536 ret = unlink (path);
537 if (ret && errno(*__errno_location ()) != ENOENT2) {
538 gf_log (this->name, GF_LOG_DEBUG, "Unable to unlink %s, "do { do { if (0) printf ("Unable to unlink %s, " "reason: %s"
, path, strerror((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 539, GF_LOG_DEBUG
, "Unable to unlink %s, " "reason: %s", path, strerror((*__errno_location
()))); } while (0)
539 "reason: %s", path, strerror(errno))do { do { if (0) printf ("Unable to unlink %s, " "reason: %s"
, path, strerror((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 539, GF_LOG_DEBUG
, "Unable to unlink %s, " "reason: %s", path, strerror((*__errno_location
()))); } while (0);
540 }
541 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
542 }
543
544 closedir (dir);
545
546 ret = rmdir (brickdir);
547
548out:
549 gf_log (this->name, GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__,
549, GF_LOG_DEBUG, "Returning with %d", ret); } while (0);
550 return ret;
551}
552
553static int
554_storeslaves (dict_t *this, char *key, data_t *value, void *data)
555{
556 int32_t ret = 0;
557 glusterd_store_handle_t *shandle = NULL((void*)0);
558 xlator_t *xl = NULL((void*)0);
559
560 xl = THIS(*__glusterfs_this_location());
561 GF_ASSERT (xl)do { if (!(xl)) { do { do { if (0) printf ("Assertion failed: "
"xl"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 561, GF_LOG_ERROR, "Assertion failed: " "xl")
; } while (0); } } while (0);
562
563 shandle = (glusterd_store_handle_t*)data;
564
565 GF_ASSERT (shandle)do { if (!(shandle)) { do { do { if (0) printf ("Assertion failed: "
"shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 565, GF_LOG_ERROR, "Assertion failed: " "shandle"
); } while (0); } } while (0);
566 GF_ASSERT (shandle->fd > 0)do { if (!(shandle->fd > 0)) { do { do { if (0) printf (
"Assertion failed: " "shandle->fd > 0"); } while (0); _gf_log_callingfn
("", "glusterd-store.c", __FUNCTION__, 566, GF_LOG_ERROR, "Assertion failed: "
"shandle->fd > 0"); } while (0); } } while (0);
567 GF_ASSERT (shandle->path)do { if (!(shandle->path)) { do { do { if (0) printf ("Assertion failed: "
"shandle->path"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 567, GF_LOG_ERROR, "Assertion failed: " "shandle->path"
); } while (0); } } while (0);
568 GF_ASSERT (key)do { if (!(key)) { do { do { if (0) printf ("Assertion failed: "
"key"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 568, GF_LOG_ERROR, "Assertion failed: " "key"
); } while (0); } } while (0);
569 GF_ASSERT (value && value->data)do { if (!(value && value->data)) { do { do { if (
0) printf ("Assertion failed: " "value && value->data"
); } while (0); _gf_log_callingfn ("", "glusterd-store.c", __FUNCTION__
, 569, GF_LOG_ERROR, "Assertion failed: " "value && value->data"
); } while (0); } } while (0);
570
571 if ((!shandle) || (shandle->fd <= 0) || (!shandle->path))
572 return -1;
573
574 if (!key)
575 return -1;
576 if (!value || !value->data)
577 return -1;
578
579 gf_log (xl->name, GF_LOG_DEBUG, "Storing in volinfo:key= %s, val=%s",do { do { if (0) printf ("Storing in volinfo:key= %s, val=%s"
, key, value->data); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 580, GF_LOG_DEBUG, "Storing in volinfo:key= %s, val=%s"
, key, value->data); } while (0)
580 key, value->data)do { do { if (0) printf ("Storing in volinfo:key= %s, val=%s"
, key, value->data); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 580, GF_LOG_DEBUG, "Storing in volinfo:key= %s, val=%s"
, key, value->data); } while (0);
581
582 ret = glusterd_store_save_value (shandle->fd, key, (char*)value->data);
583 if (ret) {
584 gf_log (xl->name, GF_LOG_ERROR, "Unable to write into store"do { do { if (0) printf ("Unable to write into store" " handle for path: %s"
, shandle->path); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 585, GF_LOG_ERROR, "Unable to write into store"
" handle for path: %s", shandle->path); } while (0)
585 " handle for path: %s", shandle->path)do { do { if (0) printf ("Unable to write into store" " handle for path: %s"
, shandle->path); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 585, GF_LOG_ERROR, "Unable to write into store"
" handle for path: %s", shandle->path); } while (0);
586 return -1;
587 }
588 return 0;
589}
590
591
592int _storeopts (dict_t *this, char *key, data_t *value, void *data)
593{
594 int32_t ret = 0;
595 int32_t exists = 0;
596 glusterd_store_handle_t *shandle = NULL((void*)0);
597 xlator_t *xl = NULL((void*)0);
598
599 xl = THIS(*__glusterfs_this_location());
600 GF_ASSERT (xl)do { if (!(xl)) { do { do { if (0) printf ("Assertion failed: "
"xl"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 600, GF_LOG_ERROR, "Assertion failed: " "xl")
; } while (0); } } while (0);
601
602 shandle = (glusterd_store_handle_t*)data;
603
604 GF_ASSERT (shandle)do { if (!(shandle)) { do { do { if (0) printf ("Assertion failed: "
"shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 604, GF_LOG_ERROR, "Assertion failed: " "shandle"
); } while (0); } } while (0);
605 GF_ASSERT (shandle->fd > 0)do { if (!(shandle->fd > 0)) { do { do { if (0) printf (
"Assertion failed: " "shandle->fd > 0"); } while (0); _gf_log_callingfn
("", "glusterd-store.c", __FUNCTION__, 605, GF_LOG_ERROR, "Assertion failed: "
"shandle->fd > 0"); } while (0); } } while (0);
606 GF_ASSERT (shandle->path)do { if (!(shandle->path)) { do { do { if (0) printf ("Assertion failed: "
"shandle->path"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 606, GF_LOG_ERROR, "Assertion failed: " "shandle->path"
); } while (0); } } while (0);
607 GF_ASSERT (key)do { if (!(key)) { do { do { if (0) printf ("Assertion failed: "
"key"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 607, GF_LOG_ERROR, "Assertion failed: " "key"
); } while (0); } } while (0);
608 GF_ASSERT (value && value->data)do { if (!(value && value->data)) { do { do { if (
0) printf ("Assertion failed: " "value && value->data"
); } while (0); _gf_log_callingfn ("", "glusterd-store.c", __FUNCTION__
, 608, GF_LOG_ERROR, "Assertion failed: " "value && value->data"
); } while (0); } } while (0);
609
610 if ((!shandle) || (shandle->fd <= 0) || (!shandle->path))
611 return -1;
612
613 if (!key)
614 return -1;
615 if (!value || !value->data)
616 return -1;
617
618 if (is_key_glusterd_hooks_friendly (key)) {
619 exists = 1;
620
621 } else {
622 exists = glusterd_check_option_exists (key, NULL((void*)0));
623 }
624
625 if (1 == exists) {
626 gf_log (xl->name, GF_LOG_DEBUG, "Storing in volinfo:key= %s, "do { do { if (0) printf ("Storing in volinfo:key= %s, " "val=%s"
, key, value->data); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 627, GF_LOG_DEBUG, "Storing in volinfo:key= %s, "
"val=%s", key, value->data); } while (0)
627 "val=%s", key, value->data)do { do { if (0) printf ("Storing in volinfo:key= %s, " "val=%s"
, key, value->data); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 627, GF_LOG_DEBUG, "Storing in volinfo:key= %s, "
"val=%s", key, value->data); } while (0);
628
629 } else {
630 gf_log (xl->name, GF_LOG_DEBUG, "Discarding:key= %s, val=%s",do { do { if (0) printf ("Discarding:key= %s, val=%s", key, value
->data); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 631, GF_LOG_DEBUG, "Discarding:key= %s, val=%s"
, key, value->data); } while (0)
631 key, value->data)do { do { if (0) printf ("Discarding:key= %s, val=%s", key, value
->data); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 631, GF_LOG_DEBUG, "Discarding:key= %s, val=%s"
, key, value->data); } while (0);
632 return 0;
633 }
634
635 ret = glusterd_store_save_value (shandle->fd, key, (char*)value->data);
636 if (ret) {
637 gf_log (xl->name, GF_LOG_ERROR, "Unable to write into store"do { do { if (0) printf ("Unable to write into store" " handle for path: %s"
, shandle->path); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 638, GF_LOG_ERROR, "Unable to write into store"
" handle for path: %s", shandle->path); } while (0)
638 " handle for path: %s", shandle->path)do { do { if (0) printf ("Unable to write into store" " handle for path: %s"
, shandle->path); } while (0); _gf_log (xl->name, "glusterd-store.c"
, __FUNCTION__, 638, GF_LOG_ERROR, "Unable to write into store"
" handle for path: %s", shandle->path); } while (0);
639 return -1;
640 }
641 return 0;
642}
643
644int32_t
645glusterd_volume_exclude_options_write (int fd, glusterd_volinfo_t *volinfo)
646{
647 char *str = NULL((void*)0);
648
649 GF_ASSERT (fd > 0)do { if (!(fd > 0)) { do { do { if (0) printf ("Assertion failed: "
"fd > 0"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 649, GF_LOG_ERROR, "Assertion failed: " "fd > 0"
); } while (0); } } while (0);
650 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 650, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
651
652 char buf[PATH_MAX4096] = {0,};
653 int32_t ret = -1;
654
655 snprintf (buf, sizeof (buf), "%d", volinfo->type);
656 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_TYPE"type", buf);
657 if (ret)
658 goto out;
659
660 snprintf (buf, sizeof (buf), "%d", volinfo->brick_count);
661 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_COUNT"count", buf);
662 if (ret)
663 goto out;
664
665 snprintf (buf, sizeof (buf), "%d", volinfo->status);
666 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_STATUS"status", buf);
667 if (ret)
668 goto out;
669
670 snprintf (buf, sizeof (buf), "%d", volinfo->sub_count);
671 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_SUB_COUNT"sub_count",
672 buf);
673 if (ret)
674 goto out;
675
676 snprintf (buf, sizeof (buf), "%d", volinfo->stripe_count);
677 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_STRIPE_CNT"stripe_count",
678 buf);
679 if (ret)
680 goto out;
681
682 snprintf (buf, sizeof (buf), "%d", volinfo->replica_count);
683 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_REPLICA_CNT"replica_count",
684 buf);
685 if (ret)
686 goto out;
687
688 snprintf (buf, sizeof (buf), "%d", volinfo->version);
689 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_VERSION"version",
690 buf);
691 if (ret)
692 goto out;
693
694 snprintf (buf, sizeof (buf), "%d", volinfo->transport_type);
695 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_TRANSPORT"transport-type",
696 buf);
697 if (ret)
698 goto out;
699
700 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_ID"volume-id",
701 uuid_utoa (volinfo->volume_id));
702 if (ret)
703 goto out;
704
705 str = glusterd_auth_get_username (volinfo);
706 if (str) {
707 ret = glusterd_store_save_value (fd,
708 GLUSTERD_STORE_KEY_USERNAME"username",
709 str);
710 if (ret)
711 goto out;
712 }
713
714 str = glusterd_auth_get_password (volinfo);
715 if (str) {
716 ret = glusterd_store_save_value (fd,
717 GLUSTERD_STORE_KEY_PASSWORD"password",
718 str);
719 if (ret)
720 goto out;
721 }
722
723 if (volinfo->backend == GD_VOL_BK_BD) {
724 snprintf (buf, sizeof (buf), "%d", volinfo->backend);
725 ret = glusterd_store_save_value (fd,
726 GLUSTERD_STORE_KEY_VOL_BACKEND"backend", buf);
727 if (ret)
728 goto out;
729 }
730
731out:
732 if (ret)
733 gf_log (THIS->name, GF_LOG_ERROR, "Unable to write volume "do { do { if (0) printf ("Unable to write volume " "values for %s"
, volinfo->volname); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-store.c", __FUNCTION__, 734, GF_LOG_ERROR
, "Unable to write volume " "values for %s", volinfo->volname
); } while (0)
734 "values for %s", volinfo->volname)do { do { if (0) printf ("Unable to write volume " "values for %s"
, volinfo->volname); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "glusterd-store.c", __FUNCTION__, 734, GF_LOG_ERROR
, "Unable to write volume " "values for %s", volinfo->volname
); } while (0);
735 return ret;
736}
737
738static void
739glusterd_store_voldirpath_set (glusterd_volinfo_t *volinfo, char *voldirpath,
740 size_t len)
741{
742 glusterd_conf_t *priv = NULL((void*)0);
743
744 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 744, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
745 priv = THIS(*__glusterfs_this_location())->private;
746 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 746, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
747
748 snprintf (voldirpath, len, "%s/%s/%s", priv->workdir,
749 GLUSTERD_VOLUME_DIR_PREFIX"vols", volinfo->volname);
750}
751
752static int32_t
753glusterd_store_create_volume_dir (glusterd_volinfo_t *volinfo)
754{
755 int32_t ret = -1;
756 char voldirpath[PATH_MAX4096] = {0,};
757
758 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 758, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
759
760 glusterd_store_voldirpath_set (volinfo, voldirpath,
761 sizeof (voldirpath));
762 ret = glusterd_store_mkdir (voldirpath);
763 gf_log (THIS->name, GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 763, GF_LOG_DEBUG, "Returning with %d", ret);
} while (0);
764 return ret;
765}
766
767int32_t
768glusterd_store_volinfo_write (int fd, glusterd_volinfo_t *volinfo)
769{
770 int32_t ret = -1;
771 glusterd_store_handle_t *shandle = NULL((void*)0);
772 GF_ASSERT (fd > 0)do { if (!(fd > 0)) { do { do { if (0) printf ("Assertion failed: "
"fd > 0"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 772, GF_LOG_ERROR, "Assertion failed: " "fd > 0"
); } while (0); } } while (0);
773 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 773, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
774 GF_ASSERT (volinfo->shandle)do { if (!(volinfo->shandle)) { do { do { if (0) printf ("Assertion failed: "
"volinfo->shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 774, GF_LOG_ERROR, "Assertion failed: " "volinfo->shandle"
); } while (0); } } while (0);
775
776 shandle = volinfo->shandle;
777 ret = glusterd_volume_exclude_options_write (fd, volinfo);
778 if (ret)
779 goto out;
780
781 shandle->fd = fd;
782 dict_foreach (volinfo->dict, _storeopts, shandle);
783
784 dict_foreach (volinfo->gsync_slaves, _storeslaves, shandle);
785 shandle->fd = 0;
786out:
787 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 787, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
788 return ret;
789}
790
791static void
792glusterd_store_rbstatepath_set (glusterd_volinfo_t *volinfo, char *rbstatepath,
793 size_t len)
794{
795 char voldirpath[PATH_MAX4096] = {0,};
796 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 796, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
797 GF_ASSERT (rbstatepath)do { if (!(rbstatepath)) { do { do { if (0) printf ("Assertion failed: "
"rbstatepath"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 797, GF_LOG_ERROR, "Assertion failed: " "rbstatepath"
); } while (0); } } while (0);
798 GF_ASSERT (len <= PATH_MAX)do { if (!(len <= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len <= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 798, GF_LOG_ERROR, "Assertion failed: " "len <= PATH_MAX"
); } while (0); } } while (0);
799
800 glusterd_store_voldirpath_set (volinfo, voldirpath,
801 sizeof (voldirpath));
802 snprintf (rbstatepath, len, "%s/%s", voldirpath,
803 GLUSTERD_VOLUME_RBSTATE_FILE"rbstate");
804}
805
806static void
807glusterd_store_volfpath_set (glusterd_volinfo_t *volinfo, char *volfpath,
808 size_t len)
809{
810 char voldirpath[PATH_MAX4096] = {0,};
811 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 811, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
812 GF_ASSERT (volfpath)do { if (!(volfpath)) { do { do { if (0) printf ("Assertion failed: "
"volfpath"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 812, GF_LOG_ERROR, "Assertion failed: " "volfpath"
); } while (0); } } while (0);
813 GF_ASSERT (len <= PATH_MAX)do { if (!(len <= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len <= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 813, GF_LOG_ERROR, "Assertion failed: " "len <= PATH_MAX"
); } while (0); } } while (0);
814
815 glusterd_store_voldirpath_set (volinfo, voldirpath,
816 sizeof (voldirpath));
817 snprintf (volfpath, len, "%s/%s", voldirpath, GLUSTERD_VOLUME_INFO_FILE"info");
818}
819
820static void
821glusterd_store_node_state_path_set (glusterd_volinfo_t *volinfo,
822 char *node_statepath, size_t len)
823{
824 char voldirpath[PATH_MAX4096] = {0,};
825 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 825, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
826 GF_ASSERT (node_statepath)do { if (!(node_statepath)) { do { do { if (0) printf ("Assertion failed: "
"node_statepath"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 826, GF_LOG_ERROR, "Assertion failed: " "node_statepath"
); } while (0); } } while (0);
827 GF_ASSERT (len <= PATH_MAX)do { if (!(len <= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len <= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 827, GF_LOG_ERROR, "Assertion failed: " "len <= PATH_MAX"
); } while (0); } } while (0);
828
829 glusterd_store_voldirpath_set (volinfo, voldirpath,
830 sizeof (voldirpath));
831 snprintf (node_statepath, len, "%s/%s", voldirpath,
832 GLUSTERD_NODE_STATE_FILE"node_state.info");
833}
834
835int32_t
836glusterd_store_create_rbstate_shandle_on_absence (glusterd_volinfo_t *volinfo)
837{
838 char rbstatepath[PATH_MAX4096] = {0};
839 int32_t ret = 0;
840
841 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 841, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
842
843 glusterd_store_rbstatepath_set (volinfo, rbstatepath, sizeof (rbstatepath));
844 ret = glusterd_store_handle_create_on_absence (&volinfo->rb_shandle,
845 rbstatepath);
846 return ret;
847}
848
849int32_t
850glusterd_store_create_vol_shandle_on_absence (glusterd_volinfo_t *volinfo)
851{
852 char volfpath[PATH_MAX4096] = {0};
853 int32_t ret = 0;
854
855 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 855, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
856
857 glusterd_store_volfpath_set (volinfo, volfpath, sizeof (volfpath));
858 ret = glusterd_store_handle_create_on_absence (&volinfo->shandle,
859 volfpath);
860 return ret;
861}
862
863int32_t
864glusterd_store_create_nodestate_sh_on_absence (glusterd_volinfo_t *volinfo)
865{
866 char node_state_path[PATH_MAX4096] = {0};
867 int32_t ret = 0;
868
869 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 869, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
870
871 glusterd_store_node_state_path_set (volinfo, node_state_path,
872 sizeof (node_state_path));
873 ret =
874 glusterd_store_handle_create_on_absence (&volinfo->node_state_shandle,
875 node_state_path);
876
877 return ret;
878}
879
880int32_t
881glusterd_store_brickinfos (glusterd_volinfo_t *volinfo, int vol_fd)
882{
883 int32_t ret = 0;
884 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
885 int32_t brick_count = 0;
886
887 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 887, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
888
889 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)))) {
890 ret = glusterd_store_brickinfo (volinfo, brickinfo,
891 brick_count, vol_fd);
892 if (ret)
893 goto out;
894 brick_count++;
895 }
896out:
897 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 897, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
898 return ret;
899}
900
901int32_t
902glusterd_store_rbstate_write (int fd, glusterd_volinfo_t *volinfo)
903{
904 int ret = -1;
905 int port = 0;
906 char buf[PATH_MAX4096] = {0, };
907
908 GF_ASSERT (fd > 0)do { if (!(fd > 0)) { do { do { if (0) printf ("Assertion failed: "
"fd > 0"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 908, GF_LOG_ERROR, "Assertion failed: " "fd > 0"
); } while (0); } } while (0);
909 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 909, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
910
911 snprintf (buf, sizeof (buf), "%d", volinfo->rep_brick.rb_status);
912 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_RB_STATUS"rb_status",
913 buf);
914 if (ret)
915 goto out;
916
917 if (volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) {
918
919 snprintf (buf, sizeof (buf), "%s:%s",
920 volinfo->rep_brick.src_brick->hostname,
921 volinfo->rep_brick.src_brick->path);
922 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_RB_SRC_BRICK"rb_src",
923 buf);
924 if (ret)
925 goto out;
926
927 snprintf (buf, sizeof (buf), "%s:%s",
928 volinfo->rep_brick.dst_brick->hostname,
929 volinfo->rep_brick.dst_brick->path);
930 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_RB_DST_BRICK"rb_dst",
931 buf);
932 if (ret)
933 goto out;
934
935 switch (volinfo->transport_type) {
936 case GF_TRANSPORT_RDMA:
937 port = volinfo->rep_brick.dst_brick->rdma_port;
938 break;
939
940 case GF_TRANSPORT_TCP:
941 case GF_TRANSPORT_BOTH_TCP_RDMA:
942 port = volinfo->rep_brick.dst_brick->port;
943 break;
944 }
945
946 snprintf (buf, sizeof (buf), "%d", port);
947 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_RB_DST_PORT"rb_port",
948 buf);
949 if (ret)
950 goto out;
951 uuid_unparse (volinfo->rep_brick.rb_id, buf);
952 ret = glusterd_store_save_value (fd, GF_REPLACE_BRICK_TID_KEY"replace-brick-id",
953 buf);
954 }
955
956 ret = 0;
957out:
958 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 958, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
959 return ret;
960}
961
962int32_t
963glusterd_store_perform_rbstate_store (glusterd_volinfo_t *volinfo)
964{
965 int fd = -1;
966 int32_t ret = -1;
967 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 967, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
968
969 fd = glusterd_store_mkstemp (volinfo->rb_shandle);
970 if (fd <= 0) {
971 ret = -1;
972 goto out;
973 }
974
975 ret = glusterd_store_rbstate_write (fd, volinfo);
976 if (ret)
977 goto out;
978
979 ret = glusterd_store_rename_tmppath (volinfo->rb_shandle);
980 if (ret)
981 goto out;
982
983out:
984 if (ret && (fd > 0))
985 glusterd_store_unlink_tmppath (volinfo->rb_shandle);
986 if (fd > 0)
987 close (fd);
988 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 988, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
989 return ret;
990}
991
992int32_t
993glusterd_store_node_state_write (int fd, glusterd_volinfo_t *volinfo)
994{
995 int ret = -1;
996 char buf[PATH_MAX4096] = {0, };
997
998 GF_ASSERT (fd > 0)do { if (!(fd > 0)) { do { do { if (0) printf ("Assertion failed: "
"fd > 0"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 998, GF_LOG_ERROR, "Assertion failed: " "fd > 0"
); } while (0); } } while (0);
999 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 999, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1000
1001 if (volinfo->rebal.defrag_cmd == GF_DEFRAG_CMD_STATUS) {
1002 ret = 0;
1003 goto out;
1004 }
1005
1006 snprintf (buf, sizeof (buf), "%d", volinfo->rebal.defrag_cmd);
1007 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_DEFRAG"rebalance_status",
1008 buf);
1009 if (ret)
1010 goto out;
1011
1012 snprintf (buf, sizeof (buf), "%d", volinfo->rebal.op);
1013 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_DEFRAG_OP"rebalance_op",
1014 buf);
1015 if (ret)
1016 goto out;
1017
1018 if (volinfo->rebal.defrag_cmd) {
1019 uuid_unparse (volinfo->rebal.rebalance_id, buf);
1020 ret = glusterd_store_save_value (fd,
1021 GF_REBALANCE_TID_KEY"rebalance-id",
1022 buf);
1023 }
1024out:
1025 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 1025, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
1026 return ret;
1027}
1028
1029int32_t
1030glusterd_store_perform_node_state_store (glusterd_volinfo_t *volinfo)
1031{
1032 int fd = -1;
1033 int32_t ret = -1;
1034 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1034, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1035
1036 fd = glusterd_store_mkstemp (volinfo->node_state_shandle);
1037 if (fd <= 0) {
1038 ret = -1;
1039 goto out;
1040 }
1041
1042 ret = glusterd_store_node_state_write (fd, volinfo);
1043 if (ret)
1044 goto out;
1045
1046 ret = glusterd_store_rename_tmppath (volinfo->node_state_shandle);
1047 if (ret)
1048 goto out;
1049
1050out:
1051 if (ret && (fd > 0))
1052 glusterd_store_unlink_tmppath (volinfo->node_state_shandle);
1053 if (fd > 0)
1054 close (fd);
1055 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 1055, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
1056 return ret;
1057}
1058
1059int32_t
1060glusterd_store_perform_volume_store (glusterd_volinfo_t *volinfo)
1061{
1062 int fd = -1;
1063 int32_t ret = -1;
1064 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1064, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1065
1066 fd = glusterd_store_mkstemp (volinfo->shandle);
1067 if (fd <= 0) {
1068 ret = -1;
1069 goto out;
1070 }
1071
1072 ret = glusterd_store_volinfo_write (fd, volinfo);
1073 if (ret)
1074 goto out;
1075
1076 ret = glusterd_store_brickinfos (volinfo, fd);
1077 if (ret)
1078 goto out;
1079
1080out:
1081 if (ret && (fd > 0))
1082 glusterd_store_unlink_tmppath (volinfo->shandle);
1083 if (fd > 0)
1084 close (fd);
1085 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 1085, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
1086 return ret;
1087}
1088
1089void
1090glusterd_perform_volinfo_version_action (glusterd_volinfo_t *volinfo,
1091 glusterd_volinfo_ver_ac_t ac)
1092{
1093 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1093, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1094
1095 switch (ac) {
1096 case GLUSTERD_VOLINFO_VER_AC_NONE:
1097 break;
1098 case GLUSTERD_VOLINFO_VER_AC_INCREMENT:
1099 volinfo->version++;
1100 break;
1101 case GLUSTERD_VOLINFO_VER_AC_DECREMENT:
1102 volinfo->version--;
1103 break;
1104 }
1105}
1106
1107void
1108glusterd_store_bricks_cleanup_tmp (glusterd_volinfo_t *volinfo)
1109{
1110 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
1111
1112 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1112, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1113
1114 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)))) {
1115 glusterd_store_unlink_tmppath (brickinfo->shandle);
1116 }
1117}
1118
1119void
1120glusterd_store_volume_cleanup_tmp (glusterd_volinfo_t *volinfo)
1121{
1122 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1122, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1123
1124 glusterd_store_bricks_cleanup_tmp (volinfo);
1125
1126 glusterd_store_unlink_tmppath (volinfo->shandle);
1127
1128 glusterd_store_unlink_tmppath (volinfo->rb_shandle);
1129
1130 glusterd_store_unlink_tmppath (volinfo->node_state_shandle);
1131}
1132
1133int32_t
1134glusterd_store_brickinfos_atomic_update (glusterd_volinfo_t *volinfo)
1135{
1136 int ret = -1;
1137 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
1138
1139 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1139, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1140
1141 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)))) {
1142 ret = glusterd_store_rename_tmppath (brickinfo->shandle);
1143 if (ret)
1144 goto out;
1145 }
1146out:
1147 return ret;
1148}
1149
1150int32_t
1151glusterd_store_volinfo_atomic_update (glusterd_volinfo_t *volinfo)
1152{
1153 int ret = -1;
1154 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1154, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1155
1156 ret = glusterd_store_rename_tmppath (volinfo->shandle);
1157 if (ret)
1158 goto out;
1159
1160out:
1161 if (ret)
1162 gf_log (THIS->name, GF_LOG_ERROR, "Couldn't rename "do { do { if (0) printf ("Couldn't rename " "temporary file(s): Reason %s"
, strerror ((*__errno_location ()))); } while (0); _gf_log ((
*__glusterfs_this_location())->name, "glusterd-store.c", __FUNCTION__
, 1163, GF_LOG_ERROR, "Couldn't rename " "temporary file(s): Reason %s"
, strerror ((*__errno_location ()))); } while (0)
1163 "temporary file(s): Reason %s", strerror (errno))do { do { if (0) printf ("Couldn't rename " "temporary file(s): Reason %s"
, strerror ((*__errno_location ()))); } while (0); _gf_log ((
*__glusterfs_this_location())->name, "glusterd-store.c", __FUNCTION__
, 1163, GF_LOG_ERROR, "Couldn't rename " "temporary file(s): Reason %s"
, strerror ((*__errno_location ()))); } while (0);
1164 return ret;
1165}
1166
1167int32_t
1168glusterd_store_volume_atomic_update (glusterd_volinfo_t *volinfo)
1169{
1170 int ret = -1;
1171 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1171, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1172
1173 ret = glusterd_store_brickinfos_atomic_update (volinfo);
1174 if (ret)
1175 goto out;
1176
1177 ret = glusterd_store_volinfo_atomic_update (volinfo);
1178
1179out:
1180 return ret;
1181}
1182
1183int32_t
1184glusterd_store_volinfo (glusterd_volinfo_t *volinfo, glusterd_volinfo_ver_ac_t ac)
1185{
1186 int32_t ret = -1;
1187
1188 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1188, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1189
1190 glusterd_perform_volinfo_version_action (volinfo, ac);
1191 ret = glusterd_store_create_volume_dir (volinfo);
1192 if (ret)
1193 goto out;
1194
1195 ret = glusterd_store_create_vol_shandle_on_absence (volinfo);
1196 if (ret)
1197 goto out;
1198
1199 ret = glusterd_store_create_rbstate_shandle_on_absence (volinfo);
1200 if (ret)
1201 goto out;
1202
1203 ret = glusterd_store_create_nodestate_sh_on_absence (volinfo);
1204 if (ret)
1205 goto out;
1206
1207 ret = glusterd_store_perform_volume_store (volinfo);
1208 if (ret)
1209 goto out;
1210
1211 ret = glusterd_store_volume_atomic_update (volinfo);
1212 if (ret) {
1213 glusterd_perform_volinfo_version_action (volinfo,
1214 GLUSTERD_VOLINFO_VER_AC_DECREMENT);
1215 goto out;
1216 }
1217
1218 ret = glusterd_store_perform_rbstate_store (volinfo);
1219 if (ret)
1220 goto out;
1221
1222 ret = glusterd_store_perform_node_state_store (volinfo);
1223 if (ret)
1224 goto out;
1225
1226 //checksum should be computed at the end
1227 ret = glusterd_volume_compute_cksum (volinfo);
1228 if (ret)
1229 goto out;
1230
1231out:
1232 if (ret)
1233 glusterd_store_volume_cleanup_tmp (volinfo);
1234
1235 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 1235, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
1236
1237 return ret;
1238}
1239
1240
1241int32_t
1242glusterd_store_delete_volume (glusterd_volinfo_t *volinfo)
1243{
1244 char pathname[PATH_MAX4096] = {0,};
1245 int32_t ret = 0;
1246 glusterd_conf_t *priv = NULL((void*)0);
1247 DIR *dir = NULL((void*)0);
1248 struct dirent *entry = NULL((void*)0);
1249 char path[PATH_MAX4096] = {0,};
1250 char delete_path[PATH_MAX4096] = {0,};
1251 char trashdir[PATH_MAX4096] = {0,};
1252 struct stat st = {0, };
1253 xlator_t *this = NULL((void*)0);
1254 gf_boolean_t rename_fail = _gf_false;
1255
1256 this = THIS(*__glusterfs_this_location());
1257 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1257, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
1258
1259 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1259, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
1260 priv = this->private;
1261
1262 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1262, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
1263
1264 GLUSTERD_GET_VOLUME_DIR (pathname, volinfo, priv)snprintf (pathname, 4096, "%s/vols/%s", priv->workdir, volinfo
->volname);;
1265
1266 snprintf (delete_path, sizeof (delete_path),
1267 "%s/"GLUSTERD_TRASH"trash""/%s.deleted", priv->workdir,
1268 uuid_utoa (volinfo->volume_id));
1269
1270 snprintf (trashdir, sizeof (trashdir), "%s/"GLUSTERD_TRASH"trash",
1271 priv->workdir);
1272
1273 ret = mkdir (trashdir, 0777);
1274 if (ret && errno(*__errno_location ()) != EEXIST17) {
1275 gf_log (this->name, GF_LOG_ERROR, "Failed to create trash "do { do { if (0) printf ("Failed to create trash " "directory, reason : %s"
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1276, GF_LOG_ERROR
, "Failed to create trash " "directory, reason : %s", strerror
((*__errno_location ()))); } while (0)
1276 "directory, reason : %s", strerror (errno))do { do { if (0) printf ("Failed to create trash " "directory, reason : %s"
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1276, GF_LOG_ERROR
, "Failed to create trash " "directory, reason : %s", strerror
((*__errno_location ()))); } while (0);
1277 ret = -1;
1278 goto out;
1279 }
1280
1281 ret = rename (pathname, delete_path);
1282 if (ret) {
1283 gf_log (this->name, GF_LOG_ERROR, "Failed to rename volume "do { do { if (0) printf ("Failed to rename volume " "directory for volume %s"
, volinfo->volname); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1284, GF_LOG_ERROR, "Failed to rename volume "
"directory for volume %s", volinfo->volname); } while (0)
1284 "directory for volume %s", volinfo->volname)do { do { if (0) printf ("Failed to rename volume " "directory for volume %s"
, volinfo->volname); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1284, GF_LOG_ERROR, "Failed to rename volume "
"directory for volume %s", volinfo->volname); } while (0);
1285 rename_fail = _gf_true;
1286 goto out;
1287 }
1288
1289 dir = opendir (delete_path);
1290 if (!dir) {
1291 gf_log (this->name, GF_LOG_DEBUG, "Failed to open directory %s."do { do { if (0) printf ("Failed to open directory %s." " Reason : %s"
, delete_path, strerror ((*__errno_location ()))); } while (0
); _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 1292
, GF_LOG_DEBUG, "Failed to open directory %s." " Reason : %s"
, delete_path, strerror ((*__errno_location ()))); } while (0
)
1292 " Reason : %s", delete_path, strerror (errno))do { do { if (0) printf ("Failed to open directory %s." " Reason : %s"
, delete_path, strerror ((*__errno_location ()))); } while (0
); _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 1292
, GF_LOG_DEBUG, "Failed to open directory %s." " Reason : %s"
, delete_path, strerror ((*__errno_location ()))); } while (0
);
1293 ret = 0;
1294 goto out;
1295 }
1296 ret = glusterd_store_remove_bricks (volinfo, delete_path);
1297
1298 if (ret) {
1299 gf_log (this->name, GF_LOG_DEBUG, "Remove bricks failed for %s",do { do { if (0) printf ("Remove bricks failed for %s", volinfo
->volname); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1300, GF_LOG_DEBUG, "Remove bricks failed for %s"
, volinfo->volname); } while (0)
1300 volinfo->volname)do { do { if (0) printf ("Remove bricks failed for %s", volinfo
->volname); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1300, GF_LOG_DEBUG, "Remove bricks failed for %s"
, volinfo->volname); } while (0);
1301 }
1302
1303 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
1304 while (entry) {
1305
1306 snprintf (path, PATH_MAX4096, "%s/%s", delete_path, entry->d_name);
1307 ret = stat (path, &st);
1308 if (ret == -1) {
1309 gf_log (this->name, GF_LOG_DEBUG, "Failed to stat "do { do { if (0) printf ("Failed to stat " "entry %s : %s", path
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1310, GF_LOG_DEBUG
, "Failed to stat " "entry %s : %s", path, strerror ((*__errno_location
()))); } while (0)
1310 "entry %s : %s", path, strerror (errno))do { do { if (0) printf ("Failed to stat " "entry %s : %s", path
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1310, GF_LOG_DEBUG
, "Failed to stat " "entry %s : %s", path, strerror ((*__errno_location
()))); } while (0);
1311 goto stat_failed;
1312 }
1313
1314 if (S_ISDIR (st.st_mode)((((st.st_mode)) & 0170000) == (0040000)))
1315 ret = rmdir (path);
1316 else
1317 ret = unlink (path);
1318
1319 if (ret) {
1320 gf_log (this->name, GF_LOG_DEBUG, " Failed to remove "do { do { if (0) printf (" Failed to remove " "%s. Reason : %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 1321, GF_LOG_DEBUG
, " Failed to remove " "%s. Reason : %s", path, strerror ((*__errno_location
()))); } while (0)
1321 "%s. Reason : %s", path, strerror (errno))do { do { if (0) printf (" Failed to remove " "%s. Reason : %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 1321, GF_LOG_DEBUG
, " Failed to remove " "%s. Reason : %s", path, strerror ((*__errno_location
()))); } while (0);
1322 }
1323
1324 gf_log (this->name, GF_LOG_DEBUG, "%s %s",do { do { if (0) printf ("%s %s", ret ? "Failed to remove":"Removed"
, entry->d_name); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1326, GF_LOG_DEBUG, "%s %s", ret ? "Failed to remove"
:"Removed", entry->d_name); } while (0)
1325 ret ? "Failed to remove":"Removed",do { do { if (0) printf ("%s %s", ret ? "Failed to remove":"Removed"
, entry->d_name); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1326, GF_LOG_DEBUG, "%s %s", ret ? "Failed to remove"
:"Removed", entry->d_name); } while (0)
1326 entry->d_name)do { do { if (0) printf ("%s %s", ret ? "Failed to remove":"Removed"
, entry->d_name); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1326, GF_LOG_DEBUG, "%s %s", ret ? "Failed to remove"
:"Removed", entry->d_name); } while (0);
1327stat_failed:
1328 memset (path, 0, sizeof(path));
1329 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
1330 }
1331
1332 ret = closedir (dir);
1333 if (ret) {
1334 gf_log (this->name, GF_LOG_DEBUG, "Failed to close dir %s. "do { do { if (0) printf ("Failed to close dir %s. " "Reason : %s"
,delete_path, strerror ((*__errno_location ()))); } while (0)
; _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 1335
, GF_LOG_DEBUG, "Failed to close dir %s. " "Reason : %s",delete_path
, strerror ((*__errno_location ()))); } while (0)
1335 "Reason : %s",delete_path, strerror (errno))do { do { if (0) printf ("Failed to close dir %s. " "Reason : %s"
,delete_path, strerror ((*__errno_location ()))); } while (0)
; _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 1335
, GF_LOG_DEBUG, "Failed to close dir %s. " "Reason : %s",delete_path
, strerror ((*__errno_location ()))); } while (0);
1336 }
1337
1338 ret = rmdir (delete_path);
1339 if (ret) {
1340 gf_log (this->name, GF_LOG_DEBUG, "Failed to rmdir: %s,err: %s",do { do { if (0) printf ("Failed to rmdir: %s,err: %s", delete_path
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1341, GF_LOG_DEBUG
, "Failed to rmdir: %s,err: %s", delete_path, strerror ((*__errno_location
()))); } while (0)
1341 delete_path, strerror (errno))do { do { if (0) printf ("Failed to rmdir: %s,err: %s", delete_path
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1341, GF_LOG_DEBUG
, "Failed to rmdir: %s,err: %s", delete_path, strerror ((*__errno_location
()))); } while (0);
1342 }
1343 ret = rmdir (trashdir);
1344 if (ret) {
1345 gf_log (this->name, GF_LOG_DEBUG, "Failed to rmdir: %s, Reason:"do { do { if (0) printf ("Failed to rmdir: %s, Reason:" " %s"
, trashdir, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 1346, GF_LOG_DEBUG
, "Failed to rmdir: %s, Reason:" " %s", trashdir, strerror ((
*__errno_location ()))); } while (0)
1346 " %s", trashdir, strerror (errno))do { do { if (0) printf ("Failed to rmdir: %s, Reason:" " %s"
, trashdir, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 1346, GF_LOG_DEBUG
, "Failed to rmdir: %s, Reason:" " %s", trashdir, strerror ((
*__errno_location ()))); } while (0);
1347 }
1348
1349out:
1350 if (volinfo->shandle) {
1351 glusterd_store_handle_destroy (volinfo->shandle);
1352 volinfo->shandle = NULL((void*)0);
1353 }
1354 ret = (rename_fail == _gf_true) ? -1: 0;
1355
1356 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-store.c", __FUNCTION__, 1356, GF_LOG_DEBUG
, "Returning %d", ret); } while (0);
1357 return ret;
1358}
1359
1360
1361int
1362glusterd_store_read_and_tokenize (FILE *file, char *str,
1363 char **iter_key, char **iter_val,
1364 glusterd_store_op_errno_t *store_errno)
1365{
1366 int32_t ret = -1;
1367 char *savetok = NULL((void*)0);
1368
1369 GF_ASSERT (file)do { if (!(file)) { do { do { if (0) printf ("Assertion failed: "
"file"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1369, GF_LOG_ERROR, "Assertion failed: " "file"
); } while (0); } } while (0);
1370 GF_ASSERT (str)do { if (!(str)) { do { do { if (0) printf ("Assertion failed: "
"str"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1370, GF_LOG_ERROR, "Assertion failed: " "str"
); } while (0); } } while (0);
1371 GF_ASSERT (iter_key)do { if (!(iter_key)) { do { do { if (0) printf ("Assertion failed: "
"iter_key"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1371, GF_LOG_ERROR, "Assertion failed: " "iter_key"
); } while (0); } } while (0);
1372 GF_ASSERT (iter_val)do { if (!(iter_val)) { do { do { if (0) printf ("Assertion failed: "
"iter_val"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1372, GF_LOG_ERROR, "Assertion failed: " "iter_val"
); } while (0); } } while (0);
1373 GF_ASSERT (store_errno)do { if (!(store_errno)) { do { do { if (0) printf ("Assertion failed: "
"store_errno"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1373, GF_LOG_ERROR, "Assertion failed: " "store_errno"
); } while (0); } } while (0);
1374
1375 ret = fscanf (file, "%s", str);
1376 if (ret <= 0 || feof (file)) {
1377 ret = -1;
1378 *store_errno = GD_STORE_EOF;
1379 goto out;
1380 }
1381
1382 *iter_key = strtok_r (str, "=", &savetok);
1383 if (*iter_key == NULL((void*)0)) {
1384 ret = -1;
1385 *store_errno = GD_STORE_KEY_NULL;
1386 goto out;
1387 }
1388
1389 *iter_val = strtok_r (NULL((void*)0), "=", &savetok);
1390 if (*iter_key == NULL((void*)0)) {
1391 ret = -1;
1392 *store_errno = GD_STORE_VALUE_NULL;
1393 goto out;
1394 }
1395
1396 *store_errno = GD_STORE_SUCCESS;
1397 ret = 0;
1398out:
1399 return ret;
1400}
1401
1402int32_t
1403glusterd_store_retrieve_value (glusterd_store_handle_t *handle,
1404 char *key, char **value)
1405{
1406 int32_t ret = -1;
1407 char *scan_str = NULL((void*)0);
1408 char *iter_key = NULL((void*)0);
1409 char *iter_val = NULL((void*)0);
1410 char *free_str = NULL((void*)0);
1411 struct stat st = {0,};
1412 glusterd_store_op_errno_t store_errno = GD_STORE_SUCCESS;
1413
1414 GF_ASSERT (handle)do { if (!(handle)) { do { do { if (0) printf ("Assertion failed: "
"handle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1414, GF_LOG_ERROR, "Assertion failed: " "handle"
); } while (0); } } while (0);
1415
1416 handle->fd = open (handle->path, O_RDWR02);
1417
1418 if (handle->fd == -1) {
1419 gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",do { do { if (0) printf ("Unable to open file %s errno: %s", handle
->path, strerror ((*__errno_location ()))); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1420, GF_LOG_ERROR, "Unable to open file %s errno: %s"
, handle->path, strerror ((*__errno_location ()))); } while
(0)
1420 handle->path, strerror (errno))do { do { if (0) printf ("Unable to open file %s errno: %s", handle
->path, strerror ((*__errno_location ()))); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1420, GF_LOG_ERROR, "Unable to open file %s errno: %s"
, handle->path, strerror ((*__errno_location ()))); } while
(0);
1421 goto out;
1422 }
1423 if (!handle->read)
1424 handle->read = fdopen (handle->fd, "r");
1425
1426 if (!handle->read) {
1427 gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %s",do { do { if (0) printf ("Unable to open file %s errno: %s", handle
->path, strerror ((*__errno_location ()))); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1428, GF_LOG_ERROR, "Unable to open file %s errno: %s"
, handle->path, strerror ((*__errno_location ()))); } while
(0)
1428 handle->path, strerror (errno))do { do { if (0) printf ("Unable to open file %s errno: %s", handle
->path, strerror ((*__errno_location ()))); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1428, GF_LOG_ERROR, "Unable to open file %s errno: %s"
, handle->path, strerror ((*__errno_location ()))); } while
(0);
1429 goto out;
1430 }
1431
1432 ret = fstat (handle->fd, &st);
1433 if (ret < 0) {
1434 gf_log ("glusterd", GF_LOG_WARNING,do { do { if (0) printf ("stat on file failed"); } while (0);
_gf_log ("glusterd", "glusterd-store.c", __FUNCTION__, 1435,
GF_LOG_WARNING, "stat on file failed"); } while (0)
1435 "stat on file failed")do { do { if (0) printf ("stat on file failed"); } while (0);
_gf_log ("glusterd", "glusterd-store.c", __FUNCTION__, 1435,
GF_LOG_WARNING, "stat on file failed"); } while (0);
1436 ret = -1;
1437 store_errno = GD_STORE_STAT_FAILED;
1438 goto out;
1439 }
1440
1441 scan_str = GF_CALLOC (1, st.st_size,__gf_calloc (1, st.st_size, gf_gld_mt_char)
1442 gf_gld_mt_char)__gf_calloc (1, st.st_size, gf_gld_mt_char);
1443 if (scan_str == NULL((void*)0)) {
1444 ret = -1;
1445 store_errno = GD_STORE_ENOMEM;
1446 goto out;
1447 }
1448
1449 free_str = scan_str;
1450
1451 do {
1452 ret = glusterd_store_read_and_tokenize (handle->read, scan_str,
1453 &iter_key, &iter_val,
1454 &store_errno);
1455 if (ret < 0) {
1456 goto out;
1457 }
1458
1459 gf_log ("", GF_LOG_DEBUG, "key %s read", iter_key)do { do { if (0) printf ("key %s read", iter_key); } while (0
); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1459, GF_LOG_DEBUG
, "key %s read", iter_key); } while (0);
1460
1461 if (!strcmp (key, iter_key)) {
1462 gf_log ("", GF_LOG_DEBUG, "key %s found", key)do { do { if (0) printf ("key %s found", key); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1462, GF_LOG_DEBUG, "key %s found"
, key); } while (0);
1463 ret = 0;
1464 if (iter_val)
1465 *value = gf_strdup (iter_val);
1466 goto out;
1467 }
1468 } while (1);
1469out:
1470 if (handle->fd > 0) {
1471 close (handle->fd);
1472 handle->read = NULL((void*)0);
1473 }
1474
1475 GF_FREE (free_str)__gf_free (free_str);
1476
1477 return ret;
1478}
1479
1480int32_t
1481glusterd_store_save_value (int fd, char *key, char *value)
1482{
1483 int32_t ret = -1;
1484 FILE *fp = NULL((void*)0);
1485 xlator_t *this = NULL((void*)0);
1486
1487 this = THIS(*__glusterfs_this_location());
1488 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1488, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
1489 GF_ASSERT (fd > 0)do { if (!(fd > 0)) { do { do { if (0) printf ("Assertion failed: "
"fd > 0"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1489, GF_LOG_ERROR, "Assertion failed: " "fd > 0"
); } while (0); } } while (0);
1490 GF_ASSERT (key)do { if (!(key)) { do { do { if (0) printf ("Assertion failed: "
"key"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1490, GF_LOG_ERROR, "Assertion failed: " "key"
); } while (0); } } while (0);
1491 GF_ASSERT (value)do { if (!(value)) { do { do { if (0) printf ("Assertion failed: "
"value"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1491, GF_LOG_ERROR, "Assertion failed: " "value"
); } while (0); } } while (0);
1492
1493 fp = fdopen (fd, "a+");
1494 if (fp == NULL((void*)0)) {
1495 gf_log (this->name, GF_LOG_WARNING, "fdopen failed.")do { do { if (0) printf ("fdopen failed."); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 1495, GF_LOG_WARNING
, "fdopen failed."); } while (0);
1496 ret = -1;
1497 goto out;
1498 }
1499
1500 ret = fprintf (fp, "%s=%s\n", key, value);
1501 if (ret < 0) {
1502 gf_log (this->name, GF_LOG_WARNING, "Unable to store key: %s,"do { do { if (0) printf ("Unable to store key: %s," "value: %s, error: %s"
, key, value, strerror ((*__errno_location ()))); } while (0)
; _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 1504
, GF_LOG_WARNING, "Unable to store key: %s," "value: %s, error: %s"
, key, value, strerror ((*__errno_location ()))); } while (0)
1503 "value: %s, error: %s", key, value,do { do { if (0) printf ("Unable to store key: %s," "value: %s, error: %s"
, key, value, strerror ((*__errno_location ()))); } while (0)
; _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 1504
, GF_LOG_WARNING, "Unable to store key: %s," "value: %s, error: %s"
, key, value, strerror ((*__errno_location ()))); } while (0)
1504 strerror (errno))do { do { if (0) printf ("Unable to store key: %s," "value: %s, error: %s"
, key, value, strerror ((*__errno_location ()))); } while (0)
; _gf_log (this->name, "glusterd-store.c", __FUNCTION__, 1504
, GF_LOG_WARNING, "Unable to store key: %s," "value: %s, error: %s"
, key, value, strerror ((*__errno_location ()))); } while (0);
1505 ret = -1;
1506 goto out;
1507 }
1508
1509 ret = fflush (fp);
1510 if (feof (fp)) {
1511 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("fflush failed, error: %s", strerror
((*__errno_location ()))); } while (0); _gf_log (this->name
, "glusterd-store.c", __FUNCTION__, 1513, GF_LOG_WARNING, "fflush failed, error: %s"
, strerror ((*__errno_location ()))); } while (0)
1512 "fflush failed, error: %s",do { do { if (0) printf ("fflush failed, error: %s", strerror
((*__errno_location ()))); } while (0); _gf_log (this->name
, "glusterd-store.c", __FUNCTION__, 1513, GF_LOG_WARNING, "fflush failed, error: %s"
, strerror ((*__errno_location ()))); } while (0)
1513 strerror (errno))do { do { if (0) printf ("fflush failed, error: %s", strerror
((*__errno_location ()))); } while (0); _gf_log (this->name
, "glusterd-store.c", __FUNCTION__, 1513, GF_LOG_WARNING, "fflush failed, error: %s"
, strerror ((*__errno_location ()))); } while (0);
1514 ret = -1;
1515 goto out;
1516 }
1517
1518 ret = 0;
1519out:
1520
1521 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-store.c", __FUNCTION__, 1521, GF_LOG_DEBUG
, "returning: %d", ret); } while (0);
1522 return ret;
1523}
1524
1525int32_t
1526glusterd_store_handle_new (char *path, glusterd_store_handle_t **handle)
1527{
1528 int32_t ret = -1;
1529 glusterd_store_handle_t *shandle = NULL((void*)0);
1530 int fd = -1;
1531 char *spath = NULL((void*)0);
1532 xlator_t *this = NULL((void*)0);
1533
1534 this = THIS(*__glusterfs_this_location());
1535 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1535, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
1536
1537 shandle = GF_CALLOC (1, sizeof (*shandle), gf_gld_mt_store_handle_t)__gf_calloc (1, sizeof (*shandle), gf_gld_mt_store_handle_t);
1538 if (!shandle)
1539 goto out;
1540
1541 spath = gf_strdup (path);
1542
1543 if (!spath)
1544 goto out;
1545
1546 fd = open (path, O_RDWR02 | O_CREAT0100 | O_APPEND02000, 0600);
1547 if (fd <= 0) {
1548 gf_log (this->name, GF_LOG_ERROR, "Failed to open file: %s, "do { do { if (0) printf ("Failed to open file: %s, " "error: %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 1549, GF_LOG_ERROR
, "Failed to open file: %s, " "error: %s", path, strerror ((*
__errno_location ()))); } while (0)
1549 "error: %s", path, strerror (errno))do { do { if (0) printf ("Failed to open file: %s, " "error: %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
(this->name, "glusterd-store.c", __FUNCTION__, 1549, GF_LOG_ERROR
, "Failed to open file: %s, " "error: %s", path, strerror ((*
__errno_location ()))); } while (0);
1550 goto out;
1551 }
1552
1553 ret = glusterd_store_sync_direntry (spath);
1554 if (ret)
1555 goto out;
1556
1557 shandle->path = spath;
1558 *handle = shandle;
1559
1560 ret = 0;
1561out:
1562 if (fd > 0)
1563 close (fd);
1564
1565 if (ret == -1) {
1566 GF_FREE (spath)__gf_free (spath);
1567 GF_FREE (shandle)__gf_free (shandle);
1568 }
1569
1570 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-store.c", __FUNCTION__, 1570, GF_LOG_DEBUG
, "Returning %d", ret); } while (0);
1571 return ret;
1572}
1573
1574int
1575glusterd_store_handle_retrieve (char *path, glusterd_store_handle_t **handle)
1576{
1577 int32_t ret = -1;
1578 struct stat statbuf = {0};
1579
1580 ret = stat (path, &statbuf);
1581 if (ret) {
1582 gf_log ("glusterd", GF_LOG_ERROR, "Unable to retrieve store "do { do { if (0) printf ("Unable to retrieve store " "handle for %s, error: %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
("glusterd", "glusterd-store.c", __FUNCTION__, 1583, GF_LOG_ERROR
, "Unable to retrieve store " "handle for %s, error: %s", path
, strerror ((*__errno_location ()))); } while (0)
1583 "handle for %s, error: %s", path, strerror (errno))do { do { if (0) printf ("Unable to retrieve store " "handle for %s, error: %s"
, path, strerror ((*__errno_location ()))); } while (0); _gf_log
("glusterd", "glusterd-store.c", __FUNCTION__, 1583, GF_LOG_ERROR
, "Unable to retrieve store " "handle for %s, error: %s", path
, strerror ((*__errno_location ()))); } while (0);
1584 goto out;
1585 }
1586 ret = glusterd_store_handle_new (path, handle);
1587out:
1588 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1588, GF_LOG_DEBUG, "Returning %d"
, ret); } while (0);
1589 return ret;
1590}
1591
1592int32_t
1593glusterd_store_handle_destroy (glusterd_store_handle_t *handle)
1594{
1595 int32_t ret = -1;
1596
1597 if (!handle) {
1598 ret = 0;
1599 goto out;
1600 }
1601
1602 GF_FREE (handle->path)__gf_free (handle->path);
1603
1604 GF_FREE (handle)__gf_free (handle);
1605
1606 ret = 0;
1607
1608out:
1609 gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
((*__glusterfs_this_location())->name, "glusterd-store.c"
, __FUNCTION__, 1609, GF_LOG_DEBUG, "Returning %d", ret); } while
(0);
1610
1611 return ret;
1612}
1613
1614int
1615glusterd_store_global_info (xlator_t *this)
1616{
1617 int ret = -1;
1618 glusterd_conf_t *conf = NULL((void*)0);
1619 char op_version_str[15] = {0,};
1620 char path[PATH_MAX4096] = {0,};
1621 glusterd_store_handle_t *handle = NULL((void*)0);
1622 char *uuid_str = NULL((void*)0);
1623
1624 conf = this->private;
1625
1626 uuid_str = gf_strdup (uuid_utoa (MY_UUID(__glusterd_uuid())));
1627 if (!uuid_str)
1628 goto out;
1629
1630 if (!conf->handle) {
1631 snprintf (path, PATH_MAX4096, "%s/%s", conf->workdir,
1632 GLUSTERD_INFO_FILE"glusterd.info");
1633 ret = glusterd_store_handle_new (path, &handle);
1634 if (ret) {
1635 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Unable to get store handle"); } while
(0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1636, GF_LOG_ERROR, "Unable to get store handle"); } while (
0)
1636 "Unable to get store handle")do { do { if (0) printf ("Unable to get store handle"); } while
(0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1636, GF_LOG_ERROR, "Unable to get store handle"); } while (
0);
1637 goto out;
1638 }
1639
1640 conf->handle = handle;
1641 } else
1642 handle = conf->handle;
1643
1644 /* These options need to be available for all users */
1645 ret = chmod (handle->path, 0644);
1646 if (ret) {
1647 gf_log (this->name, GF_LOG_ERROR, "chmod error for %s: %s",do { do { if (0) printf ("chmod error for %s: %s", "glusterd.info"
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1648, GF_LOG_ERROR
, "chmod error for %s: %s", "glusterd.info", strerror ((*__errno_location
()))); } while (0)
1648 GLUSTERD_INFO_FILE, strerror (errno))do { do { if (0) printf ("chmod error for %s: %s", "glusterd.info"
, strerror ((*__errno_location ()))); } while (0); _gf_log (this
->name, "glusterd-store.c", __FUNCTION__, 1648, GF_LOG_ERROR
, "chmod error for %s: %s", "glusterd.info", strerror ((*__errno_location
()))); } while (0);
1649 goto out;
1650 }
1651
1652 handle->fd = glusterd_store_mkstemp (handle);
1653 if (handle->fd <= 0) {
1654 ret = -1;
1655 goto out;
1656 }
1657
1658 ret = glusterd_store_save_value (handle->fd, GLUSTERD_STORE_UUID_KEY"UUID",
1659 uuid_str);
1660 if (ret) {
1661 gf_log (this->name, GF_LOG_CRITICAL,do { do { if (0) printf ("Storing uuid failed ret = %d", ret)
; } while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1662, GF_LOG_CRITICAL, "Storing uuid failed ret = %d", ret)
; } while (0)
1662 "Storing uuid failed ret = %d", ret)do { do { if (0) printf ("Storing uuid failed ret = %d", ret)
; } while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1662, GF_LOG_CRITICAL, "Storing uuid failed ret = %d", ret)
; } while (0);
1663 goto out;
1664 }
1665
1666 snprintf (op_version_str, 15, "%d", conf->op_version);
1667 ret = glusterd_store_save_value (handle->fd, GD_OP_VERSION_KEY"operating-version",
1668 op_version_str);
1669 if (ret) {
1670 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Storing op-version failed ret = %d"
, ret); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1671, GF_LOG_ERROR, "Storing op-version failed ret = %d"
, ret); } while (0)
1671 "Storing op-version failed ret = %d", ret)do { do { if (0) printf ("Storing op-version failed ret = %d"
, ret); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1671, GF_LOG_ERROR, "Storing op-version failed ret = %d"
, ret); } while (0);
1672 goto out;
1673 }
1674
1675 ret = glusterd_store_rename_tmppath (handle);
1676out:
1677 if (ret && (handle->fd > 0))
1678 glusterd_store_unlink_tmppath (handle);
1679
1680 if (handle->fd > 0) {
1681 close (handle->fd);
1682 handle->fd = 0;
1683 }
1684
1685 if (uuid_str)
1686 GF_FREE (uuid_str)__gf_free (uuid_str);
1687
1688 if (ret)
1689 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Failed to store glusterd global-info"
); } while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1690, GF_LOG_ERROR, "Failed to store glusterd global-info")
; } while (0)
1690 "Failed to store glusterd global-info")do { do { if (0) printf ("Failed to store glusterd global-info"
); } while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1690, GF_LOG_ERROR, "Failed to store glusterd global-info")
; } while (0);
1691
1692 return ret;
1693}
1694
1695int
1696glusterd_retrieve_op_version (xlator_t *this, int *op_version)
1697{
1698 char *op_version_str = NULL((void*)0);
1699 glusterd_conf_t *priv = NULL((void*)0);
1700 int ret = -1;
1701 int tmp_version = 0;
1702 char *tmp = NULL((void*)0);
1703 char path[PATH_MAX4096] = {0,};
1704 glusterd_store_handle_t *handle = NULL((void*)0);
1705
1706 priv = this->private;
1707
1708 if (!priv->handle) {
1709 snprintf (path, PATH_MAX4096, "%s/%s", priv->workdir,
1710 GLUSTERD_INFO_FILE"glusterd.info");
1711 ret = glusterd_store_handle_retrieve (path, &handle);
1712
1713 if (ret) {
1714 gf_log ("", GF_LOG_ERROR, "Unable to get store "do { do { if (0) printf ("Unable to get store " "handle!"); }
while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1715
, GF_LOG_ERROR, "Unable to get store " "handle!"); } while (0
)
1715 "handle!")do { do { if (0) printf ("Unable to get store " "handle!"); }
while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1715
, GF_LOG_ERROR, "Unable to get store " "handle!"); } while (0
);
1716 goto out;
1717 }
1718
1719 priv->handle = handle;
1720 }
1721
1722 ret = glusterd_store_retrieve_value (priv->handle,
1723 GD_OP_VERSION_KEY"operating-version",
1724 &op_version_str);
1725 if (ret) {
1726 gf_log (this->name, GF_LOG_DEBUG,do { do { if (0) printf ("No previous op_version present"); }
while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1727, GF_LOG_DEBUG, "No previous op_version present"); } while
(0)
1727 "No previous op_version present")do { do { if (0) printf ("No previous op_version present"); }
while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1727, GF_LOG_DEBUG, "No previous op_version present"); } while
(0);
1728 goto out;
1729 }
1730
1731 tmp_version = strtol (op_version_str, &tmp, 10);
1732 if ((tmp_version <= 0) || (tmp && strlen (tmp) > 1)) {
1733 gf_log (this->name, GF_LOG_WARNING, "invalid version number")do { do { if (0) printf ("invalid version number"); } while (
0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__,
1733, GF_LOG_WARNING, "invalid version number"); } while (0);
1734 goto out;
1735 }
1736
1737 *op_version = tmp_version;
1738
1739 ret = 0;
1740out:
1741 if (op_version_str)
1742 GF_FREE (op_version_str)__gf_free (op_version_str);
1743
1744 return ret;
1745}
1746
1747static int
1748glusterd_restore_op_version (xlator_t *this)
1749{
1750 glusterd_conf_t *conf = NULL((void*)0);
1751 int ret = 0;
1752 int op_version = 0;
1753
1754 conf = this->private;
1755
1756 ret = glusterd_retrieve_op_version (this, &op_version);
1757 if (!ret) {
1758 if ((op_version < GD_OP_VERSION_MIN1) ||
1759 (op_version > GD_OP_VERSION_MAX2)) {
1760 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("wrong op-version (%d) retreived", op_version
); } while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1761, GF_LOG_ERROR, "wrong op-version (%d) retreived", op_version
); } while (0)
1761 "wrong op-version (%d) retreived", op_version)do { do { if (0) printf ("wrong op-version (%d) retreived", op_version
); } while (0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 1761, GF_LOG_ERROR, "wrong op-version (%d) retreived", op_version
); } while (0);
1762 ret = -1;
1763 goto out;
1764 }
1765 conf->op_version = op_version;
1766 gf_log ("glusterd", GF_LOG_INFO,do { do { if (0) printf ("retrieved op-version: %d", conf->
op_version); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1767, GF_LOG_INFO, "retrieved op-version: %d"
, conf->op_version); } while (0)
1767 "retrieved op-version: %d", conf->op_version)do { do { if (0) printf ("retrieved op-version: %d", conf->
op_version); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1767, GF_LOG_INFO, "retrieved op-version: %d"
, conf->op_version); } while (0);
1768 goto out;
1769 }
1770
1771 gf_log (this->name, GF_LOG_INFO, "op-version not found in store, "do { do { if (0) printf ("op-version not found in store, " "setting it to minimum op-version : %d"
, 1); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1772, GF_LOG_INFO, "op-version not found in store, "
"setting it to minimum op-version : %d", 1); } while (0)
1772 "setting it to minimum op-version : %d", GD_OP_VERSION_MIN)do { do { if (0) printf ("op-version not found in store, " "setting it to minimum op-version : %d"
, 1); } while (0); _gf_log (this->name, "glusterd-store.c"
, __FUNCTION__, 1772, GF_LOG_INFO, "op-version not found in store, "
"setting it to minimum op-version : %d", 1); } while (0);
1773
1774 /* If op-version is missing, set it to GD_OP_VERSION_MIN */
1775 conf->op_version = GD_OP_VERSION_MIN1;
1776 ret = 0;
1777out:
1778 return ret;
1779}
1780
1781int32_t
1782glusterd_retrieve_uuid ()
1783{
1784 char *uuid_str = NULL((void*)0);
1785 int32_t ret = -1;
1786 glusterd_store_handle_t *handle = NULL((void*)0);
1787 glusterd_conf_t *priv = NULL((void*)0);
1788 char path[PATH_MAX4096] = {0,};
1789
1790 priv = THIS(*__glusterfs_this_location())->private;
1791
1792 if (!priv->handle) {
1793 snprintf (path, PATH_MAX4096, "%s/%s", priv->workdir,
1794 GLUSTERD_INFO_FILE"glusterd.info");
1795 ret = glusterd_store_handle_retrieve (path, &handle);
1796
1797 if (ret) {
1798 gf_log ("", GF_LOG_ERROR, "Unable to get store "do { do { if (0) printf ("Unable to get store " "handle!"); }
while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1799
, GF_LOG_ERROR, "Unable to get store " "handle!"); } while (0
)
1799 "handle!")do { do { if (0) printf ("Unable to get store " "handle!"); }
while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1799
, GF_LOG_ERROR, "Unable to get store " "handle!"); } while (0
);
1800 goto out;
1801 }
1802
1803 priv->handle = handle;
1804 }
1805
1806 ret = glusterd_store_retrieve_value (priv->handle,
1807 GLUSTERD_STORE_UUID_KEY"UUID",
1808 &uuid_str);
1809
1810 if (ret) {
1811 gf_log ("", GF_LOG_INFO, "No previous uuid is present")do { do { if (0) printf ("No previous uuid is present"); } while
(0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1811, GF_LOG_INFO
, "No previous uuid is present"); } while (0);
1812 goto out;
1813 }
1814
1815 uuid_parse (uuid_str, priv->uuid);
1816
1817out:
1818 GF_FREE (uuid_str)__gf_free (uuid_str);
1819 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1819, GF_LOG_DEBUG, "Returning %d"
, ret); } while (0);
1820 return ret;
1821}
1822
1823int32_t
1824glusterd_store_iter_new (glusterd_store_handle_t *shandle,
1825 glusterd_store_iter_t **iter)
1826{
1827 int32_t ret = -1;
1828 glusterd_store_iter_t *tmp_iter = NULL((void*)0);
1829 int fd = -1;
1830
1831 GF_ASSERT (shandle)do { if (!(shandle)) { do { do { if (0) printf ("Assertion failed: "
"shandle"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1831, GF_LOG_ERROR, "Assertion failed: " "shandle"
); } while (0); } } while (0);
1832 GF_ASSERT (iter)do { if (!(iter)) { do { do { if (0) printf ("Assertion failed: "
"iter"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1832, GF_LOG_ERROR, "Assertion failed: " "iter"
); } while (0); } } while (0);
1833
1834 tmp_iter = GF_CALLOC (1, sizeof (*tmp_iter),__gf_calloc (1, sizeof (*tmp_iter), gf_gld_mt_store_iter_t)
1835 gf_gld_mt_store_iter_t)__gf_calloc (1, sizeof (*tmp_iter), gf_gld_mt_store_iter_t);
1836
1837 if (!tmp_iter) {
1838 gf_log ("", GF_LOG_ERROR, "Out of Memory")do { do { if (0) printf ("Out of Memory"); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 1838, GF_LOG_ERROR, "Out of Memory"
); } while (0);
1839 goto out;
1840 }
1841
1842 fd = open (shandle->path, O_RDWR02);
1843
1844 if (fd < 0) {
1845 gf_log ("", GF_LOG_ERROR, "Unable to open %s, errno: %d",do { do { if (0) printf ("Unable to open %s, errno: %d", shandle
->path, (*__errno_location ())); } while (0); _gf_log ("",
"glusterd-store.c", __FUNCTION__, 1846, GF_LOG_ERROR, "Unable to open %s, errno: %d"
, shandle->path, (*__errno_location ())); } while (0)
1846 shandle->path, errno)do { do { if (0) printf ("Unable to open %s, errno: %d", shandle
->path, (*__errno_location ())); } while (0); _gf_log ("",
"glusterd-store.c", __FUNCTION__, 1846, GF_LOG_ERROR, "Unable to open %s, errno: %d"
, shandle->path, (*__errno_location ())); } while (0);
1847 goto out;
1848 }
1849
1850 tmp_iter->fd = fd;
1851
1852 tmp_iter->file = fdopen (tmp_iter->fd, "r");
1853
1854 if (!tmp_iter->file) {
1855 gf_log ("", GF_LOG_ERROR, "Unable to open file %s errno: %d",do { do { if (0) printf ("Unable to open file %s errno: %d", shandle
->path, (*__errno_location ())); } while (0); _gf_log ("",
"glusterd-store.c", __FUNCTION__, 1856, GF_LOG_ERROR, "Unable to open file %s errno: %d"
, shandle->path, (*__errno_location ())); } while (0)
1856 shandle->path, errno)do { do { if (0) printf ("Unable to open file %s errno: %d", shandle
->path, (*__errno_location ())); } while (0); _gf_log ("",
"glusterd-store.c", __FUNCTION__, 1856, GF_LOG_ERROR, "Unable to open file %s errno: %d"
, shandle->path, (*__errno_location ())); } while (0);
1857 goto out;
1858 }
1859
1860 strncpy (tmp_iter->filepath, shandle->path, sizeof (tmp_iter->filepath));
1861 tmp_iter->filepath[sizeof (tmp_iter->filepath) - 1] = 0;
1862 *iter = tmp_iter;
1863 ret = 0;
1864
1865out:
1866 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1866, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
1867 return ret;
1868}
1869
1870int32_t
1871glusterd_store_validate_key_value (char *storepath, char *key, char*val,
1872 glusterd_store_op_errno_t *op_errno)
1873{
1874 int ret = 0;
1875
1876 GF_ASSERT (op_errno)do { if (!(op_errno)) { do { do { if (0) printf ("Assertion failed: "
"op_errno"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1876, GF_LOG_ERROR, "Assertion failed: " "op_errno"
); } while (0); } } while (0);
1877 GF_ASSERT (storepath)do { if (!(storepath)) { do { do { if (0) printf ("Assertion failed: "
"storepath"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1877, GF_LOG_ERROR, "Assertion failed: " "storepath"
); } while (0); } } while (0);
1878
1879 if ((key == NULL((void*)0)) && (val == NULL((void*)0))) {
1880 ret = -1;
1881 gf_log ("glusterd", GF_LOG_ERROR, "Glusterd store may be "do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid key and value (null) in %s"
, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1883, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid key and value (null) in %s"
, storepath); } while (0)
1882 "corrupted, Invalid key and value (null) in %s",do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid key and value (null) in %s"
, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1883, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid key and value (null) in %s"
, storepath); } while (0)
1883 storepath)do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid key and value (null) in %s"
, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1883, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid key and value (null) in %s"
, storepath); } while (0);
1884 *op_errno = GD_STORE_KEY_VALUE_NULL;
1885 } else if (key == NULL((void*)0)) {
1886 ret = -1;
1887 gf_log ("glusterd", GF_LOG_ERROR, "Glusterd store may be "do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid key (null) in %s"
, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1888, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid key (null) in %s"
, storepath); } while (0)
1888 "corrupted, Invalid key (null) in %s", storepath)do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid key (null) in %s"
, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1888, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid key (null) in %s"
, storepath); } while (0);
1889 *op_errno = GD_STORE_KEY_NULL;
1890 } else if (val == NULL((void*)0)) {
1891 ret = -1;
1892 gf_log ("glusterd", GF_LOG_ERROR, "Glusterd store may be "do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid value (null) for key %s in %s"
, key, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1894, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid value (null) for key %s in %s"
, key, storepath); } while (0)
1893 "corrupted, Invalid value (null) for key %s in %s",do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid value (null) for key %s in %s"
, key, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1894, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid value (null) for key %s in %s"
, key, storepath); } while (0)
1894 key, storepath)do { do { if (0) printf ("Glusterd store may be " "corrupted, Invalid value (null) for key %s in %s"
, key, storepath); } while (0); _gf_log ("glusterd", "glusterd-store.c"
, __FUNCTION__, 1894, GF_LOG_ERROR, "Glusterd store may be " "corrupted, Invalid value (null) for key %s in %s"
, key, storepath); } while (0);
1895 *op_errno = GD_STORE_VALUE_NULL;
1896 } else {
1897 ret = 0;
1898 *op_errno = GD_STORE_SUCCESS;
1899 }
1900
1901 return ret;
1902}
1903
1904int32_t
1905glusterd_store_iter_get_next (glusterd_store_iter_t *iter,
1906 char **key, char **value,
1907 glusterd_store_op_errno_t *op_errno)
1908{
1909 int32_t ret = -1;
1910 char *scan_str = NULL((void*)0);
1911 char *free_str = NULL((void*)0);
1912 char *iter_key = NULL((void*)0);
1913 char *iter_val = NULL((void*)0);
1914 struct stat st = {0,};
1915 glusterd_store_op_errno_t store_errno = GD_STORE_SUCCESS;
1916
1917 GF_ASSERT (iter)do { if (!(iter)) { do { do { if (0) printf ("Assertion failed: "
"iter"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1917, GF_LOG_ERROR, "Assertion failed: " "iter"
); } while (0); } } while (0);
1918 GF_ASSERT (iter->file)do { if (!(iter->file)) { do { do { if (0) printf ("Assertion failed: "
"iter->file"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1918, GF_LOG_ERROR, "Assertion failed: " "iter->file"
); } while (0); } } while (0);
1919 GF_ASSERT (key)do { if (!(key)) { do { do { if (0) printf ("Assertion failed: "
"key"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1919, GF_LOG_ERROR, "Assertion failed: " "key"
); } while (0); } } while (0);
1920 GF_ASSERT (value)do { if (!(value)) { do { do { if (0) printf ("Assertion failed: "
"value"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 1920, GF_LOG_ERROR, "Assertion failed: " "value"
); } while (0); } } while (0);
1921
1922 ret = fstat (iter->fd, &st);
1923 if (ret < 0) {
1924 gf_log ("glusterd", GF_LOG_WARNING,do { do { if (0) printf ("stat on file failed"); } while (0);
_gf_log ("glusterd", "glusterd-store.c", __FUNCTION__, 1925,
GF_LOG_WARNING, "stat on file failed"); } while (0)
1925 "stat on file failed")do { do { if (0) printf ("stat on file failed"); } while (0);
_gf_log ("glusterd", "glusterd-store.c", __FUNCTION__, 1925,
GF_LOG_WARNING, "stat on file failed"); } while (0);
1926 ret = -1;
1927 store_errno = GD_STORE_STAT_FAILED;
1928 goto out;
1929 }
1930
1931 scan_str = GF_CALLOC (1, st.st_size,__gf_calloc (1, st.st_size, gf_gld_mt_char)
1932 gf_gld_mt_char)__gf_calloc (1, st.st_size, gf_gld_mt_char);
1933 if (scan_str == NULL((void*)0)) {
1934 ret = -1;
1935 store_errno = GD_STORE_ENOMEM;
1936 goto out;
1937 }
1938
1939 *key = NULL((void*)0);
1940 *value = NULL((void*)0);
1941
1942 free_str = scan_str;
1943
1944 ret = glusterd_store_read_and_tokenize (iter->file, scan_str,
1945 &iter_key, &iter_val,
1946 &store_errno);
1947 if (ret < 0) {
1948 goto out;
1949 }
1950
1951
1952 ret = glusterd_store_validate_key_value (iter->filepath, iter_key,
1953 iter_val, &store_errno);
1954 if (ret)
1955 goto out;
1956
1957 *value = gf_strdup (iter_val);
1958
1959 *key = gf_strdup (iter_key);
1960 if (!iter_key || !iter_val) {
1961 ret = -1;
1962 store_errno = GD_STORE_ENOMEM;
1963 goto out;
1964 }
1965
1966 ret = 0;
1967
1968out:
1969 if (ret) {
1970 if (*key) {
1971 GF_FREE (*key)__gf_free (*key);
1972 *key = NULL((void*)0);
1973 }
1974 if (*value) {
1975 GF_FREE (*value)__gf_free (*value);
1976 *value = NULL((void*)0);
1977 }
1978 }
1979 GF_FREE (free_str)__gf_free (free_str);
1980 if (op_errno)
1981 *op_errno = store_errno;
1982
1983 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 1983, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
1984 return ret;
1985}
1986
1987int32_t
1988glusterd_store_iter_get_matching (glusterd_store_iter_t *iter,
1989 char *key, char **value)
1990{
1991 int32_t ret = -1;
1992 char *tmp_key = NULL((void*)0);
1993 char *tmp_value = NULL((void*)0);
1994
1995 ret = glusterd_store_iter_get_next (iter, &tmp_key, &tmp_value,
1996 NULL((void*)0));
1997 while (!ret) {
1998 if (!strncmp (key, tmp_key, strlen (key))){
1999 *value = tmp_value;
2000 GF_FREE (tmp_key)__gf_free (tmp_key);
2001 goto out;
2002 }
2003 GF_FREE (tmp_key)__gf_free (tmp_key);
2004 GF_FREE (tmp_value)__gf_free (tmp_value);
2005 ret = glusterd_store_iter_get_next (iter, &tmp_key,
2006 &tmp_value, NULL((void*)0));
2007 }
2008out:
2009 return ret;
2010}
2011
2012int32_t
2013glusterd_store_iter_destroy (glusterd_store_iter_t *iter)
2014{
2015 int32_t ret = -1;
2016
2017 if (!iter)
2018 return 0;
2019
2020 if (iter->file)
2021 ret = fclose (iter->file);
2022 else
2023 ret = 0;
2024
2025 if (ret) {
2026 gf_log ("", GF_LOG_ERROR, "Unable to close fd: %d, ret: %d, "do { do { if (0) printf ("Unable to close fd: %d, ret: %d, " "errno: %d"
,iter->fd, ret, (*__errno_location ())); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 2027, GF_LOG_ERROR, "Unable to close fd: %d, ret: %d, "
"errno: %d" ,iter->fd, ret, (*__errno_location ())); } while
(0)
2027 "errno: %d" ,iter->fd, ret, errno)do { do { if (0) printf ("Unable to close fd: %d, ret: %d, " "errno: %d"
,iter->fd, ret, (*__errno_location ())); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 2027, GF_LOG_ERROR, "Unable to close fd: %d, ret: %d, "
"errno: %d" ,iter->fd, ret, (*__errno_location ())); } while
(0);
2028 }
2029
2030 GF_FREE (iter)__gf_free (iter);
2031
2032 return ret;
2033}
2034
2035char*
2036glusterd_store_strerror (glusterd_store_op_errno_t op_errno)
2037{
2038 switch (op_errno) {
2039 case GD_STORE_SUCCESS:
2040 return "Success";
2041 case GD_STORE_KEY_NULL:
2042 return "Invalid Key";
2043 case GD_STORE_VALUE_NULL:
2044 return "Invalid Value";
2045 case GD_STORE_KEY_VALUE_NULL:
2046 return "Invalid Key and Value";
2047 case GD_STORE_EOF:
2048 return "No data";
2049 case GD_STORE_ENOMEM:
2050 return "No memory";
2051 default:
2052 return "Invalid errno";
2053 }
2054 return "Invalid errno";
2055}
2056
2057int32_t
2058glusterd_store_retrieve_bricks (glusterd_volinfo_t *volinfo)
2059{
2060
2061 int32_t ret = 0;
2062 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
2063 glusterd_store_iter_t *iter = NULL((void*)0);
2064 char *key = NULL((void*)0);
2065 char *value = NULL((void*)0);
2066 char brickdir[PATH_MAX4096] = {0,};
2067 char path[PATH_MAX4096] = {0,};
2068 glusterd_conf_t *priv = NULL((void*)0);
2069 int32_t brick_count = 0;
2070 char tmpkey[4096] = {0,};
2071 glusterd_store_iter_t *tmpiter = NULL((void*)0);
2072 char *tmpvalue = NULL((void*)0);
2073 struct pmap_registry *pmap = NULL((void*)0);
2074 glusterd_store_op_errno_t op_errno = GD_STORE_SUCCESS;
2075
2076 GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: "
"volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2076, GF_LOG_ERROR, "Assertion failed: " "volinfo"
); } while (0); } } while (0);
2077 GF_ASSERT (volinfo->volname)do { if (!(volinfo->volname)) { do { do { if (0) printf ("Assertion failed: "
"volinfo->volname"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2077, GF_LOG_ERROR, "Assertion failed: " "volinfo->volname"
); } while (0); } } while (0);
2078
2079 priv = THIS(*__glusterfs_this_location())->private;
2080
2081 GLUSTERD_GET_BRICK_DIR (brickdir, volinfo, priv)snprintf (brickdir, 4096, "%s/%s/%s/%s", priv->workdir, "vols"
, volinfo->volname, "bricks");
2082
2083 ret = glusterd_store_iter_new (volinfo->shandle, &tmpiter);
2084
2085 if (ret)
2086 goto out;
2087
2088 while (brick_count < volinfo->brick_count) {
2089 ret = glusterd_brickinfo_new (&brickinfo);
2090
2091 if (ret)
2092 goto out;
2093 snprintf (tmpkey, sizeof (tmpkey), "%s-%d",
2094 GLUSTERD_STORE_KEY_VOL_BRICK"brick",brick_count);
2095 ret = glusterd_store_iter_get_matching (tmpiter, tmpkey,
2096 &tmpvalue);
2097 snprintf (path, sizeof (path), "%s/%s", brickdir, tmpvalue);
2098
2099 GF_FREE (tmpvalue)__gf_free (tmpvalue);
2100
2101 tmpvalue = NULL((void*)0);
2102
2103 ret = glusterd_store_handle_retrieve (path, &brickinfo->shandle);
2104
2105 if (ret)
2106 goto out;
2107
2108 ret = glusterd_store_iter_new (brickinfo->shandle, &iter);
2109
2110 if (ret)
2111 goto out;
2112
2113 ret = glusterd_store_iter_get_next (iter, &key, &value,
2114 &op_errno);
2115 if (ret) {
2116 gf_log ("glusterd", GF_LOG_ERROR, "Unable to iterate "do { do { if (0) printf ("Unable to iterate " "the store for brick: %s, reason: %s"
, path, glusterd_store_strerror (op_errno)); } while (0); _gf_log
("glusterd", "glusterd-store.c", __FUNCTION__, 2118, GF_LOG_ERROR
, "Unable to iterate " "the store for brick: %s, reason: %s",
path, glusterd_store_strerror (op_errno)); } while (0)
2117 "the store for brick: %s, reason: %s", path,do { do { if (0) printf ("Unable to iterate " "the store for brick: %s, reason: %s"
, path, glusterd_store_strerror (op_errno)); } while (0); _gf_log
("glusterd", "glusterd-store.c", __FUNCTION__, 2118, GF_LOG_ERROR
, "Unable to iterate " "the store for brick: %s, reason: %s",
path, glusterd_store_strerror (op_errno)); } while (0)
2118 glusterd_store_strerror (op_errno))do { do { if (0) printf ("Unable to iterate " "the store for brick: %s, reason: %s"
, path, glusterd_store_strerror (op_errno)); } while (0); _gf_log
("glusterd", "glusterd-store.c", __FUNCTION__, 2118, GF_LOG_ERROR
, "Unable to iterate " "the store for brick: %s, reason: %s",
path, glusterd_store_strerror (op_errno)); } while (0);
2119 goto out;
2120 }
2121 while (!ret) {
2122 if (!strncmp (key, GLUSTERD_STORE_KEY_BRICK_HOSTNAME"hostname",
2123 strlen (GLUSTERD_STORE_KEY_BRICK_HOSTNAME"hostname"))) {
2124 strncpy (brickinfo->hostname, value, 1024);
2125 } else if (!strncmp (key, GLUSTERD_STORE_KEY_BRICK_PATH"path",
2126 strlen (GLUSTERD_STORE_KEY_BRICK_PATH"path"))) {
2127 strncpy (brickinfo->path, value,
2128 sizeof (brickinfo->path));
2129 } else if (!strncmp (key, GLUSTERD_STORE_KEY_BRICK_PORT"listen-port",
2130 strlen (GLUSTERD_STORE_KEY_BRICK_PORT"listen-port"))) {
2131 gf_string2int (value, &brickinfo->port);
2132
2133 if (brickinfo->port < GF_IANA_PRIV_PORTS_START49152){
2134 /* This is required to adhere to the
2135 IANA standards */
2136 brickinfo->port = 0;
2137 } else {
2138 /* This is required to have proper ports
2139 assigned to bricks after restart */
2140 pmap = pmap_registry_get (THIS(*__glusterfs_this_location()));
2141 if (pmap->last_alloc <= brickinfo->port)
2142 pmap->last_alloc =
2143 brickinfo->port + 1;
2144 }
2145 } else if (!strncmp (key, GLUSTERD_STORE_KEY_BRICK_RDMA_PORT"rdma.listen-port",
2146 strlen (GLUSTERD_STORE_KEY_BRICK_RDMA_PORT"rdma.listen-port"))) {
2147 gf_string2int (value, &brickinfo->rdma_port);
2148
2149 if (brickinfo->rdma_port <
2150 GF_IANA_PRIV_PORTS_START49152){
2151 /* This is required to adhere to the
2152 IANA standards */
2153 brickinfo->rdma_port = 0;
2154 } else {
2155 /* This is required to have proper ports
2156 assigned to bricks after restart */
2157 pmap = pmap_registry_get (THIS(*__glusterfs_this_location()));
2158 if (pmap->last_alloc <=
2159 brickinfo->rdma_port)
2160 pmap->last_alloc =
2161 brickinfo->rdma_port +1;
2162 }
2163
2164 } else if (!strncmp (key, GLUSTERD_STORE_KEY_BRICK_DECOMMISSIONED"decommissioned",
2165 strlen (GLUSTERD_STORE_KEY_BRICK_DECOMMISSIONED"decommissioned"))) {
2166 gf_string2int (value, &brickinfo->decommissioned);
2167 } else {
2168 gf_log ("", GF_LOG_ERROR, "Unknown key: %s",do { do { if (0) printf ("Unknown key: %s", key); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 2169, GF_LOG_ERROR
, "Unknown key: %s", key); } while (0)
2169 key)do { do { if (0) printf ("Unknown key: %s", key); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 2169, GF_LOG_ERROR
, "Unknown key: %s", key); } while (0);
2170 }
2171
2172 GF_FREE (key)__gf_free (key);
2173 GF_FREE (value)__gf_free (value);
2174 key = NULL((void*)0);
2175 value = NULL((void*)0);
2176
2177 ret = glusterd_store_iter_get_next (iter, &key, &value,
2178 &op_errno);
2179 }
2180
2181 if (op_errno != GD_STORE_EOF)
2182 goto out;
2183 ret = glusterd_store_iter_destroy (iter);
2184
2185 if (ret)
2186 goto out;
2187
2188 list_add_tail (&brickinfo->brick_list, &volinfo->bricks);
2189 brick_count++;
2190 }
2191
2192 ret = glusterd_store_iter_destroy (tmpiter);
2193 if (ret)
2194 goto out;
2195out:
2196 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2196, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2197
2198 return ret;
2199}
2200
2201
2202int32_t
2203glusterd_store_retrieve_rbstate (char *volname)
2204{
2205 int32_t ret = -1;
2206 glusterd_volinfo_t *volinfo = NULL((void*)0);
2207 glusterd_store_iter_t *iter = NULL((void*)0);
2208 char *key = NULL((void*)0);
2209 char *value = NULL((void*)0);
2210 char volpath[PATH_MAX4096] = {0,};
2211 glusterd_conf_t *priv = NULL((void*)0);
2212 char path[PATH_MAX4096] = {0,};
2213 glusterd_store_op_errno_t op_errno = GD_STORE_SUCCESS;
2214
2215 priv = THIS(*__glusterfs_this_location())->private;
2216
2217 ret = glusterd_volinfo_find (volname, &volinfo);
2218 if (ret) {
2219 gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get"do { do { if (0) printf ("Couldn't get" "volinfo for %s.", volname
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-store.c", __FUNCTION__, 2220, GF_LOG_ERROR, "Couldn't get"
"volinfo for %s.", volname); } while (0)
2220 "volinfo for %s.", volname)do { do { if (0) printf ("Couldn't get" "volinfo for %s.", volname
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-store.c", __FUNCTION__, 2220, GF_LOG_ERROR, "Couldn't get"
"volinfo for %s.", volname); } while (0);
2221 goto out;
2222 }
2223
2224 GLUSTERD_GET_VOLUME_DIR(volpath, volinfo, priv)snprintf (volpath, 4096, "%s/vols/%s", priv->workdir, volinfo
->volname);;
2225 snprintf (path, sizeof (path), "%s/%s", volpath,
2226 GLUSTERD_VOLUME_RBSTATE_FILE"rbstate");
2227
2228 ret = glusterd_store_handle_retrieve (path, &volinfo->rb_shandle);
2229
2230 if (ret)
2231 goto out;
2232
2233 ret = glusterd_store_iter_new (volinfo->rb_shandle, &iter);
2234
2235 if (ret)
2236 goto out;
2237
2238 ret = glusterd_store_iter_get_next (iter, &key, &value, &op_errno);
2239 if (ret)
2240 goto out;
2241
2242 while (!ret) {
2243 if (!strncmp (key, GLUSTERD_STORE_KEY_RB_STATUS"rb_status",
2244 strlen (GLUSTERD_STORE_KEY_RB_STATUS"rb_status"))) {
2245 volinfo->rep_brick.rb_status = atoi (value);
2246 }
2247
2248 if (volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) {
2249 if (!strncmp (key, GLUSTERD_STORE_KEY_RB_SRC_BRICK"rb_src",
2250 strlen (GLUSTERD_STORE_KEY_RB_SRC_BRICK"rb_src"))) {
2251 ret = glusterd_brickinfo_new_from_brick (value,
2252 &volinfo->rep_brick.src_brick);
2253 if (ret)
2254 goto out;
2255 } else if (!strncmp (key, GLUSTERD_STORE_KEY_RB_DST_BRICK"rb_dst",
2256 strlen (GLUSTERD_STORE_KEY_RB_DST_BRICK"rb_dst"))) {
2257 ret = glusterd_brickinfo_new_from_brick (value,
2258 &volinfo->rep_brick.dst_brick);
2259 if (ret)
2260 goto out;
2261 } else if (!strncmp (key, GLUSTERD_STORE_KEY_RB_DST_PORT"rb_port",
2262 strlen (GLUSTERD_STORE_KEY_RB_DST_PORT"rb_port"))) {
2263 switch (volinfo->transport_type) {
2264 case GF_TRANSPORT_RDMA:
2265 volinfo->rep_brick.dst_brick->rdma_port =
2266 atoi (value);
2267 break;
2268
2269 case GF_TRANSPORT_TCP:
2270 case GF_TRANSPORT_BOTH_TCP_RDMA:
2271 volinfo->rep_brick.dst_brick->port =
2272 atoi (value);
2273 break;
2274 }
2275 } else if (!strncmp (key, GF_REPLACE_BRICK_TID_KEY"replace-brick-id",
2276 strlen (GF_REPLACE_BRICK_TID_KEY"replace-brick-id"))) {
2277 uuid_parse (value,
2278 volinfo->rep_brick.rb_id);
2279 }
2280 }
2281
2282 GF_FREE (key)__gf_free (key);
2283 GF_FREE (value)__gf_free (value);
2284 key = NULL((void*)0);
2285 value = NULL((void*)0);
2286
2287 ret = glusterd_store_iter_get_next (iter, &key, &value,
2288 &op_errno);
2289 }
2290
2291 if (op_errno != GD_STORE_EOF)
2292 goto out;
2293
2294 ret = glusterd_store_iter_destroy (iter);
2295
2296 if (ret)
2297 goto out;
2298
2299out:
2300 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2300, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2301
2302 return ret;
2303}
2304
2305int32_t
2306glusterd_store_retrieve_node_state (char *volname)
2307{
2308 int32_t ret = -1;
2309 glusterd_volinfo_t *volinfo = NULL((void*)0);
2310 glusterd_store_iter_t *iter = NULL((void*)0);
2311 char *key = NULL((void*)0);
2312 char *value = NULL((void*)0);
2313 char volpath[PATH_MAX4096] = {0,};
2314 glusterd_conf_t *priv = NULL((void*)0);
2315 char path[PATH_MAX4096] = {0,};
2316 glusterd_store_op_errno_t op_errno = GD_STORE_SUCCESS;
2317
2318 priv = THIS(*__glusterfs_this_location())->private;
2319
2320 ret = glusterd_volinfo_find (volname, &volinfo);
2321 if (ret) {
2322 gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get"do { do { if (0) printf ("Couldn't get" "volinfo for %s.", volname
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-store.c", __FUNCTION__, 2323, GF_LOG_ERROR, "Couldn't get"
"volinfo for %s.", volname); } while (0)
2323 "volinfo for %s.", volname)do { do { if (0) printf ("Couldn't get" "volinfo for %s.", volname
); } while (0); _gf_log ((*__glusterfs_this_location())->name
, "glusterd-store.c", __FUNCTION__, 2323, GF_LOG_ERROR, "Couldn't get"
"volinfo for %s.", volname); } while (0);
2324 goto out;
2325 }
2326
2327 GLUSTERD_GET_VOLUME_DIR(volpath, volinfo, priv)snprintf (volpath, 4096, "%s/vols/%s", priv->workdir, volinfo
->volname);;
2328 snprintf (path, sizeof (path), "%s/%s", volpath,
2329 GLUSTERD_NODE_STATE_FILE"node_state.info");
2330
2331 ret = glusterd_store_handle_retrieve (path,
2332 &volinfo->node_state_shandle);
2333 if (ret)
2334 goto out;
2335
2336 ret = glusterd_store_iter_new (volinfo->node_state_shandle, &iter);
2337
2338 if (ret)
2339 goto out;
2340
2341 ret = glusterd_store_iter_get_next (iter, &key, &value, &op_errno);
2342 if (ret)
2343 goto out;
2344
2345 while (ret == 0) {
2346 if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_DEFRAG"rebalance_status",
2347 strlen (GLUSTERD_STORE_KEY_VOL_DEFRAG"rebalance_status"))) {
2348 volinfo->rebal.defrag_cmd = atoi (value);
2349 }
2350
2351 if (volinfo->rebal.defrag_cmd) {
2352 if (!strncmp (key, GF_REBALANCE_TID_KEY"rebalance-id",
2353 strlen (GF_REBALANCE_TID_KEY"rebalance-id")))
2354 uuid_parse (value, volinfo->rebal.rebalance_id);
2355
2356 if (!strncmp (key, GLUSTERD_STORE_KEY_DEFRAG_OP"rebalance_op",
2357 strlen (GLUSTERD_STORE_KEY_DEFRAG_OP"rebalance_op")))
2358 volinfo->rebal.op = atoi (value);
2359 }
2360
2361 GF_FREE (key)__gf_free (key);
2362 GF_FREE (value)__gf_free (value);
2363 key = NULL((void*)0);
2364 value = NULL((void*)0);
2365
2366 ret = glusterd_store_iter_get_next (iter, &key, &value,
2367 &op_errno);
2368 }
2369
2370 if (op_errno != GD_STORE_EOF)
2371 goto out;
2372
2373 ret = glusterd_store_iter_destroy (iter);
2374
2375 if (ret)
2376 goto out;
2377
2378out:
2379 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2379, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2380
2381 return ret;
2382}
2383
2384int32_t
2385glusterd_store_retrieve_volume (char *volname)
2386{
2387 int32_t ret = -1;
2388 glusterd_volinfo_t *volinfo = NULL((void*)0);
2389 glusterd_store_iter_t *iter = NULL((void*)0);
2390 char *key = NULL((void*)0);
2391 char *value = NULL((void*)0);
2392 char volpath[PATH_MAX4096] = {0,};
2393 glusterd_conf_t *priv = NULL((void*)0);
2394 char path[PATH_MAX4096] = {0,};
2395 int exists = 0;
2396 glusterd_store_op_errno_t op_errno = GD_STORE_SUCCESS;
2397
2398 ret = glusterd_volinfo_new (&volinfo);
2399
2400 if (ret)
2401 goto out;
2402
2403 strncpy (volinfo->volname, volname, GLUSTERD_MAX_VOLUME_NAME1000);
2404
2405 priv = THIS(*__glusterfs_this_location())->private;
2406
2407 GLUSTERD_GET_VOLUME_DIR(volpath, volinfo, priv)snprintf (volpath, 4096, "%s/vols/%s", priv->workdir, volinfo
->volname);;
2408 snprintf (path, sizeof (path), "%s/%s", volpath,
2409 GLUSTERD_VOLUME_INFO_FILE"info");
2410
2411 ret = glusterd_store_handle_retrieve (path, &volinfo->shandle);
2412
2413 if (ret)
2414 goto out;
2415
2416 ret = glusterd_store_iter_new (volinfo->shandle, &iter);
2417
2418 if (ret)
2419 goto out;
2420
2421 ret = glusterd_store_iter_get_next (iter, &key, &value, &op_errno);
2422 if (ret)
2423 goto out;
2424
2425 while (!ret) {
2426 if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_TYPE"type",
2427 strlen (GLUSTERD_STORE_KEY_VOL_TYPE"type"))) {
2428 volinfo->type = atoi (value);
2429 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_COUNT"count",
2430 strlen (GLUSTERD_STORE_KEY_VOL_COUNT"count"))) {
2431 volinfo->brick_count = atoi (value);
2432 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_STATUS"status",
2433 strlen (GLUSTERD_STORE_KEY_VOL_STATUS"status"))) {
2434 volinfo->status = atoi (value);
2435 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_VERSION"version",
2436 strlen (GLUSTERD_STORE_KEY_VOL_VERSION"version"))) {
2437 volinfo->version = atoi (value);
2438 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_PORT"port",
2439 strlen (GLUSTERD_STORE_KEY_VOL_PORT"port"))) {
2440 volinfo->port = atoi (value);
2441 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_SUB_COUNT"sub_count",
2442 strlen (GLUSTERD_STORE_KEY_VOL_SUB_COUNT"sub_count"))) {
2443 volinfo->sub_count = atoi (value);
2444 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_STRIPE_CNT"stripe_count",
2445 strlen (GLUSTERD_STORE_KEY_VOL_STRIPE_CNT"stripe_count"))) {
2446 volinfo->stripe_count = atoi (value);
2447 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_REPLICA_CNT"replica_count",
2448 strlen (GLUSTERD_STORE_KEY_VOL_REPLICA_CNT"replica_count"))) {
2449 volinfo->replica_count = atoi (value);
2450 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_TRANSPORT"transport-type",
2451 strlen (GLUSTERD_STORE_KEY_VOL_TRANSPORT"transport-type"))) {
2452 volinfo->transport_type = atoi (value);
2453 volinfo->nfs_transport_type = volinfo->transport_type;
2454 if (volinfo->transport_type == GF_TRANSPORT_BOTH_TCP_RDMA) {
2455 volinfo->nfs_transport_type = GF_DEFAULT_NFS_TRANSPORTGF_TRANSPORT_RDMA;
2456 }
2457 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_ID"volume-id",
2458 strlen (GLUSTERD_STORE_KEY_VOL_ID"volume-id"))) {
2459 ret = uuid_parse (value, volinfo->volume_id);
2460 if (ret)
2461 gf_log ("", GF_LOG_WARNING,do { do { if (0) printf ("failed to parse uuid"); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 2462, GF_LOG_WARNING
, "failed to parse uuid"); } while (0)
2462 "failed to parse uuid")do { do { if (0) printf ("failed to parse uuid"); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 2462, GF_LOG_WARNING
, "failed to parse uuid"); } while (0);
2463
2464 } else if (!strncmp (key, GLUSTERD_STORE_KEY_USERNAME"username",
2465 strlen (GLUSTERD_STORE_KEY_USERNAME"username"))) {
2466
2467 glusterd_auth_set_username (volinfo, value);
2468
2469 } else if (!strncmp (key, GLUSTERD_STORE_KEY_PASSWORD"password",
2470 strlen (GLUSTERD_STORE_KEY_PASSWORD"password"))) {
2471
2472 glusterd_auth_set_password (volinfo, value);
2473
2474 } else if (strstr (key, "slave")) {
2475 ret = dict_set_dynstr (volinfo->gsync_slaves, key,
2476 gf_strdup (value));
2477 if (ret) {
2478 gf_log ("",GF_LOG_ERROR, "Error in "do { do { if (0) printf ("Error in " "dict_set_str"); } while
(0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2479, GF_LOG_ERROR
, "Error in " "dict_set_str"); } while (0)
2479 "dict_set_str")do { do { if (0) printf ("Error in " "dict_set_str"); } while
(0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2479, GF_LOG_ERROR
, "Error in " "dict_set_str"); } while (0);
2480 goto out;
2481 }
2482 gf_log ("", GF_LOG_DEBUG, "Parsed as "GEOREP" "do { do { if (0) printf ("Parsed as ""geo-replication"" " " slave:key=%s,value:%s"
, key, value); } while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__
, 2483, GF_LOG_DEBUG, "Parsed as ""geo-replication"" " " slave:key=%s,value:%s"
, key, value); } while (0)
2483 " slave:key=%s,value:%s", key, value)do { do { if (0) printf ("Parsed as ""geo-replication"" " " slave:key=%s,value:%s"
, key, value); } while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__
, 2483, GF_LOG_DEBUG, "Parsed as ""geo-replication"" " " slave:key=%s,value:%s"
, key, value); } while (0);
2484
2485 } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_BACKEND"backend",
2486 strlen (GLUSTERD_STORE_KEY_VOL_BACKEND"backend"))) {
2487 volinfo->backend = atoi (value);
2488 } else {
2489
2490 if (is_key_glusterd_hooks_friendly (key)) {
2491 exists = 1;
2492
2493 } else {
2494 exists = glusterd_check_option_exists (key,
2495 NULL((void*)0));
2496 }
2497
2498 switch (exists) {
2499 case -1:
2500 ret = -1;
2501 goto out;
2502
2503 case 0:
2504 gf_log ("", GF_LOG_ERROR, "Unknown key: %s",do { do { if (0) printf ("Unknown key: %s", key); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 2505, GF_LOG_ERROR
, "Unknown key: %s", key); } while (0)
2505 key)do { do { if (0) printf ("Unknown key: %s", key); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 2505, GF_LOG_ERROR
, "Unknown key: %s", key); } while (0);
2506 break;
2507
2508 case 1:
2509 ret = dict_set_str(volinfo->dict, key,
2510 gf_strdup (value));
2511 if (ret) {
2512 gf_log ("",GF_LOG_ERROR, "Error in "do { do { if (0) printf ("Error in " "dict_set_str"); } while
(0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2513, GF_LOG_ERROR
, "Error in " "dict_set_str"); } while (0)
2513 "dict_set_str")do { do { if (0) printf ("Error in " "dict_set_str"); } while
(0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2513, GF_LOG_ERROR
, "Error in " "dict_set_str"); } while (0);
2514 goto out;
2515 }
2516 gf_log ("", GF_LOG_DEBUG, "Parsed as Volume-"do { do { if (0) printf ("Parsed as Volume-" "set:key=%s,value:%s"
, key, value); } while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__
, 2517, GF_LOG_DEBUG, "Parsed as Volume-" "set:key=%s,value:%s"
, key, value); } while (0)
2517 "set:key=%s,value:%s", key, value)do { do { if (0) printf ("Parsed as Volume-" "set:key=%s,value:%s"
, key, value); } while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__
, 2517, GF_LOG_DEBUG, "Parsed as Volume-" "set:key=%s,value:%s"
, key, value); } while (0);
2518 break;
2519 }
2520 }
2521
2522 GF_FREE (key)__gf_free (key);
2523 GF_FREE (value)__gf_free (value);
2524 key = NULL((void*)0);
2525 value = NULL((void*)0);
2526
2527 ret = glusterd_store_iter_get_next (iter, &key, &value,
2528 &op_errno);
2529 }
2530
2531 /* backward compatibility */
2532 {
2533
2534 switch (volinfo->type) {
2535
2536 case GF_CLUSTER_TYPE_NONE:
2537 volinfo->stripe_count = 1;
2538 volinfo->replica_count = 1;
2539 break;
2540
2541 case GF_CLUSTER_TYPE_STRIPE:
2542 volinfo->stripe_count = volinfo->sub_count;
2543 volinfo->replica_count = 1;
2544 break;
2545
2546 case GF_CLUSTER_TYPE_REPLICATE:
2547 volinfo->stripe_count = 1;
2548 volinfo->replica_count = volinfo->sub_count;
2549 break;
2550
2551 case GF_CLUSTER_TYPE_STRIPE_REPLICATE:
2552 /* Introduced in 3.3 */
2553 GF_ASSERT (volinfo->stripe_count > 0)do { if (!(volinfo->stripe_count > 0)) { do { do { if (
0) printf ("Assertion failed: " "volinfo->stripe_count > 0"
); } while (0); _gf_log_callingfn ("", "glusterd-store.c", __FUNCTION__
, 2553, GF_LOG_ERROR, "Assertion failed: " "volinfo->stripe_count > 0"
); } while (0); } } while (0);
2554 GF_ASSERT (volinfo->replica_count > 0)do { if (!(volinfo->replica_count > 0)) { do { do { if (
0) printf ("Assertion failed: " "volinfo->replica_count > 0"
); } while (0); _gf_log_callingfn ("", "glusterd-store.c", __FUNCTION__
, 2554, GF_LOG_ERROR, "Assertion failed: " "volinfo->replica_count > 0"
); } while (0); } } while (0);
2555 break;
2556
2557 default:
2558 GF_ASSERT (0)do { if (!(0)) { do { do { if (0) printf ("Assertion failed: "
"0"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2558, GF_LOG_ERROR, "Assertion failed: " "0")
; } while (0); } } while (0);
2559 break;
2560 }
2561
2562 volinfo->dist_leaf_count = glusterd_get_dist_leaf_count (volinfo);
2563
2564 volinfo->subvol_count = (volinfo->brick_count /
2565 volinfo->dist_leaf_count);
2566
2567 }
2568
2569 if (op_errno != GD_STORE_EOF)
2570 goto out;
2571
2572 ret = glusterd_store_iter_destroy (iter);
2573
2574 if (ret)
2575 goto out;
2576
2577 ret = glusterd_store_retrieve_bricks (volinfo);
2578 if (ret)
2579 goto out;
2580
2581 ret = glusterd_volume_compute_cksum (volinfo);
2582 if (ret)
2583 goto out;
2584
2585 gd_update_volume_op_versions (volinfo);
2586
2587 list_add_tail (&volinfo->vol_list, &priv->volumes);
2588
2589out:
2590 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2590, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2591
2592 return ret;
2593}
2594
2595inline void
2596glusterd_store_set_options_path (glusterd_conf_t *conf, char *path, size_t len)
2597{
2598 snprintf (path, len, "%s/options", conf->workdir);
2599}
2600
2601int
2602_store_global_opts (dict_t *this, char *key, data_t *value, void *data)
2603{
2604 glusterd_store_handle_t *shandle = data;
2605
2606 glusterd_store_save_value (shandle->fd, key, (char*)value->data);
2607 return 0;
2608}
2609
2610int32_t
2611glusterd_store_options (xlator_t *this, dict_t *opts)
2612{
2613 glusterd_store_handle_t *shandle = NULL((void*)0);
2614 glusterd_conf_t *conf = NULL((void*)0);
2615 char path[PATH_MAX4096] = {0};
2616 int fd = -1;
2617 int32_t ret = -1;
2618
2619 conf = this->private;
2620 glusterd_store_set_options_path (conf, path, sizeof (path));
2621
2622 ret = glusterd_store_handle_new (path, &shandle);
2623 if (ret)
2624 goto out;
2625
2626 fd = glusterd_store_mkstemp (shandle);
2627 if (fd <= 0) {
2628 ret = -1;
2629 goto out;
2630 }
2631
2632 shandle->fd = fd;
2633 dict_foreach (opts, _store_global_opts, shandle);
2634 shandle->fd = 0;
2635 ret = glusterd_store_rename_tmppath (shandle);
2636 if (ret)
2637 goto out;
2638out:
2639 glusterd_store_handle_destroy (shandle);
2640 if (fd >=0 )
2641 close (fd);
2642 return ret;
2643}
2644
2645int32_t
2646glusterd_store_retrieve_options (xlator_t *this)
2647{
2648 char path[PATH_MAX4096] = {0};
2649 glusterd_conf_t *conf = NULL((void*)0);
2650 glusterd_store_handle_t *shandle = NULL((void*)0);
2651 glusterd_store_iter_t *iter = NULL((void*)0);
2652 char *key = NULL((void*)0);
2653 char *value = NULL((void*)0);
2654 glusterd_store_op_errno_t op_errno = 0;
2655 int ret = -1;
2656
2657 conf = this->private;
2658 glusterd_store_set_options_path (conf, path, sizeof (path));
2659
2660 ret = glusterd_store_handle_retrieve (path, &shandle);
2661 if (ret)
2662 goto out;
2663
2664 ret = glusterd_store_iter_new (shandle, &iter);
2665 if (ret)
2666 goto out;
2667
2668 ret = glusterd_store_iter_get_next (iter, &key, &value, &op_errno);
2669 while (!ret) {
2670 ret = dict_set_dynstr (conf->opts, key, value);
2671 if (ret) {
2672 GF_FREE (key)__gf_free (key);
2673 GF_FREE (value)__gf_free (value);
2674 goto out;
2675 }
2676 GF_FREE (key)__gf_free (key);
2677 key = NULL((void*)0);
2678 value = NULL((void*)0);
2679
2680 ret = glusterd_store_iter_get_next (iter, &key, &value,
2681 &op_errno);
2682 }
2683 if (op_errno != GD_STORE_EOF)
2684 goto out;
2685 ret = 0;
2686out:
2687 glusterd_store_iter_destroy (iter);
2688 glusterd_store_handle_destroy (shandle);
2689 return ret;
2690}
2691
2692int32_t
2693glusterd_store_retrieve_volumes (xlator_t *this)
2694{
2695 int32_t ret = 0;
2696 char path[PATH_MAX4096] = {0,};
2697 glusterd_conf_t *priv = NULL((void*)0);
2698 DIR *dir = NULL((void*)0);
2699 struct dirent *entry = NULL((void*)0);
2700 glusterd_volinfo_t *volinfo = NULL((void*)0);
2701
2702 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2702, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
2703 priv = this->private;
2704
2705 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2705, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
2706
2707 snprintf (path, PATH_MAX4096, "%s/%s", priv->workdir,
2708 GLUSTERD_VOLUME_DIR_PREFIX"vols");
2709
2710 dir = opendir (path);
2711
2712 if (!dir) {
2713 gf_log ("", GF_LOG_ERROR, "Unable to open dir %s", path)do { do { if (0) printf ("Unable to open dir %s", path); } while
(0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2713, GF_LOG_ERROR
, "Unable to open dir %s", path); } while (0);
2714 ret = -1;
2715 goto out;
2716 }
2717
2718 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
2719
2720 while (entry) {
2721 ret = glusterd_store_retrieve_volume (entry->d_name);
2722 if (ret) {
2723 gf_log ("", GF_LOG_ERROR, "Unable to restore "do { do { if (0) printf ("Unable to restore " "volume: %s", entry
->d_name); } while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__
, 2724, GF_LOG_ERROR, "Unable to restore " "volume: %s", entry
->d_name); } while (0)
2724 "volume: %s", entry->d_name)do { do { if (0) printf ("Unable to restore " "volume: %s", entry
->d_name); } while (0); _gf_log ("", "glusterd-store.c", __FUNCTION__
, 2724, GF_LOG_ERROR, "Unable to restore " "volume: %s", entry
->d_name); } while (0);
2725 goto out;
2726 }
2727
2728 ret = glusterd_store_retrieve_rbstate (entry->d_name);
2729 if (ret) {
2730 /* Backward compatibility */
2731 gf_log ("", GF_LOG_INFO, "Creating a new rbstate "do { do { if (0) printf ("Creating a new rbstate " "for volume: %s."
, entry->d_name); } while (0); _gf_log ("", "glusterd-store.c"
, __FUNCTION__, 2732, GF_LOG_INFO, "Creating a new rbstate " "for volume: %s."
, entry->d_name); } while (0)
2732 "for volume: %s.", entry->d_name)do { do { if (0) printf ("Creating a new rbstate " "for volume: %s."
, entry->d_name); } while (0); _gf_log ("", "glusterd-store.c"
, __FUNCTION__, 2732, GF_LOG_INFO, "Creating a new rbstate " "for volume: %s."
, entry->d_name); } while (0);
2733 ret = glusterd_volinfo_find (entry->d_name, &volinfo);
2734 ret = glusterd_store_create_rbstate_shandle_on_absence (volinfo);
2735 ret = glusterd_store_perform_rbstate_store (volinfo);
2736 }
2737
2738 ret = glusterd_store_retrieve_node_state (entry->d_name);
2739 if (ret) {
2740 /* Backward compatibility */
2741 gf_log ("", GF_LOG_INFO, "Creating a new node_state "do { do { if (0) printf ("Creating a new node_state " "for volume: %s."
, entry->d_name); } while (0); _gf_log ("", "glusterd-store.c"
, __FUNCTION__, 2742, GF_LOG_INFO, "Creating a new node_state "
"for volume: %s.", entry->d_name); } while (0)
2742 "for volume: %s.", entry->d_name)do { do { if (0) printf ("Creating a new node_state " "for volume: %s."
, entry->d_name); } while (0); _gf_log ("", "glusterd-store.c"
, __FUNCTION__, 2742, GF_LOG_INFO, "Creating a new node_state "
"for volume: %s.", entry->d_name); } while (0);
2743 ret = glusterd_volinfo_find (entry->d_name, &volinfo);
2744 ret =
2745 glusterd_store_create_nodestate_sh_on_absence (volinfo);
2746 ret = glusterd_store_perform_node_state_store (volinfo);
2747
2748 }
2749 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
2750 }
2751
2752out:
2753 if (dir)
2754 closedir (dir);
2755 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2755, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2756
2757 return ret;
2758}
2759
2760int32_t
2761glusterd_store_delete_peerinfo (glusterd_peerinfo_t *peerinfo)
2762{
2763 int32_t ret = -1;
2764 glusterd_conf_t *priv = NULL((void*)0);
2765 char peerdir[PATH_MAX4096] = {0,};
2766 char filepath[PATH_MAX4096] = {0,};
2767 char hostname_path[PATH_MAX4096] = {0,};
2768
2769
2770 if (!peerinfo) {
2771 ret = 0;
2772 goto out;
2773 }
2774
2775 priv = THIS(*__glusterfs_this_location())->private;
2776
2777 snprintf (peerdir, PATH_MAX4096, "%s/peers", priv->workdir);
2778
2779
2780 if (uuid_is_null (peerinfo->uuid)) {
2781
2782 if (peerinfo->hostname) {
2783 snprintf (filepath, PATH_MAX4096, "%s/%s", peerdir,
2784 peerinfo->hostname);
2785 } else {
2786 ret = 0;
2787 goto out;
2788 }
2789 } else {
2790
2791 snprintf (filepath, PATH_MAX4096, "%s/%s", peerdir,
2792 uuid_utoa (peerinfo->uuid));
2793 snprintf (hostname_path, PATH_MAX4096, "%s/%s",
2794 peerdir, peerinfo->hostname);
2795
2796 ret = unlink (hostname_path);
2797
2798 if (!ret)
2799 goto out;
2800 }
2801
2802 ret = unlink (filepath);
2803 if (ret && (errno(*__errno_location ()) == ENOENT2))
2804 ret = 0;
2805
2806out:
2807 if (peerinfo->shandle) {
2808 glusterd_store_handle_destroy (peerinfo->shandle);
2809 peerinfo->shandle = NULL((void*)0);
2810 }
2811 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2811, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2812
2813 return ret;
2814}
2815
2816void
2817glusterd_store_peerinfo_dirpath_set (char *path, size_t len)
2818{
2819 glusterd_conf_t *priv = NULL((void*)0);
2820 GF_ASSERT (path)do { if (!(path)) { do { do { if (0) printf ("Assertion failed: "
"path"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2820, GF_LOG_ERROR, "Assertion failed: " "path"
); } while (0); } } while (0);
2821 GF_ASSERT (len >= PATH_MAX)do { if (!(len >= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len >= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2821, GF_LOG_ERROR, "Assertion failed: " "len >= PATH_MAX"
); } while (0); } } while (0);
2822
2823 priv = THIS(*__glusterfs_this_location())->private;
2824 snprintf (path, len, "%s/peers", priv->workdir);
2825}
2826
2827int32_t
2828glusterd_store_create_peer_dir ()
2829{
2830 int32_t ret = 0;
2831 char path[PATH_MAX4096];
2832
2833 glusterd_store_peerinfo_dirpath_set (path, sizeof (path));
2834 ret = glusterd_store_mkdir (path);
2835
2836 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2836, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2837 return ret;
2838}
2839
2840static void
2841glusterd_store_uuid_peerpath_set (glusterd_peerinfo_t *peerinfo, char *peerfpath,
2842 size_t len)
2843{
2844 char peerdir[PATH_MAX4096];
2845 char str[50] = {0};
2846
2847 GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: "
"peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2847, GF_LOG_ERROR, "Assertion failed: " "peerinfo"
); } while (0); } } while (0);
2848 GF_ASSERT (peerfpath)do { if (!(peerfpath)) { do { do { if (0) printf ("Assertion failed: "
"peerfpath"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2848, GF_LOG_ERROR, "Assertion failed: " "peerfpath"
); } while (0); } } while (0);
2849 GF_ASSERT (len >= PATH_MAX)do { if (!(len >= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len >= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2849, GF_LOG_ERROR, "Assertion failed: " "len >= PATH_MAX"
); } while (0); } } while (0);
2850
2851 glusterd_store_peerinfo_dirpath_set (peerdir, sizeof (peerdir));
2852 uuid_unparse (peerinfo->uuid, str);
2853 snprintf (peerfpath, len, "%s/%s", peerdir, str);
2854}
2855
2856static void
2857glusterd_store_hostname_peerpath_set (glusterd_peerinfo_t *peerinfo,
2858 char *peerfpath, size_t len)
2859{
2860 char peerdir[PATH_MAX4096];
2861
2862 GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: "
"peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2862, GF_LOG_ERROR, "Assertion failed: " "peerinfo"
); } while (0); } } while (0);
2863 GF_ASSERT (peerfpath)do { if (!(peerfpath)) { do { do { if (0) printf ("Assertion failed: "
"peerfpath"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2863, GF_LOG_ERROR, "Assertion failed: " "peerfpath"
); } while (0); } } while (0);
2864 GF_ASSERT (len >= PATH_MAX)do { if (!(len >= 4096)) { do { do { if (0) printf ("Assertion failed: "
"len >= PATH_MAX"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2864, GF_LOG_ERROR, "Assertion failed: " "len >= PATH_MAX"
); } while (0); } } while (0);
2865
2866 glusterd_store_peerinfo_dirpath_set (peerdir, sizeof (peerdir));
2867 snprintf (peerfpath, len, "%s/%s", peerdir, peerinfo->hostname);
2868}
2869
2870int32_t
2871glusterd_store_peerinfo_hostname_shandle_create (glusterd_peerinfo_t *peerinfo)
2872{
2873 char peerfpath[PATH_MAX4096];
2874 int32_t ret = -1;
2875
2876 glusterd_store_hostname_peerpath_set (peerinfo, peerfpath,
2877 sizeof (peerfpath));
2878 ret = glusterd_store_handle_create_on_absence (&peerinfo->shandle,
2879 peerfpath);
2880 return ret;
2881}
2882
2883int32_t
2884glusterd_store_peerinfo_uuid_shandle_create (glusterd_peerinfo_t *peerinfo)
2885{
2886 char peerfpath[PATH_MAX4096];
2887 int32_t ret = -1;
2888
2889 glusterd_store_uuid_peerpath_set (peerinfo, peerfpath,
2890 sizeof (peerfpath));
2891 ret = glusterd_store_handle_create_on_absence (&peerinfo->shandle,
2892 peerfpath);
2893 return ret;
2894}
2895
2896int32_t
2897glusterd_peerinfo_hostname_shandle_check_destroy (glusterd_peerinfo_t *peerinfo)
2898{
2899 char peerfpath[PATH_MAX4096];
2900 int32_t ret = -1;
2901 struct stat stbuf = {0,};
2902
2903 glusterd_store_hostname_peerpath_set (peerinfo, peerfpath,
2904 sizeof (peerfpath));
2905 ret = stat (peerfpath, &stbuf);
2906 if (!ret) {
2907 if (peerinfo->shandle)
2908 glusterd_store_handle_destroy (peerinfo->shandle);
2909 peerinfo->shandle = NULL((void*)0);
2910 ret = unlink (peerfpath);
2911 }
2912 return ret;
2913}
2914
2915int32_t
2916glusterd_store_create_peer_shandle (glusterd_peerinfo_t *peerinfo)
2917{
2918 int32_t ret = 0;
2919
2920 GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: "
"peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2920, GF_LOG_ERROR, "Assertion failed: " "peerinfo"
); } while (0); } } while (0);
2921
2922 if (glusterd_peerinfo_is_uuid_unknown (peerinfo)) {
2923 ret = glusterd_store_peerinfo_hostname_shandle_create (peerinfo);
2924 } else {
2925 ret = glusterd_peerinfo_hostname_shandle_check_destroy (peerinfo);
Value stored to 'ret' is never read
2926 ret = glusterd_store_peerinfo_uuid_shandle_create (peerinfo);
2927 }
2928 return ret;
2929}
2930
2931int32_t
2932glusterd_store_peer_write (int fd, glusterd_peerinfo_t *peerinfo)
2933{
2934 char buf[50] = {0};
2935 int32_t ret = 0;
2936
2937 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_PEER_UUID"uuid",
2938 uuid_utoa (peerinfo->uuid));
2939 if (ret)
2940 goto out;
2941
2942 snprintf (buf, sizeof (buf), "%d", peerinfo->state.state);
2943 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_PEER_STATE"state", buf);
2944 if (ret)
2945 goto out;
2946
2947 ret = glusterd_store_save_value (fd, GLUSTERD_STORE_KEY_PEER_HOSTNAME"hostname" "1",
2948 peerinfo->hostname);
2949 if (ret)
2950 goto out;
2951
2952out:
2953 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 2953, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
2954 return ret;
2955}
2956
2957int32_t
2958glusterd_store_perform_peer_store (glusterd_peerinfo_t *peerinfo)
2959{
2960 int fd = -1;
2961 int32_t ret = -1;
2962
2963 GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: "
"peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2963, GF_LOG_ERROR, "Assertion failed: " "peerinfo"
); } while (0); } } while (0);
2964
2965 fd = glusterd_store_mkstemp (peerinfo->shandle);
2966 if (fd <= 0) {
2967 ret = -1;
2968 goto out;
2969 }
2970
2971 ret = glusterd_store_peer_write (fd, peerinfo);
2972 if (ret)
2973 goto out;
2974
2975 ret = glusterd_store_rename_tmppath (peerinfo->shandle);
2976out:
2977 if (ret && (fd > 0))
2978 glusterd_store_unlink_tmppath (peerinfo->shandle);
2979 if (fd > 0)
2980 close (fd);
2981 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 2981, GF_LOG_DEBUG, "Returning %d"
, ret); } while (0);
2982 return ret;
2983}
2984
2985int32_t
2986glusterd_store_peerinfo (glusterd_peerinfo_t *peerinfo)
2987{
2988 int32_t ret = -1;
2989
2990 GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: "
"peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 2990, GF_LOG_ERROR, "Assertion failed: " "peerinfo"
); } while (0); } } while (0);
2991
2992 ret = glusterd_store_create_peer_dir ();
2993 if (ret)
2994 goto out;
2995
2996 ret = glusterd_store_create_peer_shandle (peerinfo);
2997 if (ret)
2998 goto out;
2999
3000 ret = glusterd_store_perform_peer_store (peerinfo);
3001out:
3002 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 3002, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
3003 return ret;
3004}
3005
3006int32_t
3007glusterd_store_retrieve_peers (xlator_t *this)
3008{
3009 int32_t ret = 0;
3010 glusterd_conf_t *priv = NULL((void*)0);
3011 DIR *dir = NULL((void*)0);
3012 struct dirent *entry = NULL((void*)0);
3013 char path[PATH_MAX4096] = {0,};
3014 glusterd_peerinfo_t *peerinfo = NULL((void*)0);
3015 uuid_t uuid = {0,};
3016 char *hostname = NULL((void*)0);
3017 int32_t state = 0;
3018 glusterd_store_handle_t *shandle = NULL((void*)0);
3019 char filepath[PATH_MAX4096] = {0,};
3020 glusterd_store_iter_t *iter = NULL((void*)0);
3021 char *key = NULL((void*)0);
3022 char *value = NULL((void*)0);
3023 glusterd_peerctx_args_t args = {0};
3024 glusterd_store_op_errno_t op_errno = GD_STORE_SUCCESS;
3025
3026 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 3026, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
3027 priv = this->private;
3028
3029 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 3029, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
3030
3031 snprintf (path, PATH_MAX4096, "%s/%s", priv->workdir,
3032 GLUSTERD_PEER_DIR_PREFIX"peers");
3033
3034 dir = opendir (path);
3035
3036 if (!dir) {
3037 gf_log ("", GF_LOG_ERROR, "Unable to open dir %s", path)do { do { if (0) printf ("Unable to open dir %s", path); } while
(0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 3037, GF_LOG_ERROR
, "Unable to open dir %s", path); } while (0);
3038 ret = -1;
3039 goto out;
3040 }
3041
3042 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
3043
3044 while (entry) {
3045 snprintf (filepath, PATH_MAX4096, "%s/%s", path, entry->d_name);
3046 ret = glusterd_store_handle_retrieve (filepath, &shandle);
3047 if (ret)
3048 goto out;
3049
3050 ret = glusterd_store_iter_new (shandle, &iter);
3051 if (ret)
3052 goto out;
3053
3054 ret = glusterd_store_iter_get_next (iter, &key, &value,
3055 &op_errno);
3056 if (ret)
3057 goto out;
3058
3059 while (!ret) {
3060
3061 if (!strncmp (GLUSTERD_STORE_KEY_PEER_UUID"uuid", key,
3062 strlen (GLUSTERD_STORE_KEY_PEER_UUID"uuid"))) {
3063 if (value)
3064 uuid_parse (value, uuid);
3065 } else if (!strncmp (GLUSTERD_STORE_KEY_PEER_STATE"state",
3066 key,
3067 strlen (GLUSTERD_STORE_KEY_PEER_STATE"state"))) {
3068 state = atoi (value);
3069 } else if (!strncmp (GLUSTERD_STORE_KEY_PEER_HOSTNAME"hostname",
3070 key,
3071 strlen (GLUSTERD_STORE_KEY_PEER_HOSTNAME"hostname"))) {
3072 hostname = gf_strdup (value);
3073 } else {
3074 gf_log ("", GF_LOG_ERROR, "Unknown key: %s",do { do { if (0) printf ("Unknown key: %s", key); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 3075, GF_LOG_ERROR
, "Unknown key: %s", key); } while (0)
3075 key)do { do { if (0) printf ("Unknown key: %s", key); } while (0)
; _gf_log ("", "glusterd-store.c", __FUNCTION__, 3075, GF_LOG_ERROR
, "Unknown key: %s", key); } while (0);
3076 }
3077
3078 GF_FREE (key)__gf_free (key);
3079 GF_FREE (value)__gf_free (value);
3080 key = NULL((void*)0);
3081 value = NULL((void*)0);
3082
3083 ret = glusterd_store_iter_get_next (iter, &key, &value,
3084 &op_errno);
3085 }
3086 if (op_errno != GD_STORE_EOF)
3087 goto out;
3088
3089 (void) glusterd_store_iter_destroy (iter);
3090
3091 ret = glusterd_friend_add (hostname, 0, state, &uuid,
3092 &peerinfo, 1, NULL((void*)0));
3093
3094 GF_FREE (hostname)__gf_free (hostname);
3095 if (ret)
3096 goto out;
3097
3098 peerinfo->shandle = shandle;
3099 glusterd_for_each_entry (entry, dir)do { entry = ((void*)0); if (dir) { entry = readdir (dir); while
(entry && (!strcmp (entry->d_name, ".") || !strcmp
(entry->d_name, ".."))) { entry = readdir (dir); } } } while
(0);;
3100 }
3101
3102 args.mode = GD_MODE_ON;
3103 list_for_each_entry (peerinfo, &priv->peers, uuid_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((&priv->
peers)->next)-(unsigned long)(&((typeof(*peerinfo) *)0
)->uuid_list))); &peerinfo->uuid_list != (&priv
->peers); peerinfo = ((typeof(*peerinfo) *)((char *)(peerinfo
->uuid_list.next)-(unsigned long)(&((typeof(*peerinfo)
*)0)->uuid_list)))) {
3104 ret = glusterd_friend_rpc_create (this, peerinfo, &args);
3105 if (ret)
3106 goto out;
3107 }
3108
3109out:
3110 if (dir)
3111 closedir (dir);
3112 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 3112, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
3113
3114 return ret;
3115}
3116
3117int32_t
3118glusterd_resolve_all_bricks (xlator_t *this)
3119{
3120 int32_t ret = 0;
3121 glusterd_conf_t *priv = NULL((void*)0);
3122 glusterd_volinfo_t *volinfo = NULL((void*)0);
3123 glusterd_brickinfo_t *brickinfo = NULL((void*)0);
3124
3125 GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: "
"this"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 3125, GF_LOG_ERROR, "Assertion failed: " "this"
); } while (0); } } while (0);
3126 priv = this->private;
3127
3128 GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: "
"priv"); } while (0); _gf_log_callingfn ("", "glusterd-store.c"
, __FUNCTION__, 3128, GF_LOG_ERROR, "Assertion failed: " "priv"
); } while (0); } } while (0);
3129
3130 list_for_each_entry (volinfo, &priv->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&priv->
volumes)->next)-(unsigned long)(&((typeof(*volinfo) *)
0)->vol_list))); &volinfo->vol_list != (&priv->
volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo->
vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)->
vol_list)))) {
3131 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)))) {
3132 ret = glusterd_resolve_brick (brickinfo);
3133 if (ret) {
3134 gf_log ("glusterd", GF_LOG_ERROR,do { do { if (0) printf ("resolve brick failed in restore"); }
while (0); _gf_log ("glusterd", "glusterd-store.c", __FUNCTION__
, 3135, GF_LOG_ERROR, "resolve brick failed in restore"); } while
(0)
3135 "resolve brick failed in restore")do { do { if (0) printf ("resolve brick failed in restore"); }
while (0); _gf_log ("glusterd", "glusterd-store.c", __FUNCTION__
, 3135, GF_LOG_ERROR, "resolve brick failed in restore"); } while
(0);
3136 goto out;
3137 }
3138 }
3139 }
3140
3141out:
3142 gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while (
0); _gf_log ("", "glusterd-store.c", __FUNCTION__, 3142, GF_LOG_DEBUG
, "Returning with %d", ret); } while (0);
3143
3144 return ret;
3145}
3146
3147int32_t
3148glusterd_restore ()
3149{
3150 int32_t ret = -1;
3151 xlator_t *this = NULL((void*)0);
3152
3153 this = THIS(*__glusterfs_this_location());
3154
3155 ret = glusterd_restore_op_version (this);
3156 if (ret) {
3157 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("Failed to restore op_version"); } while
(0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 3158, GF_LOG_ERROR, "Failed to restore op_version"); } while
(0)
3158 "Failed to restore op_version")do { do { if (0) printf ("Failed to restore op_version"); } while
(0); _gf_log (this->name, "glusterd-store.c", __FUNCTION__
, 3158, GF_LOG_ERROR, "Failed to restore op_version"); } while
(0);
3159 goto out;
3160 }
3161
3162 ret = glusterd_store_retrieve_volumes (this);
3163 if (ret)
3164 goto out;
3165
3166 ret = glusterd_store_retrieve_peers (this);
3167 if (ret)
3168 goto out;
3169
3170 ret = glusterd_resolve_all_bricks (this);
3171 if (ret)
3172 goto out;
3173
3174out:
3175 gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log
("", "glusterd-store.c", __FUNCTION__, 3175, GF_LOG_DEBUG, "Returning %d"
, ret); } while (0);
3176 return ret;
3177}