File: | xlators/mgmt/glusterd/src/glusterd-store.c |
Location: | line 462, column 16 |
Description: | Access to field 'private' results in a dereference of a null pointer (loaded from variable 'this') |
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 | ||||
47 | static int32_t | |||
48 | glusterd_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 | ||||
64 | int32_t | |||
65 | glusterd_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 | ||||
82 | int32_t | |||
83 | glusterd_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 | ||||
101 | int | |||
102 | glusterd_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; | |||
132 | out: | |||
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 | ||||
147 | int32_t | |||
148 | glusterd_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); | |||
165 | out: | |||
166 | return ret; | |||
167 | } | |||
168 | ||||
169 | int32_t | |||
170 | glusterd_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 | ||||
190 | static void | |||
191 | glusterd_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 | ||||
203 | int32_t | |||
204 | glusterd_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 | ||||
221 | static void | |||
222 | glusterd_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 | ||||
233 | static void | |||
234 | glusterd_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 | ||||
248 | static void | |||
249 | glusterd_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 | ||||
270 | gf_boolean_t | |||
271 | glusterd_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 | ||||
307 | out: | |||
308 | if (brickinfo) | |||
309 | glusterd_brickinfo_delete (brickinfo); | |||
310 | if (volinfo) | |||
311 | glusterd_volinfo_delete (volinfo); | |||
312 | ||||
313 | return ret; | |||
314 | } | |||
315 | ||||
316 | int32_t | |||
317 | glusterd_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 | ||||
333 | out: | |||
334 | return ret; | |||
335 | } | |||
336 | ||||
337 | int32_t | |||
338 | glusterd_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 | ||||
354 | int32_t | |||
355 | glusterd_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 | ||||
387 | out: | |||
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 | ||||
392 | int32_t | |||
393 | glusterd_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 | ||||
409 | out: | |||
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 | ||||
418 | int32_t | |||
419 | glusterd_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); | |||
443 | out: | |||
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 | ||||
448 | int32_t | |||
449 | glusterd_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 | ||||
491 | out: | |||
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 | ||||
500 | int32_t | |||
501 | glusterd_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 | ||||
548 | out: | |||
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 | ||||
553 | static 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 | ||||
592 | int _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 | ||||
644 | int32_t | |||
645 | glusterd_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 | ||||
731 | out: | |||
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 | ||||
738 | static void | |||
739 | glusterd_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 | ||||
752 | static int32_t | |||
753 | glusterd_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 | ||||
767 | int32_t | |||
768 | glusterd_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; | |||
786 | out: | |||
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 | ||||
791 | static void | |||
792 | glusterd_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 | ||||
806 | static void | |||
807 | glusterd_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 | ||||
820 | static void | |||
821 | glusterd_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 | ||||
835 | int32_t | |||
836 | glusterd_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 | ||||
849 | int32_t | |||
850 | glusterd_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 | ||||
863 | int32_t | |||
864 | glusterd_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 | ||||
880 | int32_t | |||
881 | glusterd_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 | } | |||
896 | out: | |||
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 | ||||
901 | int32_t | |||
902 | glusterd_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; | |||
957 | out: | |||
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 | ||||
962 | int32_t | |||
963 | glusterd_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 | ||||
983 | out: | |||
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 | ||||
992 | int32_t | |||
993 | glusterd_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 | } | |||
1024 | out: | |||
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 | ||||
1029 | int32_t | |||
1030 | glusterd_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 | ||||
1050 | out: | |||
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 | ||||
1059 | int32_t | |||
1060 | glusterd_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 | ||||
1080 | out: | |||
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 | ||||
1089 | void | |||
1090 | glusterd_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 | ||||
1107 | void | |||
1108 | glusterd_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 | ||||
1119 | void | |||
1120 | glusterd_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 | ||||
1133 | int32_t | |||
1134 | glusterd_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 | } | |||
1146 | out: | |||
1147 | return ret; | |||
1148 | } | |||
1149 | ||||
1150 | int32_t | |||
1151 | glusterd_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 | ||||
1160 | out: | |||
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 | ||||
1167 | int32_t | |||
1168 | glusterd_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 | ||||
1179 | out: | |||
1180 | return ret; | |||
1181 | } | |||
1182 | ||||
1183 | int32_t | |||
1184 | glusterd_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 | ||||
1231 | out: | |||
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 | ||||
1241 | int32_t | |||
1242 | glusterd_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); | |||
1327 | stat_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 | ||||
1349 | out: | |||
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 | ||||
1361 | int | |||
1362 | glusterd_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; | |||
1398 | out: | |||
1399 | return ret; | |||
1400 | } | |||
1401 | ||||
1402 | int32_t | |||
1403 | glusterd_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); | |||
1469 | out: | |||
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 | ||||
1480 | int32_t | |||
1481 | glusterd_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; | |||
1519 | out: | |||
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 | ||||
1525 | int32_t | |||
1526 | glusterd_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; | |||
1561 | out: | |||
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 | ||||
1574 | int | |||
1575 | glusterd_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); | |||
1587 | out: | |||
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 | ||||
1592 | int32_t | |||
1593 | glusterd_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 | ||||
1608 | out: | |||
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 | ||||
1614 | int | |||
1615 | glusterd_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); | |||
1676 | out: | |||
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 | ||||
1695 | int | |||
1696 | glusterd_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; | |||
1740 | out: | |||
1741 | if (op_version_str) | |||
1742 | GF_FREE (op_version_str)__gf_free (op_version_str); | |||
1743 | ||||
1744 | return ret; | |||
1745 | } | |||
1746 | ||||
1747 | static int | |||
1748 | glusterd_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; | |||
1777 | out: | |||
1778 | return ret; | |||
1779 | } | |||
1780 | ||||
1781 | int32_t | |||
1782 | glusterd_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 | ||||
1817 | out: | |||
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 | ||||
1823 | int32_t | |||
1824 | glusterd_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 | ||||
1865 | out: | |||
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 | ||||
1870 | int32_t | |||
1871 | glusterd_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 | ||||
1904 | int32_t | |||
1905 | glusterd_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 | ||||
1968 | out: | |||
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 | ||||
1987 | int32_t | |||
1988 | glusterd_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 | } | |||
2008 | out: | |||
2009 | return ret; | |||
2010 | } | |||
2011 | ||||
2012 | int32_t | |||
2013 | glusterd_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 | ||||
2035 | char* | |||
2036 | glusterd_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 | ||||
2057 | int32_t | |||
2058 | glusterd_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; | |||
2195 | out: | |||
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 | ||||
2202 | int32_t | |||
2203 | glusterd_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 | ||||
2299 | out: | |||
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 | ||||
2305 | int32_t | |||
2306 | glusterd_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 | ||||
2378 | out: | |||
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 | ||||
2384 | int32_t | |||
2385 | glusterd_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 | ||||
2589 | out: | |||
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 | ||||
2595 | inline void | |||
2596 | glusterd_store_set_options_path (glusterd_conf_t *conf, char *path, size_t len) | |||
2597 | { | |||
2598 | snprintf (path, len, "%s/options", conf->workdir); | |||
2599 | } | |||
2600 | ||||
2601 | int | |||
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 | ||||
2610 | int32_t | |||
2611 | glusterd_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; | |||
2638 | out: | |||
2639 | glusterd_store_handle_destroy (shandle); | |||
2640 | if (fd >=0 ) | |||
2641 | close (fd); | |||
2642 | return ret; | |||
2643 | } | |||
2644 | ||||
2645 | int32_t | |||
2646 | glusterd_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; | |||
2686 | out: | |||
2687 | glusterd_store_iter_destroy (iter); | |||
2688 | glusterd_store_handle_destroy (shandle); | |||
2689 | return ret; | |||
2690 | } | |||
2691 | ||||
2692 | int32_t | |||
2693 | glusterd_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 | ||||
2752 | out: | |||
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 | ||||
2760 | int32_t | |||
2761 | glusterd_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 | ||||
2806 | out: | |||
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 | ||||
2816 | void | |||
2817 | glusterd_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 | ||||
2827 | int32_t | |||
2828 | glusterd_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 | ||||
2840 | static void | |||
2841 | glusterd_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 | ||||
2856 | static void | |||
2857 | glusterd_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 | ||||
2870 | int32_t | |||
2871 | glusterd_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 | ||||
2883 | int32_t | |||
2884 | glusterd_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 | ||||
2896 | int32_t | |||
2897 | glusterd_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 | ||||
2915 | int32_t | |||
2916 | glusterd_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); | |||
2926 | ret = glusterd_store_peerinfo_uuid_shandle_create (peerinfo); | |||
2927 | } | |||
2928 | return ret; | |||
2929 | } | |||
2930 | ||||
2931 | int32_t | |||
2932 | glusterd_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 | ||||
2952 | out: | |||
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 | ||||
2957 | int32_t | |||
2958 | glusterd_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); | |||
2976 | out: | |||
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 | ||||
2985 | int32_t | |||
2986 | glusterd_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); | |||
3001 | out: | |||
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 | ||||
3006 | int32_t | |||
3007 | glusterd_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 | ||||
3109 | out: | |||
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 | ||||
3117 | int32_t | |||
3118 | glusterd_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 | ||||
3141 | out: | |||
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 | ||||
3147 | int32_t | |||
3148 | glusterd_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 | ||||
3174 | out: | |||
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 | } |