File: | xlators/mgmt/glusterd/src/glusterd-utils.c |
Location: | line 4642, column 9 |
Description: | Access to field 'next' results in a dereference of a null pointer |
1 | /* | ||
2 | Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com> | ||
3 | This file is part of GlusterFS. | ||
4 | |||
5 | This file is licensed to you under your choice of the GNU Lesser | ||
6 | General Public License, version 3 or any later version (LGPLv3 or | ||
7 | later), or the GNU General Public License, version 2 (GPLv2), in all | ||
8 | cases as published by the Free Software Foundation. | ||
9 | */ | ||
10 | #ifndef _CONFIG_H | ||
11 | #define _CONFIG_H | ||
12 | #include "config.h" | ||
13 | #endif | ||
14 | #include <openssl/md5.h> | ||
15 | #include <inttypes.h> | ||
16 | |||
17 | #include "globals.h" | ||
18 | #include "glusterfs.h" | ||
19 | #include "compat.h" | ||
20 | #include "dict.h" | ||
21 | #include "xlator.h" | ||
22 | #include "logging.h" | ||
23 | #include "timer.h" | ||
24 | #include "defaults.h" | ||
25 | #include "compat.h" | ||
26 | #include "syncop.h" | ||
27 | #include "run.h" | ||
28 | #include "compat-errno.h" | ||
29 | #include "statedump.h" | ||
30 | #include "syscall.h" | ||
31 | #include "glusterd-mem-types.h" | ||
32 | #include "glusterd.h" | ||
33 | #include "glusterd-op-sm.h" | ||
34 | #include "glusterd-sm.h" | ||
35 | #include "glusterd-utils.h" | ||
36 | #include "glusterd-store.h" | ||
37 | #include "glusterd-volgen.h" | ||
38 | #include "glusterd-pmap.h" | ||
39 | |||
40 | #include "xdr-generic.h" | ||
41 | #include <sys/resource.h> | ||
42 | #include <inttypes.h> | ||
43 | #include <signal.h> | ||
44 | #include <sys/types.h> | ||
45 | #include <net/if.h> | ||
46 | #include <sys/ioctl.h> | ||
47 | #include <sys/socket.h> | ||
48 | #include <rpc/pmap_clnt.h> | ||
49 | #include <unistd.h> | ||
50 | #include <fnmatch.h> | ||
51 | #include <sys/statvfs.h> | ||
52 | #include <ifaddrs.h> | ||
53 | |||
54 | #ifdef GF_LINUX_HOST_OS1 | ||
55 | #include <mntent.h> | ||
56 | #endif | ||
57 | |||
58 | #ifdef GF_SOLARIS_HOST_OS | ||
59 | #include <sys/sockio.h> | ||
60 | #endif | ||
61 | |||
62 | #define NFS_PROGRAM100003 100003 | ||
63 | #define NFSV3_VERSION3 3 | ||
64 | |||
65 | #define MOUNT_PROGRAM100005 100005 | ||
66 | #define MOUNTV3_VERSION3 3 | ||
67 | #define MOUNTV1_VERSION1 1 | ||
68 | |||
69 | #define NLM_PROGRAM100021 100021 | ||
70 | #define NLMV4_VERSION4 4 | ||
71 | #define NLMV1_VERSION1 1 | ||
72 | |||
73 | #define CEILING_POS(X)(((X)-(int)(X)) > 0 ? (int)((X)+1) : (int)(X)) (((X)-(int)(X)) > 0 ? (int)((X)+1) : (int)(X)) | ||
74 | |||
75 | static glusterd_lock_t lock; | ||
76 | |||
77 | static void | ||
78 | md5_wrapper(const unsigned char *data, size_t len, char *md5) | ||
79 | { | ||
80 | unsigned short i = 0; | ||
81 | unsigned short lim = MD5_DIGEST_LENGTH16*2+1; | ||
82 | unsigned char scratch[MD5_DIGEST_LENGTH16] = {0,}; | ||
83 | MD5(data, len, scratch); | ||
84 | for (; i < MD5_DIGEST_LENGTH16; i++) | ||
85 | snprintf(md5 + i * 2, lim-i*2, "%02x", scratch[i]); | ||
86 | } | ||
87 | |||
88 | int32_t | ||
89 | glusterd_get_lock_owner (uuid_t *uuid) | ||
90 | { | ||
91 | uuid_copy (*uuid, lock.owner) ; | ||
92 | return 0; | ||
93 | } | ||
94 | |||
95 | static int32_t | ||
96 | glusterd_set_lock_owner (uuid_t owner) | ||
97 | { | ||
98 | uuid_copy (lock.owner, owner); | ||
99 | //TODO: set timestamp | ||
100 | return 0; | ||
101 | } | ||
102 | |||
103 | static int32_t | ||
104 | glusterd_unset_lock_owner (uuid_t owner) | ||
105 | { | ||
106 | uuid_clear (lock.owner); | ||
107 | //TODO: set timestamp | ||
108 | return 0; | ||
109 | } | ||
110 | |||
111 | gf_boolean_t | ||
112 | glusterd_is_fuse_available () | ||
113 | { | ||
114 | |||
115 | int fd = 0; | ||
116 | |||
117 | fd = open ("/dev/fuse", O_RDWR02); | ||
118 | |||
119 | if (fd > -1 && !close (fd)) | ||
120 | return _gf_true; | ||
121 | else | ||
122 | return _gf_false; | ||
123 | } | ||
124 | |||
125 | gf_boolean_t | ||
126 | glusterd_is_loopback_localhost (const struct sockaddr *sa, char *hostname) | ||
127 | { | ||
128 | GF_ASSERT (sa)do { if (!(sa)) { do { do { if (0) printf ("Assertion failed: " "sa"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 128, GF_LOG_ERROR, "Assertion failed: " "sa") ; } while (0); } } while (0); | ||
129 | |||
130 | gf_boolean_t is_local = _gf_false; | ||
131 | const struct in_addr *addr4 = NULL((void*)0); | ||
132 | const struct in6_addr *addr6 = NULL((void*)0); | ||
133 | uint8_t *ap = NULL((void*)0); | ||
134 | struct in6_addr loopbackaddr6 = IN6ADDR_LOOPBACK_INIT{ { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }; | ||
135 | |||
136 | switch (sa->sa_family) { | ||
137 | case AF_INET2: | ||
138 | addr4 = &(((struct sockaddr_in *)sa)->sin_addr); | ||
139 | ap = (uint8_t*)&addr4->s_addr; | ||
140 | if (ap[0] == 127) | ||
141 | is_local = _gf_true; | ||
142 | break; | ||
143 | |||
144 | case AF_INET610: | ||
145 | addr6 = &(((struct sockaddr_in6 *)sa)->sin6_addr); | ||
146 | if (memcmp (addr6, &loopbackaddr6, | ||
147 | sizeof (loopbackaddr6)) == 0) | ||
148 | is_local = _gf_true; | ||
149 | break; | ||
150 | |||
151 | default: | ||
152 | if (hostname) | ||
153 | gf_log ("glusterd", GF_LOG_ERROR,do { do { if (0) printf ("unknown address family %d for %s", sa ->sa_family, hostname); } while (0); _gf_log ("glusterd", "glusterd-utils.c" , __FUNCTION__, 155, GF_LOG_ERROR, "unknown address family %d for %s" , sa->sa_family, hostname); } while (0) | ||
154 | "unknown address family %d for %s",do { do { if (0) printf ("unknown address family %d for %s", sa ->sa_family, hostname); } while (0); _gf_log ("glusterd", "glusterd-utils.c" , __FUNCTION__, 155, GF_LOG_ERROR, "unknown address family %d for %s" , sa->sa_family, hostname); } while (0) | ||
155 | sa->sa_family, hostname)do { do { if (0) printf ("unknown address family %d for %s", sa ->sa_family, hostname); } while (0); _gf_log ("glusterd", "glusterd-utils.c" , __FUNCTION__, 155, GF_LOG_ERROR, "unknown address family %d for %s" , sa->sa_family, hostname); } while (0); | ||
156 | break; | ||
157 | } | ||
158 | |||
159 | return is_local; | ||
160 | } | ||
161 | |||
162 | char * | ||
163 | get_ip_from_addrinfo (struct addrinfo *addr, char **ip) | ||
164 | { | ||
165 | char buf[64]; | ||
166 | void *in_addr = NULL((void*)0); | ||
167 | struct sockaddr_in *s4 = NULL((void*)0); | ||
168 | struct sockaddr_in6 *s6 = NULL((void*)0); | ||
169 | |||
170 | switch (addr->ai_family) | ||
171 | { | ||
172 | case AF_INET2: | ||
173 | s4 = (struct sockaddr_in *)addr->ai_addr; | ||
174 | in_addr = &s4->sin_addr; | ||
175 | break; | ||
176 | |||
177 | case AF_INET610: | ||
178 | s6 = (struct sockaddr_in6 *)addr->ai_addr; | ||
179 | in_addr = &s6->sin6_addr; | ||
180 | break; | ||
181 | |||
182 | default: | ||
183 | gf_log ("glusterd", GF_LOG_ERROR, "Invalid family")do { do { if (0) printf ("Invalid family"); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 183, GF_LOG_ERROR , "Invalid family"); } while (0); | ||
184 | return NULL((void*)0); | ||
185 | } | ||
186 | |||
187 | if (!inet_ntop(addr->ai_family, in_addr, buf, sizeof(buf))) { | ||
188 | gf_log ("glusterd", GF_LOG_ERROR, "String conversion failed")do { do { if (0) printf ("String conversion failed"); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 188 , GF_LOG_ERROR, "String conversion failed"); } while (0); | ||
189 | return NULL((void*)0); | ||
190 | } | ||
191 | |||
192 | *ip = strdup (buf); | ||
193 | return *ip; | ||
194 | } | ||
195 | |||
196 | gf_boolean_t | ||
197 | glusterd_interface_search (char *ip) | ||
198 | { | ||
199 | int32_t ret = -1; | ||
200 | gf_boolean_t found = _gf_false; | ||
201 | struct ifaddrs *ifaddr, *ifa; | ||
202 | int family; | ||
203 | char host[NI_MAXHOST1025]; | ||
204 | xlator_t *this = NULL((void*)0); | ||
205 | char *pct = NULL((void*)0); | ||
206 | |||
207 | this = THIS(*__glusterfs_this_location()); | ||
208 | |||
209 | ret = getifaddrs (&ifaddr); | ||
210 | |||
211 | if (ret != 0) { | ||
212 | gf_log (this->name, GF_LOG_ERROR, "getifaddrs() failed: %s\n",do { do { if (0) printf ("getifaddrs() failed: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 213, GF_LOG_ERROR, "getifaddrs() failed: %s\n" , gai_strerror(ret)); } while (0) | ||
213 | gai_strerror(ret))do { do { if (0) printf ("getifaddrs() failed: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 213, GF_LOG_ERROR, "getifaddrs() failed: %s\n" , gai_strerror(ret)); } while (0); | ||
214 | goto out; | ||
215 | } | ||
216 | |||
217 | for (ifa = ifaddr; ifa != NULL((void*)0); ifa = ifa->ifa_next) { | ||
218 | if (!ifa->ifa_addr) { | ||
219 | /* | ||
220 | * This seemingly happens if an interface hasn't | ||
221 | * been bound to a particular protocol (seen with | ||
222 | * TUN devices). | ||
223 | */ | ||
224 | continue; | ||
225 | } | ||
226 | family = ifa->ifa_addr->sa_family; | ||
227 | |||
228 | if (family != AF_INET2 && family != AF_INET610) | ||
229 | continue; | ||
230 | |||
231 | ret = getnameinfo (ifa->ifa_addr, | ||
232 | (family == AF_INET2) ? sizeof(struct sockaddr_in) : | ||
233 | sizeof(struct sockaddr_in6), | ||
234 | host, NI_MAXHOST1025, NULL((void*)0), 0, NI_NUMERICHOST1); | ||
235 | |||
236 | if (ret != 0) { | ||
237 | gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("getnameinfo() failed: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 239, GF_LOG_ERROR, "getnameinfo() failed: %s\n" , gai_strerror(ret)); } while (0) | ||
238 | "getnameinfo() failed: %s\n",do { do { if (0) printf ("getnameinfo() failed: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 239, GF_LOG_ERROR, "getnameinfo() failed: %s\n" , gai_strerror(ret)); } while (0) | ||
239 | gai_strerror(ret))do { do { if (0) printf ("getnameinfo() failed: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 239, GF_LOG_ERROR, "getnameinfo() failed: %s\n" , gai_strerror(ret)); } while (0); | ||
240 | goto out; | ||
241 | } | ||
242 | |||
243 | /* | ||
244 | * Sometimes the address comes back as addr%eth0 or | ||
245 | * similar. Since % is an invalid character, we can | ||
246 | * strip it out with confidence that doing so won't | ||
247 | * harm anything. | ||
248 | */ | ||
249 | pct = index(host,'%'); | ||
250 | if (pct) { | ||
251 | *pct = '\0'; | ||
252 | } | ||
253 | |||
254 | if (strncmp (ip, host, NI_MAXHOST1025) == 0) { | ||
255 | gf_log (this->name, GF_LOG_DEBUG,do { do { if (0) printf ("%s is local address at interface %s" , ip, ifa->ifa_name); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 257, GF_LOG_DEBUG, "%s is local address at interface %s" , ip, ifa->ifa_name); } while (0) | ||
256 | "%s is local address at interface %s",do { do { if (0) printf ("%s is local address at interface %s" , ip, ifa->ifa_name); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 257, GF_LOG_DEBUG, "%s is local address at interface %s" , ip, ifa->ifa_name); } while (0) | ||
257 | ip, ifa->ifa_name)do { do { if (0) printf ("%s is local address at interface %s" , ip, ifa->ifa_name); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 257, GF_LOG_DEBUG, "%s is local address at interface %s" , ip, ifa->ifa_name); } while (0); | ||
258 | found = _gf_true; | ||
259 | goto out; | ||
260 | } | ||
261 | } | ||
262 | out: | ||
263 | if(ifaddr) | ||
264 | freeifaddrs (ifaddr); | ||
265 | return found; | ||
266 | } | ||
267 | |||
268 | |||
269 | gf_boolean_t | ||
270 | glusterd_is_local_addr (char *hostname) | ||
271 | { | ||
272 | int32_t ret = -1; | ||
273 | struct addrinfo *result = NULL((void*)0); | ||
274 | struct addrinfo *res = NULL((void*)0); | ||
275 | gf_boolean_t found = _gf_false; | ||
276 | char *ip = NULL((void*)0); | ||
277 | xlator_t *this = NULL((void*)0); | ||
278 | |||
279 | this = THIS(*__glusterfs_this_location()); | ||
280 | ret = getaddrinfo (hostname, NULL((void*)0), NULL((void*)0), &result); | ||
281 | |||
282 | if (ret != 0) { | ||
283 | gf_log (this->name, GF_LOG_ERROR, "error in getaddrinfo: %s\n",do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 284, GF_LOG_ERROR, "error in getaddrinfo: %s\n" , gai_strerror(ret)); } while (0) | ||
284 | gai_strerror(ret))do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 284, GF_LOG_ERROR, "error in getaddrinfo: %s\n" , gai_strerror(ret)); } while (0); | ||
285 | goto out; | ||
286 | } | ||
287 | |||
288 | for (res = result; res != NULL((void*)0); res = res->ai_next) { | ||
289 | gf_log (this->name, GF_LOG_DEBUG, "%s ",do { do { if (0) printf ("%s ", get_ip_from_addrinfo (res, & ip)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 290, GF_LOG_DEBUG, "%s ", get_ip_from_addrinfo (res, &ip)); } while (0) | ||
290 | get_ip_from_addrinfo (res, &ip))do { do { if (0) printf ("%s ", get_ip_from_addrinfo (res, & ip)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 290, GF_LOG_DEBUG, "%s ", get_ip_from_addrinfo (res, &ip)); } while (0); | ||
291 | |||
292 | found = glusterd_is_loopback_localhost (res->ai_addr, hostname) | ||
293 | || glusterd_interface_search (ip); | ||
294 | if (found) | ||
295 | goto out; | ||
296 | } | ||
297 | |||
298 | out: | ||
299 | if (result) | ||
300 | freeaddrinfo (result); | ||
301 | |||
302 | if (!found) | ||
303 | gf_log (this->name, GF_LOG_DEBUG, "%s is not local", hostname)do { do { if (0) printf ("%s is not local", hostname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 303, GF_LOG_DEBUG, "%s is not local", hostname); } while (0 ); | ||
304 | |||
305 | return found; | ||
306 | } | ||
307 | |||
308 | int32_t | ||
309 | glusterd_lock (uuid_t uuid) | ||
310 | { | ||
311 | |||
312 | uuid_t owner; | ||
313 | char new_owner_str[50]; | ||
314 | char owner_str[50]; | ||
315 | int ret = -1; | ||
316 | xlator_t *this = NULL((void*)0); | ||
317 | |||
318 | this = THIS(*__glusterfs_this_location()); | ||
319 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 319, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
320 | |||
321 | GF_ASSERT (uuid)do { if (!(uuid)) { do { do { if (0) printf ("Assertion failed: " "uuid"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 321, GF_LOG_ERROR, "Assertion failed: " "uuid" ); } while (0); } } while (0); | ||
322 | |||
323 | glusterd_get_lock_owner (&owner); | ||
324 | |||
325 | if (!uuid_is_null (owner)) { | ||
326 | gf_log (this->name, GF_LOG_ERROR, "Unable to get lock"do { do { if (0) printf ("Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 329, GF_LOG_ERROR, "Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0) | ||
327 | " for uuid: %s, lock held by: %s",do { do { if (0) printf ("Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 329, GF_LOG_ERROR, "Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0) | ||
328 | uuid_utoa_r (uuid, new_owner_str),do { do { if (0) printf ("Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 329, GF_LOG_ERROR, "Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0) | ||
329 | uuid_utoa_r (owner, owner_str))do { do { if (0) printf ("Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 329, GF_LOG_ERROR, "Unable to get lock" " for uuid: %s, lock held by: %s" , uuid_utoa_r (uuid, new_owner_str), uuid_utoa_r (owner, owner_str )); } while (0); | ||
330 | goto out; | ||
331 | } | ||
332 | |||
333 | ret = glusterd_set_lock_owner (uuid); | ||
334 | |||
335 | if (!ret) { | ||
336 | gf_log (this->name, GF_LOG_DEBUG, "Cluster lock held by"do { do { if (0) printf ("Cluster lock held by" " %s", uuid_utoa (uuid)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 337, GF_LOG_DEBUG, "Cluster lock held by" " %s" , uuid_utoa (uuid)); } while (0) | ||
337 | " %s", uuid_utoa (uuid))do { do { if (0) printf ("Cluster lock held by" " %s", uuid_utoa (uuid)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 337, GF_LOG_DEBUG, "Cluster lock held by" " %s" , uuid_utoa (uuid)); } while (0); | ||
338 | } | ||
339 | |||
340 | out: | ||
341 | return ret; | ||
342 | } | ||
343 | |||
344 | |||
345 | int32_t | ||
346 | glusterd_unlock (uuid_t uuid) | ||
347 | { | ||
348 | uuid_t owner; | ||
349 | char new_owner_str[50]; | ||
350 | char owner_str[50]; | ||
351 | int32_t ret = -1; | ||
352 | xlator_t *this = NULL((void*)0); | ||
353 | |||
354 | this = THIS(*__glusterfs_this_location()); | ||
355 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 355, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
356 | |||
357 | GF_ASSERT (uuid)do { if (!(uuid)) { do { do { if (0) printf ("Assertion failed: " "uuid"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 357, GF_LOG_ERROR, "Assertion failed: " "uuid" ); } while (0); } } while (0); | ||
358 | |||
359 | glusterd_get_lock_owner (&owner); | ||
360 | |||
361 | if (uuid_is_null (owner)) { | ||
362 | gf_log (this->name, GF_LOG_ERROR, "Cluster lock not held!")do { do { if (0) printf ("Cluster lock not held!"); } while ( 0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 362, GF_LOG_ERROR, "Cluster lock not held!"); } while (0); | ||
363 | goto out; | ||
364 | } | ||
365 | |||
366 | ret = uuid_compare (uuid, owner); | ||
367 | |||
368 | if (ret) { | ||
369 | gf_log (this->name, GF_LOG_ERROR, "Cluster lock held by %s ,"do { do { if (0) printf ("Cluster lock held by %s ," "unlock req from %s!" , uuid_utoa_r (owner ,owner_str) , uuid_utoa_r (uuid, new_owner_str )); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 371, GF_LOG_ERROR, "Cluster lock held by %s ," "unlock req from %s!" , uuid_utoa_r (owner ,owner_str) , uuid_utoa_r (uuid, new_owner_str )); } while (0) | ||
370 | "unlock req from %s!", uuid_utoa_r (owner ,owner_str)do { do { if (0) printf ("Cluster lock held by %s ," "unlock req from %s!" , uuid_utoa_r (owner ,owner_str) , uuid_utoa_r (uuid, new_owner_str )); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 371, GF_LOG_ERROR, "Cluster lock held by %s ," "unlock req from %s!" , uuid_utoa_r (owner ,owner_str) , uuid_utoa_r (uuid, new_owner_str )); } while (0) | ||
371 | , uuid_utoa_r (uuid, new_owner_str))do { do { if (0) printf ("Cluster lock held by %s ," "unlock req from %s!" , uuid_utoa_r (owner ,owner_str) , uuid_utoa_r (uuid, new_owner_str )); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 371, GF_LOG_ERROR, "Cluster lock held by %s ," "unlock req from %s!" , uuid_utoa_r (owner ,owner_str) , uuid_utoa_r (uuid, new_owner_str )); } while (0); | ||
372 | goto out; | ||
373 | } | ||
374 | |||
375 | ret = glusterd_unset_lock_owner (uuid); | ||
376 | |||
377 | if (ret) { | ||
378 | gf_log (this->name, GF_LOG_ERROR, "Unable to clear cluster "do { do { if (0) printf ("Unable to clear cluster " "lock"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 379, GF_LOG_ERROR, "Unable to clear cluster " "lock"); } while (0) | ||
379 | "lock")do { do { if (0) printf ("Unable to clear cluster " "lock"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 379, GF_LOG_ERROR, "Unable to clear cluster " "lock"); } while (0); | ||
380 | goto out; | ||
381 | } | ||
382 | |||
383 | ret = 0; | ||
384 | |||
385 | out: | ||
386 | return ret; | ||
387 | } | ||
388 | |||
389 | |||
390 | int | ||
391 | glusterd_get_uuid (uuid_t *uuid) | ||
392 | { | ||
393 | glusterd_conf_t *priv = NULL((void*)0); | ||
394 | |||
395 | priv = THIS(*__glusterfs_this_location())->private; | ||
396 | |||
397 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 397, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
398 | |||
399 | uuid_copy (*uuid, MY_UUID(__glusterd_uuid())); | ||
400 | |||
401 | return 0; | ||
402 | } | ||
403 | |||
404 | int | ||
405 | glusterd_submit_request (struct rpc_clnt *rpc, void *req, | ||
406 | call_frame_t *frame, rpc_clnt_prog_t *prog, | ||
407 | int procnum, struct iobref *iobref, | ||
408 | xlator_t *this, fop_cbk_fn_t cbkfn, xdrproc_t xdrproc) | ||
409 | { | ||
410 | int ret = -1; | ||
411 | struct iobuf *iobuf = NULL((void*)0); | ||
412 | int count = 0; | ||
413 | char new_iobref = 0, start_ping = 0; | ||
414 | struct iovec iov = {0, }; | ||
415 | ssize_t req_size = 0; | ||
416 | |||
417 | GF_ASSERT (rpc)do { if (!(rpc)) { do { do { if (0) printf ("Assertion failed: " "rpc"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 417, GF_LOG_ERROR, "Assertion failed: " "rpc" ); } while (0); } } while (0); | ||
418 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 418, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
419 | |||
420 | if (req) { | ||
421 | req_size = xdr_sizeof (xdrproc, req); | ||
422 | iobuf = iobuf_get2 (this->ctx->iobuf_pool, req_size); | ||
423 | if (!iobuf) { | ||
424 | goto out; | ||
425 | }; | ||
426 | |||
427 | if (!iobref) { | ||
428 | iobref = iobref_new (); | ||
429 | if (!iobref) { | ||
430 | goto out; | ||
431 | } | ||
432 | |||
433 | new_iobref = 1; | ||
434 | } | ||
435 | |||
436 | iobref_add (iobref, iobuf); | ||
437 | |||
438 | iov.iov_base = iobuf->ptr; | ||
439 | iov.iov_len = iobuf_pagesize (iobuf)(iobuf->iobuf_arena->page_size); | ||
440 | |||
441 | /* Create the xdr payload */ | ||
442 | ret = xdr_serialize_generic (iov, req, xdrproc); | ||
443 | if (ret == -1) { | ||
444 | goto out; | ||
445 | } | ||
446 | iov.iov_len = ret; | ||
447 | count = 1; | ||
448 | } | ||
449 | |||
450 | /* Send the msg */ | ||
451 | ret = rpc_clnt_submit (rpc, prog, procnum, cbkfn, | ||
452 | &iov, count, | ||
453 | NULL((void*)0), 0, iobref, frame, NULL((void*)0), 0, NULL((void*)0), 0, NULL((void*)0)); | ||
454 | |||
455 | if (ret == 0) { | ||
456 | pthread_mutex_lock (&rpc->conn.lock); | ||
457 | { | ||
458 | if (!rpc->conn.ping_started) { | ||
459 | start_ping = 1; | ||
460 | } | ||
461 | } | ||
462 | pthread_mutex_unlock (&rpc->conn.lock); | ||
463 | } | ||
464 | |||
465 | if (start_ping) | ||
466 | //client_start_ping ((void *) this); | ||
467 | |||
468 | ret = 0; | ||
469 | out: | ||
470 | if (new_iobref) { | ||
471 | iobref_unref (iobref); | ||
472 | } | ||
473 | |||
474 | iobuf_unref (iobuf); | ||
475 | |||
476 | return ret; | ||
477 | } | ||
478 | |||
479 | struct iobuf * | ||
480 | glusterd_serialize_reply (rpcsvc_request_t *req, void *arg, | ||
481 | struct iovec *outmsg, xdrproc_t xdrproc) | ||
482 | { | ||
483 | struct iobuf *iob = NULL((void*)0); | ||
484 | ssize_t retlen = -1; | ||
485 | ssize_t rsp_size = 0; | ||
486 | |||
487 | /* First, get the io buffer into which the reply in arg will | ||
488 | * be serialized. | ||
489 | */ | ||
490 | rsp_size = xdr_sizeof (xdrproc, arg); | ||
491 | iob = iobuf_get2 (req->svc->ctx->iobuf_pool, rsp_size); | ||
492 | if (!iob) { | ||
493 | gf_log ("", GF_LOG_ERROR, "Failed to get iobuf")do { do { if (0) printf ("Failed to get iobuf"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 493, GF_LOG_ERROR , "Failed to get iobuf"); } while (0); | ||
494 | goto ret; | ||
495 | } | ||
496 | |||
497 | iobuf_to_iovec (iob, outmsg); | ||
498 | /* Use the given serializer to translate the give C structure in arg | ||
499 | * to XDR format which will be written into the buffer in outmsg. | ||
500 | */ | ||
501 | /* retlen is used to received the error since size_t is unsigned and we | ||
502 | * need -1 for error notification during encoding. | ||
503 | */ | ||
504 | retlen = xdr_serialize_generic (*outmsg, arg, xdrproc); | ||
505 | if (retlen == -1) { | ||
506 | gf_log ("", GF_LOG_ERROR, "Failed to encode message")do { do { if (0) printf ("Failed to encode message"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 506, GF_LOG_ERROR , "Failed to encode message"); } while (0); | ||
507 | goto ret; | ||
508 | } | ||
509 | |||
510 | outmsg->iov_len = retlen; | ||
511 | ret: | ||
512 | if (retlen == -1) { | ||
513 | iobuf_unref (iob); | ||
514 | iob = NULL((void*)0); | ||
515 | } | ||
516 | |||
517 | return iob; | ||
518 | } | ||
519 | |||
520 | int | ||
521 | glusterd_submit_reply (rpcsvc_request_t *req, void *arg, | ||
522 | struct iovec *payload, int payloadcount, | ||
523 | struct iobref *iobref, xdrproc_t xdrproc) | ||
524 | { | ||
525 | struct iobuf *iob = NULL((void*)0); | ||
526 | int ret = -1; | ||
527 | struct iovec rsp = {0,}; | ||
528 | char new_iobref = 0; | ||
529 | |||
530 | if (!req) { | ||
531 | GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: " "req"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 531, GF_LOG_ERROR, "Assertion failed: " "req" ); } while (0); } } while (0); | ||
532 | goto out; | ||
533 | } | ||
534 | |||
535 | if (!iobref) { | ||
536 | iobref = iobref_new (); | ||
537 | if (!iobref) { | ||
538 | gf_log ("", GF_LOG_ERROR, "out of memory")do { do { if (0) printf ("out of memory"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 538, GF_LOG_ERROR, "out of memory" ); } while (0); | ||
539 | goto out; | ||
540 | } | ||
541 | |||
542 | new_iobref = 1; | ||
543 | } | ||
544 | |||
545 | iob = glusterd_serialize_reply (req, arg, &rsp, xdrproc); | ||
546 | if (!iob) { | ||
547 | gf_log ("", GF_LOG_ERROR, "Failed to serialize reply")do { do { if (0) printf ("Failed to serialize reply"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 547, GF_LOG_ERROR , "Failed to serialize reply"); } while (0); | ||
548 | } else { | ||
549 | iobref_add (iobref, iob); | ||
550 | } | ||
551 | |||
552 | ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount, | ||
553 | iobref); | ||
554 | |||
555 | /* Now that we've done our job of handing the message to the RPC layer | ||
556 | * we can safely unref the iob in the hope that RPC layer must have | ||
557 | * ref'ed the iob on receiving into the txlist. | ||
558 | */ | ||
559 | if (ret == -1) { | ||
560 | gf_log ("", GF_LOG_ERROR, "Reply submission failed")do { do { if (0) printf ("Reply submission failed"); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 560, GF_LOG_ERROR , "Reply submission failed"); } while (0); | ||
561 | goto out; | ||
562 | } | ||
563 | |||
564 | ret = 0; | ||
565 | out: | ||
566 | |||
567 | if (new_iobref) { | ||
568 | iobref_unref (iobref); | ||
569 | } | ||
570 | |||
571 | if (iob) | ||
572 | iobuf_unref (iob); | ||
573 | return ret; | ||
574 | } | ||
575 | |||
576 | gf_boolean_t | ||
577 | glusterd_check_volume_exists (char *volname) | ||
578 | { | ||
579 | char pathname[1024] = {0,}; | ||
580 | struct stat stbuf = {0,}; | ||
581 | int32_t ret = -1; | ||
582 | glusterd_conf_t *priv = NULL((void*)0); | ||
583 | |||
584 | priv = THIS(*__glusterfs_this_location())->private; | ||
585 | |||
586 | snprintf (pathname, 1024, "%s/vols/%s", priv->workdir, | ||
587 | volname); | ||
588 | |||
589 | ret = stat (pathname, &stbuf); | ||
590 | |||
591 | if (ret) { | ||
592 | gf_log (THIS->name, GF_LOG_DEBUG, "Volume %s does not exist."do { do { if (0) printf ("Volume %s does not exist." "stat failed with errno : %d on path: %s" , volname, (*__errno_location ()), pathname); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 594, GF_LOG_DEBUG, "Volume %s does not exist." "stat failed with errno : %d on path: %s", volname, (*__errno_location ()), pathname); } while (0) | ||
593 | "stat failed with errno : %d on path: %s",do { do { if (0) printf ("Volume %s does not exist." "stat failed with errno : %d on path: %s" , volname, (*__errno_location ()), pathname); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 594, GF_LOG_DEBUG, "Volume %s does not exist." "stat failed with errno : %d on path: %s", volname, (*__errno_location ()), pathname); } while (0) | ||
594 | volname, errno, pathname)do { do { if (0) printf ("Volume %s does not exist." "stat failed with errno : %d on path: %s" , volname, (*__errno_location ()), pathname); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 594, GF_LOG_DEBUG, "Volume %s does not exist." "stat failed with errno : %d on path: %s", volname, (*__errno_location ()), pathname); } while (0); | ||
595 | return _gf_false; | ||
596 | } | ||
597 | |||
598 | return _gf_true; | ||
599 | } | ||
600 | |||
601 | int32_t | ||
602 | glusterd_volinfo_new (glusterd_volinfo_t **volinfo) | ||
603 | { | ||
604 | glusterd_volinfo_t *new_volinfo = NULL((void*)0); | ||
605 | int32_t ret = -1; | ||
606 | |||
607 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 607, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
608 | |||
609 | new_volinfo = GF_CALLOC (1, sizeof(*new_volinfo),__gf_calloc (1, sizeof(*new_volinfo), gf_gld_mt_glusterd_volinfo_t ) | ||
610 | gf_gld_mt_glusterd_volinfo_t)__gf_calloc (1, sizeof(*new_volinfo), gf_gld_mt_glusterd_volinfo_t ); | ||
611 | |||
612 | if (!new_volinfo) | ||
613 | goto out; | ||
614 | |||
615 | INIT_LIST_HEAD (&new_volinfo->vol_list)do { (&new_volinfo->vol_list)->next = (&new_volinfo ->vol_list)->prev = &new_volinfo->vol_list; } while (0); | ||
616 | INIT_LIST_HEAD (&new_volinfo->bricks)do { (&new_volinfo->bricks)->next = (&new_volinfo ->bricks)->prev = &new_volinfo->bricks; } while ( 0); | ||
617 | |||
618 | new_volinfo->dict = dict_new (); | ||
619 | if (!new_volinfo->dict) { | ||
620 | GF_FREE (new_volinfo)__gf_free (new_volinfo); | ||
621 | |||
622 | goto out; | ||
623 | } | ||
624 | |||
625 | new_volinfo->gsync_slaves = dict_new (); | ||
626 | if (!new_volinfo->gsync_slaves) { | ||
627 | GF_FREE (new_volinfo)__gf_free (new_volinfo); | ||
628 | |||
629 | goto out; | ||
630 | } | ||
631 | |||
632 | new_volinfo->xl = THIS(*__glusterfs_this_location()); | ||
633 | |||
634 | *volinfo = new_volinfo; | ||
635 | |||
636 | ret = 0; | ||
637 | |||
638 | out: | ||
639 | 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-utils.c" , __FUNCTION__, 639, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
640 | return ret; | ||
641 | } | ||
642 | |||
643 | void | ||
644 | glusterd_auth_cleanup (glusterd_volinfo_t *volinfo) { | ||
645 | |||
646 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 646, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
647 | |||
648 | GF_FREE (volinfo->auth.username)__gf_free (volinfo->auth.username); | ||
649 | |||
650 | GF_FREE (volinfo->auth.password)__gf_free (volinfo->auth.password); | ||
651 | } | ||
652 | |||
653 | char * | ||
654 | glusterd_auth_get_username (glusterd_volinfo_t *volinfo) { | ||
655 | |||
656 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 656, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
657 | |||
658 | return volinfo->auth.username; | ||
659 | } | ||
660 | |||
661 | char * | ||
662 | glusterd_auth_get_password (glusterd_volinfo_t *volinfo) { | ||
663 | |||
664 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 664, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
665 | |||
666 | return volinfo->auth.password; | ||
667 | } | ||
668 | |||
669 | int32_t | ||
670 | glusterd_auth_set_username (glusterd_volinfo_t *volinfo, char *username) { | ||
671 | |||
672 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 672, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
673 | GF_ASSERT (username)do { if (!(username)) { do { do { if (0) printf ("Assertion failed: " "username"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 673, GF_LOG_ERROR, "Assertion failed: " "username" ); } while (0); } } while (0); | ||
674 | |||
675 | volinfo->auth.username = gf_strdup (username); | ||
676 | return 0; | ||
677 | } | ||
678 | |||
679 | int32_t | ||
680 | glusterd_auth_set_password (glusterd_volinfo_t *volinfo, char *password) { | ||
681 | |||
682 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 682, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
683 | GF_ASSERT (password)do { if (!(password)) { do { do { if (0) printf ("Assertion failed: " "password"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 683, GF_LOG_ERROR, "Assertion failed: " "password" ); } while (0); } } while (0); | ||
684 | |||
685 | volinfo->auth.password = gf_strdup (password); | ||
686 | return 0; | ||
687 | } | ||
688 | |||
689 | int32_t | ||
690 | glusterd_brickinfo_delete (glusterd_brickinfo_t *brickinfo) | ||
691 | { | ||
692 | int32_t ret = -1; | ||
693 | |||
694 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 694, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
695 | |||
696 | list_del_init (&brickinfo->brick_list); | ||
697 | |||
698 | GF_FREE (brickinfo->logfile)__gf_free (brickinfo->logfile); | ||
699 | GF_FREE (brickinfo)__gf_free (brickinfo); | ||
700 | |||
701 | ret = 0; | ||
702 | |||
703 | return ret; | ||
704 | } | ||
705 | |||
706 | int32_t | ||
707 | glusterd_volume_brickinfos_delete (glusterd_volinfo_t *volinfo) | ||
708 | { | ||
709 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
710 | glusterd_brickinfo_t *tmp = NULL((void*)0); | ||
711 | int32_t ret = 0; | ||
712 | |||
713 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 713, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
714 | |||
715 | list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks,for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*brickinfo ) *)0)->brick_list))), tmp = ((typeof(*brickinfo) *)((char *)(brickinfo->brick_list.next)-(unsigned long)(&((typeof (*brickinfo) *)0)->brick_list))); &brickinfo->brick_list != (&volinfo->bricks); brickinfo = tmp, tmp = ((typeof (*tmp) *)((char *)(tmp->brick_list.next)-(unsigned long)(& ((typeof(*tmp) *)0)->brick_list)))) | ||
716 | brick_list)for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*brickinfo ) *)0)->brick_list))), tmp = ((typeof(*brickinfo) *)((char *)(brickinfo->brick_list.next)-(unsigned long)(&((typeof (*brickinfo) *)0)->brick_list))); &brickinfo->brick_list != (&volinfo->bricks); brickinfo = tmp, tmp = ((typeof (*tmp) *)((char *)(tmp->brick_list.next)-(unsigned long)(& ((typeof(*tmp) *)0)->brick_list)))) { | ||
717 | ret = glusterd_brickinfo_delete (brickinfo); | ||
718 | if (ret) | ||
719 | goto out; | ||
720 | } | ||
721 | |||
722 | out: | ||
723 | 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-utils.c" , __FUNCTION__, 723, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
724 | return ret; | ||
725 | } | ||
726 | |||
727 | int32_t | ||
728 | glusterd_volinfo_delete (glusterd_volinfo_t *volinfo) | ||
729 | { | ||
730 | int32_t ret = -1; | ||
731 | |||
732 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 732, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
733 | |||
734 | list_del_init (&volinfo->vol_list); | ||
735 | |||
736 | ret = glusterd_volume_brickinfos_delete (volinfo); | ||
737 | if (ret) | ||
738 | goto out; | ||
739 | if (volinfo->dict) | ||
740 | dict_unref (volinfo->dict); | ||
741 | if (volinfo->gsync_slaves) | ||
742 | dict_unref (volinfo->gsync_slaves); | ||
743 | GF_FREE (volinfo->logdir)__gf_free (volinfo->logdir); | ||
744 | |||
745 | glusterd_auth_cleanup (volinfo); | ||
746 | |||
747 | GF_FREE (volinfo)__gf_free (volinfo); | ||
748 | ret = 0; | ||
749 | |||
750 | out: | ||
751 | 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-utils.c" , __FUNCTION__, 751, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
752 | return ret; | ||
753 | } | ||
754 | |||
755 | |||
756 | int32_t | ||
757 | glusterd_brickinfo_new (glusterd_brickinfo_t **brickinfo) | ||
758 | { | ||
759 | glusterd_brickinfo_t *new_brickinfo = NULL((void*)0); | ||
760 | int32_t ret = -1; | ||
761 | |||
762 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 762, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
763 | |||
764 | new_brickinfo = GF_CALLOC (1, sizeof(*new_brickinfo),__gf_calloc (1, sizeof(*new_brickinfo), gf_gld_mt_glusterd_brickinfo_t ) | ||
765 | gf_gld_mt_glusterd_brickinfo_t)__gf_calloc (1, sizeof(*new_brickinfo), gf_gld_mt_glusterd_brickinfo_t ); | ||
766 | |||
767 | if (!new_brickinfo) | ||
768 | goto out; | ||
769 | |||
770 | INIT_LIST_HEAD (&new_brickinfo->brick_list)do { (&new_brickinfo->brick_list)->next = (&new_brickinfo ->brick_list)->prev = &new_brickinfo->brick_list ; } while (0); | ||
771 | |||
772 | *brickinfo = new_brickinfo; | ||
773 | |||
774 | ret = 0; | ||
775 | |||
776 | out: | ||
777 | 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-utils.c" , __FUNCTION__, 777, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
778 | return ret; | ||
779 | } | ||
780 | |||
781 | int32_t | ||
782 | glusterd_resolve_brick (glusterd_brickinfo_t *brickinfo) | ||
783 | { | ||
784 | int32_t ret = -1; | ||
785 | xlator_t *this = NULL((void*)0); | ||
786 | |||
787 | this = THIS(*__glusterfs_this_location()); | ||
788 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 788, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
789 | |||
790 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 790, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
791 | |||
792 | ret = glusterd_hostname_to_uuid (brickinfo->hostname, brickinfo->uuid); | ||
793 | 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-utils.c", __FUNCTION__, 793, GF_LOG_DEBUG , "Returning %d", ret); } while (0); | ||
794 | return ret; | ||
795 | } | ||
796 | |||
797 | int32_t | ||
798 | glusterd_brickinfo_new_from_brick (char *brick, | ||
799 | glusterd_brickinfo_t **brickinfo) | ||
800 | { | ||
801 | int32_t ret = -1; | ||
802 | glusterd_brickinfo_t *new_brickinfo = NULL((void*)0); | ||
803 | char *hostname = NULL((void*)0); | ||
804 | char *path = NULL((void*)0); | ||
805 | char *tmp_host = NULL((void*)0); | ||
806 | char *tmp_path = NULL((void*)0); | ||
807 | |||
808 | GF_ASSERT (brick)do { if (!(brick)) { do { do { if (0) printf ("Assertion failed: " "brick"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 808, GF_LOG_ERROR, "Assertion failed: " "brick" ); } while (0); } } while (0); | ||
809 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 809, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
810 | |||
811 | tmp_host = gf_strdup (brick); | ||
812 | if (tmp_host && !get_host_name (tmp_host, &hostname)) | ||
813 | goto out; | ||
814 | tmp_path = gf_strdup (brick); | ||
815 | if (tmp_path && !get_path_name (tmp_path, &path)) | ||
816 | goto out; | ||
817 | |||
818 | GF_ASSERT (hostname)do { if (!(hostname)) { do { do { if (0) printf ("Assertion failed: " "hostname"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 818, GF_LOG_ERROR, "Assertion failed: " "hostname" ); } while (0); } } while (0); | ||
819 | GF_ASSERT (path)do { if (!(path)) { do { do { if (0) printf ("Assertion failed: " "path"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 819, GF_LOG_ERROR, "Assertion failed: " "path" ); } while (0); } } while (0); | ||
820 | |||
821 | ret = glusterd_brickinfo_new (&new_brickinfo); | ||
822 | if (ret) | ||
823 | goto out; | ||
824 | |||
825 | ret = gf_canonicalize_path (path); | ||
826 | if (ret) | ||
827 | goto out; | ||
828 | |||
829 | strncpy (new_brickinfo->hostname, hostname, 1024); | ||
830 | strncpy (new_brickinfo->path, path, 1024); | ||
831 | |||
832 | *brickinfo = new_brickinfo; | ||
833 | |||
834 | ret = 0; | ||
835 | out: | ||
836 | GF_FREE (tmp_host)__gf_free (tmp_host); | ||
837 | if (tmp_host) | ||
838 | GF_FREE (tmp_path)__gf_free (tmp_path); | ||
839 | 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-utils.c" , __FUNCTION__, 839, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
840 | return ret; | ||
841 | } | ||
842 | |||
843 | static gf_boolean_t | ||
844 | _is_prefix (char *str1, char *str2) | ||
845 | { | ||
846 | GF_ASSERT (str1)do { if (!(str1)) { do { do { if (0) printf ("Assertion failed: " "str1"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 846, GF_LOG_ERROR, "Assertion failed: " "str1" ); } while (0); } } while (0); | ||
847 | GF_ASSERT (str2)do { if (!(str2)) { do { do { if (0) printf ("Assertion failed: " "str2"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 847, GF_LOG_ERROR, "Assertion failed: " "str2" ); } while (0); } } while (0); | ||
848 | |||
849 | int i = 0; | ||
850 | int len1 = 0; | ||
851 | int len2 = 0; | ||
852 | int small_len = 0; | ||
853 | char *bigger = NULL((void*)0); | ||
854 | gf_boolean_t prefix = _gf_true; | ||
855 | |||
856 | len1 = strlen (str1); | ||
857 | len2 = strlen (str2); | ||
858 | small_len = min (len1, len2)((len1)<(len2)?(len1):(len2)); | ||
859 | for (i = 0; i < small_len; i++) { | ||
860 | if (str1[i] != str2[i]) { | ||
861 | prefix = _gf_false; | ||
862 | break; | ||
863 | } | ||
864 | } | ||
865 | |||
866 | if (len1 < len2) | ||
867 | bigger = str2; | ||
868 | |||
869 | else if (len1 > len2) | ||
870 | bigger = str1; | ||
871 | |||
872 | else | ||
873 | return prefix; | ||
874 | |||
875 | if (bigger[small_len] != '/') | ||
876 | prefix = _gf_false; | ||
877 | |||
878 | return prefix; | ||
879 | } | ||
880 | |||
881 | /* Checks if @path is available in the peer identified by @uuid | ||
882 | * 'availability' is determined by querying current state of volumes | ||
883 | * in the cluster. */ | ||
884 | gf_boolean_t | ||
885 | glusterd_is_brickpath_available (uuid_t uuid, char *path) | ||
886 | { | ||
887 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
888 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
889 | glusterd_conf_t *priv = NULL((void*)0); | ||
890 | gf_boolean_t available = _gf_false; | ||
891 | char tmp_path[PATH_MAX4096+1] = {0}; | ||
892 | char tmp_brickpath[PATH_MAX4096+1] = {0}; | ||
893 | |||
894 | priv = THIS(*__glusterfs_this_location())->private; | ||
895 | |||
896 | strncpy (tmp_path, path, PATH_MAX4096); | ||
897 | /* path may not yet exist */ | ||
898 | if (!realpath (path, tmp_path)) { | ||
899 | if (errno(*__errno_location ()) != ENOENT2) { | ||
900 | goto out; | ||
901 | } | ||
902 | /* When realpath(3) fails, tmp_path is undefined. */ | ||
903 | strncpy(tmp_path,path,PATH_MAX4096); | ||
904 | } | ||
905 | |||
906 | 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)))) { | ||
907 | 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)))) { | ||
908 | if (uuid_compare (uuid, brickinfo->uuid)) | ||
909 | continue; | ||
910 | |||
911 | if (!realpath (brickinfo->path, tmp_brickpath)) { | ||
912 | if (errno(*__errno_location ()) == ENOENT2) | ||
913 | strncpy (tmp_brickpath, brickinfo->path, | ||
914 | PATH_MAX4096); | ||
915 | else | ||
916 | goto out; | ||
917 | } | ||
918 | |||
919 | if (_is_prefix (tmp_brickpath, tmp_path)) | ||
920 | goto out; | ||
921 | } | ||
922 | } | ||
923 | available = _gf_true; | ||
924 | out: | ||
925 | return available; | ||
926 | } | ||
927 | |||
928 | int | ||
929 | glusterd_validate_and_create_brickpath (glusterd_brickinfo_t *brickinfo, | ||
930 | uuid_t volume_id, char **op_errstr, | ||
931 | gf_boolean_t is_force) | ||
932 | { | ||
933 | int ret = -1; | ||
934 | char parentdir[PATH_MAX4096] = {0,}; | ||
935 | struct stat parent_st = {0,}; | ||
936 | struct stat brick_st = {0,}; | ||
937 | struct stat root_st = {0,}; | ||
938 | char msg[2048] = {0,}; | ||
939 | gf_boolean_t is_created = _gf_false; | ||
940 | |||
941 | ret = mkdir (brickinfo->path, 0777); | ||
942 | if (ret) { | ||
943 | if (errno(*__errno_location ()) != EEXIST17) { | ||
944 | snprintf (msg, sizeof (msg), "Failed to create brick " | ||
945 | "directory for brick %s:%s. Reason : %s ", | ||
946 | brickinfo->hostname, brickinfo->path, | ||
947 | strerror (errno(*__errno_location ()))); | ||
948 | goto out; | ||
949 | } | ||
950 | } else { | ||
951 | is_created = _gf_true; | ||
952 | } | ||
953 | |||
954 | ret = lstat (brickinfo->path, &brick_st); | ||
955 | if (ret) { | ||
956 | snprintf (msg, sizeof (msg), "lstat failed on %s. Reason : %s", | ||
957 | brickinfo->path, strerror (errno(*__errno_location ()))); | ||
958 | goto out; | ||
959 | } | ||
960 | |||
961 | if ((!is_created) && (!S_ISDIR (brick_st.st_mode)((((brick_st.st_mode)) & 0170000) == (0040000)))) { | ||
962 | snprintf (msg, sizeof (msg), "The provided path %s which is " | ||
963 | "already present, is not a directory", | ||
964 | brickinfo->path); | ||
965 | ret = -1; | ||
966 | goto out; | ||
967 | } | ||
968 | |||
969 | snprintf (parentdir, sizeof (parentdir), "%s/..", brickinfo->path); | ||
970 | |||
971 | ret = lstat ("/", &root_st); | ||
972 | if (ret) { | ||
973 | snprintf (msg, sizeof (msg), "lstat failed on /. Reason : %s", | ||
974 | strerror (errno(*__errno_location ()))); | ||
975 | goto out; | ||
976 | } | ||
977 | |||
978 | ret = lstat (parentdir, &parent_st); | ||
979 | if (ret) { | ||
980 | snprintf (msg, sizeof (msg), "lstat failed on %s. Reason : %s", | ||
981 | parentdir, strerror (errno(*__errno_location ()))); | ||
982 | goto out; | ||
983 | } | ||
984 | |||
985 | if (!is_force) { | ||
986 | if (brick_st.st_dev != parent_st.st_dev) { | ||
987 | snprintf (msg, sizeof (msg), "The brick %s:%s is a " | ||
988 | "mount point. Please create a sub-directory " | ||
989 | "under the mount point and use that as the " | ||
990 | "brick directory. Or use 'force' at the end " | ||
991 | "of the command if you want to override this " | ||
992 | "behavior.", brickinfo->hostname, | ||
993 | brickinfo->path); | ||
994 | ret = -1; | ||
995 | goto out; | ||
996 | } | ||
997 | else if (parent_st.st_dev == root_st.st_dev) { | ||
998 | snprintf (msg, sizeof (msg), "The brick %s:%s is " | ||
999 | "is being created in the root partition. It " | ||
1000 | "is recommended that you don't use the " | ||
1001 | "system's root partition for storage backend." | ||
1002 | " Or use 'force' at the end of the command if" | ||
1003 | " you want to override this behavior.", | ||
1004 | brickinfo->hostname, brickinfo->path); | ||
1005 | ret = -1; | ||
1006 | goto out; | ||
1007 | } | ||
1008 | } | ||
1009 | |||
1010 | ret = glusterd_check_and_set_brick_xattr (brickinfo->hostname, | ||
1011 | brickinfo->path, volume_id, | ||
1012 | op_errstr); | ||
1013 | if (ret) | ||
1014 | goto out; | ||
1015 | |||
1016 | ret = 0; | ||
1017 | |||
1018 | out: | ||
1019 | if (ret && is_created) | ||
1020 | rmdir (brickinfo->path); | ||
1021 | if (ret && !*op_errstr && msg[0] != '\0') | ||
1022 | *op_errstr = gf_strdup (msg); | ||
1023 | |||
1024 | return ret; | ||
1025 | } | ||
1026 | |||
1027 | int32_t | ||
1028 | glusterd_volume_brickinfo_get (uuid_t uuid, char *hostname, char *path, | ||
1029 | glusterd_volinfo_t *volinfo, | ||
1030 | glusterd_brickinfo_t **brickinfo) | ||
1031 | { | ||
1032 | glusterd_brickinfo_t *brickiter = NULL((void*)0); | ||
1033 | uuid_t peer_uuid = {0}; | ||
1034 | int32_t ret = -1; | ||
1035 | xlator_t *this = NULL((void*)0); | ||
1036 | |||
1037 | this = THIS(*__glusterfs_this_location()); | ||
1038 | |||
1039 | if (uuid) { | ||
1040 | uuid_copy (peer_uuid, uuid); | ||
1041 | } else { | ||
1042 | ret = glusterd_hostname_to_uuid (hostname, peer_uuid); | ||
1043 | if (ret) | ||
1044 | goto out; | ||
1045 | } | ||
1046 | ret = -1; | ||
1047 | list_for_each_entry (brickiter, &volinfo->bricks, brick_list)for (brickiter = ((typeof(*brickiter) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*brickiter ) *)0)->brick_list))); &brickiter->brick_list != (& volinfo->bricks); brickiter = ((typeof(*brickiter) *)((char *)(brickiter->brick_list.next)-(unsigned long)(&((typeof (*brickiter) *)0)->brick_list)))) { | ||
1048 | |||
1049 | if ((uuid_is_null (brickiter->uuid)) && | ||
1050 | (glusterd_resolve_brick (brickiter) != 0)) | ||
1051 | goto out; | ||
1052 | if (uuid_compare (peer_uuid, brickiter->uuid)) | ||
1053 | continue; | ||
1054 | |||
1055 | if (strcmp (brickiter->path, path) == 0) { | ||
1056 | gf_log (this->name, GF_LOG_DEBUG, LOGSTR_FOUND_BRICK,do { do { if (0) printf ("Found brick %s:%s in volume %s", brickiter ->hostname, brickiter->path, volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1058, GF_LOG_DEBUG, "Found brick %s:%s in volume %s", brickiter ->hostname, brickiter->path, volinfo->volname); } while (0) | ||
1057 | brickiter->hostname, brickiter->path,do { do { if (0) printf ("Found brick %s:%s in volume %s", brickiter ->hostname, brickiter->path, volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1058, GF_LOG_DEBUG, "Found brick %s:%s in volume %s", brickiter ->hostname, brickiter->path, volinfo->volname); } while (0) | ||
1058 | volinfo->volname)do { do { if (0) printf ("Found brick %s:%s in volume %s", brickiter ->hostname, brickiter->path, volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1058, GF_LOG_DEBUG, "Found brick %s:%s in volume %s", brickiter ->hostname, brickiter->path, volinfo->volname); } while (0); | ||
1059 | ret = 0; | ||
1060 | if (brickinfo) | ||
1061 | *brickinfo = brickiter; | ||
1062 | break; | ||
1063 | } | ||
1064 | } | ||
1065 | |||
1066 | out: | ||
1067 | 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-utils.c", __FUNCTION__, 1067, GF_LOG_DEBUG , "Returning %d", ret); } while (0); | ||
1068 | return ret; | ||
1069 | } | ||
1070 | |||
1071 | int32_t | ||
1072 | glusterd_volume_brickinfo_get_by_brick (char *brick, | ||
1073 | glusterd_volinfo_t *volinfo, | ||
1074 | glusterd_brickinfo_t **brickinfo) | ||
1075 | { | ||
1076 | int32_t ret = -1; | ||
1077 | glusterd_brickinfo_t *tmp_brickinfo = NULL((void*)0); | ||
1078 | |||
1079 | GF_ASSERT (brick)do { if (!(brick)) { do { do { if (0) printf ("Assertion failed: " "brick"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1079, GF_LOG_ERROR, "Assertion failed: " "brick" ); } while (0); } } while (0); | ||
1080 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1080, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
1081 | |||
1082 | ret = glusterd_brickinfo_new_from_brick (brick, &tmp_brickinfo); | ||
1083 | if (ret) | ||
1084 | goto out; | ||
1085 | |||
1086 | ret = glusterd_volume_brickinfo_get (NULL((void*)0), tmp_brickinfo->hostname, | ||
1087 | tmp_brickinfo->path, volinfo, | ||
1088 | brickinfo); | ||
1089 | (void) glusterd_brickinfo_delete (tmp_brickinfo); | ||
1090 | out: | ||
1091 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 1091, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | ||
1092 | return ret; | ||
1093 | } | ||
1094 | |||
1095 | gf_boolean_t | ||
1096 | glusterd_is_brick_decommissioned (glusterd_volinfo_t *volinfo, char *hostname, | ||
1097 | char *path) | ||
1098 | { | ||
1099 | gf_boolean_t decommissioned = _gf_false; | ||
1100 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
1101 | int ret = -1; | ||
1102 | |||
1103 | ret = glusterd_volume_brickinfo_get (NULL((void*)0), hostname, path, volinfo, | ||
1104 | &brickinfo); | ||
1105 | if (ret) | ||
1106 | goto out; | ||
1107 | decommissioned = brickinfo->decommissioned; | ||
1108 | out: | ||
1109 | return decommissioned; | ||
1110 | } | ||
1111 | |||
1112 | int32_t | ||
1113 | glusterd_friend_cleanup (glusterd_peerinfo_t *peerinfo) | ||
1114 | { | ||
1115 | GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: " "peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1115, GF_LOG_ERROR, "Assertion failed: " "peerinfo" ); } while (0); } } while (0); | ||
1116 | glusterd_peerctx_t *peerctx = NULL((void*)0); | ||
1117 | gf_boolean_t quorum_action = _gf_false; | ||
1118 | |||
1119 | if (peerinfo->quorum_contrib != QUORUM_NONE) | ||
1120 | quorum_action = _gf_true; | ||
1121 | if (peerinfo->rpc) { | ||
1122 | /* cleanup the saved-frames before last unref */ | ||
1123 | rpc_clnt_connection_cleanup (&peerinfo->rpc->conn); | ||
1124 | |||
1125 | peerctx = peerinfo->rpc->mydata; | ||
1126 | peerinfo->rpc->mydata = NULL((void*)0); | ||
1127 | peerinfo->rpc = rpc_clnt_unref (peerinfo->rpc); | ||
1128 | peerinfo->rpc = NULL((void*)0); | ||
1129 | if (peerctx) { | ||
1130 | GF_FREE (peerctx->errstr)__gf_free (peerctx->errstr); | ||
1131 | GF_FREE (peerctx)__gf_free (peerctx); | ||
1132 | } | ||
1133 | } | ||
1134 | glusterd_peer_destroy (peerinfo); | ||
1135 | |||
1136 | if (quorum_action) | ||
1137 | glusterd_do_quorum_action (); | ||
1138 | return 0; | ||
1139 | } | ||
1140 | |||
1141 | int32_t | ||
1142 | glusterd_volinfo_find (char *volname, glusterd_volinfo_t **volinfo) | ||
1143 | { | ||
1144 | glusterd_volinfo_t *tmp_volinfo = NULL((void*)0); | ||
1145 | int32_t ret = -1; | ||
1146 | xlator_t *this = NULL((void*)0); | ||
1147 | glusterd_conf_t *priv = NULL((void*)0); | ||
1148 | |||
1149 | GF_ASSERT (volname)do { if (!(volname)) { do { do { if (0) printf ("Assertion failed: " "volname"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1149, GF_LOG_ERROR, "Assertion failed: " "volname" ); } while (0); } } while (0); | ||
1150 | |||
1151 | this = THIS(*__glusterfs_this_location()); | ||
1152 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1152, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
1153 | |||
1154 | priv = this->private; | ||
1155 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1155, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
1156 | |||
1157 | list_for_each_entry (tmp_volinfo, &priv->volumes, vol_list)for (tmp_volinfo = ((typeof(*tmp_volinfo) *)((char *)((&priv ->volumes)->next)-(unsigned long)(&((typeof(*tmp_volinfo ) *)0)->vol_list))); &tmp_volinfo->vol_list != (& priv->volumes); tmp_volinfo = ((typeof(*tmp_volinfo) *)((char *)(tmp_volinfo->vol_list.next)-(unsigned long)(&((typeof (*tmp_volinfo) *)0)->vol_list)))) { | ||
1158 | if (!strcmp (tmp_volinfo->volname, volname)) { | ||
1159 | gf_log (this->name, GF_LOG_DEBUG, "Volume %s found", volname)do { do { if (0) printf ("Volume %s found", volname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1159, GF_LOG_DEBUG, "Volume %s found", volname); } while (0 ); | ||
1160 | ret = 0; | ||
1161 | *volinfo = tmp_volinfo; | ||
1162 | break; | ||
1163 | } | ||
1164 | } | ||
1165 | |||
1166 | 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-utils.c", __FUNCTION__, 1166, GF_LOG_DEBUG , "Returning %d", ret); } while (0); | ||
1167 | return ret; | ||
1168 | } | ||
1169 | |||
1170 | int32_t | ||
1171 | glusterd_service_stop (const char *service, char *pidfile, int sig, | ||
1172 | gf_boolean_t force_kill) | ||
1173 | { | ||
1174 | int32_t ret = -1; | ||
1175 | pid_t pid = -1; | ||
1176 | xlator_t *this = NULL((void*)0); | ||
1177 | |||
1178 | this = THIS(*__glusterfs_this_location()); | ||
1179 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1179, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
1180 | if (!glusterd_is_service_running (pidfile, &pid)) { | ||
1181 | ret = 0; | ||
1182 | gf_log (this->name, GF_LOG_INFO, "%s already stopped", service)do { do { if (0) printf ("%s already stopped", service); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1182, GF_LOG_INFO, "%s already stopped", service); } while ( 0); | ||
1183 | goto out; | ||
1184 | } | ||
1185 | gf_log (this->name, GF_LOG_DEBUG, "Stopping gluster %s running in pid: "do { do { if (0) printf ("Stopping gluster %s running in pid: " "%d", service, pid); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 1186, GF_LOG_DEBUG, "Stopping gluster %s running in pid: " "%d", service, pid); } while (0) | ||
1186 | "%d", service, pid)do { do { if (0) printf ("Stopping gluster %s running in pid: " "%d", service, pid); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 1186, GF_LOG_DEBUG, "Stopping gluster %s running in pid: " "%d", service, pid); } while (0); | ||
1187 | |||
1188 | ret = kill (pid, sig); | ||
1189 | if (!force_kill) | ||
1190 | goto out; | ||
1191 | |||
1192 | sleep (1); | ||
1193 | if (glusterd_is_service_running (pidfile, NULL((void*)0))) { | ||
1194 | ret = kill (pid, SIGKILL9); | ||
1195 | if (ret) { | ||
1196 | gf_log (this->name, GF_LOG_ERROR, "Unable to "do { do { if (0) printf ("Unable to " "kill pid %d reason: %s" , pid, strerror((*__errno_location ()))); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 1198, GF_LOG_ERROR , "Unable to " "kill pid %d reason: %s", pid, strerror((*__errno_location ()))); } while (0) | ||
1197 | "kill pid %d reason: %s", pid,do { do { if (0) printf ("Unable to " "kill pid %d reason: %s" , pid, strerror((*__errno_location ()))); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 1198, GF_LOG_ERROR , "Unable to " "kill pid %d reason: %s", pid, strerror((*__errno_location ()))); } while (0) | ||
1198 | strerror(errno))do { do { if (0) printf ("Unable to " "kill pid %d reason: %s" , pid, strerror((*__errno_location ()))); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 1198, GF_LOG_ERROR , "Unable to " "kill pid %d reason: %s", pid, strerror((*__errno_location ()))); } while (0); | ||
1199 | goto out; | ||
1200 | } | ||
1201 | } | ||
1202 | |||
1203 | ret = 0; | ||
1204 | out: | ||
1205 | return ret; | ||
1206 | } | ||
1207 | |||
1208 | void | ||
1209 | glusterd_set_socket_filepath (char *sock_filepath, char *sockpath, size_t len) | ||
1210 | { | ||
1211 | char md5_sum[MD5_DIGEST_LENGTH16*2+1] = {0,}; | ||
1212 | |||
1213 | md5_wrapper ((unsigned char *) sock_filepath, strlen(sock_filepath), md5_sum); | ||
1214 | snprintf (sockpath, len, "%s/%s.socket", GLUSTERD_SOCK_DIR"/var/run", md5_sum); | ||
1215 | } | ||
1216 | |||
1217 | void | ||
1218 | glusterd_set_brick_socket_filepath (glusterd_volinfo_t *volinfo, | ||
1219 | glusterd_brickinfo_t *brickinfo, | ||
1220 | char *sockpath, size_t len) | ||
1221 | { | ||
1222 | char export_path[PATH_MAX4096] = {0,}; | ||
1223 | char sock_filepath[PATH_MAX4096] = {0,}; | ||
1224 | char volume_dir[PATH_MAX4096] = {0,}; | ||
1225 | xlator_t *this = NULL((void*)0); | ||
1226 | glusterd_conf_t *priv = NULL((void*)0); | ||
1227 | int expected_file_len = 0; | ||
1228 | |||
1229 | expected_file_len = strlen (GLUSTERD_SOCK_DIR"/var/run") + strlen ("/") + | ||
1230 | MD5_DIGEST_LENGTH16*2 + strlen (".socket") + 1; | ||
1231 | GF_ASSERT (len >= expected_file_len)do { if (!(len >= expected_file_len)) { do { do { if (0) printf ("Assertion failed: " "len >= expected_file_len"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c", __FUNCTION__ , 1231, GF_LOG_ERROR, "Assertion failed: " "len >= expected_file_len" ); } while (0); } } while (0); | ||
1232 | this = THIS(*__glusterfs_this_location()); | ||
1233 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1233, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
1234 | |||
1235 | priv = this->private; | ||
1236 | |||
1237 | GLUSTERD_GET_VOLUME_DIR (volume_dir, volinfo, priv)snprintf (volume_dir, 4096, "%s/vols/%s", priv->workdir, volinfo ->volname);; | ||
1238 | GLUSTERD_REMOVE_SLASH_FROM_PATH (brickinfo->path, export_path)do { int i = 0; for (i = 1; i < strlen (brickinfo->path ); i++) { export_path[i-1] = brickinfo->path[i]; if (export_path [i-1] == '/') export_path[i-1] = '-'; } } while (0); | ||
1239 | snprintf (sock_filepath, PATH_MAX4096, "%s/run/%s-%s", | ||
1240 | volume_dir, brickinfo->hostname, export_path); | ||
1241 | |||
1242 | glusterd_set_socket_filepath (sock_filepath, sockpath, len); | ||
1243 | } | ||
1244 | |||
1245 | /* connection happens only if it is not aleady connected, | ||
1246 | * reconnections are taken care by rpc-layer | ||
1247 | */ | ||
1248 | int32_t | ||
1249 | glusterd_brick_connect (glusterd_volinfo_t *volinfo, | ||
1250 | glusterd_brickinfo_t *brickinfo) | ||
1251 | { | ||
1252 | int ret = 0; | ||
1253 | char socketpath[PATH_MAX4096] = {0}; | ||
1254 | dict_t *options = NULL((void*)0); | ||
1255 | struct rpc_clnt *rpc = NULL((void*)0); | ||
1256 | glusterd_conf_t *priv = THIS(*__glusterfs_this_location())->private; | ||
1257 | |||
1258 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1258, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
1259 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1259, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
1260 | |||
1261 | if (brickinfo->rpc == NULL((void*)0)) { | ||
1262 | glusterd_set_brick_socket_filepath (volinfo, brickinfo, | ||
1263 | socketpath, | ||
1264 | sizeof (socketpath)); | ||
1265 | |||
1266 | /* Setting frame-timeout to 10mins (600seconds). | ||
1267 | * Unix domain sockets ensures that the connection is reliable. | ||
1268 | * The default timeout of 30mins used for unreliable network | ||
1269 | * connections is too long for unix domain socket connections. | ||
1270 | */ | ||
1271 | ret = rpc_clnt_transport_unix_options_build (&options, | ||
1272 | socketpath, 600); | ||
1273 | if (ret) | ||
1274 | goto out; | ||
1275 | synclock_unlock (&priv->big_lock); | ||
1276 | ret = glusterd_rpc_create (&rpc, options, | ||
1277 | glusterd_brick_rpc_notify, | ||
1278 | brickinfo); | ||
1279 | synclock_lock (&priv->big_lock); | ||
1280 | if (ret) | ||
1281 | goto out; | ||
1282 | brickinfo->rpc = rpc; | ||
1283 | } | ||
1284 | out: | ||
1285 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 1285, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | ||
1286 | return ret; | ||
1287 | } | ||
1288 | |||
1289 | /* Caller should ensure that brick process is not running*/ | ||
1290 | static void | ||
1291 | _reap_brick_process (char *pidfile, char *brickpath) | ||
1292 | { | ||
1293 | unlink (pidfile); | ||
1294 | /* Brick process is not running and pmap may have an entry for it.*/ | ||
1295 | pmap_registry_remove (THIS(*__glusterfs_this_location()), 0, brickpath, | ||
1296 | GF_PMAP_PORT_BRICKSERVER, NULL((void*)0)); | ||
1297 | } | ||
1298 | |||
1299 | static int | ||
1300 | _mk_rundir_p (glusterd_volinfo_t *volinfo) | ||
1301 | { | ||
1302 | char voldir[PATH_MAX4096] = {0,}; | ||
1303 | char rundir[PATH_MAX4096] = {0,}; | ||
1304 | glusterd_conf_t *priv = NULL((void*)0); | ||
1305 | xlator_t *this = NULL((void*)0); | ||
1306 | int ret = -1; | ||
1307 | |||
1308 | this = THIS(*__glusterfs_this_location()); | ||
1309 | priv = this->private; | ||
1310 | GLUSTERD_GET_VOLUME_DIR (voldir, volinfo, priv)snprintf (voldir, 4096, "%s/vols/%s", priv->workdir, volinfo ->volname);; | ||
1311 | snprintf (rundir, sizeof (rundir)-1, "%s/run", voldir); | ||
1312 | ret = mkdir_p (rundir, 0777, _gf_true); | ||
1313 | if (ret) | ||
1314 | gf_log (this->name, GF_LOG_ERROR, "Failed to create rundir")do { do { if (0) printf ("Failed to create rundir"); } while ( 0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 1314, GF_LOG_ERROR, "Failed to create rundir"); } while (0); | ||
1315 | return ret; | ||
1316 | } | ||
1317 | |||
1318 | int32_t | ||
1319 | glusterd_volume_start_glusterfs (glusterd_volinfo_t *volinfo, | ||
1320 | glusterd_brickinfo_t *brickinfo, | ||
1321 | gf_boolean_t wait) | ||
1322 | { | ||
1323 | int32_t ret = -1; | ||
1324 | xlator_t *this = NULL((void*)0); | ||
1325 | glusterd_conf_t *priv = NULL((void*)0); | ||
1326 | char pidfile[PATH_MAX4096+1] = {0,}; | ||
1327 | char volfile[PATH_MAX4096] = {0,}; | ||
1328 | runner_t runner = {0,}; | ||
1329 | char exp_path[PATH_MAX4096] = {0,}; | ||
1330 | char logfile[PATH_MAX4096] = {0,}; | ||
1331 | int port = 0; | ||
1332 | int rdma_port = 0; | ||
1333 | char socketpath[PATH_MAX4096] = {0}; | ||
1334 | char glusterd_uuid[1024] = {0,}; | ||
1335 | char valgrind_logfile[PATH_MAX4096] = {0}; | ||
1336 | |||
1337 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1337, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
1338 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1338, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
1339 | |||
1340 | this = THIS(*__glusterfs_this_location()); | ||
1341 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1341, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
1342 | |||
1343 | priv = this->private; | ||
1344 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1344, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
1345 | |||
1346 | ret = _mk_rundir_p (volinfo); | ||
1347 | if (ret) | ||
1348 | goto out; | ||
1349 | GLUSTERD_GET_BRICK_PIDFILE (pidfile, volinfo, brickinfo, priv)do { char exp_path[4096] = {0,}; char volpath[4096] = {0,}; snprintf (volpath, 4096, "%s/vols/%s", priv->workdir, volinfo-> volname);; do { int i = 0; for (i = 1; i < strlen (brickinfo ->path); i++) { exp_path[i-1] = brickinfo->path[i]; if ( exp_path[i-1] == '/') exp_path[i-1] = '-'; } } while (0); snprintf (pidfile, 4096, "%s/run/%s-%s.pid", volpath, brickinfo->hostname , exp_path); } while (0); | ||
1350 | if (glusterd_is_service_running (pidfile, NULL((void*)0))) | ||
1351 | goto connect; | ||
1352 | |||
1353 | _reap_brick_process (pidfile, brickinfo->path); | ||
1354 | |||
1355 | port = brickinfo->port; | ||
1356 | if (!port) | ||
1357 | port = pmap_registry_alloc (THIS(*__glusterfs_this_location())); | ||
1358 | |||
1359 | runinit (&runner); | ||
1360 | |||
1361 | if (priv->valgrind) { | ||
1362 | /* Run bricks with valgrind */ | ||
1363 | if (volinfo->logdir) { | ||
1364 | snprintf (valgrind_logfile, PATH_MAX4096, | ||
1365 | "%s/valgrind-%s-%s.log", | ||
1366 | volinfo->logdir, | ||
1367 | volinfo->volname, exp_path); | ||
1368 | } else { | ||
1369 | snprintf (valgrind_logfile, PATH_MAX4096, | ||
1370 | "%s/bricks/valgrind-%s-%s.log", | ||
1371 | DEFAULT_LOG_FILE_DIRECTORY"/usr/local/var" "/log/glusterfs", | ||
1372 | volinfo->volname, exp_path); | ||
1373 | } | ||
1374 | |||
1375 | runner_add_args (&runner, "valgrind", "--leak-check=full", | ||
1376 | "--trace-children=yes", "--track-origins=yes", | ||
1377 | NULL((void*)0)); | ||
1378 | runner_argprintf (&runner, "--log-file=%s", valgrind_logfile); | ||
1379 | } | ||
1380 | |||
1381 | GLUSTERD_REMOVE_SLASH_FROM_PATH (brickinfo->path, exp_path)do { int i = 0; for (i = 1; i < strlen (brickinfo->path ); i++) { exp_path[i-1] = brickinfo->path[i]; if (exp_path [i-1] == '/') exp_path[i-1] = '-'; } } while (0); | ||
1382 | snprintf (volfile, PATH_MAX4096, "%s.%s.%s", volinfo->volname, | ||
1383 | brickinfo->hostname, exp_path); | ||
1384 | |||
1385 | if (volinfo->logdir) { | ||
1386 | snprintf (logfile, PATH_MAX4096, "%s/%s.log", | ||
1387 | volinfo->logdir, exp_path); | ||
1388 | } else { | ||
1389 | snprintf (logfile, PATH_MAX4096, "%s/bricks/%s.log", | ||
1390 | DEFAULT_LOG_FILE_DIRECTORY"/usr/local/var" "/log/glusterfs", exp_path); | ||
1391 | } | ||
1392 | if (!brickinfo->logfile) | ||
1393 | brickinfo->logfile = gf_strdup (logfile); | ||
1394 | |||
1395 | glusterd_set_brick_socket_filepath (volinfo, brickinfo, socketpath, | ||
1396 | sizeof (socketpath)); | ||
1397 | |||
1398 | (void) snprintf (glusterd_uuid, 1024, "*-posix.glusterd-uuid=%s", | ||
1399 | uuid_utoa (MY_UUID(__glusterd_uuid()))); | ||
1400 | runner_add_args (&runner, SBIN_DIR"/usr/local/sbin""/glusterfsd", | ||
1401 | "-s", brickinfo->hostname, "--volfile-id", volfile, | ||
1402 | "-p", pidfile, "-S", socketpath, | ||
1403 | "--brick-name", brickinfo->path, | ||
1404 | "-l", brickinfo->logfile, | ||
1405 | "--xlator-option", glusterd_uuid, | ||
1406 | NULL((void*)0)); | ||
1407 | |||
1408 | runner_add_arg (&runner, "--brick-port"); | ||
1409 | if (volinfo->transport_type != GF_TRANSPORT_BOTH_TCP_RDMA) { | ||
1410 | runner_argprintf (&runner, "%d", port); | ||
1411 | } else { | ||
1412 | rdma_port = brickinfo->rdma_port; | ||
1413 | if (!rdma_port) | ||
1414 | rdma_port = pmap_registry_alloc (THIS(*__glusterfs_this_location())); | ||
1415 | runner_argprintf (&runner, "%d,%d", port, rdma_port); | ||
1416 | runner_add_arg (&runner, "--xlator-option"); | ||
1417 | runner_argprintf (&runner, "%s-server.transport.rdma.listen-port=%d", | ||
1418 | volinfo->volname, rdma_port); | ||
1419 | } | ||
1420 | |||
1421 | runner_add_arg (&runner, "--xlator-option"); | ||
1422 | runner_argprintf (&runner, "%s-server.listen-port=%d", | ||
1423 | volinfo->volname, port); | ||
1424 | |||
1425 | if (volinfo->memory_accounting) | ||
1426 | runner_add_arg (&runner, "--mem-accounting"); | ||
1427 | |||
1428 | runner_log (&runner, "", GF_LOG_DEBUG, "Starting GlusterFS"); | ||
1429 | if (wait) { | ||
1430 | synclock_unlock (&priv->big_lock); | ||
1431 | ret = runner_run (&runner); | ||
1432 | synclock_lock (&priv->big_lock); | ||
1433 | |||
1434 | } else { | ||
1435 | ret = runner_run_nowait (&runner); | ||
1436 | } | ||
1437 | |||
1438 | if (ret) | ||
1439 | goto out; | ||
1440 | |||
1441 | brickinfo->port = port; | ||
1442 | brickinfo->rdma_port = rdma_port; | ||
1443 | |||
1444 | connect: | ||
1445 | ret = glusterd_brick_connect (volinfo, brickinfo); | ||
1446 | if (ret) | ||
1447 | goto out; | ||
1448 | out: | ||
1449 | return ret; | ||
1450 | } | ||
1451 | |||
1452 | int32_t | ||
1453 | glusterd_brick_unlink_socket_file (glusterd_volinfo_t *volinfo, | ||
1454 | glusterd_brickinfo_t *brickinfo) | ||
1455 | { | ||
1456 | char path[PATH_MAX4096] = {0,}; | ||
1457 | char socketpath[PATH_MAX4096] = {0}; | ||
1458 | xlator_t *this = NULL((void*)0); | ||
1459 | glusterd_conf_t *priv = NULL((void*)0); | ||
1460 | int ret = 0; | ||
1461 | |||
1462 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1462, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
1463 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1463, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
1464 | |||
1465 | this = THIS(*__glusterfs_this_location()); | ||
1466 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1466, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
1467 | |||
1468 | priv = this->private; | ||
1469 | GLUSTERD_GET_VOLUME_DIR (path, volinfo, priv)snprintf (path, 4096, "%s/vols/%s", priv->workdir, volinfo ->volname);; | ||
1470 | glusterd_set_brick_socket_filepath (volinfo, brickinfo, socketpath, | ||
1471 | sizeof (socketpath)); | ||
1472 | ret = unlink (socketpath); | ||
1473 | if (ret && (ENOENT2 == errno(*__errno_location ()))) { | ||
1474 | ret = 0; | ||
1475 | } else { | ||
1476 | gf_log (this->name, GF_LOG_ERROR, "Failed to remove %s"do { do { if (0) printf ("Failed to remove %s" " error: %s", socketpath , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 1477, GF_LOG_ERROR , "Failed to remove %s" " error: %s", socketpath, strerror (( *__errno_location ()))); } while (0) | ||
1477 | " error: %s", socketpath, strerror (errno))do { do { if (0) printf ("Failed to remove %s" " error: %s", socketpath , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 1477, GF_LOG_ERROR , "Failed to remove %s" " error: %s", socketpath, strerror (( *__errno_location ()))); } while (0); | ||
1478 | } | ||
1479 | |||
1480 | return ret; | ||
1481 | } | ||
1482 | |||
1483 | int32_t | ||
1484 | glusterd_brick_disconnect (glusterd_brickinfo_t *brickinfo) | ||
1485 | { | ||
1486 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1486, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
1487 | |||
1488 | if (brickinfo->rpc) { | ||
1489 | /* cleanup the saved-frames before last unref */ | ||
1490 | rpc_clnt_connection_cleanup (&brickinfo->rpc->conn); | ||
1491 | |||
1492 | rpc_clnt_unref (brickinfo->rpc); | ||
1493 | brickinfo->rpc = NULL((void*)0); | ||
1494 | } | ||
1495 | return 0; | ||
1496 | } | ||
1497 | |||
1498 | int32_t | ||
1499 | glusterd_volume_stop_glusterfs (glusterd_volinfo_t *volinfo, | ||
1500 | glusterd_brickinfo_t *brickinfo, | ||
1501 | gf_boolean_t del_brick) | ||
1502 | { | ||
1503 | xlator_t *this = NULL((void*)0); | ||
1504 | glusterd_conf_t *priv = NULL((void*)0); | ||
1505 | char pidfile[PATH_MAX4096] = {0,}; | ||
1506 | int ret = 0; | ||
1507 | |||
1508 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1508, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
1509 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1509, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
1510 | |||
1511 | this = THIS(*__glusterfs_this_location()); | ||
1512 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1512, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
1513 | |||
1514 | priv = this->private; | ||
1515 | if (del_brick) | ||
1516 | list_del_init (&brickinfo->brick_list); | ||
1517 | |||
1518 | if (GLUSTERD_STATUS_STARTED == volinfo->status) { | ||
1519 | (void) glusterd_brick_disconnect (brickinfo); | ||
1520 | GLUSTERD_GET_BRICK_PIDFILE (pidfile, volinfo, brickinfo, priv)do { char exp_path[4096] = {0,}; char volpath[4096] = {0,}; snprintf (volpath, 4096, "%s/vols/%s", priv->workdir, volinfo-> volname);; do { int i = 0; for (i = 1; i < strlen (brickinfo ->path); i++) { exp_path[i-1] = brickinfo->path[i]; if ( exp_path[i-1] == '/') exp_path[i-1] = '-'; } } while (0); snprintf (pidfile, 4096, "%s/run/%s-%s.pid", volpath, brickinfo->hostname , exp_path); } while (0); | ||
1521 | ret = glusterd_service_stop ("brick", pidfile, SIGTERM15, _gf_false); | ||
1522 | if (ret == 0) { | ||
1523 | glusterd_set_brick_status (brickinfo, GF_BRICK_STOPPED); | ||
1524 | (void) glusterd_brick_unlink_socket_file (volinfo, brickinfo); | ||
1525 | } | ||
1526 | } | ||
1527 | |||
1528 | if (del_brick) | ||
1529 | glusterd_delete_brick (volinfo, brickinfo); | ||
1530 | |||
1531 | return ret; | ||
1532 | } | ||
1533 | |||
1534 | int32_t | ||
1535 | glusterd_peer_hostname_new (char *hostname, glusterd_peer_hostname_t **name) | ||
1536 | { | ||
1537 | glusterd_peer_hostname_t *peer_hostname = NULL((void*)0); | ||
1538 | int32_t ret = -1; | ||
1539 | |||
1540 | GF_ASSERT (hostname)do { if (!(hostname)) { do { do { if (0) printf ("Assertion failed: " "hostname"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1540, GF_LOG_ERROR, "Assertion failed: " "hostname" ); } while (0); } } while (0); | ||
1541 | GF_ASSERT (name)do { if (!(name)) { do { do { if (0) printf ("Assertion failed: " "name"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1541, GF_LOG_ERROR, "Assertion failed: " "name" ); } while (0); } } while (0); | ||
1542 | |||
1543 | peer_hostname = GF_CALLOC (1, sizeof (*peer_hostname),__gf_calloc (1, sizeof (*peer_hostname), gf_gld_mt_peer_hostname_t ) | ||
1544 | gf_gld_mt_peer_hostname_t)__gf_calloc (1, sizeof (*peer_hostname), gf_gld_mt_peer_hostname_t ); | ||
1545 | |||
1546 | if (!peer_hostname) | ||
1547 | goto out; | ||
1548 | |||
1549 | peer_hostname->hostname = gf_strdup (hostname); | ||
1550 | INIT_LIST_HEAD (&peer_hostname->hostname_list)do { (&peer_hostname->hostname_list)->next = (& peer_hostname->hostname_list)->prev = &peer_hostname ->hostname_list; } while (0); | ||
1551 | |||
1552 | *name = peer_hostname; | ||
1553 | ret = 0; | ||
1554 | |||
1555 | out: | ||
1556 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 1556, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | ||
1557 | return ret; | ||
1558 | } | ||
1559 | |||
1560 | /* Free LINE[0..N-1] and then the LINE buffer. */ | ||
1561 | static void | ||
1562 | free_lines (char **line, size_t n) | ||
1563 | { | ||
1564 | size_t i; | ||
1565 | for (i = 0; i < n; i++) | ||
1566 | GF_FREE (line[i])__gf_free (line[i]); | ||
1567 | GF_FREE (line)__gf_free (line); | ||
1568 | } | ||
1569 | |||
1570 | char ** | ||
1571 | glusterd_readin_file (const char *filepath, int *line_count) | ||
1572 | { | ||
1573 | int ret = -1; | ||
1574 | int n = 8; | ||
1575 | int counter = 0; | ||
1576 | char buffer[PATH_MAX4096 + 256] = {0}; | ||
1577 | char **lines = NULL((void*)0); | ||
1578 | FILE *fp = NULL((void*)0); | ||
1579 | void *p; | ||
1580 | |||
1581 | fp = fopen (filepath, "r"); | ||
1582 | if (!fp) | ||
1583 | goto out; | ||
1584 | |||
1585 | lines = GF_CALLOC (1, n * sizeof (*lines), gf_gld_mt_charptr)__gf_calloc (1, n * sizeof (*lines), gf_gld_mt_charptr); | ||
1586 | if (!lines) | ||
1587 | goto out; | ||
1588 | |||
1589 | for (counter = 0; fgets (buffer, sizeof (buffer), fp); counter++) { | ||
1590 | |||
1591 | if (counter == n-1) { | ||
1592 | n *= 2; | ||
1593 | p = GF_REALLOC (lines, n * sizeof (char *))__gf_realloc (lines, n * sizeof (char *)); | ||
1594 | if (!p) { | ||
1595 | free_lines (lines, n/2); | ||
1596 | lines = NULL((void*)0); | ||
1597 | goto out; | ||
1598 | } | ||
1599 | lines = p; | ||
1600 | } | ||
1601 | |||
1602 | lines[counter] = gf_strdup (buffer); | ||
1603 | } | ||
1604 | |||
1605 | lines[counter] = NULL((void*)0); | ||
1606 | /* Reduce allocation to minimal size. */ | ||
1607 | p = GF_REALLOC (lines, (counter + 1) * sizeof (char *))__gf_realloc (lines, (counter + 1) * sizeof (char *)); | ||
1608 | if (!p) { | ||
1609 | free_lines (lines, counter); | ||
1610 | lines = NULL((void*)0); | ||
1611 | goto out; | ||
1612 | } | ||
1613 | lines = p; | ||
1614 | |||
1615 | *line_count = counter; | ||
1616 | ret = 0; | ||
1617 | |||
1618 | out: | ||
1619 | if (ret) | ||
1620 | gf_log (THIS->name, GF_LOG_ERROR, "%s", strerror (errno))do { do { if (0) printf ("%s", strerror ((*__errno_location ( )))); } while (0); _gf_log ((*__glusterfs_this_location())-> name, "glusterd-utils.c", __FUNCTION__, 1620, GF_LOG_ERROR, "%s" , strerror ((*__errno_location ()))); } while (0); | ||
1621 | if (fp) | ||
1622 | fclose (fp); | ||
1623 | |||
1624 | return lines; | ||
1625 | } | ||
1626 | |||
1627 | int | ||
1628 | glusterd_compare_lines (const void *a, const void *b) { | ||
1629 | |||
1630 | return strcmp(* (char * const *) a, * (char * const *) b); | ||
1631 | } | ||
1632 | |||
1633 | int | ||
1634 | glusterd_sort_and_redirect (const char *src_filepath, int dest_fd) | ||
1635 | { | ||
1636 | int ret = -1; | ||
1637 | int line_count = 0; | ||
1638 | int counter = 0; | ||
1639 | char **lines = NULL((void*)0); | ||
1640 | |||
1641 | |||
1642 | if (!src_filepath || dest_fd < 0) | ||
1643 | goto out; | ||
1644 | |||
1645 | lines = glusterd_readin_file (src_filepath, &line_count); | ||
1646 | if (!lines) | ||
1647 | goto out; | ||
1648 | |||
1649 | qsort (lines, line_count, sizeof (*lines), glusterd_compare_lines); | ||
1650 | |||
1651 | for (counter = 0; lines[counter]; counter++) { | ||
1652 | |||
1653 | ret = write (dest_fd, lines[counter], | ||
1654 | strlen (lines[counter])); | ||
1655 | if (ret < 0) | ||
1656 | goto out; | ||
1657 | |||
1658 | GF_FREE (lines[counter])__gf_free (lines[counter]); | ||
1659 | } | ||
1660 | |||
1661 | ret = 0; | ||
1662 | out: | ||
1663 | GF_FREE (lines)__gf_free (lines); | ||
1664 | |||
1665 | return ret; | ||
1666 | } | ||
1667 | |||
1668 | int | ||
1669 | glusterd_volume_compute_cksum (glusterd_volinfo_t *volinfo) | ||
1670 | { | ||
1671 | int32_t ret = -1; | ||
1672 | glusterd_conf_t *priv = NULL((void*)0); | ||
1673 | char path[PATH_MAX4096] = {0,}; | ||
1674 | char cksum_path[PATH_MAX4096] = {0,}; | ||
1675 | char filepath[PATH_MAX4096] = {0,}; | ||
1676 | int fd = -1; | ||
1677 | uint32_t cksum = 0; | ||
1678 | char buf[4096] = {0,}; | ||
1679 | char sort_filepath[PATH_MAX4096] = {0}; | ||
1680 | gf_boolean_t unlink_sortfile = _gf_false; | ||
1681 | int sort_fd = 0; | ||
1682 | xlator_t *this = NULL((void*)0); | ||
1683 | |||
1684 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1684, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
1685 | this = THIS(*__glusterfs_this_location()); | ||
1686 | priv = THIS(*__glusterfs_this_location())->private; | ||
1687 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1687, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
1688 | |||
1689 | GLUSTERD_GET_VOLUME_DIR (path, volinfo, priv)snprintf (path, 4096, "%s/vols/%s", priv->workdir, volinfo ->volname);; | ||
1690 | |||
1691 | snprintf (cksum_path, sizeof (cksum_path), "%s/%s", | ||
1692 | path, GLUSTERD_CKSUM_FILE"cksum"); | ||
1693 | |||
1694 | fd = open (cksum_path, O_RDWR02 | O_APPEND02000 | O_CREAT0100| O_TRUNC01000, 0600); | ||
1695 | |||
1696 | if (-1 == fd) { | ||
1697 | gf_log (this->name, GF_LOG_ERROR, "Unable to open %s, errno: %d",do { do { if (0) printf ("Unable to open %s, errno: %d", cksum_path , (*__errno_location ())); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 1698, GF_LOG_ERROR, "Unable to open %s, errno: %d" , cksum_path, (*__errno_location ())); } while (0) | ||
1698 | cksum_path, errno)do { do { if (0) printf ("Unable to open %s, errno: %d", cksum_path , (*__errno_location ())); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 1698, GF_LOG_ERROR, "Unable to open %s, errno: %d" , cksum_path, (*__errno_location ())); } while (0); | ||
1699 | ret = -1; | ||
1700 | goto out; | ||
1701 | } | ||
1702 | |||
1703 | snprintf (filepath, sizeof (filepath), "%s/%s", path, | ||
1704 | GLUSTERD_VOLUME_INFO_FILE"info"); | ||
1705 | snprintf (sort_filepath, sizeof (sort_filepath), "/tmp/%s.XXXXXX", | ||
1706 | volinfo->volname); | ||
1707 | |||
1708 | sort_fd = mkstemp (sort_filepath); | ||
1709 | if (sort_fd < 0) { | ||
1710 | gf_log (this->name, GF_LOG_ERROR, "Could not generate temp "do { do { if (0) printf ("Could not generate temp " "file, reason: %s for volume: %s" , strerror ((*__errno_location ())), volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1712, GF_LOG_ERROR, "Could not generate temp " "file, reason: %s for volume: %s" , strerror ((*__errno_location ())), volinfo->volname); } while (0) | ||
1711 | "file, reason: %s for volume: %s", strerror (errno),do { do { if (0) printf ("Could not generate temp " "file, reason: %s for volume: %s" , strerror ((*__errno_location ())), volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1712, GF_LOG_ERROR, "Could not generate temp " "file, reason: %s for volume: %s" , strerror ((*__errno_location ())), volinfo->volname); } while (0) | ||
1712 | volinfo->volname)do { do { if (0) printf ("Could not generate temp " "file, reason: %s for volume: %s" , strerror ((*__errno_location ())), volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1712, GF_LOG_ERROR, "Could not generate temp " "file, reason: %s for volume: %s" , strerror ((*__errno_location ())), volinfo->volname); } while (0); | ||
1713 | goto out; | ||
1714 | } else { | ||
1715 | unlink_sortfile = _gf_true; | ||
1716 | } | ||
1717 | |||
1718 | /* sort the info file, result in sort_filepath */ | ||
1719 | |||
1720 | ret = glusterd_sort_and_redirect (filepath, sort_fd); | ||
1721 | if (ret) { | ||
1722 | gf_log (this->name, GF_LOG_ERROR, "sorting info file failed")do { do { if (0) printf ("sorting info file failed"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 1722, GF_LOG_ERROR, "sorting info file failed"); } while (0 ); | ||
1723 | goto out; | ||
1724 | } | ||
1725 | |||
1726 | ret = close (sort_fd); | ||
1727 | if (ret) | ||
1728 | goto out; | ||
1729 | |||
1730 | ret = get_checksum_for_path (sort_filepath, &cksum); | ||
1731 | |||
1732 | if (ret) { | ||
1733 | gf_log (this->name, GF_LOG_ERROR, "Unable to get checksum"do { do { if (0) printf ("Unable to get checksum" " for path: %s" , sort_filepath); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 1734, GF_LOG_ERROR, "Unable to get checksum" " for path: %s" , sort_filepath); } while (0) | ||
1734 | " for path: %s", sort_filepath)do { do { if (0) printf ("Unable to get checksum" " for path: %s" , sort_filepath); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 1734, GF_LOG_ERROR, "Unable to get checksum" " for path: %s" , sort_filepath); } while (0); | ||
1735 | goto out; | ||
1736 | } | ||
1737 | |||
1738 | snprintf (buf, sizeof (buf), "%s=%u\n", "info", cksum); | ||
1739 | ret = write (fd, buf, strlen (buf)); | ||
1740 | |||
1741 | if (ret <= 0) { | ||
1742 | ret = -1; | ||
1743 | goto out; | ||
1744 | } | ||
1745 | |||
1746 | ret = get_checksum_for_file (fd, &cksum); | ||
1747 | |||
1748 | if (ret) | ||
1749 | goto out; | ||
1750 | |||
1751 | volinfo->cksum = cksum; | ||
1752 | |||
1753 | out: | ||
1754 | if (fd > 0) | ||
1755 | close (fd); | ||
1756 | if (unlink_sortfile) | ||
1757 | unlink (sort_filepath); | ||
1758 | 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-utils.c", __FUNCTION__, 1758, GF_LOG_DEBUG, "Returning with %d", ret); } while (0); | ||
1759 | |||
1760 | return ret; | ||
1761 | } | ||
1762 | |||
1763 | int | ||
1764 | _add_dict_to_prdict (dict_t *this, char *key, data_t *value, void *data) | ||
1765 | { | ||
1766 | glusterd_dict_ctx_t *ctx = NULL((void*)0); | ||
1767 | char optkey[512] = {0,}; | ||
1768 | int ret = -1; | ||
1769 | |||
1770 | ctx = data; | ||
1771 | snprintf (optkey, sizeof (optkey), "%s.%s%d", ctx->prefix, | ||
1772 | ctx->key_name, ctx->opt_count); | ||
1773 | ret = dict_set_str (ctx->dict, optkey, key); | ||
1774 | if (ret) | ||
1775 | gf_log ("", GF_LOG_ERROR, "option add for %s%d %s",do { do { if (0) printf ("option add for %s%d %s", ctx->key_name , ctx->opt_count, key); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 1776, GF_LOG_ERROR, "option add for %s%d %s", ctx->key_name, ctx->opt_count, key); } while (0) | ||
1776 | ctx->key_name, ctx->opt_count, key)do { do { if (0) printf ("option add for %s%d %s", ctx->key_name , ctx->opt_count, key); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 1776, GF_LOG_ERROR, "option add for %s%d %s", ctx->key_name, ctx->opt_count, key); } while (0); | ||
1777 | snprintf (optkey, sizeof (optkey), "%s.%s%d", ctx->prefix, | ||
1778 | ctx->val_name, ctx->opt_count); | ||
1779 | ret = dict_set_str (ctx->dict, optkey, value->data); | ||
1780 | if (ret) | ||
1781 | gf_log ("", GF_LOG_ERROR, "option add for %s%d %s",do { do { if (0) printf ("option add for %s%d %s", ctx->val_name , ctx->opt_count, value->data); } while (0); _gf_log ("" , "glusterd-utils.c", __FUNCTION__, 1782, GF_LOG_ERROR, "option add for %s%d %s" , ctx->val_name, ctx->opt_count, value->data); } while (0) | ||
1782 | ctx->val_name, ctx->opt_count, value->data)do { do { if (0) printf ("option add for %s%d %s", ctx->val_name , ctx->opt_count, value->data); } while (0); _gf_log ("" , "glusterd-utils.c", __FUNCTION__, 1782, GF_LOG_ERROR, "option add for %s%d %s" , ctx->val_name, ctx->opt_count, value->data); } while (0); | ||
1783 | ctx->opt_count++; | ||
1784 | |||
1785 | return ret; | ||
1786 | } | ||
1787 | |||
1788 | int32_t | ||
1789 | glusterd_add_bricks_hname_path_to_dict (dict_t *dict, | ||
1790 | glusterd_volinfo_t *volinfo) | ||
1791 | { | ||
1792 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
1793 | int ret = 0; | ||
1794 | char key[256] = {0}; | ||
1795 | int index = 0; | ||
1796 | |||
1797 | |||
1798 | 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)))) { | ||
1799 | snprintf (key, sizeof (key), "%d-hostname", index); | ||
1800 | ret = dict_set_str (dict, key, brickinfo->hostname); | ||
1801 | if (ret) | ||
1802 | goto out; | ||
1803 | |||
1804 | snprintf (key, sizeof (key), "%d-path", index); | ||
1805 | ret = dict_set_str (dict, key, brickinfo->path); | ||
1806 | if (ret) | ||
1807 | goto out; | ||
1808 | |||
1809 | index++; | ||
1810 | } | ||
1811 | out: | ||
1812 | return ret; | ||
1813 | } | ||
1814 | |||
1815 | int32_t | ||
1816 | glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, | ||
1817 | dict_t *dict, int32_t count) | ||
1818 | { | ||
1819 | int32_t ret = -1; | ||
1820 | char prefix[512] = {0,}; | ||
1821 | char key[512] = {0,}; | ||
1822 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
1823 | int32_t i = 1; | ||
1824 | char *volume_id_str = NULL((void*)0); | ||
1825 | char *src_brick = NULL((void*)0); | ||
1826 | char *dst_brick = NULL((void*)0); | ||
1827 | char *str = NULL((void*)0); | ||
1828 | glusterd_dict_ctx_t ctx = {0}; | ||
1829 | char *rebalance_id_str = NULL((void*)0); | ||
1830 | char *rb_id_str = NULL((void*)0); | ||
1831 | |||
1832 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1832, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | ||
1833 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 1833, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
1834 | |||
1835 | snprintf (key, sizeof (key), "volume%d.name", count); | ||
1836 | ret = dict_set_str (dict, key, volinfo->volname); | ||
1837 | if (ret) | ||
1838 | goto out; | ||
1839 | |||
1840 | memset (key, 0, sizeof (key)); | ||
1841 | snprintf (key, sizeof (key), "volume%d.type", count); | ||
1842 | ret = dict_set_int32 (dict, key, volinfo->type); | ||
1843 | if (ret) | ||
1844 | goto out; | ||
1845 | |||
1846 | memset (key, 0, sizeof (key)); | ||
1847 | snprintf (key, sizeof (key), "volume%d.brick_count", count); | ||
1848 | ret = dict_set_int32 (dict, key, volinfo->brick_count); | ||
1849 | if (ret) | ||
1850 | goto out; | ||
1851 | |||
1852 | memset (key, 0, sizeof (key)); | ||
1853 | snprintf (key, sizeof (key), "volume%d.version", count); | ||
1854 | ret = dict_set_int32 (dict, key, volinfo->version); | ||
1855 | if (ret) | ||
1856 | goto out; | ||
1857 | |||
1858 | memset (key, 0, sizeof (key)); | ||
1859 | snprintf (key, sizeof (key), "volume%d.status", count); | ||
1860 | ret = dict_set_int32 (dict, key, volinfo->status); | ||
1861 | if (ret) | ||
1862 | goto out; | ||
1863 | |||
1864 | memset (key, 0, sizeof (key)); | ||
1865 | snprintf (key, sizeof (key), "volume%d.sub_count", count); | ||
1866 | ret = dict_set_int32 (dict, key, volinfo->sub_count); | ||
1867 | if (ret) | ||
1868 | goto out; | ||
1869 | |||
1870 | memset (key, 0, sizeof (key)); | ||
1871 | snprintf (key, sizeof (key), "volume%d.stripe_count", count); | ||
1872 | ret = dict_set_int32 (dict, key, volinfo->stripe_count); | ||
1873 | if (ret) | ||
1874 | goto out; | ||
1875 | |||
1876 | memset (key, 0, sizeof (key)); | ||
1877 | snprintf (key, sizeof (key), "volume%d.replica_count", count); | ||
1878 | ret = dict_set_int32 (dict, key, volinfo->replica_count); | ||
1879 | if (ret) | ||
1880 | goto out; | ||
1881 | |||
1882 | memset (key, 0, sizeof (key)); | ||
1883 | snprintf (key, sizeof (key), "volume%d.dist_count", count); | ||
1884 | ret = dict_set_int32 (dict, key, volinfo->dist_leaf_count); | ||
1885 | if (ret) | ||
1886 | goto out; | ||
1887 | |||
1888 | memset (key, 0, sizeof (key)); | ||
1889 | snprintf (key, sizeof (key), "volume%d.ckusm", count); | ||
1890 | ret = dict_set_int64 (dict, key, volinfo->cksum); | ||
1891 | if (ret) | ||
1892 | goto out; | ||
1893 | |||
1894 | memset (key, 0, sizeof (key)); | ||
1895 | snprintf (key, sizeof (key), "volume%d.transport_type", count); | ||
1896 | ret = dict_set_uint32 (dict, key, volinfo->transport_type); | ||
1897 | if (ret) | ||
1898 | goto out; | ||
1899 | |||
1900 | volume_id_str = gf_strdup (uuid_utoa (volinfo->volume_id)); | ||
1901 | if (!volume_id_str) { | ||
1902 | ret = -1; | ||
1903 | goto out; | ||
1904 | } | ||
1905 | memset (key, 0, sizeof (key)); | ||
1906 | snprintf (key, sizeof (key), "volume%d.volume_id", count); | ||
1907 | ret = dict_set_dynstr (dict, key, volume_id_str); | ||
1908 | if (ret) | ||
1909 | goto out; | ||
1910 | volume_id_str = NULL((void*)0); | ||
1911 | |||
1912 | memset (key, 0, sizeof (key)); | ||
1913 | snprintf (key, sizeof (key), "volume%d.username", count); | ||
1914 | str = glusterd_auth_get_username (volinfo); | ||
1915 | if (str) { | ||
1916 | ret = dict_set_dynstr (dict, key, gf_strdup (str)); | ||
1917 | if (ret) | ||
1918 | goto out; | ||
1919 | } | ||
1920 | |||
1921 | memset (key, 0, sizeof (key)); | ||
1922 | snprintf (key, sizeof (key), "volume%d.password", count); | ||
1923 | str = glusterd_auth_get_password (volinfo); | ||
1924 | if (str) { | ||
1925 | ret = dict_set_dynstr (dict, key, gf_strdup (str)); | ||
1926 | if (ret) | ||
1927 | goto out; | ||
1928 | } | ||
1929 | |||
1930 | memset (key, 0, sizeof (key)); | ||
1931 | snprintf (key, 256, "volume%d.rebalance", count); | ||
1932 | ret = dict_set_int32 (dict, key, volinfo->rebal.defrag_cmd); | ||
1933 | if (ret) | ||
1934 | goto out; | ||
1935 | |||
1936 | if (volinfo->rebal.defrag_cmd) { | ||
1937 | rebalance_id_str = gf_strdup (uuid_utoa | ||
1938 | (volinfo->rebal.rebalance_id)); | ||
1939 | if (!rebalance_id_str) { | ||
1940 | ret = -1; | ||
1941 | goto out; | ||
1942 | } | ||
1943 | memset (key, 0, sizeof (key)); | ||
1944 | snprintf (key, 256, "volume%d.rebalance-id", count); | ||
1945 | ret = dict_set_dynstr (dict, key, rebalance_id_str); | ||
1946 | if (ret) | ||
1947 | goto out; | ||
1948 | rebalance_id_str = NULL((void*)0); | ||
1949 | } | ||
1950 | |||
1951 | memset (key, 0, sizeof (key)); | ||
1952 | snprintf (key, sizeof (key), "volume%d.rebalance-op", count); | ||
1953 | ret = dict_set_uint32 (dict, key, volinfo->rebal.op); | ||
1954 | if (ret) | ||
1955 | goto out; | ||
1956 | |||
1957 | memset (key, 0, sizeof (key)); | ||
1958 | snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_STATUS"rb_status", count); | ||
1959 | ret = dict_set_int32 (dict, key, volinfo->rep_brick.rb_status); | ||
1960 | if (ret) | ||
1961 | goto out; | ||
1962 | |||
1963 | if (volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) { | ||
1964 | |||
1965 | memset (key, 0, sizeof (key)); | ||
1966 | snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK"rb_src", | ||
1967 | count); | ||
1968 | gf_asprintf (&src_brick, "%s:%s", | ||
1969 | volinfo->rep_brick.src_brick->hostname, | ||
1970 | volinfo->rep_brick.src_brick->path); | ||
1971 | ret = dict_set_dynstr (dict, key, src_brick); | ||
1972 | if (ret) | ||
1973 | goto out; | ||
1974 | |||
1975 | memset (key, 0, sizeof (key)); | ||
1976 | snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_DST_BRICK"rb_dst", | ||
1977 | count); | ||
1978 | gf_asprintf (&dst_brick, "%s:%s", | ||
1979 | volinfo->rep_brick.dst_brick->hostname, | ||
1980 | volinfo->rep_brick.dst_brick->path); | ||
1981 | ret = dict_set_dynstr (dict, key, dst_brick); | ||
1982 | if (ret) | ||
1983 | goto out; | ||
1984 | |||
1985 | rb_id_str = gf_strdup (uuid_utoa (volinfo->rep_brick.rb_id)); | ||
1986 | if (!rb_id_str) { | ||
1987 | ret = -1; | ||
1988 | goto out; | ||
1989 | } | ||
1990 | |||
1991 | memset (key, 0, sizeof (key)); | ||
1992 | snprintf (key, sizeof (key), "volume%d.rb_id", count); | ||
1993 | ret = dict_set_dynstr (dict, key, rb_id_str); | ||
1994 | if (ret) | ||
1995 | goto out; | ||
1996 | rb_id_str = NULL((void*)0); | ||
1997 | } | ||
1998 | |||
1999 | snprintf (prefix, sizeof (prefix), "volume%d", count); | ||
2000 | ctx.dict = dict; | ||
2001 | ctx.prefix = prefix; | ||
2002 | ctx.opt_count = 1; | ||
2003 | ctx.key_name = "key"; | ||
2004 | ctx.val_name = "value"; | ||
2005 | GF_ASSERT (volinfo->dict)do { if (!(volinfo->dict)) { do { do { if (0) printf ("Assertion failed: " "volinfo->dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2005, GF_LOG_ERROR, "Assertion failed: " "volinfo->dict" ); } while (0); } } while (0); | ||
2006 | |||
2007 | dict_foreach (volinfo->dict, _add_dict_to_prdict, &ctx); | ||
2008 | ctx.opt_count--; | ||
2009 | memset (key, 0, sizeof (key)); | ||
2010 | snprintf (key, sizeof (key), "volume%d.opt-count", count); | ||
2011 | ret = dict_set_int32 (dict, key, ctx.opt_count); | ||
2012 | if (ret) | ||
2013 | goto out; | ||
2014 | |||
2015 | ctx.dict = dict; | ||
2016 | ctx.prefix = prefix; | ||
2017 | ctx.opt_count = 1; | ||
2018 | ctx.key_name = "slave-num"; | ||
2019 | ctx.val_name = "slave-val"; | ||
2020 | GF_ASSERT (volinfo->gsync_slaves)do { if (!(volinfo->gsync_slaves)) { do { do { if (0) printf ("Assertion failed: " "volinfo->gsync_slaves"); } while ( 0); _gf_log_callingfn ("", "glusterd-utils.c", __FUNCTION__, 2020 , GF_LOG_ERROR, "Assertion failed: " "volinfo->gsync_slaves" ); } while (0); } } while (0); | ||
2021 | |||
2022 | dict_foreach (volinfo->gsync_slaves, _add_dict_to_prdict, &ctx); | ||
2023 | ctx.opt_count--; | ||
2024 | |||
2025 | memset (key, 0, sizeof (key)); | ||
2026 | snprintf (key, sizeof (key), "volume%d.gsync-count", count); | ||
2027 | ret = dict_set_int32 (dict, key, ctx.opt_count); | ||
2028 | if (ret) | ||
2029 | goto out; | ||
2030 | |||
2031 | 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)))) { | ||
2032 | memset (key, 0, sizeof (key)); | ||
2033 | snprintf (key, sizeof (key), "volume%d.brick%d.hostname", | ||
2034 | count, i); | ||
2035 | ret = dict_set_str (dict, key, brickinfo->hostname); | ||
2036 | if (ret) | ||
2037 | goto out; | ||
2038 | |||
2039 | memset (key, 0, sizeof (key)); | ||
2040 | snprintf (key, sizeof (key), "volume%d.brick%d.path", | ||
2041 | count, i); | ||
2042 | ret = dict_set_str (dict, key, brickinfo->path); | ||
2043 | if (ret) | ||
2044 | goto out; | ||
2045 | |||
2046 | i++; | ||
2047 | } | ||
2048 | |||
2049 | |||
2050 | out: | ||
2051 | GF_FREE (volume_id_str)__gf_free (volume_id_str); | ||
2052 | GF_FREE (rebalance_id_str)__gf_free (rebalance_id_str); | ||
2053 | GF_FREE (rb_id_str)__gf_free (rb_id_str); | ||
2054 | |||
2055 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2055, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2056 | |||
2057 | return ret; | ||
2058 | } | ||
2059 | |||
2060 | int32_t | ||
2061 | glusterd_build_volume_dict (dict_t **vols) | ||
2062 | { | ||
2063 | int32_t ret = -1; | ||
2064 | dict_t *dict = NULL((void*)0); | ||
2065 | glusterd_conf_t *priv = NULL((void*)0); | ||
2066 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
2067 | int32_t count = 0; | ||
2068 | glusterd_dict_ctx_t ctx = {0}; | ||
2069 | |||
2070 | priv = THIS(*__glusterfs_this_location())->private; | ||
2071 | |||
2072 | dict = dict_new (); | ||
2073 | |||
2074 | if (!dict) | ||
2075 | goto out; | ||
2076 | |||
2077 | 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)))) { | ||
2078 | count++; | ||
2079 | ret = glusterd_add_volume_to_dict (volinfo, dict, count); | ||
2080 | if (ret) | ||
2081 | goto out; | ||
2082 | } | ||
2083 | |||
2084 | |||
2085 | ret = dict_set_int32 (dict, "count", count); | ||
2086 | if (ret) | ||
2087 | goto out; | ||
2088 | |||
2089 | ctx.dict = dict; | ||
2090 | ctx.prefix = "global"; | ||
2091 | ctx.opt_count = 1; | ||
2092 | ctx.key_name = "key"; | ||
2093 | ctx.val_name = "val"; | ||
2094 | dict_foreach (priv->opts, _add_dict_to_prdict, &ctx); | ||
2095 | ctx.opt_count--; | ||
2096 | ret = dict_set_int32 (dict, "global-opt-count", ctx.opt_count); | ||
2097 | if (ret) | ||
2098 | goto out; | ||
2099 | |||
2100 | *vols = dict; | ||
2101 | out: | ||
2102 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2102, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2103 | if (ret) | ||
2104 | dict_unref (dict); | ||
2105 | |||
2106 | return ret; | ||
2107 | } | ||
2108 | |||
2109 | int32_t | ||
2110 | glusterd_compare_friend_volume (dict_t *vols, int32_t count, int32_t *status, | ||
2111 | char *hostname) | ||
2112 | { | ||
2113 | |||
2114 | int32_t ret = -1; | ||
2115 | char key[512] = {0,}; | ||
2116 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
2117 | char *volname = NULL((void*)0); | ||
2118 | uint32_t cksum = 0; | ||
2119 | int32_t version = 0; | ||
2120 | |||
2121 | GF_ASSERT (vols)do { if (!(vols)) { do { do { if (0) printf ("Assertion failed: " "vols"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2121, GF_LOG_ERROR, "Assertion failed: " "vols" ); } while (0); } } while (0); | ||
2122 | GF_ASSERT (status)do { if (!(status)) { do { do { if (0) printf ("Assertion failed: " "status"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2122, GF_LOG_ERROR, "Assertion failed: " "status" ); } while (0); } } while (0); | ||
2123 | |||
2124 | snprintf (key, sizeof (key), "volume%d.name", count); | ||
2125 | ret = dict_get_str (vols, key, &volname); | ||
2126 | if (ret) | ||
2127 | goto out; | ||
2128 | |||
2129 | ret = glusterd_volinfo_find (volname, &volinfo); | ||
2130 | |||
2131 | if (ret) { | ||
2132 | *status = GLUSTERD_VOL_COMP_UPDATE_REQ; | ||
2133 | ret = 0; | ||
2134 | goto out; | ||
2135 | } | ||
2136 | |||
2137 | memset (key, 0, sizeof (key)); | ||
2138 | snprintf (key, sizeof (key), "volume%d.version", count); | ||
2139 | ret = dict_get_int32 (vols, key, &version); | ||
2140 | if (ret) | ||
2141 | goto out; | ||
2142 | |||
2143 | if (version > volinfo->version) { | ||
2144 | //Mismatch detected | ||
2145 | ret = 0; | ||
2146 | gf_log ("", GF_LOG_ERROR, "Version of volume %s differ."do { do { if (0) printf ("Version of volume %s differ." "local version = %d, remote version = %d on peer %s" , volinfo->volname, volinfo->version, version, hostname ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 2148, GF_LOG_ERROR, "Version of volume %s differ." "local version = %d, remote version = %d on peer %s" , volinfo->volname, volinfo->version, version, hostname ); } while (0) | ||
2147 | "local version = %d, remote version = %d on peer %s",do { do { if (0) printf ("Version of volume %s differ." "local version = %d, remote version = %d on peer %s" , volinfo->volname, volinfo->version, version, hostname ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 2148, GF_LOG_ERROR, "Version of volume %s differ." "local version = %d, remote version = %d on peer %s" , volinfo->volname, volinfo->version, version, hostname ); } while (0) | ||
2148 | volinfo->volname, volinfo->version, version, hostname)do { do { if (0) printf ("Version of volume %s differ." "local version = %d, remote version = %d on peer %s" , volinfo->volname, volinfo->version, version, hostname ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 2148, GF_LOG_ERROR, "Version of volume %s differ." "local version = %d, remote version = %d on peer %s" , volinfo->volname, volinfo->version, version, hostname ); } while (0); | ||
2149 | *status = GLUSTERD_VOL_COMP_UPDATE_REQ; | ||
2150 | goto out; | ||
2151 | } else if (version < volinfo->version) { | ||
2152 | *status = GLUSTERD_VOL_COMP_SCS; | ||
2153 | goto out; | ||
2154 | } | ||
2155 | |||
2156 | //Now, versions are same, compare cksums. | ||
2157 | // | ||
2158 | memset (key, 0, sizeof (key)); | ||
2159 | snprintf (key, sizeof (key), "volume%d.ckusm", count); | ||
2160 | ret = dict_get_uint32 (vols, key, &cksum); | ||
2161 | if (ret) | ||
2162 | goto out; | ||
2163 | |||
2164 | if (cksum != volinfo->cksum) { | ||
2165 | ret = 0; | ||
2166 | gf_log ("", GF_LOG_ERROR, "Cksums of volume %s differ."do { do { if (0) printf ("Cksums of volume %s differ." " local cksum = %u, remote cksum = %u on peer %s" , volinfo->volname, volinfo->cksum, cksum, hostname); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2168 , GF_LOG_ERROR, "Cksums of volume %s differ." " local cksum = %u, remote cksum = %u on peer %s" , volinfo->volname, volinfo->cksum, cksum, hostname); } while (0) | ||
2167 | " local cksum = %u, remote cksum = %u on peer %s",do { do { if (0) printf ("Cksums of volume %s differ." " local cksum = %u, remote cksum = %u on peer %s" , volinfo->volname, volinfo->cksum, cksum, hostname); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2168 , GF_LOG_ERROR, "Cksums of volume %s differ." " local cksum = %u, remote cksum = %u on peer %s" , volinfo->volname, volinfo->cksum, cksum, hostname); } while (0) | ||
2168 | volinfo->volname, volinfo->cksum, cksum, hostname)do { do { if (0) printf ("Cksums of volume %s differ." " local cksum = %u, remote cksum = %u on peer %s" , volinfo->volname, volinfo->cksum, cksum, hostname); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2168 , GF_LOG_ERROR, "Cksums of volume %s differ." " local cksum = %u, remote cksum = %u on peer %s" , volinfo->volname, volinfo->cksum, cksum, hostname); } while (0); | ||
2169 | *status = GLUSTERD_VOL_COMP_RJT; | ||
2170 | goto out; | ||
2171 | } | ||
2172 | |||
2173 | *status = GLUSTERD_VOL_COMP_SCS; | ||
2174 | |||
2175 | out: | ||
2176 | gf_log ("", GF_LOG_DEBUG, "Returning with ret: %d, status: %d",do { do { if (0) printf ("Returning with ret: %d, status: %d" , ret, *status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 2177, GF_LOG_DEBUG, "Returning with ret: %d, status: %d" , ret, *status); } while (0) | ||
2177 | ret, *status)do { do { if (0) printf ("Returning with ret: %d, status: %d" , ret, *status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 2177, GF_LOG_DEBUG, "Returning with ret: %d, status: %d" , ret, *status); } while (0); | ||
2178 | return ret; | ||
2179 | } | ||
2180 | |||
2181 | static int32_t | ||
2182 | import_prdict_dict (dict_t *vols, dict_t *dst_dict, char *key_prefix, | ||
2183 | char *value_prefix, int opt_count, char *prefix) | ||
2184 | { | ||
2185 | char key[512] = {0,}; | ||
2186 | int32_t ret = 0; | ||
2187 | int i = 1; | ||
2188 | char *opt_key = NULL((void*)0); | ||
2189 | char *opt_val = NULL((void*)0); | ||
2190 | char *dup_opt_val = NULL((void*)0); | ||
2191 | char msg[2048] = {0}; | ||
2192 | |||
2193 | while (i <= opt_count) { | ||
2194 | memset (key, 0, sizeof (key)); | ||
2195 | snprintf (key, sizeof (key), "%s.%s%d", | ||
2196 | prefix, key_prefix, i); | ||
2197 | ret = dict_get_str (vols, key, &opt_key); | ||
2198 | if (ret) { | ||
2199 | snprintf (msg, sizeof (msg), "Volume dict key not " | ||
2200 | "specified"); | ||
2201 | goto out; | ||
2202 | } | ||
2203 | |||
2204 | memset (key, 0, sizeof (key)); | ||
2205 | snprintf (key, sizeof (key), "%s.%s%d", | ||
2206 | prefix, value_prefix, i); | ||
2207 | ret = dict_get_str (vols, key, &opt_val); | ||
2208 | if (ret) { | ||
2209 | snprintf (msg, sizeof (msg), "Volume dict value not " | ||
2210 | "specified"); | ||
2211 | goto out; | ||
2212 | } | ||
2213 | dup_opt_val = gf_strdup (opt_val); | ||
2214 | if (!dup_opt_val) { | ||
2215 | ret = -1; | ||
2216 | goto out; | ||
2217 | } | ||
2218 | ret = dict_set_dynstr (dst_dict, opt_key, dup_opt_val); | ||
2219 | if (ret) { | ||
2220 | snprintf (msg, sizeof (msg), "Volume set %s %s " | ||
2221 | "unsuccessful", opt_key, dup_opt_val); | ||
2222 | goto out; | ||
2223 | } | ||
2224 | i++; | ||
2225 | } | ||
2226 | |||
2227 | out: | ||
2228 | if (msg[0]) | ||
2229 | gf_log ("glusterd", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 2229, GF_LOG_ERROR, "%s", msg); } while (0); | ||
2230 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2230, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2231 | return ret; | ||
2232 | |||
2233 | } | ||
2234 | |||
2235 | gf_boolean_t | ||
2236 | glusterd_is_quorum_option (char *option) | ||
2237 | { | ||
2238 | gf_boolean_t res = _gf_false; | ||
2239 | int i = 0; | ||
2240 | char *keys[] = {GLUSTERD_QUORUM_TYPE_KEY"cluster.server-quorum-type", | ||
2241 | GLUSTERD_QUORUM_RATIO_KEY"cluster.server-quorum-ratio", NULL((void*)0)}; | ||
2242 | |||
2243 | for (i = 0; keys[i]; i++) { | ||
2244 | if (strcmp (option, keys[i]) == 0) { | ||
2245 | res = _gf_true; | ||
2246 | break; | ||
2247 | } | ||
2248 | } | ||
2249 | return res; | ||
2250 | } | ||
2251 | |||
2252 | gf_boolean_t | ||
2253 | glusterd_is_quorum_changed (dict_t *options, char *option, char *value) | ||
2254 | { | ||
2255 | int ret = 0; | ||
2256 | gf_boolean_t reconfigured = _gf_false; | ||
2257 | gf_boolean_t all = _gf_false; | ||
2258 | char *oldquorum = NULL((void*)0); | ||
2259 | char *newquorum = NULL((void*)0); | ||
2260 | char *oldratio = NULL((void*)0); | ||
2261 | char *newratio = NULL((void*)0); | ||
2262 | |||
2263 | if ((strcmp ("all", option) != 0) && | ||
2264 | !glusterd_is_quorum_option (option)) | ||
2265 | goto out; | ||
2266 | |||
2267 | if (strcmp ("all", option) == 0) | ||
2268 | all = _gf_true; | ||
2269 | |||
2270 | if (all || (strcmp (GLUSTERD_QUORUM_TYPE_KEY"cluster.server-quorum-type", option) == 0)) { | ||
2271 | newquorum = value; | ||
2272 | ret = dict_get_str (options, GLUSTERD_QUORUM_TYPE_KEY"cluster.server-quorum-type", | ||
2273 | &oldquorum); | ||
2274 | } | ||
2275 | |||
2276 | if (all || (strcmp (GLUSTERD_QUORUM_RATIO_KEY"cluster.server-quorum-ratio", option) == 0)) { | ||
2277 | newratio = value; | ||
2278 | ret = dict_get_str (options, GLUSTERD_QUORUM_RATIO_KEY"cluster.server-quorum-ratio", | ||
2279 | &oldratio); | ||
2280 | } | ||
2281 | |||
2282 | reconfigured = _gf_true; | ||
2283 | |||
2284 | if (oldquorum && newquorum && (strcmp (oldquorum, newquorum) == 0)) | ||
2285 | reconfigured = _gf_false; | ||
2286 | if (oldratio && newratio && (strcmp (oldratio, newratio) == 0)) | ||
2287 | reconfigured = _gf_false; | ||
2288 | |||
2289 | if ((oldratio == NULL((void*)0)) && (newratio == NULL((void*)0)) && (oldquorum == NULL((void*)0)) && | ||
2290 | (newquorum == NULL((void*)0))) | ||
2291 | reconfigured = _gf_false; | ||
2292 | out: | ||
2293 | return reconfigured; | ||
2294 | } | ||
2295 | |||
2296 | static inline gf_boolean_t | ||
2297 | _is_contributing_to_quorum (gd_quorum_contrib_t contrib) | ||
2298 | { | ||
2299 | if ((contrib == QUORUM_UP) || (contrib == QUORUM_DOWN)) | ||
2300 | return _gf_true; | ||
2301 | return _gf_false; | ||
2302 | } | ||
2303 | |||
2304 | static inline gf_boolean_t | ||
2305 | _does_quorum_meet (int active_count, int quorum_count) | ||
2306 | { | ||
2307 | return (active_count >= quorum_count); | ||
2308 | } | ||
2309 | |||
2310 | int | ||
2311 | glusterd_get_quorum_cluster_counts (xlator_t *this, int *active_count, | ||
2312 | int *quorum_count) | ||
2313 | { | ||
2314 | glusterd_peerinfo_t *peerinfo = NULL((void*)0); | ||
2315 | glusterd_conf_t *conf = NULL((void*)0); | ||
2316 | int ret = -1; | ||
2317 | int inquorum_count = 0; | ||
2318 | char *val = NULL((void*)0); | ||
2319 | double quorum_percentage = 0.0; | ||
2320 | gf_boolean_t ratio = _gf_false; | ||
2321 | int count = 0; | ||
2322 | |||
2323 | conf = this->private; | ||
2324 | //Start with counting self | ||
2325 | inquorum_count = 1; | ||
2326 | if (active_count) | ||
2327 | *active_count = 1; | ||
2328 | list_for_each_entry (peerinfo, &conf->peers, uuid_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((&conf-> peers)->next)-(unsigned long)(&((typeof(*peerinfo) *)0 )->uuid_list))); &peerinfo->uuid_list != (&conf ->peers); peerinfo = ((typeof(*peerinfo) *)((char *)(peerinfo ->uuid_list.next)-(unsigned long)(&((typeof(*peerinfo) *)0)->uuid_list)))) { | ||
2329 | if (peerinfo->quorum_contrib == QUORUM_WAITING) | ||
2330 | goto out; | ||
2331 | |||
2332 | if (_is_contributing_to_quorum (peerinfo->quorum_contrib)) | ||
2333 | inquorum_count = inquorum_count + 1; | ||
2334 | |||
2335 | if (active_count && (peerinfo->quorum_contrib == QUORUM_UP)) | ||
2336 | *active_count = *active_count + 1; | ||
2337 | } | ||
2338 | |||
2339 | ret = dict_get_str (conf->opts, GLUSTERD_QUORUM_RATIO_KEY"cluster.server-quorum-ratio", &val); | ||
2340 | if (ret == 0) { | ||
2341 | ratio = _gf_true; | ||
2342 | ret = gf_string2percent (val, &quorum_percentage); | ||
2343 | if (!ret) | ||
2344 | ratio = _gf_true; | ||
2345 | } | ||
2346 | if (ratio) | ||
2347 | count = CEILING_POS (inquorum_count *(((inquorum_count * quorum_percentage / 100.0)-(int)(inquorum_count * quorum_percentage / 100.0)) > 0 ? (int)((inquorum_count * quorum_percentage / 100.0)+1) : (int)(inquorum_count * quorum_percentage / 100.0)) | ||
2348 | quorum_percentage / 100.0)(((inquorum_count * quorum_percentage / 100.0)-(int)(inquorum_count * quorum_percentage / 100.0)) > 0 ? (int)((inquorum_count * quorum_percentage / 100.0)+1) : (int)(inquorum_count * quorum_percentage / 100.0)); | ||
2349 | else | ||
2350 | count = (inquorum_count * 50 / 100) + 1; | ||
2351 | |||
2352 | *quorum_count = count; | ||
2353 | ret = 0; | ||
2354 | out: | ||
2355 | return ret; | ||
2356 | } | ||
2357 | |||
2358 | gf_boolean_t | ||
2359 | glusterd_is_volume_in_server_quorum (glusterd_volinfo_t *volinfo) | ||
2360 | { | ||
2361 | gf_boolean_t res = _gf_false; | ||
2362 | char *quorum_type = NULL((void*)0); | ||
2363 | int ret = 0; | ||
2364 | |||
2365 | ret = dict_get_str (volinfo->dict, GLUSTERD_QUORUM_TYPE_KEY"cluster.server-quorum-type", | ||
2366 | &quorum_type); | ||
2367 | if (ret) | ||
2368 | goto out; | ||
2369 | |||
2370 | if (strcmp (quorum_type, GLUSTERD_SERVER_QUORUM"server") == 0) | ||
2371 | res = _gf_true; | ||
2372 | out: | ||
2373 | return res; | ||
2374 | } | ||
2375 | |||
2376 | gf_boolean_t | ||
2377 | glusterd_is_any_volume_in_server_quorum (xlator_t *this) | ||
2378 | { | ||
2379 | glusterd_conf_t *conf = NULL((void*)0); | ||
2380 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
2381 | |||
2382 | conf = this->private; | ||
2383 | list_for_each_entry (volinfo, &conf->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&conf-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&conf-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | ||
2384 | if (glusterd_is_volume_in_server_quorum (volinfo)) { | ||
2385 | return _gf_true; | ||
2386 | } | ||
2387 | } | ||
2388 | return _gf_false; | ||
2389 | } | ||
2390 | |||
2391 | gf_boolean_t | ||
2392 | does_gd_meet_server_quorum (xlator_t *this) | ||
2393 | { | ||
2394 | int quorum_count = 0; | ||
2395 | int active_count = 0; | ||
2396 | gf_boolean_t in = _gf_false; | ||
2397 | glusterd_conf_t *conf = NULL((void*)0); | ||
2398 | int ret = -1; | ||
2399 | |||
2400 | conf = this->private; | ||
2401 | ret = glusterd_get_quorum_cluster_counts (this, &active_count, | ||
2402 | &quorum_count); | ||
2403 | if (ret) | ||
2404 | goto out; | ||
2405 | |||
2406 | if (!_does_quorum_meet (active_count, quorum_count)) { | ||
2407 | goto out; | ||
2408 | } | ||
2409 | |||
2410 | in = _gf_true; | ||
2411 | out: | ||
2412 | return in; | ||
2413 | } | ||
2414 | |||
2415 | int | ||
2416 | glusterd_spawn_daemons (void *opaque) | ||
2417 | { | ||
2418 | glusterd_conf_t *conf = THIS(*__glusterfs_this_location())->private; | ||
2419 | gf_boolean_t start_bricks = (long) opaque; | ||
2420 | |||
2421 | if (start_bricks) | ||
2422 | glusterd_restart_bricks (conf); | ||
2423 | glusterd_restart_gsyncds (conf); | ||
2424 | glusterd_restart_rebalance (conf); | ||
2425 | return 0; | ||
2426 | } | ||
2427 | |||
2428 | void | ||
2429 | glusterd_do_volume_quorum_action (xlator_t *this, glusterd_volinfo_t *volinfo, | ||
2430 | gf_boolean_t meets_quorum) | ||
2431 | { | ||
2432 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
2433 | glusterd_conf_t *conf = NULL((void*)0); | ||
2434 | |||
2435 | conf = this->private; | ||
2436 | if (volinfo->status != GLUSTERD_STATUS_STARTED) | ||
2437 | goto out; | ||
2438 | |||
2439 | if (!glusterd_is_volume_in_server_quorum (volinfo)) | ||
2440 | meets_quorum = _gf_true; | ||
2441 | |||
2442 | 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)))) { | ||
2443 | if (!glusterd_is_local_brick (this, volinfo, brickinfo)) | ||
2444 | continue; | ||
2445 | if (meets_quorum) | ||
2446 | glusterd_brick_start (volinfo, brickinfo, _gf_false); | ||
2447 | else | ||
2448 | glusterd_brick_stop (volinfo, brickinfo, _gf_false); | ||
2449 | } | ||
2450 | out: | ||
2451 | return; | ||
2452 | } | ||
2453 | |||
2454 | int | ||
2455 | glusterd_do_quorum_action () | ||
2456 | { | ||
2457 | xlator_t *this = NULL((void*)0); | ||
2458 | glusterd_conf_t *conf = NULL((void*)0); | ||
2459 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
2460 | int ret = 0; | ||
2461 | int active_count = 0; | ||
2462 | int quorum_count = 0; | ||
2463 | gf_boolean_t meets = _gf_false; | ||
2464 | |||
2465 | this = THIS(*__glusterfs_this_location()); | ||
2466 | conf = this->private; | ||
2467 | |||
2468 | conf->pending_quorum_action = _gf_true; | ||
2469 | ret = glusterd_lock (conf->uuid); | ||
2470 | if (ret) | ||
2471 | goto out; | ||
2472 | |||
2473 | { | ||
2474 | ret = glusterd_get_quorum_cluster_counts (this, &active_count, | ||
2475 | &quorum_count); | ||
2476 | if (ret) | ||
2477 | goto unlock; | ||
2478 | |||
2479 | if (_does_quorum_meet (active_count, quorum_count)) | ||
2480 | meets = _gf_true; | ||
2481 | list_for_each_entry (volinfo, &conf->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&conf-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&conf-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | ||
2482 | glusterd_do_volume_quorum_action (this, volinfo, meets); | ||
2483 | } | ||
2484 | } | ||
2485 | unlock: | ||
2486 | (void)glusterd_unlock (conf->uuid); | ||
2487 | conf->pending_quorum_action = _gf_false; | ||
2488 | out: | ||
2489 | return ret; | ||
2490 | } | ||
2491 | |||
2492 | int32_t | ||
2493 | glusterd_import_friend_volume_opts (dict_t *vols, int count, | ||
2494 | glusterd_volinfo_t *volinfo) | ||
2495 | { | ||
2496 | char key[512] = {0,}; | ||
2497 | int32_t ret = -1; | ||
2498 | int opt_count = 0; | ||
2499 | char msg[2048] = {0}; | ||
2500 | char volume_prefix[1024] = {0}; | ||
2501 | |||
2502 | memset (key, 0, sizeof (key)); | ||
2503 | snprintf (key, sizeof (key), "volume%d.opt-count", count); | ||
2504 | ret = dict_get_int32 (vols, key, &opt_count); | ||
2505 | if (ret) { | ||
2506 | snprintf (msg, sizeof (msg), "Volume option count not " | ||
2507 | "specified for %s", volinfo->volname); | ||
2508 | goto out; | ||
2509 | } | ||
2510 | |||
2511 | snprintf (volume_prefix, sizeof (volume_prefix), "volume%d", count); | ||
2512 | ret = import_prdict_dict (vols, volinfo->dict, "key", "value", | ||
2513 | opt_count, volume_prefix); | ||
2514 | if (ret) { | ||
2515 | snprintf (msg, sizeof (msg), "Unable to import options dict " | ||
2516 | "specified for %s", volinfo->volname); | ||
2517 | goto out; | ||
2518 | } | ||
2519 | |||
2520 | memset (key, 0, sizeof (key)); | ||
2521 | snprintf (key, sizeof (key), "volume%d.gsync-count", count); | ||
2522 | ret = dict_get_int32 (vols, key, &opt_count); | ||
2523 | if (ret) { | ||
2524 | snprintf (msg, sizeof (msg), "Gsync count not " | ||
2525 | "specified for %s", volinfo->volname); | ||
2526 | goto out; | ||
2527 | } | ||
2528 | |||
2529 | ret = import_prdict_dict (vols, volinfo->gsync_slaves, "slave-num", | ||
2530 | "slave-val", opt_count, volume_prefix); | ||
2531 | if (ret) { | ||
2532 | snprintf (msg, sizeof (msg), "Unable to import gsync sessions " | ||
2533 | "specified for %s", volinfo->volname); | ||
2534 | goto out; | ||
2535 | } | ||
2536 | |||
2537 | out: | ||
2538 | if (msg[0]) | ||
2539 | gf_log ("glusterd", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 2539, GF_LOG_ERROR, "%s", msg); } while (0); | ||
2540 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2540, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2541 | return ret; | ||
2542 | } | ||
2543 | |||
2544 | int32_t | ||
2545 | glusterd_import_new_brick (dict_t *vols, int32_t vol_count, | ||
2546 | int32_t brick_count, | ||
2547 | glusterd_brickinfo_t **brickinfo) | ||
2548 | { | ||
2549 | char key[512] = {0,}; | ||
2550 | int ret = -1; | ||
2551 | char *hostname = NULL((void*)0); | ||
2552 | char *path = NULL((void*)0); | ||
2553 | glusterd_brickinfo_t *new_brickinfo = NULL((void*)0); | ||
2554 | char msg[2048] = {0}; | ||
2555 | |||
2556 | GF_ASSERT (vols)do { if (!(vols)) { do { do { if (0) printf ("Assertion failed: " "vols"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2556, GF_LOG_ERROR, "Assertion failed: " "vols" ); } while (0); } } while (0); | ||
2557 | GF_ASSERT (vol_count >= 0)do { if (!(vol_count >= 0)) { do { do { if (0) printf ("Assertion failed: " "vol_count >= 0"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2557, GF_LOG_ERROR, "Assertion failed: " "vol_count >= 0" ); } while (0); } } while (0); | ||
2558 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2558, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
2559 | |||
2560 | memset (key, 0, sizeof (key)); | ||
2561 | snprintf (key, sizeof (key), "volume%d.brick%d.hostname", | ||
2562 | vol_count, brick_count); | ||
2563 | ret = dict_get_str (vols, key, &hostname); | ||
2564 | if (ret) { | ||
2565 | snprintf (msg, sizeof (msg), "%s missing in payload", key); | ||
2566 | goto out; | ||
2567 | } | ||
2568 | |||
2569 | memset (key, 0, sizeof (key)); | ||
2570 | snprintf (key, sizeof (key), "volume%d.brick%d.path", | ||
2571 | vol_count, brick_count); | ||
2572 | ret = dict_get_str (vols, key, &path); | ||
2573 | if (ret) { | ||
2574 | snprintf (msg, sizeof (msg), "%s missing in payload", key); | ||
2575 | goto out; | ||
2576 | } | ||
2577 | |||
2578 | ret = glusterd_brickinfo_new (&new_brickinfo); | ||
2579 | if (ret) | ||
2580 | goto out; | ||
2581 | |||
2582 | strcpy (new_brickinfo->path, path); | ||
2583 | strcpy (new_brickinfo->hostname, hostname); | ||
2584 | //peerinfo might not be added yet | ||
2585 | (void) glusterd_resolve_brick (new_brickinfo); | ||
2586 | ret = 0; | ||
2587 | *brickinfo = new_brickinfo; | ||
2588 | out: | ||
2589 | if (msg[0]) | ||
2590 | gf_log ("glusterd", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 2590, GF_LOG_ERROR, "%s", msg); } while (0); | ||
2591 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2591, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2592 | return ret; | ||
2593 | } | ||
2594 | |||
2595 | int32_t | ||
2596 | glusterd_import_bricks (dict_t *vols, int32_t vol_count, | ||
2597 | glusterd_volinfo_t *new_volinfo) | ||
2598 | { | ||
2599 | int ret = -1; | ||
2600 | int brick_count = 1; | ||
2601 | glusterd_brickinfo_t *new_brickinfo = NULL((void*)0); | ||
2602 | |||
2603 | GF_ASSERT (vols)do { if (!(vols)) { do { do { if (0) printf ("Assertion failed: " "vols"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2603, GF_LOG_ERROR, "Assertion failed: " "vols" ); } while (0); } } while (0); | ||
2604 | GF_ASSERT (vol_count >= 0)do { if (!(vol_count >= 0)) { do { do { if (0) printf ("Assertion failed: " "vol_count >= 0"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2604, GF_LOG_ERROR, "Assertion failed: " "vol_count >= 0" ); } while (0); } } while (0); | ||
2605 | GF_ASSERT (new_volinfo)do { if (!(new_volinfo)) { do { do { if (0) printf ("Assertion failed: " "new_volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2605, GF_LOG_ERROR, "Assertion failed: " "new_volinfo" ); } while (0); } } while (0); | ||
2606 | while (brick_count <= new_volinfo->brick_count) { | ||
2607 | |||
2608 | ret = glusterd_import_new_brick (vols, vol_count, brick_count, | ||
2609 | &new_brickinfo); | ||
2610 | if (ret) | ||
2611 | goto out; | ||
2612 | list_add_tail (&new_brickinfo->brick_list, &new_volinfo->bricks); | ||
2613 | brick_count++; | ||
2614 | } | ||
2615 | ret = 0; | ||
2616 | out: | ||
2617 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2617, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2618 | return ret; | ||
2619 | } | ||
2620 | |||
2621 | int32_t | ||
2622 | glusterd_import_volinfo (dict_t *vols, int count, | ||
2623 | glusterd_volinfo_t **volinfo) | ||
2624 | { | ||
2625 | int ret = -1; | ||
2626 | char key[256] = {0}; | ||
2627 | char *volname = NULL((void*)0); | ||
2628 | glusterd_volinfo_t *new_volinfo = NULL((void*)0); | ||
2629 | char *volume_id_str = NULL((void*)0); | ||
2630 | char msg[2048] = {0}; | ||
2631 | char *src_brick = NULL((void*)0); | ||
2632 | char *dst_brick = NULL((void*)0); | ||
2633 | char *str = NULL((void*)0); | ||
2634 | int rb_status = 0; | ||
2635 | char *rebalance_id_str = NULL((void*)0); | ||
2636 | char *rb_id_str = NULL((void*)0); | ||
2637 | |||
2638 | GF_ASSERT (vols)do { if (!(vols)) { do { do { if (0) printf ("Assertion failed: " "vols"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2638, GF_LOG_ERROR, "Assertion failed: " "vols" ); } while (0); } } while (0); | ||
2639 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2639, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
2640 | |||
2641 | snprintf (key, sizeof (key), "volume%d.name", count); | ||
2642 | ret = dict_get_str (vols, key, &volname); | ||
2643 | if (ret) { | ||
2644 | snprintf (msg, sizeof (msg), "%s missing in payload", key); | ||
2645 | goto out; | ||
2646 | } | ||
2647 | |||
2648 | ret = glusterd_volinfo_new (&new_volinfo); | ||
2649 | if (ret) | ||
2650 | goto out; | ||
2651 | strncpy (new_volinfo->volname, volname, sizeof (new_volinfo->volname)); | ||
2652 | |||
2653 | |||
2654 | memset (key, 0, sizeof (key)); | ||
2655 | snprintf (key, sizeof (key), "volume%d.type", count); | ||
2656 | ret = dict_get_int32 (vols, key, &new_volinfo->type); | ||
2657 | if (ret) { | ||
2658 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2659 | key, volname); | ||
2660 | goto out; | ||
2661 | } | ||
2662 | |||
2663 | memset (key, 0, sizeof (key)); | ||
2664 | snprintf (key, sizeof (key), "volume%d.brick_count", count); | ||
2665 | ret = dict_get_int32 (vols, key, &new_volinfo->brick_count); | ||
2666 | if (ret) { | ||
2667 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2668 | key, volname); | ||
2669 | goto out; | ||
2670 | } | ||
2671 | |||
2672 | memset (key, 0, sizeof (key)); | ||
2673 | snprintf (key, sizeof (key), "volume%d.version", count); | ||
2674 | ret = dict_get_int32 (vols, key, &new_volinfo->version); | ||
2675 | if (ret) { | ||
2676 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2677 | key, volname); | ||
2678 | goto out; | ||
2679 | } | ||
2680 | |||
2681 | memset (key, 0, sizeof (key)); | ||
2682 | snprintf (key, sizeof (key), "volume%d.status", count); | ||
2683 | ret = dict_get_int32 (vols, key, (int32_t *)&new_volinfo->status); | ||
2684 | if (ret) { | ||
2685 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2686 | key, volname); | ||
2687 | goto out; | ||
2688 | } | ||
2689 | |||
2690 | memset (key, 0, sizeof (key)); | ||
2691 | snprintf (key, sizeof (key), "volume%d.sub_count", count); | ||
2692 | ret = dict_get_int32 (vols, key, &new_volinfo->sub_count); | ||
2693 | if (ret) { | ||
2694 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2695 | key, volname); | ||
2696 | goto out; | ||
2697 | } | ||
2698 | |||
2699 | /* not having a 'stripe_count' key is not a error | ||
2700 | (as peer may be of old version) */ | ||
2701 | memset (key, 0, sizeof (key)); | ||
2702 | snprintf (key, sizeof (key), "volume%d.stripe_count", count); | ||
2703 | ret = dict_get_int32 (vols, key, &new_volinfo->stripe_count); | ||
2704 | if (ret) | ||
2705 | gf_log (THIS->name, GF_LOG_INFO,do { do { if (0) printf ("peer is possibly old version"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 2706, GF_LOG_INFO, "peer is possibly old version" ); } while (0) | ||
2706 | "peer is possibly old version")do { do { if (0) printf ("peer is possibly old version"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 2706, GF_LOG_INFO, "peer is possibly old version" ); } while (0); | ||
2707 | |||
2708 | /* not having a 'replica_count' key is not a error | ||
2709 | (as peer may be of old version) */ | ||
2710 | memset (key, 0, sizeof (key)); | ||
2711 | snprintf (key, sizeof (key), "volume%d.replica_count", count); | ||
2712 | ret = dict_get_int32 (vols, key, &new_volinfo->replica_count); | ||
2713 | if (ret) | ||
2714 | gf_log (THIS->name, GF_LOG_INFO,do { do { if (0) printf ("peer is possibly old version"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 2715, GF_LOG_INFO, "peer is possibly old version" ); } while (0) | ||
2715 | "peer is possibly old version")do { do { if (0) printf ("peer is possibly old version"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 2715, GF_LOG_INFO, "peer is possibly old version" ); } while (0); | ||
2716 | |||
2717 | /* not having a 'dist_count' key is not a error | ||
2718 | (as peer may be of old version) */ | ||
2719 | memset (key, 0, sizeof (key)); | ||
2720 | snprintf (key, sizeof (key), "volume%d.dist_count", count); | ||
2721 | ret = dict_get_int32 (vols, key, &new_volinfo->dist_leaf_count); | ||
2722 | if (ret) | ||
2723 | gf_log (THIS->name, GF_LOG_INFO,do { do { if (0) printf ("peer is possibly old version"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 2724, GF_LOG_INFO, "peer is possibly old version" ); } while (0) | ||
2724 | "peer is possibly old version")do { do { if (0) printf ("peer is possibly old version"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 2724, GF_LOG_INFO, "peer is possibly old version" ); } while (0); | ||
2725 | |||
2726 | memset (key, 0, sizeof (key)); | ||
2727 | snprintf (key, sizeof (key), "volume%d.ckusm", count); | ||
2728 | ret = dict_get_uint32 (vols, key, &new_volinfo->cksum); | ||
2729 | if (ret) { | ||
2730 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2731 | key, volname); | ||
2732 | goto out; | ||
2733 | } | ||
2734 | |||
2735 | memset (key, 0, sizeof (key)); | ||
2736 | snprintf (key, sizeof (key), "volume%d.volume_id", count); | ||
2737 | ret = dict_get_str (vols, key, &volume_id_str); | ||
2738 | if (ret) { | ||
2739 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2740 | key, volname); | ||
2741 | goto out; | ||
2742 | } | ||
2743 | |||
2744 | uuid_parse (volume_id_str, new_volinfo->volume_id); | ||
2745 | |||
2746 | memset (key, 0, sizeof (key)); | ||
2747 | snprintf (key, sizeof (key), "volume%d.username", count); | ||
2748 | ret = dict_get_str (vols, key, &str); | ||
2749 | if (!ret) { | ||
2750 | ret = glusterd_auth_set_username (new_volinfo, str); | ||
2751 | if (ret) | ||
2752 | goto out; | ||
2753 | } | ||
2754 | |||
2755 | memset (key, 0, sizeof (key)); | ||
2756 | snprintf (key, sizeof (key), "volume%d.password", count); | ||
2757 | ret = dict_get_str (vols, key, &str); | ||
2758 | if (!ret) { | ||
2759 | ret = glusterd_auth_set_password (new_volinfo, str); | ||
2760 | if (ret) | ||
2761 | goto out; | ||
2762 | } | ||
2763 | |||
2764 | memset (key, 0, sizeof (key)); | ||
2765 | snprintf (key, sizeof (key), "volume%d.transport_type", count); | ||
2766 | ret = dict_get_uint32 (vols, key, &new_volinfo->transport_type); | ||
2767 | if (ret) { | ||
2768 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2769 | key, volname); | ||
2770 | goto out; | ||
2771 | } | ||
2772 | |||
2773 | memset (key, 0, sizeof (key)); | ||
2774 | snprintf (key, sizeof (key), "volume%d.rebalance", count); | ||
2775 | ret = dict_get_uint32 (vols, key, &new_volinfo->rebal.defrag_cmd); | ||
2776 | if (ret) { | ||
2777 | snprintf (msg, sizeof (msg), "%s missing in payload for %s", | ||
2778 | key, volname); | ||
2779 | goto out; | ||
2780 | } | ||
2781 | |||
2782 | if (new_volinfo->rebal.defrag_cmd) { | ||
2783 | memset (key, 0, sizeof (key)); | ||
2784 | snprintf (key, sizeof (key), "volume%d.rebalance-id", count); | ||
2785 | ret = dict_get_str (vols, key, &rebalance_id_str); | ||
2786 | if (ret) { | ||
2787 | /* This is not present in older glusterfs versions, | ||
2788 | * so don't error out | ||
2789 | */ | ||
2790 | ret = 0; | ||
2791 | } else { | ||
2792 | uuid_parse (rebalance_id_str, | ||
2793 | new_volinfo->rebal.rebalance_id); | ||
2794 | } | ||
2795 | } | ||
2796 | |||
2797 | memset (key, 0, sizeof (key)); | ||
2798 | snprintf (key, sizeof (key), "volume%d.rebalance-op", count); | ||
2799 | ret = dict_get_uint32 (vols, key,(uint32_t *) &new_volinfo->rebal.op); | ||
2800 | if (ret) { | ||
2801 | /* This is not present in older glusterfs versions, | ||
2802 | * so don't error out | ||
2803 | */ | ||
2804 | ret = 0; | ||
2805 | } | ||
2806 | |||
2807 | memset (key, 0, sizeof (key)); | ||
2808 | snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_STATUS"rb_status", count); | ||
2809 | ret = dict_get_int32 (vols, key, &rb_status); | ||
2810 | if (ret) | ||
2811 | goto out; | ||
2812 | new_volinfo->rep_brick.rb_status = rb_status; | ||
2813 | |||
2814 | if (new_volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) { | ||
2815 | |||
2816 | memset (key, 0, sizeof (key)); | ||
2817 | snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK"rb_src", | ||
2818 | count); | ||
2819 | ret = dict_get_str (vols, key, &src_brick); | ||
2820 | if (ret) | ||
2821 | goto out; | ||
2822 | |||
2823 | ret = glusterd_brickinfo_new_from_brick (src_brick, | ||
2824 | &new_volinfo->rep_brick.src_brick); | ||
2825 | if (ret) { | ||
2826 | gf_log ("", GF_LOG_ERROR, "Unable to create"do { do { if (0) printf ("Unable to create" " src brickinfo") ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2827, GF_LOG_ERROR, "Unable to create" " src brickinfo"); } while (0) | ||
2827 | " src brickinfo")do { do { if (0) printf ("Unable to create" " src brickinfo") ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2827, GF_LOG_ERROR, "Unable to create" " src brickinfo"); } while (0); | ||
2828 | goto out; | ||
2829 | } | ||
2830 | |||
2831 | memset (key, 0, sizeof (key)); | ||
2832 | snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_DST_BRICK"rb_dst", | ||
2833 | count); | ||
2834 | ret = dict_get_str (vols, key, &dst_brick); | ||
2835 | if (ret) | ||
2836 | goto out; | ||
2837 | |||
2838 | ret = glusterd_brickinfo_new_from_brick (dst_brick, | ||
2839 | &new_volinfo->rep_brick.dst_brick); | ||
2840 | if (ret) { | ||
2841 | gf_log ("", GF_LOG_ERROR, "Unable to create"do { do { if (0) printf ("Unable to create" " dst brickinfo") ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2842, GF_LOG_ERROR, "Unable to create" " dst brickinfo"); } while (0) | ||
2842 | " dst brickinfo")do { do { if (0) printf ("Unable to create" " dst brickinfo") ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2842, GF_LOG_ERROR, "Unable to create" " dst brickinfo"); } while (0); | ||
2843 | goto out; | ||
2844 | } | ||
2845 | |||
2846 | memset (key, 0, sizeof (key)); | ||
2847 | snprintf (key, sizeof (key), "volume%d.rb_id", count); | ||
2848 | ret = dict_get_str (vols, key, &rb_id_str); | ||
2849 | if (ret) { | ||
2850 | /* This is not present in older glusterfs versions, | ||
2851 | * so don't error out | ||
2852 | */ | ||
2853 | ret = 0; | ||
2854 | } else { | ||
2855 | uuid_parse (rb_id_str, new_volinfo->rep_brick.rb_id); | ||
2856 | } | ||
2857 | } | ||
2858 | |||
2859 | |||
2860 | ret = glusterd_import_friend_volume_opts (vols, count, new_volinfo); | ||
2861 | if (ret) | ||
2862 | goto out; | ||
2863 | ret = glusterd_import_bricks (vols, count, new_volinfo); | ||
2864 | if (ret) | ||
2865 | goto out; | ||
2866 | *volinfo = new_volinfo; | ||
2867 | out: | ||
2868 | if (msg[0]) | ||
2869 | gf_log ("glusterd", GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 2869, GF_LOG_ERROR, "%s", msg); } while (0); | ||
2870 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 2870, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2871 | return ret; | ||
2872 | } | ||
2873 | |||
2874 | int32_t | ||
2875 | glusterd_volume_disconnect_all_bricks (glusterd_volinfo_t *volinfo) | ||
2876 | { | ||
2877 | int ret = 0; | ||
2878 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
2879 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2879, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
2880 | |||
2881 | 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)))) { | ||
2882 | if (glusterd_is_brick_started (brickinfo)) { | ||
2883 | ret = glusterd_brick_disconnect (brickinfo); | ||
2884 | if (ret) { | ||
2885 | gf_log ("glusterd", GF_LOG_ERROR, "Failed to "do { do { if (0) printf ("Failed to " "disconnect %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 2887, GF_LOG_ERROR, "Failed to " "disconnect %s:%s", brickinfo->hostname, brickinfo->path ); } while (0) | ||
2886 | "disconnect %s:%s", brickinfo->hostname,do { do { if (0) printf ("Failed to " "disconnect %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 2887, GF_LOG_ERROR, "Failed to " "disconnect %s:%s", brickinfo->hostname, brickinfo->path ); } while (0) | ||
2887 | brickinfo->path)do { do { if (0) printf ("Failed to " "disconnect %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 2887, GF_LOG_ERROR, "Failed to " "disconnect %s:%s", brickinfo->hostname, brickinfo->path ); } while (0); | ||
2888 | break; | ||
2889 | } | ||
2890 | } | ||
2891 | } | ||
2892 | |||
2893 | return ret; | ||
2894 | } | ||
2895 | |||
2896 | int32_t | ||
2897 | glusterd_volinfo_copy_brick_portinfo (glusterd_volinfo_t *new_volinfo, | ||
2898 | glusterd_volinfo_t *old_volinfo) | ||
2899 | { | ||
2900 | glusterd_brickinfo_t *new_brickinfo = NULL((void*)0); | ||
2901 | glusterd_brickinfo_t *old_brickinfo = NULL((void*)0); | ||
2902 | |||
2903 | int ret = 0; | ||
2904 | GF_ASSERT (new_volinfo)do { if (!(new_volinfo)) { do { do { if (0) printf ("Assertion failed: " "new_volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2904, GF_LOG_ERROR, "Assertion failed: " "new_volinfo" ); } while (0); } } while (0); | ||
2905 | GF_ASSERT (old_volinfo)do { if (!(old_volinfo)) { do { do { if (0) printf ("Assertion failed: " "old_volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2905, GF_LOG_ERROR, "Assertion failed: " "old_volinfo" ); } while (0); } } while (0); | ||
2906 | if (_gf_false == glusterd_is_volume_started (new_volinfo)) | ||
2907 | goto out; | ||
2908 | list_for_each_entry (new_brickinfo, &new_volinfo->bricks, brick_list)for (new_brickinfo = ((typeof(*new_brickinfo) *)((char *)((& new_volinfo->bricks)->next)-(unsigned long)(&((typeof (*new_brickinfo) *)0)->brick_list))); &new_brickinfo-> brick_list != (&new_volinfo->bricks); new_brickinfo = ( (typeof(*new_brickinfo) *)((char *)(new_brickinfo->brick_list .next)-(unsigned long)(&((typeof(*new_brickinfo) *)0)-> brick_list)))) { | ||
2909 | ret = glusterd_volume_brickinfo_get (new_brickinfo->uuid, | ||
2910 | new_brickinfo->hostname, | ||
2911 | new_brickinfo->path, | ||
2912 | old_volinfo, &old_brickinfo); | ||
2913 | if ((0 == ret) && glusterd_is_brick_started (old_brickinfo)) { | ||
2914 | new_brickinfo->port = old_brickinfo->port; | ||
2915 | } | ||
2916 | } | ||
2917 | out: | ||
2918 | ret = 0; | ||
2919 | return ret; | ||
2920 | } | ||
2921 | |||
2922 | int32_t | ||
2923 | glusterd_volinfo_stop_stale_bricks (glusterd_volinfo_t *new_volinfo, | ||
2924 | glusterd_volinfo_t *old_volinfo) | ||
2925 | { | ||
2926 | glusterd_brickinfo_t *new_brickinfo = NULL((void*)0); | ||
2927 | glusterd_brickinfo_t *old_brickinfo = NULL((void*)0); | ||
2928 | |||
2929 | int ret = 0; | ||
2930 | GF_ASSERT (new_volinfo)do { if (!(new_volinfo)) { do { do { if (0) printf ("Assertion failed: " "new_volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2930, GF_LOG_ERROR, "Assertion failed: " "new_volinfo" ); } while (0); } } while (0); | ||
2931 | GF_ASSERT (old_volinfo)do { if (!(old_volinfo)) { do { do { if (0) printf ("Assertion failed: " "old_volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2931, GF_LOG_ERROR, "Assertion failed: " "old_volinfo" ); } while (0); } } while (0); | ||
2932 | if (_gf_false == glusterd_is_volume_started (old_volinfo)) | ||
2933 | goto out; | ||
2934 | list_for_each_entry (old_brickinfo, &old_volinfo->bricks, brick_list)for (old_brickinfo = ((typeof(*old_brickinfo) *)((char *)((& old_volinfo->bricks)->next)-(unsigned long)(&((typeof (*old_brickinfo) *)0)->brick_list))); &old_brickinfo-> brick_list != (&old_volinfo->bricks); old_brickinfo = ( (typeof(*old_brickinfo) *)((char *)(old_brickinfo->brick_list .next)-(unsigned long)(&((typeof(*old_brickinfo) *)0)-> brick_list)))) { | ||
2935 | ret = glusterd_volume_brickinfo_get (old_brickinfo->uuid, | ||
2936 | old_brickinfo->hostname, | ||
2937 | old_brickinfo->path, | ||
2938 | new_volinfo, &new_brickinfo); | ||
2939 | if (ret) { | ||
2940 | /*TODO: may need to switch to 'atomic' flavour of | ||
2941 | * brick_stop, once we make peer rpc program also | ||
2942 | * synctask enabled*/ | ||
2943 | ret = glusterd_brick_stop (old_volinfo, old_brickinfo, | ||
2944 | _gf_false); | ||
2945 | if (ret) | ||
2946 | gf_log ("glusterd", GF_LOG_ERROR, "Failed to "do { do { if (0) printf ("Failed to " "stop brick %s:%s", old_brickinfo ->hostname, old_brickinfo->path); } while (0); _gf_log ( "glusterd", "glusterd-utils.c", __FUNCTION__, 2948, GF_LOG_ERROR , "Failed to " "stop brick %s:%s", old_brickinfo->hostname , old_brickinfo->path); } while (0) | ||
2947 | "stop brick %s:%s", old_brickinfo->hostname,do { do { if (0) printf ("Failed to " "stop brick %s:%s", old_brickinfo ->hostname, old_brickinfo->path); } while (0); _gf_log ( "glusterd", "glusterd-utils.c", __FUNCTION__, 2948, GF_LOG_ERROR , "Failed to " "stop brick %s:%s", old_brickinfo->hostname , old_brickinfo->path); } while (0) | ||
2948 | old_brickinfo->path)do { do { if (0) printf ("Failed to " "stop brick %s:%s", old_brickinfo ->hostname, old_brickinfo->path); } while (0); _gf_log ( "glusterd", "glusterd-utils.c", __FUNCTION__, 2948, GF_LOG_ERROR , "Failed to " "stop brick %s:%s", old_brickinfo->hostname , old_brickinfo->path); } while (0); | ||
2949 | } | ||
2950 | } | ||
2951 | ret = 0; | ||
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-utils.c", __FUNCTION__, 2953, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
2954 | return ret; | ||
2955 | } | ||
2956 | |||
2957 | int32_t | ||
2958 | glusterd_delete_stale_volume (glusterd_volinfo_t *stale_volinfo, | ||
2959 | glusterd_volinfo_t *valid_volinfo) | ||
2960 | { | ||
2961 | GF_ASSERT (stale_volinfo)do { if (!(stale_volinfo)) { do { do { if (0) printf ("Assertion failed: " "stale_volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2961, GF_LOG_ERROR, "Assertion failed: " "stale_volinfo" ); } while (0); } } while (0); | ||
2962 | GF_ASSERT (valid_volinfo)do { if (!(valid_volinfo)) { do { do { if (0) printf ("Assertion failed: " "valid_volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 2962, GF_LOG_ERROR, "Assertion failed: " "valid_volinfo" ); } while (0); } } while (0); | ||
2963 | |||
2964 | /* If stale volume is in started state, copy the port numbers of the | ||
2965 | * local bricks if they exist in the valid volume information. | ||
2966 | * stop stale bricks. Stale volume information is going to be deleted. | ||
2967 | * Which deletes the valid brick information inside stale volinfo. | ||
2968 | * We dont want brick_rpc_notify to access already deleted brickinfo. | ||
2969 | * Disconnect all bricks from stale_volinfo (unconditionally), since | ||
2970 | * they are being deleted subsequently. | ||
2971 | */ | ||
2972 | if (glusterd_is_volume_started (stale_volinfo)) { | ||
2973 | if (glusterd_is_volume_started (valid_volinfo)) { | ||
2974 | (void) glusterd_volinfo_stop_stale_bricks (valid_volinfo, | ||
2975 | stale_volinfo); | ||
2976 | //Only valid bricks will be running now. | ||
2977 | (void) glusterd_volinfo_copy_brick_portinfo (valid_volinfo, | ||
2978 | stale_volinfo); | ||
2979 | |||
2980 | } else { | ||
2981 | (void) glusterd_stop_bricks (stale_volinfo); | ||
2982 | } | ||
2983 | |||
2984 | (void) glusterd_volume_disconnect_all_bricks (stale_volinfo); | ||
2985 | } | ||
2986 | /* Delete all the bricks and stores and vol files. They will be created | ||
2987 | * again by the valid_volinfo. Volume store delete should not be | ||
2988 | * performed because some of the bricks could still be running, | ||
2989 | * keeping pid files under run directory | ||
2990 | */ | ||
2991 | (void) glusterd_delete_all_bricks (stale_volinfo); | ||
2992 | if (stale_volinfo->shandle) { | ||
2993 | unlink (stale_volinfo->shandle->path); | ||
2994 | (void) glusterd_store_handle_destroy (stale_volinfo->shandle); | ||
2995 | stale_volinfo->shandle = NULL((void*)0); | ||
2996 | } | ||
2997 | (void) glusterd_volinfo_delete (stale_volinfo); | ||
2998 | return 0; | ||
2999 | } | ||
3000 | |||
3001 | int32_t | ||
3002 | glusterd_import_friend_volume (dict_t *vols, size_t count) | ||
3003 | { | ||
3004 | |||
3005 | int32_t ret = -1; | ||
3006 | glusterd_conf_t *priv = NULL((void*)0); | ||
3007 | xlator_t *this = NULL((void*)0); | ||
3008 | glusterd_volinfo_t *old_volinfo = NULL((void*)0); | ||
3009 | glusterd_volinfo_t *new_volinfo = NULL((void*)0); | ||
3010 | |||
3011 | GF_ASSERT (vols)do { if (!(vols)) { do { do { if (0) printf ("Assertion failed: " "vols"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3011, GF_LOG_ERROR, "Assertion failed: " "vols" ); } while (0); } } while (0); | ||
3012 | |||
3013 | this = THIS(*__glusterfs_this_location()); | ||
3014 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3014, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
3015 | priv = this->private; | ||
3016 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3016, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
3017 | ret = glusterd_import_volinfo (vols, count, &new_volinfo); | ||
3018 | if (ret) | ||
3019 | goto out; | ||
3020 | |||
3021 | ret = glusterd_volinfo_find (new_volinfo->volname, &old_volinfo); | ||
3022 | if (0 == ret) { | ||
3023 | (void) glusterd_delete_stale_volume (old_volinfo, new_volinfo); | ||
3024 | } | ||
3025 | |||
3026 | if (glusterd_is_volume_started (new_volinfo)) { | ||
3027 | (void) glusterd_start_bricks (new_volinfo); | ||
3028 | } | ||
3029 | |||
3030 | ret = glusterd_store_volinfo (new_volinfo, GLUSTERD_VOLINFO_VER_AC_NONE); | ||
3031 | ret = glusterd_create_volfiles_and_notify_services (new_volinfo); | ||
3032 | if (ret) | ||
3033 | goto out; | ||
3034 | |||
3035 | gd_update_volume_op_versions (new_volinfo); | ||
3036 | |||
3037 | list_add_tail (&new_volinfo->vol_list, &priv->volumes); | ||
3038 | out: | ||
3039 | gf_log ("", GF_LOG_DEBUG, "Returning with ret: %d", ret)do { do { if (0) printf ("Returning with ret: %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3039, GF_LOG_DEBUG , "Returning with ret: %d", ret); } while (0); | ||
3040 | return ret; | ||
3041 | } | ||
3042 | |||
3043 | int32_t | ||
3044 | glusterd_import_friend_volumes (dict_t *vols) | ||
3045 | { | ||
3046 | int32_t ret = -1; | ||
3047 | int32_t count = 0; | ||
3048 | int i = 1; | ||
3049 | |||
3050 | GF_ASSERT (vols)do { if (!(vols)) { do { do { if (0) printf ("Assertion failed: " "vols"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3050, GF_LOG_ERROR, "Assertion failed: " "vols" ); } while (0); } } while (0); | ||
3051 | |||
3052 | ret = dict_get_int32 (vols, "count", &count); | ||
3053 | if (ret) | ||
3054 | goto out; | ||
3055 | |||
3056 | while (i <= count) { | ||
3057 | ret = glusterd_import_friend_volume (vols, i); | ||
3058 | if (ret) | ||
3059 | goto out; | ||
3060 | i++; | ||
3061 | } | ||
3062 | |||
3063 | out: | ||
3064 | gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret)do { do { if (0) printf ("Returning with %d", ret); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3064, GF_LOG_DEBUG , "Returning with %d", ret); } while (0); | ||
3065 | return ret; | ||
3066 | } | ||
3067 | |||
3068 | int | ||
3069 | glusterd_get_global_opt_version (dict_t *opts, uint32_t *version) | ||
3070 | { | ||
3071 | int ret = -1; | ||
3072 | char *version_str = NULL((void*)0); | ||
3073 | |||
3074 | ret = dict_get_str (opts, GLUSTERD_GLOBAL_OPT_VERSION"global-option-version", &version_str); | ||
3075 | if (ret) | ||
3076 | goto out; | ||
3077 | |||
3078 | ret = gf_string2uint (version_str, version); | ||
3079 | if (ret) | ||
3080 | goto out; | ||
3081 | ret = 0; | ||
3082 | out: | ||
3083 | return ret; | ||
3084 | } | ||
3085 | |||
3086 | int | ||
3087 | glusterd_get_next_global_opt_version_str (dict_t *opts, char **version_str) | ||
3088 | { | ||
3089 | int ret = -1; | ||
3090 | char version_string[64] = {0}; | ||
3091 | uint32_t version = 0; | ||
3092 | |||
3093 | ret = glusterd_get_global_opt_version (opts, &version); | ||
3094 | if (ret) | ||
3095 | goto out; | ||
3096 | version++; | ||
3097 | snprintf (version_string, sizeof (version_string), "%"PRIu32"u", version); | ||
3098 | *version_str = gf_strdup (version_string); | ||
3099 | if (*version_str) | ||
3100 | ret = 0; | ||
3101 | out: | ||
3102 | return ret; | ||
3103 | } | ||
3104 | |||
3105 | int32_t | ||
3106 | glusterd_import_global_opts (dict_t *friend_data) | ||
3107 | { | ||
3108 | xlator_t *this = NULL((void*)0); | ||
3109 | glusterd_conf_t *conf = NULL((void*)0); | ||
3110 | int ret = -1; | ||
3111 | dict_t *import_options = NULL((void*)0); | ||
3112 | int count = 0; | ||
3113 | uint32_t local_version = 0; | ||
3114 | uint32_t remote_version = 0; | ||
3115 | |||
3116 | this = THIS(*__glusterfs_this_location()); | ||
3117 | conf = this->private; | ||
3118 | |||
3119 | ret = dict_get_int32 (friend_data, "global-opt-count", &count); | ||
3120 | if (ret) { | ||
3121 | //old version peer | ||
3122 | ret = 0; | ||
3123 | goto out; | ||
3124 | } | ||
3125 | |||
3126 | import_options = dict_new (); | ||
3127 | if (!import_options) | ||
3128 | goto out; | ||
3129 | ret = import_prdict_dict (friend_data, import_options, "key", "val", | ||
3130 | count, "global"); | ||
3131 | if (ret) { | ||
3132 | gf_log (this->name, GF_LOG_ERROR, "Failed to import"do { do { if (0) printf ("Failed to import" " global options" ); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 3133, GF_LOG_ERROR, "Failed to import" " global options"); } while (0) | ||
3133 | " global options")do { do { if (0) printf ("Failed to import" " global options" ); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 3133, GF_LOG_ERROR, "Failed to import" " global options"); } while (0); | ||
3134 | goto out; | ||
3135 | } | ||
3136 | |||
3137 | ret = glusterd_get_global_opt_version (conf->opts, &local_version); | ||
3138 | if (ret) | ||
3139 | goto out; | ||
3140 | ret = glusterd_get_global_opt_version (import_options, &remote_version); | ||
3141 | if (ret) | ||
3142 | goto out; | ||
3143 | if (remote_version > local_version) { | ||
3144 | ret = glusterd_store_options (this, import_options); | ||
3145 | if (ret) | ||
3146 | goto out; | ||
3147 | dict_unref (conf->opts); | ||
3148 | conf->opts = dict_ref (import_options); | ||
3149 | } | ||
3150 | ret = 0; | ||
3151 | out: | ||
3152 | if (import_options) | ||
3153 | dict_unref (import_options); | ||
3154 | return ret; | ||
3155 | } | ||
3156 | |||
3157 | int32_t | ||
3158 | glusterd_compare_friend_data (dict_t *vols, int32_t *status, char *hostname) | ||
3159 | { | ||
3160 | int32_t ret = -1; | ||
3161 | int32_t count = 0; | ||
3162 | int i = 1; | ||
3163 | gf_boolean_t update = _gf_false; | ||
3164 | gf_boolean_t stale_nfs = _gf_false; | ||
3165 | gf_boolean_t stale_shd = _gf_false; | ||
3166 | |||
3167 | GF_ASSERT (vols)do { if (!(vols)) { do { do { if (0) printf ("Assertion failed: " "vols"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3167, GF_LOG_ERROR, "Assertion failed: " "vols" ); } while (0); } } while (0); | ||
3168 | GF_ASSERT (status)do { if (!(status)) { do { do { if (0) printf ("Assertion failed: " "status"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3168, GF_LOG_ERROR, "Assertion failed: " "status" ); } while (0); } } while (0); | ||
3169 | |||
3170 | ret = dict_get_int32 (vols, "count", &count); | ||
3171 | if (ret) | ||
3172 | goto out; | ||
3173 | |||
3174 | while (i <= count) { | ||
3175 | ret = glusterd_compare_friend_volume (vols, i, status, | ||
3176 | hostname); | ||
3177 | if (ret) | ||
3178 | goto out; | ||
3179 | |||
3180 | if (GLUSTERD_VOL_COMP_RJT == *status) { | ||
3181 | ret = 0; | ||
3182 | goto out; | ||
3183 | } | ||
3184 | if (GLUSTERD_VOL_COMP_UPDATE_REQ == *status) | ||
3185 | update = _gf_true; | ||
3186 | |||
3187 | i++; | ||
3188 | } | ||
3189 | |||
3190 | if (update) { | ||
3191 | if (glusterd_is_nodesvc_running ("nfs")) | ||
3192 | stale_nfs = _gf_true; | ||
3193 | if (glusterd_is_nodesvc_running ("glustershd")) | ||
3194 | stale_shd = _gf_true; | ||
3195 | ret = glusterd_import_global_opts (vols); | ||
3196 | if (ret) | ||
3197 | goto out; | ||
3198 | ret = glusterd_import_friend_volumes (vols); | ||
3199 | if (ret) | ||
3200 | goto out; | ||
3201 | if (_gf_false == glusterd_are_all_volumes_stopped ()) { | ||
3202 | ret = glusterd_nodesvcs_handle_graph_change (NULL((void*)0)); | ||
3203 | } else { | ||
3204 | if (stale_nfs) | ||
3205 | glusterd_nfs_server_stop (); | ||
3206 | if (stale_shd) | ||
3207 | glusterd_shd_stop (); | ||
3208 | } | ||
3209 | } | ||
3210 | |||
3211 | out: | ||
3212 | gf_log ("", GF_LOG_DEBUG, "Returning with ret: %d, status: %d",do { do { if (0) printf ("Returning with ret: %d, status: %d" , ret, *status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 3213, GF_LOG_DEBUG, "Returning with ret: %d, status: %d" , ret, *status); } while (0) | ||
3213 | ret, *status)do { do { if (0) printf ("Returning with ret: %d, status: %d" , ret, *status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 3213, GF_LOG_DEBUG, "Returning with ret: %d, status: %d" , ret, *status); } while (0); | ||
3214 | |||
3215 | return ret; | ||
3216 | } | ||
3217 | |||
3218 | /* Valid only in if service is 'local' to glusterd. | ||
3219 | * pid can be -1, if reading pidfile failed */ | ||
3220 | gf_boolean_t | ||
3221 | glusterd_is_service_running (char *pidfile, int *pid) | ||
3222 | { | ||
3223 | FILE *file = NULL((void*)0); | ||
3224 | gf_boolean_t running = _gf_false; | ||
3225 | int ret = 0; | ||
3226 | int fno = 0; | ||
3227 | |||
3228 | file = fopen (pidfile, "r+"); | ||
3229 | if (!file) | ||
3230 | goto out; | ||
3231 | |||
3232 | fno = fileno (file); | ||
3233 | ret = lockf (fno, F_TEST3, 0); | ||
3234 | if (ret == -1) | ||
3235 | running = _gf_true; | ||
3236 | if (!pid) | ||
3237 | goto out; | ||
3238 | |||
3239 | ret = fscanf (file, "%d", pid); | ||
3240 | if (ret <= 0) { | ||
3241 | gf_log ("", GF_LOG_ERROR, "Unable to read pidfile: %s, %s",do { do { if (0) printf ("Unable to read pidfile: %s, %s", pidfile , strerror ((*__errno_location ()))); } while (0); _gf_log ("" , "glusterd-utils.c", __FUNCTION__, 3242, GF_LOG_ERROR, "Unable to read pidfile: %s, %s" , pidfile, strerror ((*__errno_location ()))); } while (0) | ||
3242 | pidfile, strerror (errno))do { do { if (0) printf ("Unable to read pidfile: %s, %s", pidfile , strerror ((*__errno_location ()))); } while (0); _gf_log ("" , "glusterd-utils.c", __FUNCTION__, 3242, GF_LOG_ERROR, "Unable to read pidfile: %s, %s" , pidfile, strerror ((*__errno_location ()))); } while (0); | ||
3243 | *pid = -1; | ||
3244 | } | ||
3245 | |||
3246 | out: | ||
3247 | if (file) | ||
3248 | fclose (file); | ||
3249 | return running; | ||
3250 | } | ||
3251 | |||
3252 | void | ||
3253 | glusterd_get_nodesvc_dir (char *server, char *workdir, | ||
3254 | char *path, size_t len) | ||
3255 | { | ||
3256 | 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-utils.c" , __FUNCTION__, 3256, GF_LOG_ERROR, "Assertion failed: " "len == PATH_MAX" ); } while (0); } } while (0); | ||
3257 | snprintf (path, len, "%s/%s", workdir, server); | ||
3258 | } | ||
3259 | |||
3260 | void | ||
3261 | glusterd_get_nodesvc_rundir (char *server, char *workdir, | ||
3262 | char *path, size_t len) | ||
3263 | { | ||
3264 | char dir[PATH_MAX4096] = {0}; | ||
3265 | 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-utils.c" , __FUNCTION__, 3265, GF_LOG_ERROR, "Assertion failed: " "len == PATH_MAX" ); } while (0); } } while (0); | ||
3266 | |||
3267 | glusterd_get_nodesvc_dir (server, workdir, dir, sizeof (dir)); | ||
3268 | snprintf (path, len, "%s/run", dir); | ||
3269 | } | ||
3270 | |||
3271 | void | ||
3272 | glusterd_get_nodesvc_pidfile (char *server, char *workdir, | ||
3273 | char *path, size_t len) | ||
3274 | { | ||
3275 | char dir[PATH_MAX4096] = {0}; | ||
3276 | 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-utils.c" , __FUNCTION__, 3276, GF_LOG_ERROR, "Assertion failed: " "len == PATH_MAX" ); } while (0); } } while (0); | ||
3277 | |||
3278 | glusterd_get_nodesvc_rundir (server, workdir, dir, sizeof (dir)); | ||
3279 | snprintf (path, len, "%s/%s.pid", dir, server); | ||
3280 | } | ||
3281 | |||
3282 | void | ||
3283 | glusterd_get_nodesvc_volfile (char *server, char *workdir, | ||
3284 | char *volfile, size_t len) | ||
3285 | { | ||
3286 | char dir[PATH_MAX4096] = {0,}; | ||
3287 | 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-utils.c" , __FUNCTION__, 3287, GF_LOG_ERROR, "Assertion failed: " "len == PATH_MAX" ); } while (0); } } while (0); | ||
3288 | |||
3289 | glusterd_get_nodesvc_dir (server, workdir, dir, sizeof (dir)); | ||
3290 | snprintf (volfile, len, "%s/%s-server.vol", dir, server); | ||
3291 | } | ||
3292 | |||
3293 | void | ||
3294 | glusterd_nodesvc_set_online_status (char *server, gf_boolean_t status) | ||
3295 | { | ||
3296 | glusterd_conf_t *priv = NULL((void*)0); | ||
3297 | |||
3298 | GF_ASSERT (server)do { if (!(server)) { do { do { if (0) printf ("Assertion failed: " "server"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3298, GF_LOG_ERROR, "Assertion failed: " "server" ); } while (0); } } while (0); | ||
3299 | priv = THIS(*__glusterfs_this_location())->private; | ||
3300 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3300, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
3301 | GF_ASSERT (priv->shd)do { if (!(priv->shd)) { do { do { if (0) printf ("Assertion failed: " "priv->shd"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3301, GF_LOG_ERROR, "Assertion failed: " "priv->shd" ); } while (0); } } while (0); | ||
3302 | GF_ASSERT (priv->nfs)do { if (!(priv->nfs)) { do { do { if (0) printf ("Assertion failed: " "priv->nfs"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3302, GF_LOG_ERROR, "Assertion failed: " "priv->nfs" ); } while (0); } } while (0); | ||
3303 | |||
3304 | if (!strcmp("glustershd", server)) | ||
3305 | priv->shd->online = status; | ||
3306 | else if (!strcmp ("nfs", server)) | ||
3307 | priv->nfs->online = status; | ||
3308 | } | ||
3309 | |||
3310 | gf_boolean_t | ||
3311 | glusterd_is_nodesvc_online (char *server) | ||
3312 | { | ||
3313 | glusterd_conf_t *conf = NULL((void*)0); | ||
3314 | gf_boolean_t online = _gf_false; | ||
3315 | |||
3316 | GF_ASSERT (server)do { if (!(server)) { do { do { if (0) printf ("Assertion failed: " "server"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3316, GF_LOG_ERROR, "Assertion failed: " "server" ); } while (0); } } while (0); | ||
3317 | conf = THIS(*__glusterfs_this_location())->private; | ||
3318 | GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: " "conf"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3318, GF_LOG_ERROR, "Assertion failed: " "conf" ); } while (0); } } while (0); | ||
3319 | GF_ASSERT (conf->shd)do { if (!(conf->shd)) { do { do { if (0) printf ("Assertion failed: " "conf->shd"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3319, GF_LOG_ERROR, "Assertion failed: " "conf->shd" ); } while (0); } } while (0); | ||
3320 | GF_ASSERT (conf->nfs)do { if (!(conf->nfs)) { do { do { if (0) printf ("Assertion failed: " "conf->nfs"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3320, GF_LOG_ERROR, "Assertion failed: " "conf->nfs" ); } while (0); } } while (0); | ||
3321 | |||
3322 | if (!strcmp (server, "glustershd")) | ||
3323 | online = conf->shd->online; | ||
3324 | else if (!strcmp (server, "nfs")) | ||
3325 | online = conf->nfs->online; | ||
3326 | |||
3327 | return online; | ||
3328 | } | ||
3329 | |||
3330 | int32_t | ||
3331 | glusterd_nodesvc_set_socket_filepath (char *rundir, uuid_t uuid, | ||
3332 | char *socketpath, int len) | ||
3333 | { | ||
3334 | char sockfilepath[PATH_MAX4096] = {0,}; | ||
3335 | |||
3336 | snprintf (sockfilepath, sizeof (sockfilepath), "%s/run-%s", | ||
3337 | rundir, uuid_utoa (uuid)); | ||
3338 | |||
3339 | glusterd_set_socket_filepath (sockfilepath, socketpath, len); | ||
3340 | return 0; | ||
3341 | } | ||
3342 | |||
3343 | struct rpc_clnt* | ||
3344 | glusterd_pending_node_get_rpc (glusterd_pending_node_t *pending_node) | ||
3345 | { | ||
3346 | struct rpc_clnt *rpc = NULL((void*)0); | ||
3347 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
3348 | nodesrv_t *shd = NULL((void*)0); | ||
3349 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
3350 | nodesrv_t *nfs = NULL((void*)0); | ||
3351 | |||
3352 | GF_VALIDATE_OR_GOTO (THIS->name, pending_node, out)do { if (!pending_node) { (*__errno_location ()) = 22; do { do { if (0) printf ("invalid argument: " "pending_node"); } while (0); _gf_log_callingfn ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 3352, GF_LOG_ERROR, "invalid argument: " "pending_node"); } while (0); goto out; } } while (0); | ||
3353 | GF_VALIDATE_OR_GOTO (THIS->name, pending_node->node, out)do { if (!pending_node->node) { (*__errno_location ()) = 22 ; do { do { if (0) printf ("invalid argument: " "pending_node->node" ); } while (0); _gf_log_callingfn ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 3353, GF_LOG_ERROR , "invalid argument: " "pending_node->node"); } while (0); goto out; } } while (0); | ||
3354 | |||
3355 | if (pending_node->type == GD_NODE_BRICK) { | ||
3356 | brickinfo = pending_node->node; | ||
3357 | rpc = brickinfo->rpc; | ||
3358 | |||
3359 | } else if (pending_node->type == GD_NODE_SHD) { | ||
3360 | shd = pending_node->node; | ||
3361 | rpc = shd->rpc; | ||
3362 | |||
3363 | } else if (pending_node->type == GD_NODE_REBALANCE) { | ||
3364 | volinfo = pending_node->node; | ||
3365 | if (volinfo->rebal.defrag) | ||
3366 | rpc = volinfo->rebal.defrag->rpc; | ||
3367 | |||
3368 | } else if (pending_node->type == GD_NODE_NFS) { | ||
3369 | nfs = pending_node->node; | ||
3370 | rpc = nfs->rpc; | ||
3371 | |||
3372 | } else { | ||
3373 | GF_ASSERT (0)do { if (!(0)) { do { do { if (0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3373, GF_LOG_ERROR, "Assertion failed: " "0") ; } while (0); } } while (0); | ||
3374 | } | ||
3375 | |||
3376 | out: | ||
3377 | return rpc; | ||
3378 | } | ||
3379 | |||
3380 | struct rpc_clnt* | ||
3381 | glusterd_nodesvc_get_rpc (char *server) | ||
3382 | { | ||
3383 | glusterd_conf_t *priv = NULL((void*)0); | ||
3384 | struct rpc_clnt *rpc = NULL((void*)0); | ||
3385 | |||
3386 | GF_ASSERT (server)do { if (!(server)) { do { do { if (0) printf ("Assertion failed: " "server"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3386, GF_LOG_ERROR, "Assertion failed: " "server" ); } while (0); } } while (0); | ||
3387 | priv = THIS(*__glusterfs_this_location())->private; | ||
3388 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3388, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
3389 | GF_ASSERT (priv->shd)do { if (!(priv->shd)) { do { do { if (0) printf ("Assertion failed: " "priv->shd"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3389, GF_LOG_ERROR, "Assertion failed: " "priv->shd" ); } while (0); } } while (0); | ||
3390 | GF_ASSERT (priv->nfs)do { if (!(priv->nfs)) { do { do { if (0) printf ("Assertion failed: " "priv->nfs"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3390, GF_LOG_ERROR, "Assertion failed: " "priv->nfs" ); } while (0); } } while (0); | ||
3391 | |||
3392 | if (!strcmp (server, "glustershd")) | ||
3393 | rpc = priv->shd->rpc; | ||
3394 | else if (!strcmp (server, "nfs")) | ||
3395 | rpc = priv->nfs->rpc; | ||
3396 | |||
3397 | return rpc; | ||
3398 | } | ||
3399 | |||
3400 | int32_t | ||
3401 | glusterd_nodesvc_set_rpc (char *server, struct rpc_clnt *rpc) | ||
3402 | { | ||
3403 | int ret = 0; | ||
3404 | xlator_t *this = NULL((void*)0); | ||
3405 | glusterd_conf_t *priv = NULL((void*)0); | ||
3406 | |||
3407 | this = THIS(*__glusterfs_this_location()); | ||
3408 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3408, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
3409 | priv = this->private; | ||
3410 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3410, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
3411 | GF_ASSERT (priv->shd)do { if (!(priv->shd)) { do { do { if (0) printf ("Assertion failed: " "priv->shd"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3411, GF_LOG_ERROR, "Assertion failed: " "priv->shd" ); } while (0); } } while (0); | ||
3412 | GF_ASSERT (priv->nfs)do { if (!(priv->nfs)) { do { do { if (0) printf ("Assertion failed: " "priv->nfs"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3412, GF_LOG_ERROR, "Assertion failed: " "priv->nfs" ); } while (0); } } while (0); | ||
3413 | |||
3414 | if (!strcmp ("glustershd", server)) | ||
3415 | priv->shd->rpc = rpc; | ||
3416 | else if (!strcmp ("nfs", server)) | ||
3417 | priv->nfs->rpc = rpc; | ||
3418 | |||
3419 | return ret; | ||
3420 | } | ||
3421 | |||
3422 | int32_t | ||
3423 | glusterd_nodesvc_connect (char *server, char *socketpath) { | ||
3424 | int ret = 0; | ||
3425 | dict_t *options = NULL((void*)0); | ||
3426 | struct rpc_clnt *rpc = NULL((void*)0); | ||
3427 | glusterd_conf_t *priv = THIS(*__glusterfs_this_location())->private; | ||
3428 | |||
3429 | rpc = glusterd_nodesvc_get_rpc (server); | ||
3430 | |||
3431 | if (rpc == NULL((void*)0)) { | ||
3432 | /* Setting frame-timeout to 10mins (600seconds). | ||
3433 | * Unix domain sockets ensures that the connection is reliable. | ||
3434 | * The default timeout of 30mins used for unreliable network | ||
3435 | * connections is too long for unix domain socket connections. | ||
3436 | */ | ||
3437 | ret = rpc_clnt_transport_unix_options_build (&options, | ||
3438 | socketpath, 600); | ||
3439 | if (ret) | ||
3440 | goto out; | ||
3441 | synclock_unlock (&priv->big_lock); | ||
3442 | ret = glusterd_rpc_create (&rpc, options, | ||
3443 | glusterd_nodesvc_rpc_notify, | ||
3444 | server); | ||
3445 | synclock_lock (&priv->big_lock); | ||
3446 | if (ret) | ||
3447 | goto out; | ||
3448 | (void) glusterd_nodesvc_set_rpc (server, rpc); | ||
3449 | } | ||
3450 | out: | ||
3451 | return ret; | ||
3452 | } | ||
3453 | |||
3454 | int32_t | ||
3455 | glusterd_nodesvc_disconnect (char *server) | ||
3456 | { | ||
3457 | struct rpc_clnt *rpc = NULL((void*)0); | ||
3458 | |||
3459 | rpc = glusterd_nodesvc_get_rpc (server); | ||
3460 | |||
3461 | if (rpc) { | ||
3462 | rpc_clnt_connection_cleanup (&rpc->conn); | ||
3463 | rpc_clnt_unref (rpc); | ||
3464 | (void)glusterd_nodesvc_set_rpc (server, NULL((void*)0)); | ||
3465 | } | ||
3466 | |||
3467 | return 0; | ||
3468 | } | ||
3469 | |||
3470 | int32_t | ||
3471 | glusterd_nodesvc_start (char *server) | ||
3472 | { | ||
3473 | int32_t ret = -1; | ||
3474 | xlator_t *this = NULL((void*)0); | ||
3475 | glusterd_conf_t *priv = NULL((void*)0); | ||
3476 | runner_t runner = {0,}; | ||
3477 | char pidfile[PATH_MAX4096] = {0,}; | ||
3478 | char logfile[PATH_MAX4096] = {0,}; | ||
3479 | char volfile[PATH_MAX4096] = {0,}; | ||
3480 | char rundir[PATH_MAX4096] = {0,}; | ||
3481 | char sockfpath[PATH_MAX4096] = {0,}; | ||
3482 | char volfileid[256] = {0}; | ||
3483 | char glusterd_uuid_option[1024] = {0}; | ||
3484 | char valgrind_logfile[PATH_MAX4096] = {0}; | ||
3485 | |||
3486 | this = THIS(*__glusterfs_this_location()); | ||
3487 | GF_ASSERT(this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3487, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
3488 | |||
3489 | priv = this->private; | ||
3490 | |||
3491 | glusterd_get_nodesvc_rundir (server, priv->workdir, | ||
3492 | rundir, sizeof (rundir)); | ||
3493 | ret = mkdir (rundir, 0777); | ||
3494 | |||
3495 | if ((ret == -1) && (EEXIST17 != errno(*__errno_location ()))) { | ||
3496 | gf_log ("", GF_LOG_ERROR, "Unable to create rundir %s",do { do { if (0) printf ("Unable to create rundir %s", rundir ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3497, GF_LOG_ERROR, "Unable to create rundir %s", rundir); } while (0) | ||
3497 | rundir)do { do { if (0) printf ("Unable to create rundir %s", rundir ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3497, GF_LOG_ERROR, "Unable to create rundir %s", rundir); } while (0); | ||
3498 | goto out; | ||
3499 | } | ||
3500 | |||
3501 | glusterd_get_nodesvc_pidfile (server, priv->workdir, | ||
3502 | pidfile, sizeof (pidfile)); | ||
3503 | glusterd_get_nodesvc_volfile (server, priv->workdir, | ||
3504 | volfile, sizeof (volfile)); | ||
3505 | ret = access (volfile, F_OK0); | ||
3506 | if (ret) { | ||
3507 | gf_log ("", GF_LOG_ERROR, "%s Volfile %s is not present",do { do { if (0) printf ("%s Volfile %s is not present", server , volfile); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3508, GF_LOG_ERROR, "%s Volfile %s is not present", server, volfile); } while (0) | ||
3508 | server, volfile)do { do { if (0) printf ("%s Volfile %s is not present", server , volfile); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3508, GF_LOG_ERROR, "%s Volfile %s is not present", server, volfile); } while (0); | ||
3509 | goto out; | ||
3510 | } | ||
3511 | |||
3512 | snprintf (logfile, PATH_MAX4096, "%s/%s.log", DEFAULT_LOG_FILE_DIRECTORY"/usr/local/var" "/log/glusterfs", | ||
3513 | server); | ||
3514 | snprintf (volfileid, sizeof (volfileid), "gluster/%s", server); | ||
3515 | |||
3516 | glusterd_nodesvc_set_socket_filepath (rundir, MY_UUID(__glusterd_uuid()), | ||
3517 | sockfpath, sizeof (sockfpath)); | ||
3518 | |||
3519 | runinit (&runner); | ||
3520 | |||
3521 | if (priv->valgrind) { | ||
3522 | snprintf (valgrind_logfile, PATH_MAX4096, | ||
3523 | "%s/valgrind-%s.log", | ||
3524 | DEFAULT_LOG_FILE_DIRECTORY"/usr/local/var" "/log/glusterfs", | ||
3525 | server); | ||
3526 | |||
3527 | runner_add_args (&runner, "valgrind", "--leak-check=full", | ||
3528 | "--trace-children=yes", "--track-origins=yes", | ||
3529 | NULL((void*)0)); | ||
3530 | runner_argprintf (&runner, "--log-file=%s", valgrind_logfile); | ||
3531 | } | ||
3532 | |||
3533 | runner_add_args (&runner, SBIN_DIR"/usr/local/sbin""/glusterfs", | ||
3534 | "-s", "localhost", | ||
3535 | "--volfile-id", volfileid, | ||
3536 | "-p", pidfile, | ||
3537 | "-l", logfile, | ||
3538 | "-S", sockfpath, NULL((void*)0)); | ||
3539 | |||
3540 | if (!strcmp (server, "glustershd")) { | ||
3541 | snprintf (glusterd_uuid_option, sizeof (glusterd_uuid_option), | ||
3542 | "*replicate*.node-uuid=%s", uuid_utoa (MY_UUID(__glusterd_uuid()))); | ||
3543 | runner_add_args (&runner, "--xlator-option", | ||
3544 | glusterd_uuid_option, NULL((void*)0)); | ||
3545 | } | ||
3546 | runner_log (&runner, "", GF_LOG_DEBUG, | ||
3547 | "Starting the nfs/glustershd services"); | ||
3548 | |||
3549 | ret = runner_run_nowait (&runner); | ||
3550 | if (ret == 0) { | ||
3551 | glusterd_nodesvc_connect (server, sockfpath); | ||
3552 | } | ||
3553 | out: | ||
3554 | return ret; | ||
3555 | } | ||
3556 | |||
3557 | int | ||
3558 | glusterd_nfs_server_start () | ||
3559 | { | ||
3560 | return glusterd_nodesvc_start ("nfs"); | ||
3561 | } | ||
3562 | |||
3563 | int | ||
3564 | glusterd_shd_start () | ||
3565 | { | ||
3566 | return glusterd_nodesvc_start ("glustershd"); | ||
3567 | } | ||
3568 | |||
3569 | gf_boolean_t | ||
3570 | glusterd_is_nodesvc_running (char *server) | ||
3571 | { | ||
3572 | char pidfile[PATH_MAX4096] = {0,}; | ||
3573 | glusterd_conf_t *priv = THIS(*__glusterfs_this_location())->private; | ||
3574 | |||
3575 | glusterd_get_nodesvc_pidfile (server, priv->workdir, | ||
3576 | pidfile, sizeof (pidfile)); | ||
3577 | return glusterd_is_service_running (pidfile, NULL((void*)0)); | ||
3578 | } | ||
3579 | |||
3580 | int32_t | ||
3581 | glusterd_nodesvc_unlink_socket_file (char *server) | ||
3582 | { | ||
3583 | int ret = 0; | ||
3584 | char sockfpath[PATH_MAX4096] = {0,}; | ||
3585 | char rundir[PATH_MAX4096] = {0,}; | ||
3586 | glusterd_conf_t *priv = THIS(*__glusterfs_this_location())->private; | ||
3587 | |||
3588 | glusterd_get_nodesvc_rundir (server, priv->workdir, | ||
3589 | rundir, sizeof (rundir)); | ||
3590 | |||
3591 | glusterd_nodesvc_set_socket_filepath (rundir, MY_UUID(__glusterd_uuid()), | ||
3592 | sockfpath, sizeof (sockfpath)); | ||
3593 | |||
3594 | ret = unlink (sockfpath); | ||
3595 | if (ret && (ENOENT2 == errno(*__errno_location ()))) { | ||
3596 | ret = 0; | ||
3597 | } else { | ||
3598 | gf_log (THIS->name, GF_LOG_ERROR, "Failed to remove %s"do { do { if (0) printf ("Failed to remove %s" " error: %s", sockfpath , strerror ((*__errno_location ()))); } while (0); _gf_log (( *__glusterfs_this_location())->name, "glusterd-utils.c", __FUNCTION__ , 3599, GF_LOG_ERROR, "Failed to remove %s" " error: %s", sockfpath , strerror ((*__errno_location ()))); } while (0) | ||
3599 | " error: %s", sockfpath, strerror (errno))do { do { if (0) printf ("Failed to remove %s" " error: %s", sockfpath , strerror ((*__errno_location ()))); } while (0); _gf_log (( *__glusterfs_this_location())->name, "glusterd-utils.c", __FUNCTION__ , 3599, GF_LOG_ERROR, "Failed to remove %s" " error: %s", sockfpath , strerror ((*__errno_location ()))); } while (0); | ||
3600 | } | ||
3601 | |||
3602 | return ret; | ||
3603 | } | ||
3604 | |||
3605 | int32_t | ||
3606 | glusterd_nodesvc_stop (char *server, int sig) | ||
3607 | { | ||
3608 | char pidfile[PATH_MAX4096] = {0,}; | ||
3609 | glusterd_conf_t *priv = THIS(*__glusterfs_this_location())->private; | ||
3610 | int ret = 0; | ||
3611 | |||
3612 | if (!glusterd_is_nodesvc_running (server)) | ||
3613 | goto out; | ||
3614 | |||
3615 | (void)glusterd_nodesvc_disconnect (server); | ||
3616 | |||
3617 | glusterd_get_nodesvc_pidfile (server, priv->workdir, | ||
3618 | pidfile, sizeof (pidfile)); | ||
3619 | ret = glusterd_service_stop (server, pidfile, sig, _gf_true); | ||
3620 | |||
3621 | if (ret == 0) { | ||
3622 | glusterd_nodesvc_set_online_status (server, _gf_false); | ||
3623 | (void)glusterd_nodesvc_unlink_socket_file (server); | ||
3624 | } | ||
3625 | out: | ||
3626 | return ret; | ||
3627 | } | ||
3628 | |||
3629 | void | ||
3630 | glusterd_nfs_pmap_deregister () | ||
3631 | { | ||
3632 | if (pmap_unset (MOUNT_PROGRAM100005, MOUNTV3_VERSION3)) | ||
3633 | gf_log ("", GF_LOG_INFO, "De-registered MOUNTV3 successfully")do { do { if (0) printf ("De-registered MOUNTV3 successfully" ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3633, GF_LOG_INFO, "De-registered MOUNTV3 successfully"); } while (0); | ||
3634 | else | ||
3635 | gf_log ("", GF_LOG_ERROR, "De-register MOUNTV3 is unsuccessful")do { do { if (0) printf ("De-register MOUNTV3 is unsuccessful" ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3635, GF_LOG_ERROR, "De-register MOUNTV3 is unsuccessful"); } while (0); | ||
3636 | |||
3637 | if (pmap_unset (MOUNT_PROGRAM100005, MOUNTV1_VERSION1)) | ||
3638 | gf_log ("", GF_LOG_INFO, "De-registered MOUNTV1 successfully")do { do { if (0) printf ("De-registered MOUNTV1 successfully" ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3638, GF_LOG_INFO, "De-registered MOUNTV1 successfully"); } while (0); | ||
3639 | else | ||
3640 | gf_log ("", GF_LOG_ERROR, "De-register MOUNTV1 is unsuccessful")do { do { if (0) printf ("De-register MOUNTV1 is unsuccessful" ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 3640, GF_LOG_ERROR, "De-register MOUNTV1 is unsuccessful"); } while (0); | ||
3641 | |||
3642 | if (pmap_unset (NFS_PROGRAM100003, NFSV3_VERSION3)) | ||
3643 | gf_log ("", GF_LOG_INFO, "De-registered NFSV3 successfully")do { do { if (0) printf ("De-registered NFSV3 successfully"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3643 , GF_LOG_INFO, "De-registered NFSV3 successfully"); } while ( 0); | ||
3644 | else | ||
3645 | gf_log ("", GF_LOG_ERROR, "De-register NFSV3 is unsuccessful")do { do { if (0) printf ("De-register NFSV3 is unsuccessful") ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3645, GF_LOG_ERROR, "De-register NFSV3 is unsuccessful"); } while (0); | ||
3646 | |||
3647 | if (pmap_unset (NLM_PROGRAM100021, NLMV4_VERSION4)) | ||
3648 | gf_log ("", GF_LOG_INFO, "De-registered NLM v4 successfully")do { do { if (0) printf ("De-registered NLM v4 successfully") ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3648, GF_LOG_INFO, "De-registered NLM v4 successfully"); } while (0); | ||
3649 | else | ||
3650 | gf_log ("", GF_LOG_ERROR, "De-registration of NLM v4 failed")do { do { if (0) printf ("De-registration of NLM v4 failed"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3650 , GF_LOG_ERROR, "De-registration of NLM v4 failed"); } while ( 0); | ||
3651 | |||
3652 | if (pmap_unset (NLM_PROGRAM100021, NLMV1_VERSION1)) | ||
3653 | gf_log ("", GF_LOG_INFO, "De-registered NLM v1 successfully")do { do { if (0) printf ("De-registered NLM v1 successfully") ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3653, GF_LOG_INFO, "De-registered NLM v1 successfully"); } while (0); | ||
3654 | else | ||
3655 | gf_log ("", GF_LOG_ERROR, "De-registration of NLM v1 failed")do { do { if (0) printf ("De-registration of NLM v1 failed"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3655 , GF_LOG_ERROR, "De-registration of NLM v1 failed"); } while ( 0); | ||
3656 | |||
3657 | } | ||
3658 | |||
3659 | int | ||
3660 | glusterd_nfs_server_stop () | ||
3661 | { | ||
3662 | int ret = 0; | ||
3663 | gf_boolean_t deregister = _gf_false; | ||
3664 | |||
3665 | if (glusterd_is_nodesvc_running ("nfs")) | ||
3666 | deregister = _gf_true; | ||
3667 | ret = glusterd_nodesvc_stop ("nfs", SIGKILL9); | ||
3668 | if (ret) | ||
3669 | goto out; | ||
3670 | if (deregister) | ||
3671 | glusterd_nfs_pmap_deregister (); | ||
3672 | out: | ||
3673 | return ret; | ||
3674 | } | ||
3675 | |||
3676 | int | ||
3677 | glusterd_shd_stop () | ||
3678 | { | ||
3679 | return glusterd_nodesvc_stop ("glustershd", SIGTERM15); | ||
3680 | } | ||
3681 | |||
3682 | int | ||
3683 | glusterd_add_node_to_dict (char *server, dict_t *dict, int count, | ||
3684 | dict_t *vol_opts) | ||
3685 | { | ||
3686 | int ret = -1; | ||
3687 | glusterd_conf_t *priv = THIS(*__glusterfs_this_location())->private; | ||
3688 | char pidfile[PATH_MAX4096] = {0,}; | ||
3689 | gf_boolean_t running = _gf_false; | ||
3690 | int pid = -1; | ||
3691 | int port = 0; | ||
3692 | char key[1024] = {0,}; | ||
3693 | |||
3694 | glusterd_get_nodesvc_pidfile (server, priv->workdir, pidfile, | ||
3695 | sizeof (pidfile)); | ||
3696 | //Consider service to be running only when glusterd sees it Online | ||
3697 | if (glusterd_is_nodesvc_online (server)) | ||
3698 | running = glusterd_is_service_running (pidfile, &pid); | ||
3699 | |||
3700 | /* For nfs-servers/self-heal-daemon setting | ||
3701 | * brick<n>.hostname = "NFS Server" / "Self-heal Daemon" | ||
3702 | * brick<n>.path = uuid | ||
3703 | * brick<n>.port = 0 | ||
3704 | * | ||
3705 | * This might be confusing, but cli displays the name of | ||
3706 | * the brick as hostname+path, so this will make more sense | ||
3707 | * when output. | ||
3708 | */ | ||
3709 | snprintf (key, sizeof (key), "brick%d.hostname", count); | ||
3710 | if (!strcmp (server, "nfs")) | ||
3711 | ret = dict_set_str (dict, key, "NFS Server"); | ||
3712 | else if (!strcmp (server, "glustershd")) | ||
3713 | ret = dict_set_str (dict, key, "Self-heal Daemon"); | ||
3714 | if (ret) | ||
3715 | goto out; | ||
3716 | |||
3717 | memset (key, 0, sizeof (key)); | ||
3718 | snprintf (key, sizeof (key), "brick%d.path", count); | ||
3719 | ret = dict_set_dynstr (dict, key, gf_strdup (uuid_utoa (MY_UUID(__glusterd_uuid())))); | ||
3720 | if (ret) | ||
3721 | goto out; | ||
3722 | |||
3723 | memset (key, 0, sizeof (key)); | ||
3724 | snprintf (key, sizeof (key), "brick%d.port", count); | ||
3725 | /* Port is available only for the NFS server. | ||
3726 | * Self-heal daemon doesn't provide any port for access | ||
3727 | * by entities other than gluster. | ||
3728 | */ | ||
3729 | if (!strcmp (server, "nfs")) { | ||
3730 | if (dict_get (vol_opts, "nfs.port")) { | ||
3731 | ret = dict_get_int32 (vol_opts, "nfs.port", &port); | ||
3732 | if (ret) | ||
3733 | goto out; | ||
3734 | } else | ||
3735 | port = GF_NFS3_PORT2049; | ||
3736 | } | ||
3737 | ret = dict_set_int32 (dict, key, port); | ||
3738 | if (ret) | ||
3739 | goto out; | ||
3740 | |||
3741 | memset (key, 0, sizeof (key)); | ||
3742 | snprintf (key, sizeof (key), "brick%d.pid", count); | ||
3743 | ret = dict_set_int32 (dict, key, pid); | ||
3744 | if (ret) | ||
3745 | goto out; | ||
3746 | |||
3747 | memset (key, 0, sizeof (key)); | ||
3748 | snprintf (key, sizeof (key), "brick%d.status", count); | ||
3749 | ret = dict_set_int32 (dict, key, running); | ||
3750 | if (ret) | ||
3751 | goto out; | ||
3752 | |||
3753 | |||
3754 | out: | ||
3755 | 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-utils.c" , __FUNCTION__, 3755, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
3756 | return ret; | ||
3757 | } | ||
3758 | |||
3759 | int | ||
3760 | glusterd_remote_hostname_get (rpcsvc_request_t *req, char *remote_host, int len) | ||
3761 | { | ||
3762 | GF_ASSERT (req)do { if (!(req)) { do { do { if (0) printf ("Assertion failed: " "req"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3762, GF_LOG_ERROR, "Assertion failed: " "req" ); } while (0); } } while (0); | ||
3763 | GF_ASSERT (remote_host)do { if (!(remote_host)) { do { do { if (0) printf ("Assertion failed: " "remote_host"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3763, GF_LOG_ERROR, "Assertion failed: " "remote_host" ); } while (0); } } while (0); | ||
3764 | GF_ASSERT (req->trans)do { if (!(req->trans)) { do { do { if (0) printf ("Assertion failed: " "req->trans"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3764, GF_LOG_ERROR, "Assertion failed: " "req->trans" ); } while (0); } } while (0); | ||
3765 | |||
3766 | char *name = NULL((void*)0); | ||
3767 | char *hostname = NULL((void*)0); | ||
3768 | char *tmp_host = NULL((void*)0); | ||
3769 | int ret = 0; | ||
3770 | |||
3771 | name = req->trans->peerinfo.identifier; | ||
3772 | tmp_host = gf_strdup (name); | ||
3773 | if (tmp_host) | ||
3774 | get_host_name (tmp_host, &hostname); | ||
3775 | |||
3776 | GF_ASSERT (hostname)do { if (!(hostname)) { do { do { if (0) printf ("Assertion failed: " "hostname"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3776, GF_LOG_ERROR, "Assertion failed: " "hostname" ); } while (0); } } while (0); | ||
3777 | if (!hostname) { | ||
3778 | memset (remote_host, 0, len); | ||
3779 | ret = -1; | ||
3780 | goto out; | ||
3781 | } | ||
3782 | |||
3783 | strncpy (remote_host, hostname, strlen (hostname)); | ||
3784 | |||
3785 | |||
3786 | out: | ||
3787 | GF_FREE (tmp_host)__gf_free (tmp_host); | ||
3788 | return ret; | ||
3789 | } | ||
3790 | |||
3791 | int | ||
3792 | glusterd_check_generate_start_service (int (*create_volfile) (), | ||
3793 | int (*stop) (), int (*start) ()) | ||
3794 | { | ||
3795 | int ret = -1; | ||
3796 | |||
3797 | ret = create_volfile (); | ||
3798 | if (ret) | ||
3799 | goto out; | ||
3800 | |||
3801 | ret = stop (); | ||
3802 | if (ret) | ||
3803 | goto out; | ||
3804 | |||
3805 | ret = start (); | ||
3806 | out: | ||
3807 | return ret; | ||
3808 | } | ||
3809 | |||
3810 | int | ||
3811 | glusterd_reconfigure_nodesvc (int (*create_volfile) ()) | ||
3812 | { | ||
3813 | int ret = -1; | ||
3814 | |||
3815 | ret = create_volfile (); | ||
3816 | if (ret) | ||
3817 | goto out; | ||
3818 | |||
3819 | ret = glusterd_fetchspec_notify (THIS(*__glusterfs_this_location())); | ||
3820 | out: | ||
3821 | return ret; | ||
3822 | } | ||
3823 | |||
3824 | int | ||
3825 | glusterd_reconfigure_shd () | ||
3826 | { | ||
3827 | int (*create_volfile) () = glusterd_create_shd_volfile; | ||
3828 | return glusterd_reconfigure_nodesvc (create_volfile); | ||
3829 | } | ||
3830 | |||
3831 | int | ||
3832 | glusterd_reconfigure_nfs () | ||
3833 | { | ||
3834 | int ret = -1; | ||
3835 | gf_boolean_t identical = _gf_false; | ||
3836 | |||
3837 | ret = glusterd_check_nfs_volfile_identical (&identical); | ||
3838 | if (ret) | ||
3839 | goto out; | ||
3840 | |||
3841 | if (identical) { | ||
3842 | ret = 0; | ||
3843 | goto out; | ||
3844 | } | ||
3845 | |||
3846 | ret = glusterd_check_generate_start_nfs (); | ||
3847 | |||
3848 | out: | ||
3849 | return ret; | ||
3850 | } | ||
3851 | |||
3852 | |||
3853 | int | ||
3854 | glusterd_check_generate_start_nfs () | ||
3855 | { | ||
3856 | int ret = 0; | ||
3857 | |||
3858 | ret = glusterd_check_generate_start_service (glusterd_create_nfs_volfile, | ||
3859 | glusterd_nfs_server_stop, | ||
3860 | glusterd_nfs_server_start); | ||
3861 | return ret; | ||
3862 | } | ||
3863 | |||
3864 | int | ||
3865 | glusterd_check_generate_start_shd () | ||
3866 | { | ||
3867 | int ret = 0; | ||
3868 | |||
3869 | ret = glusterd_check_generate_start_service (glusterd_create_shd_volfile, | ||
3870 | glusterd_shd_stop, | ||
3871 | glusterd_shd_start); | ||
3872 | if (ret == -EINVAL22) | ||
3873 | ret = 0; | ||
3874 | return ret; | ||
3875 | } | ||
3876 | |||
3877 | int | ||
3878 | glusterd_nodesvcs_batch_op (glusterd_volinfo_t *volinfo, | ||
3879 | int (*nfs_op) (), int (*shd_op) ()) | ||
3880 | { | ||
3881 | int ret = 0; | ||
3882 | |||
3883 | ret = nfs_op (); | ||
3884 | if (ret) | ||
3885 | goto out; | ||
3886 | |||
3887 | if (volinfo && !glusterd_is_volume_replicate (volinfo)) | ||
3888 | goto out; | ||
3889 | |||
3890 | ret = shd_op (); | ||
3891 | if (ret) | ||
3892 | goto out; | ||
3893 | out: | ||
3894 | return ret; | ||
3895 | } | ||
3896 | |||
3897 | int | ||
3898 | glusterd_nodesvcs_start (glusterd_volinfo_t *volinfo) | ||
3899 | { | ||
3900 | return glusterd_nodesvcs_batch_op (volinfo, | ||
3901 | glusterd_nfs_server_start, | ||
3902 | glusterd_shd_start); | ||
3903 | } | ||
3904 | |||
3905 | int | ||
3906 | glusterd_nodesvcs_stop (glusterd_volinfo_t *volinfo) | ||
3907 | { | ||
3908 | return glusterd_nodesvcs_batch_op (volinfo, | ||
3909 | glusterd_nfs_server_stop, | ||
3910 | glusterd_shd_stop); | ||
3911 | } | ||
3912 | |||
3913 | gf_boolean_t | ||
3914 | glusterd_are_all_volumes_stopped () | ||
3915 | { | ||
3916 | glusterd_conf_t *priv = NULL((void*)0); | ||
3917 | xlator_t *this = NULL((void*)0); | ||
3918 | glusterd_volinfo_t *voliter = NULL((void*)0); | ||
3919 | |||
3920 | this = THIS(*__glusterfs_this_location()); | ||
3921 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3921, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
3922 | priv = this->private; | ||
3923 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3923, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
3924 | |||
3925 | list_for_each_entry (voliter, &priv->volumes, vol_list)for (voliter = ((typeof(*voliter) *)((char *)((&priv-> volumes)->next)-(unsigned long)(&((typeof(*voliter) *) 0)->vol_list))); &voliter->vol_list != (&priv-> volumes); voliter = ((typeof(*voliter) *)((char *)(voliter-> vol_list.next)-(unsigned long)(&((typeof(*voliter) *)0)-> vol_list)))) { | ||
3926 | if (voliter->status == GLUSTERD_STATUS_STARTED) | ||
3927 | return _gf_false; | ||
3928 | } | ||
3929 | |||
3930 | return _gf_true; | ||
3931 | |||
3932 | } | ||
3933 | |||
3934 | gf_boolean_t | ||
3935 | glusterd_all_replicate_volumes_stopped () | ||
3936 | { | ||
3937 | glusterd_conf_t *priv = NULL((void*)0); | ||
3938 | xlator_t *this = NULL((void*)0); | ||
3939 | glusterd_volinfo_t *voliter = NULL((void*)0); | ||
3940 | |||
3941 | this = THIS(*__glusterfs_this_location()); | ||
3942 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3942, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
3943 | priv = this->private; | ||
3944 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3944, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
3945 | |||
3946 | list_for_each_entry (voliter, &priv->volumes, vol_list)for (voliter = ((typeof(*voliter) *)((char *)((&priv-> volumes)->next)-(unsigned long)(&((typeof(*voliter) *) 0)->vol_list))); &voliter->vol_list != (&priv-> volumes); voliter = ((typeof(*voliter) *)((char *)(voliter-> vol_list.next)-(unsigned long)(&((typeof(*voliter) *)0)-> vol_list)))) { | ||
3947 | if (!glusterd_is_volume_replicate (voliter)) | ||
3948 | continue; | ||
3949 | if (voliter->status == GLUSTERD_STATUS_STARTED) | ||
3950 | return _gf_false; | ||
3951 | } | ||
3952 | |||
3953 | return _gf_true; | ||
3954 | } | ||
3955 | |||
3956 | int | ||
3957 | glusterd_nodesvcs_handle_graph_change (glusterd_volinfo_t *volinfo) | ||
3958 | { | ||
3959 | int (*shd_op) () = NULL((void*)0); | ||
3960 | int (*nfs_op) () = NULL((void*)0); | ||
3961 | |||
3962 | shd_op = glusterd_check_generate_start_shd; | ||
3963 | nfs_op = glusterd_check_generate_start_nfs; | ||
3964 | if (glusterd_are_all_volumes_stopped ()) { | ||
3965 | shd_op = glusterd_shd_stop; | ||
3966 | nfs_op = glusterd_nfs_server_stop; | ||
3967 | } else if (glusterd_all_replicate_volumes_stopped()) { | ||
3968 | shd_op = glusterd_shd_stop; | ||
3969 | } | ||
3970 | return glusterd_nodesvcs_batch_op (volinfo, nfs_op, shd_op); | ||
3971 | } | ||
3972 | |||
3973 | int | ||
3974 | glusterd_nodesvcs_handle_reconfigure (glusterd_volinfo_t *volinfo) | ||
3975 | { | ||
3976 | return glusterd_nodesvcs_batch_op (volinfo, | ||
3977 | glusterd_reconfigure_nfs, | ||
3978 | glusterd_reconfigure_shd); | ||
3979 | } | ||
3980 | |||
3981 | int | ||
3982 | glusterd_volume_count_get (void) | ||
3983 | { | ||
3984 | glusterd_volinfo_t *tmp_volinfo = NULL((void*)0); | ||
3985 | int32_t ret = 0; | ||
3986 | xlator_t *this = NULL((void*)0); | ||
3987 | glusterd_conf_t *priv = NULL((void*)0); | ||
3988 | |||
3989 | this = THIS(*__glusterfs_this_location()); | ||
3990 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 3990, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
3991 | |||
3992 | priv = this->private; | ||
3993 | |||
3994 | list_for_each_entry (tmp_volinfo, &priv->volumes, vol_list)for (tmp_volinfo = ((typeof(*tmp_volinfo) *)((char *)((&priv ->volumes)->next)-(unsigned long)(&((typeof(*tmp_volinfo ) *)0)->vol_list))); &tmp_volinfo->vol_list != (& priv->volumes); tmp_volinfo = ((typeof(*tmp_volinfo) *)((char *)(tmp_volinfo->vol_list.next)-(unsigned long)(&((typeof (*tmp_volinfo) *)0)->vol_list)))) { | ||
3995 | ret++; | ||
3996 | } | ||
3997 | |||
3998 | |||
3999 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 3999, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | ||
4000 | return ret; | ||
4001 | |||
4002 | } | ||
4003 | |||
4004 | int | ||
4005 | glusterd_brickinfo_get (uuid_t uuid, char *hostname, char *path, | ||
4006 | glusterd_brickinfo_t **brickinfo) | ||
4007 | { | ||
4008 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
4009 | glusterd_conf_t *priv = NULL((void*)0); | ||
4010 | xlator_t *this = NULL((void*)0); | ||
4011 | int ret = -1; | ||
4012 | |||
4013 | GF_ASSERT (path)do { if (!(path)) { do { do { if (0) printf ("Assertion failed: " "path"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4013, GF_LOG_ERROR, "Assertion failed: " "path" ); } while (0); } } while (0); | ||
4014 | |||
4015 | this = THIS(*__glusterfs_this_location()); | ||
4016 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4016, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4017 | |||
4018 | priv = this->private; | ||
4019 | |||
4020 | 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)))) { | ||
4021 | |||
4022 | ret = glusterd_volume_brickinfo_get (uuid, hostname, path, | ||
4023 | volinfo, brickinfo); | ||
4024 | if (ret == 0) | ||
4025 | /*Found*/ | ||
4026 | goto out; | ||
4027 | } | ||
4028 | out: | ||
4029 | return ret; | ||
4030 | } | ||
4031 | |||
4032 | int | ||
4033 | glusterd_brick_start (glusterd_volinfo_t *volinfo, | ||
4034 | glusterd_brickinfo_t *brickinfo, | ||
4035 | gf_boolean_t wait) | ||
4036 | { | ||
4037 | int ret = -1; | ||
4038 | xlator_t *this = NULL((void*)0); | ||
4039 | glusterd_conf_t *conf = NULL((void*)0); | ||
4040 | |||
4041 | if ((!brickinfo) || (!volinfo)) | ||
4042 | goto out; | ||
4043 | |||
4044 | this = THIS(*__glusterfs_this_location()); | ||
4045 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4045, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4046 | conf = this->private; | ||
4047 | GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: " "conf"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4047, GF_LOG_ERROR, "Assertion failed: " "conf" ); } while (0); } } while (0); | ||
4048 | |||
4049 | if (uuid_is_null (brickinfo->uuid)) { | ||
4050 | ret = glusterd_resolve_brick (brickinfo); | ||
4051 | if (ret) { | ||
4052 | gf_log (this->name, GF_LOG_ERROR, FMTSTR_RESOLVE_BRICK,do { do { if (0) printf ("Could not find peer on which brick %s:%s resides" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4053, GF_LOG_ERROR , "Could not find peer on which brick %s:%s resides", brickinfo ->hostname, brickinfo->path); } while (0) | ||
4053 | brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Could not find peer on which brick %s:%s resides" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4053, GF_LOG_ERROR , "Could not find peer on which brick %s:%s resides", brickinfo ->hostname, brickinfo->path); } while (0); | ||
4054 | goto out; | ||
4055 | } | ||
4056 | } | ||
4057 | |||
4058 | if (uuid_compare (brickinfo->uuid, MY_UUID(__glusterd_uuid()))) { | ||
4059 | ret = 0; | ||
4060 | goto out; | ||
4061 | } | ||
4062 | ret = glusterd_volume_start_glusterfs (volinfo, brickinfo, wait); | ||
4063 | if (ret) { | ||
4064 | gf_log (this->name, GF_LOG_ERROR, "Unable to start brick %s:%s",do { do { if (0) printf ("Unable to start brick %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 4065, GF_LOG_ERROR , "Unable to start brick %s:%s", brickinfo->hostname, brickinfo ->path); } while (0) | ||
4065 | brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Unable to start brick %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 4065, GF_LOG_ERROR , "Unable to start brick %s:%s", brickinfo->hostname, brickinfo ->path); } while (0); | ||
4066 | goto out; | ||
4067 | } | ||
4068 | |||
4069 | out: | ||
4070 | 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-utils.c", __FUNCTION__, 4070, GF_LOG_DEBUG , "returning %d ", ret); } while (0); | ||
4071 | return ret; | ||
4072 | } | ||
4073 | |||
4074 | int | ||
4075 | glusterd_restart_bricks (glusterd_conf_t *conf) | ||
4076 | { | ||
4077 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
4078 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
4079 | gf_boolean_t start_nodesvcs = _gf_false; | ||
4080 | int ret = 0; | ||
4081 | |||
4082 | list_for_each_entry (volinfo, &conf->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&conf-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&conf-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | ||
4083 | if (volinfo->status != GLUSTERD_STATUS_STARTED) | ||
4084 | continue; | ||
4085 | start_nodesvcs = _gf_true; | ||
4086 | 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)))) { | ||
4087 | glusterd_brick_start (volinfo, brickinfo, _gf_false); | ||
4088 | } | ||
4089 | } | ||
4090 | |||
4091 | if (start_nodesvcs) | ||
4092 | glusterd_nodesvcs_handle_graph_change (NULL((void*)0)); | ||
4093 | |||
4094 | return ret; | ||
4095 | } | ||
4096 | |||
4097 | int | ||
4098 | _local_gsyncd_start (dict_t *this, char *key, data_t *value, void *data) | ||
4099 | { | ||
4100 | char *slave = NULL((void*)0); | ||
4101 | int uuid_len = 0; | ||
4102 | char uuid_str[64] = {0}; | ||
4103 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
4104 | |||
4105 | volinfo = data; | ||
4106 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4106, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
4107 | slave = strchr(value->data, ':'); | ||
4108 | if (slave) | ||
4109 | slave ++; | ||
4110 | else | ||
4111 | return 0; | ||
4112 | uuid_len = (slave - value->data - 1); | ||
4113 | |||
4114 | strncpy (uuid_str, (char*)value->data, uuid_len); | ||
4115 | glusterd_start_gsync (volinfo, slave, uuid_str, NULL((void*)0)); | ||
4116 | |||
4117 | return 0; | ||
4118 | } | ||
4119 | |||
4120 | int | ||
4121 | glusterd_volume_restart_gsyncds (glusterd_volinfo_t *volinfo) | ||
4122 | { | ||
4123 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4123, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
4124 | |||
4125 | dict_foreach (volinfo->gsync_slaves, _local_gsyncd_start, volinfo); | ||
4126 | return 0; | ||
4127 | } | ||
4128 | |||
4129 | int | ||
4130 | glusterd_restart_gsyncds (glusterd_conf_t *conf) | ||
4131 | { | ||
4132 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
4133 | int ret = 0; | ||
4134 | |||
4135 | list_for_each_entry (volinfo, &conf->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&conf-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&conf-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | ||
4136 | glusterd_volume_restart_gsyncds (volinfo); | ||
4137 | } | ||
4138 | return ret; | ||
4139 | } | ||
4140 | |||
4141 | inline int | ||
4142 | glusterd_get_dist_leaf_count (glusterd_volinfo_t *volinfo) | ||
4143 | { | ||
4144 | int rcount = volinfo->replica_count; | ||
4145 | int scount = volinfo->stripe_count; | ||
4146 | |||
4147 | return (rcount ? rcount : 1) * (scount ? scount : 1); | ||
4148 | } | ||
4149 | |||
4150 | int | ||
4151 | glusterd_get_brickinfo (xlator_t *this, const char *brickname, int port, | ||
4152 | gf_boolean_t localhost, glusterd_brickinfo_t **brickinfo) | ||
4153 | { | ||
4154 | glusterd_conf_t *priv = NULL((void*)0); | ||
4155 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
4156 | glusterd_brickinfo_t *tmpbrkinfo = NULL((void*)0); | ||
4157 | int ret = -1; | ||
4158 | |||
4159 | GF_ASSERT (brickname)do { if (!(brickname)) { do { do { if (0) printf ("Assertion failed: " "brickname"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4159, GF_LOG_ERROR, "Assertion failed: " "brickname" ); } while (0); } } while (0); | ||
4160 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4160, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4161 | |||
4162 | priv = this->private; | ||
4163 | 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)))) { | ||
4164 | list_for_each_entry (tmpbrkinfo, &volinfo->bricks,for (tmpbrkinfo = ((typeof(*tmpbrkinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*tmpbrkinfo ) *)0)->brick_list))); &tmpbrkinfo->brick_list != ( &volinfo->bricks); tmpbrkinfo = ((typeof(*tmpbrkinfo) * )((char *)(tmpbrkinfo->brick_list.next)-(unsigned long)(& ((typeof(*tmpbrkinfo) *)0)->brick_list)))) | ||
4165 | brick_list)for (tmpbrkinfo = ((typeof(*tmpbrkinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*tmpbrkinfo ) *)0)->brick_list))); &tmpbrkinfo->brick_list != ( &volinfo->bricks); tmpbrkinfo = ((typeof(*tmpbrkinfo) * )((char *)(tmpbrkinfo->brick_list.next)-(unsigned long)(& ((typeof(*tmpbrkinfo) *)0)->brick_list)))) { | ||
4166 | if (localhost && !glusterd_is_local_addr (tmpbrkinfo->hostname)) | ||
4167 | continue; | ||
4168 | if (!strcmp(tmpbrkinfo->path, brickname) && | ||
4169 | (tmpbrkinfo->port == port)) { | ||
4170 | *brickinfo = tmpbrkinfo; | ||
4171 | return 0; | ||
4172 | } | ||
4173 | } | ||
4174 | } | ||
4175 | return ret; | ||
4176 | } | ||
4177 | |||
4178 | glusterd_brickinfo_t* | ||
4179 | glusterd_get_brickinfo_by_position (glusterd_volinfo_t *volinfo, uint32_t pos) | ||
4180 | { | ||
4181 | glusterd_brickinfo_t *tmpbrkinfo = NULL((void*)0); | ||
4182 | |||
4183 | list_for_each_entry (tmpbrkinfo, &volinfo->bricks,for (tmpbrkinfo = ((typeof(*tmpbrkinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*tmpbrkinfo ) *)0)->brick_list))); &tmpbrkinfo->brick_list != ( &volinfo->bricks); tmpbrkinfo = ((typeof(*tmpbrkinfo) * )((char *)(tmpbrkinfo->brick_list.next)-(unsigned long)(& ((typeof(*tmpbrkinfo) *)0)->brick_list)))) | ||
4184 | brick_list)for (tmpbrkinfo = ((typeof(*tmpbrkinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*tmpbrkinfo ) *)0)->brick_list))); &tmpbrkinfo->brick_list != ( &volinfo->bricks); tmpbrkinfo = ((typeof(*tmpbrkinfo) * )((char *)(tmpbrkinfo->brick_list.next)-(unsigned long)(& ((typeof(*tmpbrkinfo) *)0)->brick_list)))) { | ||
4185 | if (pos == 0) | ||
4186 | return tmpbrkinfo; | ||
4187 | pos--; | ||
4188 | } | ||
4189 | return NULL((void*)0); | ||
4190 | } | ||
4191 | |||
4192 | void | ||
4193 | glusterd_set_brick_status (glusterd_brickinfo_t *brickinfo, | ||
4194 | gf_brick_status_t status) | ||
4195 | { | ||
4196 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4196, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
4197 | brickinfo->status = status; | ||
4198 | if (GF_BRICK_STARTED == status) { | ||
4199 | gf_log ("glusterd", GF_LOG_DEBUG, "Setting brick %s:%s status "do { do { if (0) printf ("Setting brick %s:%s status " "to started" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 4200, GF_LOG_DEBUG , "Setting brick %s:%s status " "to started", brickinfo->hostname , brickinfo->path); } while (0) | ||
4200 | "to started", brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Setting brick %s:%s status " "to started" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 4200, GF_LOG_DEBUG , "Setting brick %s:%s status " "to started", brickinfo->hostname , brickinfo->path); } while (0); | ||
4201 | } else { | ||
4202 | gf_log ("glusterd", GF_LOG_DEBUG, "Setting brick %s:%s status "do { do { if (0) printf ("Setting brick %s:%s status " "to stopped" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 4203, GF_LOG_DEBUG , "Setting brick %s:%s status " "to stopped", brickinfo->hostname , brickinfo->path); } while (0) | ||
4203 | "to stopped", brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Setting brick %s:%s status " "to stopped" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 4203, GF_LOG_DEBUG , "Setting brick %s:%s status " "to stopped", brickinfo->hostname , brickinfo->path); } while (0); | ||
4204 | } | ||
4205 | } | ||
4206 | |||
4207 | gf_boolean_t | ||
4208 | glusterd_is_brick_started (glusterd_brickinfo_t *brickinfo) | ||
4209 | { | ||
4210 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4210, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
4211 | return (brickinfo->status == GF_BRICK_STARTED); | ||
4212 | } | ||
4213 | |||
4214 | int | ||
4215 | glusterd_friend_brick_belongs (glusterd_volinfo_t *volinfo, | ||
4216 | glusterd_brickinfo_t *brickinfo, void* uuid) | ||
4217 | { | ||
4218 | int ret = -1; | ||
4219 | |||
4220 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4220, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
4221 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4221, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
4222 | GF_ASSERT (uuid)do { if (!(uuid)) { do { do { if (0) printf ("Assertion failed: " "uuid"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4222, GF_LOG_ERROR, "Assertion failed: " "uuid" ); } while (0); } } while (0); | ||
4223 | |||
4224 | if (uuid_is_null (brickinfo->uuid)) { | ||
4225 | ret = glusterd_resolve_brick (brickinfo); | ||
4226 | if (ret) { | ||
4227 | GF_ASSERT (0)do { if (!(0)) { do { do { if (0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4227, GF_LOG_ERROR, "Assertion failed: " "0") ; } while (0); } } while (0); | ||
4228 | goto out; | ||
4229 | } | ||
4230 | } | ||
4231 | if (!uuid_compare (brickinfo->uuid, *((uuid_t *)uuid))) | ||
4232 | return 0; | ||
4233 | out: | ||
4234 | return -1; | ||
4235 | } | ||
4236 | |||
4237 | #ifdef GF_LINUX_HOST_OS1 | ||
4238 | static int | ||
4239 | glusterd_get_brick_root (char *path, char **mount_point) | ||
4240 | { | ||
4241 | char *ptr = NULL((void*)0); | ||
4242 | char *mnt_pt = NULL((void*)0); | ||
4243 | struct stat brickstat = {0}; | ||
4244 | struct stat buf = {0}; | ||
4245 | |||
4246 | if (!path) | ||
4247 | goto err; | ||
4248 | mnt_pt = gf_strdup (path); | ||
4249 | if (!mnt_pt) | ||
4250 | goto err; | ||
4251 | if (stat (mnt_pt, &brickstat)) | ||
4252 | goto err; | ||
4253 | |||
4254 | while ((ptr = strrchr (mnt_pt, '/')) && | ||
4255 | ptr != mnt_pt) { | ||
4256 | |||
4257 | *ptr = '\0'; | ||
4258 | if (stat (mnt_pt, &buf)) { | ||
4259 | gf_log (THIS->name, GF_LOG_ERROR, "error in "do { do { if (0) printf ("error in " "stat: %s", strerror ((* __errno_location ()))); } while (0); _gf_log ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 4260, GF_LOG_ERROR , "error in " "stat: %s", strerror ((*__errno_location ()))); } while (0) | ||
4260 | "stat: %s", strerror (errno))do { do { if (0) printf ("error in " "stat: %s", strerror ((* __errno_location ()))); } while (0); _gf_log ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 4260, GF_LOG_ERROR , "error in " "stat: %s", strerror ((*__errno_location ()))); } while (0); | ||
4261 | goto err; | ||
4262 | } | ||
4263 | |||
4264 | if (brickstat.st_dev != buf.st_dev) { | ||
4265 | *ptr = '/'; | ||
4266 | break; | ||
4267 | } | ||
4268 | } | ||
4269 | |||
4270 | if (ptr == mnt_pt) { | ||
4271 | if (stat ("/", &buf)) { | ||
4272 | gf_log (THIS->name, GF_LOG_ERROR, "error in "do { do { if (0) printf ("error in " "stat: %s", strerror ((* __errno_location ()))); } while (0); _gf_log ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 4273, GF_LOG_ERROR , "error in " "stat: %s", strerror ((*__errno_location ()))); } while (0) | ||
4273 | "stat: %s", strerror (errno))do { do { if (0) printf ("error in " "stat: %s", strerror ((* __errno_location ()))); } while (0); _gf_log ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 4273, GF_LOG_ERROR , "error in " "stat: %s", strerror ((*__errno_location ()))); } while (0); | ||
4274 | goto err; | ||
4275 | } | ||
4276 | if (brickstat.st_dev == buf.st_dev) | ||
4277 | strcpy (mnt_pt, "/"); | ||
4278 | } | ||
4279 | |||
4280 | *mount_point = mnt_pt; | ||
4281 | return 0; | ||
4282 | |||
4283 | err: | ||
4284 | GF_FREE (mnt_pt)__gf_free (mnt_pt); | ||
4285 | return -1; | ||
4286 | } | ||
4287 | |||
4288 | static char* | ||
4289 | glusterd_parse_inode_size (char *stream, char *pattern) | ||
4290 | { | ||
4291 | char *needle = NULL((void*)0); | ||
4292 | char *trail = NULL((void*)0); | ||
4293 | |||
4294 | needle = strstr (stream, pattern); | ||
4295 | if (!needle) | ||
4296 | goto out; | ||
4297 | |||
4298 | needle = nwstrtail (needle, pattern); | ||
4299 | |||
4300 | trail = needle; | ||
4301 | while (trail && isdigit (*trail)((*__ctype_b_loc ())[(int) ((*trail))] & (unsigned short int ) _ISdigit)) trail++; | ||
4302 | if (trail) | ||
4303 | *trail = '\0'; | ||
4304 | |||
4305 | out: | ||
4306 | return needle; | ||
4307 | } | ||
4308 | |||
4309 | static int | ||
4310 | glusterd_add_inode_size_to_dict (dict_t *dict, int count) | ||
4311 | { | ||
4312 | int ret = -1; | ||
4313 | char key[1024] = {0}; | ||
4314 | char buffer[4096] = {0}; | ||
4315 | char *inode_size = NULL((void*)0); | ||
4316 | char *device = NULL((void*)0); | ||
4317 | char *fs_name = NULL((void*)0); | ||
4318 | char *cur_word = NULL((void*)0); | ||
4319 | char *pattern = NULL((void*)0); | ||
4320 | char *trail = NULL((void*)0); | ||
4321 | runner_t runner = {0, }; | ||
4322 | |||
4323 | memset (key, 0, sizeof (key)); | ||
4324 | snprintf (key, sizeof (key), "brick%d.device", count); | ||
4325 | ret = dict_get_str (dict, key, &device); | ||
4326 | if (ret) | ||
4327 | goto out; | ||
4328 | |||
4329 | memset (key, 0, sizeof (key)); | ||
4330 | snprintf (key, sizeof (key), "brick%d.fs_name", count); | ||
4331 | ret = dict_get_str (dict, key, &fs_name); | ||
4332 | if (ret) | ||
4333 | goto out; | ||
4334 | |||
4335 | runinit (&runner); | ||
4336 | runner_redir (&runner, STDOUT_FILENO1, RUN_PIPE-1); | ||
4337 | /* get inode size for xfs or ext2/3/4 */ | ||
4338 | if (!strcmp (fs_name, "xfs")) { | ||
4339 | |||
4340 | runner_add_args (&runner, "xfs_info", device, NULL((void*)0)); | ||
4341 | pattern = "isize="; | ||
4342 | |||
4343 | } else if (IS_EXT_FS(fs_name)(!strcmp (fs_name, "ext2") || !strcmp (fs_name, "ext3") || !strcmp (fs_name, "ext4"))) { | ||
4344 | |||
4345 | runner_add_args (&runner, "tune2fs", "-l", device, NULL((void*)0)); | ||
4346 | pattern = "Inode size:"; | ||
4347 | |||
4348 | } else { | ||
4349 | ret = 0; | ||
4350 | gf_log (THIS->name, GF_LOG_INFO, "Skipped fetching "do { do { if (0) printf ("Skipped fetching " "inode size for %s: FS type not recommended" , fs_name); } while (0); _gf_log ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 4352, GF_LOG_INFO , "Skipped fetching " "inode size for %s: FS type not recommended" , fs_name); } while (0) | ||
4351 | "inode size for %s: FS type not recommended",do { do { if (0) printf ("Skipped fetching " "inode size for %s: FS type not recommended" , fs_name); } while (0); _gf_log ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 4352, GF_LOG_INFO , "Skipped fetching " "inode size for %s: FS type not recommended" , fs_name); } while (0) | ||
4352 | fs_name)do { do { if (0) printf ("Skipped fetching " "inode size for %s: FS type not recommended" , fs_name); } while (0); _gf_log ((*__glusterfs_this_location ())->name, "glusterd-utils.c", __FUNCTION__, 4352, GF_LOG_INFO , "Skipped fetching " "inode size for %s: FS type not recommended" , fs_name); } while (0); | ||
4353 | goto out; | ||
4354 | } | ||
4355 | |||
4356 | ret = runner_start (&runner); | ||
4357 | if (ret) { | ||
4358 | gf_log (THIS->name, GF_LOG_ERROR, "could not get inode "do { do { if (0) printf ("could not get inode " "size for %s : %s package missing" , fs_name, ((strcmp (fs_name, "xfs")) ? "e2fsprogs" : "xfsprogs" )); } while (0); _gf_log ((*__glusterfs_this_location())-> name, "glusterd-utils.c", __FUNCTION__, 4361, GF_LOG_ERROR, "could not get inode " "size for %s : %s package missing", fs_name, ((strcmp (fs_name , "xfs")) ? "e2fsprogs" : "xfsprogs")); } while (0) | ||
4359 | "size for %s : %s package missing", fs_name,do { do { if (0) printf ("could not get inode " "size for %s : %s package missing" , fs_name, ((strcmp (fs_name, "xfs")) ? "e2fsprogs" : "xfsprogs" )); } while (0); _gf_log ((*__glusterfs_this_location())-> name, "glusterd-utils.c", __FUNCTION__, 4361, GF_LOG_ERROR, "could not get inode " "size for %s : %s package missing", fs_name, ((strcmp (fs_name , "xfs")) ? "e2fsprogs" : "xfsprogs")); } while (0) | ||
4360 | ((strcmp (fs_name, "xfs")) ?do { do { if (0) printf ("could not get inode " "size for %s : %s package missing" , fs_name, ((strcmp (fs_name, "xfs")) ? "e2fsprogs" : "xfsprogs" )); } while (0); _gf_log ((*__glusterfs_this_location())-> name, "glusterd-utils.c", __FUNCTION__, 4361, GF_LOG_ERROR, "could not get inode " "size for %s : %s package missing", fs_name, ((strcmp (fs_name , "xfs")) ? "e2fsprogs" : "xfsprogs")); } while (0) | ||
4361 | "e2fsprogs" : "xfsprogs"))do { do { if (0) printf ("could not get inode " "size for %s : %s package missing" , fs_name, ((strcmp (fs_name, "xfs")) ? "e2fsprogs" : "xfsprogs" )); } while (0); _gf_log ((*__glusterfs_this_location())-> name, "glusterd-utils.c", __FUNCTION__, 4361, GF_LOG_ERROR, "could not get inode " "size for %s : %s package missing", fs_name, ((strcmp (fs_name , "xfs")) ? "e2fsprogs" : "xfsprogs")); } while (0); | ||
4362 | goto out; | ||
4363 | } | ||
4364 | |||
4365 | for (;;) { | ||
4366 | if (fgets (buffer, sizeof (buffer), | ||
4367 | runner_chio (&runner, STDOUT_FILENO1)) == NULL((void*)0)) | ||
4368 | break; | ||
4369 | trail = strrchr (buffer, '\n'); | ||
4370 | if (trail) | ||
4371 | *trail = '\0'; | ||
4372 | |||
4373 | cur_word = glusterd_parse_inode_size (buffer, pattern); | ||
4374 | if (cur_word) | ||
4375 | break; | ||
4376 | } | ||
4377 | |||
4378 | ret = runner_end (&runner); | ||
4379 | if (ret) { | ||
4380 | gf_log (THIS->name, GF_LOG_ERROR, "%s exited with non-zero "do { do { if (0) printf ("%s exited with non-zero " "exit status" , ((!strcmp (fs_name, "xfs")) ? "xfs_info" : "tune2fs")); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 4382, GF_LOG_ERROR, "%s exited with non-zero " "exit status", ((!strcmp (fs_name, "xfs")) ? "xfs_info" : "tune2fs" )); } while (0) | ||
4381 | "exit status", ((!strcmp (fs_name, "xfs")) ?do { do { if (0) printf ("%s exited with non-zero " "exit status" , ((!strcmp (fs_name, "xfs")) ? "xfs_info" : "tune2fs")); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 4382, GF_LOG_ERROR, "%s exited with non-zero " "exit status", ((!strcmp (fs_name, "xfs")) ? "xfs_info" : "tune2fs" )); } while (0) | ||
4382 | "xfs_info" : "tune2fs"))do { do { if (0) printf ("%s exited with non-zero " "exit status" , ((!strcmp (fs_name, "xfs")) ? "xfs_info" : "tune2fs")); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 4382, GF_LOG_ERROR, "%s exited with non-zero " "exit status", ((!strcmp (fs_name, "xfs")) ? "xfs_info" : "tune2fs" )); } while (0); | ||
4383 | goto out; | ||
4384 | } | ||
4385 | if (!cur_word) { | ||
4386 | ret = -1; | ||
4387 | gf_log (THIS->name, GF_LOG_ERROR, "Unable to retrieve inode "do { do { if (0) printf ("Unable to retrieve inode " "size using %s" , (!strcmp (fs_name, "xfs")? "xfs_info": "tune2fs")); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 4389, GF_LOG_ERROR, "Unable to retrieve inode " "size using %s", (!strcmp (fs_name, "xfs")? "xfs_info": "tune2fs" )); } while (0) | ||
4388 | "size using %s",do { do { if (0) printf ("Unable to retrieve inode " "size using %s" , (!strcmp (fs_name, "xfs")? "xfs_info": "tune2fs")); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 4389, GF_LOG_ERROR, "Unable to retrieve inode " "size using %s", (!strcmp (fs_name, "xfs")? "xfs_info": "tune2fs" )); } while (0) | ||
4389 | (!strcmp (fs_name, "xfs")? "xfs_info": "tune2fs"))do { do { if (0) printf ("Unable to retrieve inode " "size using %s" , (!strcmp (fs_name, "xfs")? "xfs_info": "tune2fs")); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 4389, GF_LOG_ERROR, "Unable to retrieve inode " "size using %s", (!strcmp (fs_name, "xfs")? "xfs_info": "tune2fs" )); } while (0); | ||
4390 | goto out; | ||
4391 | } | ||
4392 | |||
4393 | inode_size = gf_strdup (cur_word); | ||
4394 | |||
4395 | memset (key, 0, sizeof (key)); | ||
4396 | snprintf (key, sizeof (key), "brick%d.inode_size", count); | ||
4397 | |||
4398 | ret = dict_set_dynstr (dict, key, inode_size); | ||
4399 | |||
4400 | out: | ||
4401 | if (ret) | ||
4402 | gf_log (THIS->name, GF_LOG_ERROR, "failed to get inode size")do { do { if (0) printf ("failed to get inode size"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 4402, GF_LOG_ERROR, "failed to get inode size" ); } while (0); | ||
4403 | return ret; | ||
4404 | } | ||
4405 | |||
4406 | static int | ||
4407 | glusterd_add_brick_mount_details (glusterd_brickinfo_t *brickinfo, | ||
4408 | dict_t *dict, int count) | ||
4409 | { | ||
4410 | int ret = -1; | ||
4411 | char key[1024] = {0}; | ||
4412 | char base_key[1024] = {0}; | ||
4413 | char *mnt_pt = NULL((void*)0); | ||
4414 | char *fs_name = NULL((void*)0); | ||
4415 | char *mnt_options = NULL((void*)0); | ||
4416 | char *device = NULL((void*)0); | ||
4417 | FILE *mtab = NULL((void*)0); | ||
4418 | struct mntent *entry = NULL((void*)0); | ||
4419 | |||
4420 | snprintf (base_key, sizeof (base_key), "brick%d", count); | ||
4421 | |||
4422 | ret = glusterd_get_brick_root (brickinfo->path, &mnt_pt); | ||
4423 | if (ret) | ||
4424 | goto out; | ||
4425 | |||
4426 | mtab = setmntent (_PATH_MOUNTED"/etc/mtab", "r"); | ||
4427 | if (!mtab) { | ||
4428 | ret = -1; | ||
4429 | goto out; | ||
4430 | } | ||
4431 | |||
4432 | entry = getmntent (mtab); | ||
4433 | |||
4434 | while (1) { | ||
4435 | if (!entry) { | ||
4436 | ret = -1; | ||
4437 | goto out; | ||
4438 | } | ||
4439 | if (!strcmp (entry->mnt_dir, mnt_pt) && | ||
4440 | strcmp (entry->mnt_type, "rootfs")) | ||
4441 | break; | ||
4442 | entry = getmntent (mtab); | ||
4443 | } | ||
4444 | |||
4445 | /* get device file */ | ||
4446 | memset (key, 0, sizeof (key)); | ||
4447 | snprintf (key, sizeof (key), "%s.device", base_key); | ||
4448 | |||
4449 | device = gf_strdup (entry->mnt_fsname); | ||
4450 | ret = dict_set_dynstr (dict, key, device); | ||
4451 | if (ret) | ||
4452 | goto out; | ||
4453 | |||
4454 | /* fs type */ | ||
4455 | memset (key, 0, sizeof (key)); | ||
4456 | snprintf (key, sizeof (key), "%s.fs_name", base_key); | ||
4457 | |||
4458 | fs_name = gf_strdup (entry->mnt_type); | ||
4459 | ret = dict_set_dynstr (dict, key, fs_name); | ||
4460 | if (ret) | ||
4461 | goto out; | ||
4462 | |||
4463 | /* mount options */ | ||
4464 | memset (key, 0, sizeof (key)); | ||
4465 | snprintf (key, sizeof (key), "%s.mnt_options", base_key); | ||
4466 | |||
4467 | mnt_options = gf_strdup (entry->mnt_opts); | ||
4468 | ret = dict_set_dynstr (dict, key, mnt_options); | ||
4469 | |||
4470 | out: | ||
4471 | GF_FREE (mnt_pt)__gf_free (mnt_pt); | ||
4472 | if (mtab) | ||
4473 | endmntent (mtab); | ||
4474 | |||
4475 | return ret; | ||
4476 | } | ||
4477 | #endif | ||
4478 | |||
4479 | int | ||
4480 | glusterd_add_brick_detail_to_dict (glusterd_volinfo_t *volinfo, | ||
4481 | glusterd_brickinfo_t *brickinfo, | ||
4482 | dict_t *dict, int count) | ||
4483 | { | ||
4484 | int ret = -1; | ||
4485 | uint64_t memtotal = 0; | ||
4486 | uint64_t memfree = 0; | ||
4487 | uint64_t inodes_total = 0; | ||
4488 | uint64_t inodes_free = 0; | ||
4489 | uint64_t block_size = 0; | ||
4490 | char key[1024] = {0}; | ||
4491 | char base_key[1024] = {0}; | ||
4492 | struct statvfs brickstat = {0}; | ||
4493 | xlator_t *this = NULL((void*)0); | ||
4494 | |||
4495 | this = THIS(*__glusterfs_this_location()); | ||
4496 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4496, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
4497 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4497, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
4498 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4498, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | ||
4499 | |||
4500 | snprintf (base_key, sizeof (base_key), "brick%d", count); | ||
4501 | |||
4502 | ret = statvfs (brickinfo->path, &brickstat); | ||
4503 | if (ret) { | ||
4504 | gf_log (this->name, GF_LOG_ERROR, "statfs error: %s ",do { do { if (0) printf ("statfs error: %s ", strerror ((*__errno_location ()))); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 4505, GF_LOG_ERROR, "statfs error: %s ", strerror ((*__errno_location ()))); } while (0) | ||
4505 | strerror (errno))do { do { if (0) printf ("statfs error: %s ", strerror ((*__errno_location ()))); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 4505, GF_LOG_ERROR, "statfs error: %s ", strerror ((*__errno_location ()))); } while (0); | ||
4506 | goto out; | ||
4507 | } | ||
4508 | |||
4509 | /* file system block size */ | ||
4510 | block_size = brickstat.f_bsize; | ||
4511 | memset (key, 0, sizeof (key)); | ||
4512 | snprintf (key, sizeof (key), "%s.block_size", base_key); | ||
4513 | ret = dict_set_uint64 (dict, key, block_size); | ||
4514 | if (ret) | ||
4515 | goto out; | ||
4516 | |||
4517 | /* free space in brick */ | ||
4518 | memfree = brickstat.f_bfree * brickstat.f_bsize; | ||
4519 | memset (key, 0, sizeof (key)); | ||
4520 | snprintf (key, sizeof (key), "%s.free", base_key); | ||
4521 | ret = dict_set_uint64 (dict, key, memfree); | ||
4522 | if (ret) | ||
4523 | goto out; | ||
4524 | |||
4525 | /* total space of brick */ | ||
4526 | memtotal = brickstat.f_blocks * brickstat.f_bsize; | ||
4527 | memset (key, 0, sizeof (key)); | ||
4528 | snprintf (key, sizeof (key), "%s.total", base_key); | ||
4529 | ret = dict_set_uint64 (dict, key, memtotal); | ||
4530 | if (ret) | ||
4531 | goto out; | ||
4532 | |||
4533 | /* inodes: total and free counts only for ext2/3/4 and xfs */ | ||
4534 | inodes_total = brickstat.f_files; | ||
4535 | if (inodes_total) { | ||
4536 | memset (key, 0, sizeof (key)); | ||
4537 | snprintf (key, sizeof (key), "%s.total_inodes", base_key); | ||
4538 | ret = dict_set_uint64 (dict, key, inodes_total); | ||
4539 | if (ret) | ||
4540 | goto out; | ||
4541 | } | ||
4542 | |||
4543 | inodes_free = brickstat.f_ffree; | ||
4544 | if (inodes_free) { | ||
4545 | memset (key, 0, sizeof (key)); | ||
4546 | snprintf (key, sizeof (key), "%s.free_inodes", base_key); | ||
4547 | ret = dict_set_uint64 (dict, key, inodes_free); | ||
4548 | if (ret) | ||
4549 | goto out; | ||
4550 | } | ||
4551 | #ifdef GF_LINUX_HOST_OS1 | ||
4552 | ret = glusterd_add_brick_mount_details (brickinfo, dict, count); | ||
4553 | if (ret) | ||
4554 | goto out; | ||
4555 | |||
4556 | ret = glusterd_add_inode_size_to_dict (dict, count); | ||
4557 | #endif | ||
4558 | out: | ||
4559 | if (ret) | ||
4560 | gf_log (this->name, GF_LOG_DEBUG, "Error adding brick"do { do { if (0) printf ("Error adding brick" " detail to dict: %s" , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 4561, GF_LOG_DEBUG , "Error adding brick" " detail to dict: %s", strerror ((*__errno_location ()))); } while (0) | ||
4561 | " detail to dict: %s", strerror (errno))do { do { if (0) printf ("Error adding brick" " detail to dict: %s" , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 4561, GF_LOG_DEBUG , "Error adding brick" " detail to dict: %s", strerror ((*__errno_location ()))); } while (0); | ||
4562 | return ret; | ||
4563 | } | ||
4564 | |||
4565 | int32_t | ||
4566 | glusterd_add_brick_to_dict (glusterd_volinfo_t *volinfo, | ||
4567 | glusterd_brickinfo_t *brickinfo, | ||
4568 | dict_t *dict, int32_t count) | ||
4569 | { | ||
4570 | |||
4571 | int ret = -1; | ||
4572 | int32_t pid = -1; | ||
4573 | int32_t brick_online = -1; | ||
4574 | char key[1024] = {0}; | ||
4575 | char base_key[1024] = {0}; | ||
4576 | char pidfile[PATH_MAX4096] = {0}; | ||
4577 | xlator_t *this = NULL((void*)0); | ||
4578 | glusterd_conf_t *priv = NULL((void*)0); | ||
4579 | |||
4580 | |||
4581 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4581, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
4582 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4582, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
4583 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4583, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | ||
4584 | |||
4585 | this = THIS(*__glusterfs_this_location()); | ||
4586 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4586, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4587 | |||
4588 | priv = this->private; | ||
4589 | |||
4590 | snprintf (base_key, sizeof (base_key), "brick%d", count); | ||
4591 | snprintf (key, sizeof (key), "%s.hostname", base_key); | ||
4592 | |||
4593 | ret = dict_set_str (dict, key, brickinfo->hostname); | ||
4594 | if (ret) | ||
4595 | goto out; | ||
4596 | |||
4597 | memset (key, 0, sizeof (key)); | ||
4598 | snprintf (key, sizeof (key), "%s.path", base_key); | ||
4599 | ret = dict_set_str (dict, key, brickinfo->path); | ||
4600 | if (ret) | ||
4601 | goto out; | ||
4602 | |||
4603 | memset (key, 0, sizeof (key)); | ||
4604 | snprintf (key, sizeof (key), "%s.port", base_key); | ||
4605 | ret = dict_set_int32 (dict, key, brickinfo->port); | ||
4606 | if (ret) | ||
4607 | goto out; | ||
4608 | |||
4609 | GLUSTERD_GET_BRICK_PIDFILE (pidfile, volinfo, brickinfo, priv)do { char exp_path[4096] = {0,}; char volpath[4096] = {0,}; snprintf (volpath, 4096, "%s/vols/%s", priv->workdir, volinfo-> volname);; do { int i = 0; for (i = 1; i < strlen (brickinfo ->path); i++) { exp_path[i-1] = brickinfo->path[i]; if ( exp_path[i-1] == '/') exp_path[i-1] = '-'; } } while (0); snprintf (pidfile, 4096, "%s/run/%s-%s.pid", volpath, brickinfo->hostname , exp_path); } while (0); | ||
4610 | |||
4611 | brick_online = glusterd_is_service_running (pidfile, &pid); | ||
4612 | |||
4613 | memset (key, 0, sizeof (key)); | ||
4614 | snprintf (key, sizeof (key), "%s.pid", base_key); | ||
4615 | ret = dict_set_int32 (dict, key, pid); | ||
4616 | if (ret) | ||
4617 | goto out; | ||
4618 | |||
4619 | memset (key, 0, sizeof (key)); | ||
4620 | snprintf (key, sizeof (key), "%s.status", base_key); | ||
4621 | ret = dict_set_int32 (dict, key, brick_online); | ||
4622 | |||
4623 | out: | ||
4624 | if (ret) | ||
4625 | 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-utils.c", __FUNCTION__, 4625, GF_LOG_DEBUG , "Returning %d", ret); } while (0); | ||
4626 | |||
4627 | return ret; | ||
4628 | } | ||
4629 | |||
4630 | int32_t | ||
4631 | glusterd_get_all_volnames (dict_t *dict) | ||
4632 | { | ||
4633 | int ret = -1; | ||
4634 | int32_t vol_count = 0; | ||
4635 | char key[256] = {0}; | ||
4636 | glusterd_volinfo_t *entry = NULL((void*)0); | ||
4637 | glusterd_conf_t *priv = NULL((void*)0); | ||
4638 | |||
4639 | priv = THIS(*__glusterfs_this_location())->private; | ||
4640 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4640, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
4641 | |||
4642 | list_for_each_entry (entry, &priv->volumes, vol_list)for (entry = ((typeof(*entry) *)((char *)((&priv->volumes )->next)-(unsigned long)(&((typeof(*entry) *)0)->vol_list ))); &entry->vol_list != (&priv->volumes); entry = ((typeof(*entry) *)((char *)(entry->vol_list.next)-(unsigned long)(&((typeof(*entry) *)0)->vol_list)))) { | ||
Within the expansion of the macro 'list_for_each_entry':
| |||
4643 | memset (key, 0, sizeof (key)); | ||
4644 | snprintf (key, sizeof (key), "vol%d", vol_count); | ||
4645 | ret = dict_set_str (dict, key, entry->volname); | ||
4646 | if (ret) | ||
4647 | goto out; | ||
4648 | |||
4649 | vol_count++; | ||
4650 | } | ||
4651 | |||
4652 | ret = dict_set_int32 (dict, "vol_count", vol_count); | ||
4653 | |||
4654 | out: | ||
4655 | if (ret) | ||
4656 | gf_log (THIS->name, GF_LOG_ERROR, "failed to get all "do { do { if (0) printf ("failed to get all " "volume names for status" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 4657, GF_LOG_ERROR, "failed to get all " "volume names for status"); } while (0) | ||
4657 | "volume names for status")do { do { if (0) printf ("failed to get all " "volume names for status" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 4657, GF_LOG_ERROR, "failed to get all " "volume names for status"); } while (0); | ||
4658 | return ret; | ||
4659 | } | ||
4660 | |||
4661 | int | ||
4662 | glusterd_all_volume_cond_check (glusterd_condition_func func, int status, | ||
4663 | void *ctx) | ||
4664 | { | ||
4665 | glusterd_conf_t *priv = NULL((void*)0); | ||
4666 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
4667 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
4668 | int ret = -1; | ||
4669 | xlator_t *this = NULL((void*)0); | ||
4670 | |||
4671 | this = THIS(*__glusterfs_this_location()); | ||
4672 | priv = this->private; | ||
4673 | |||
4674 | 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)))) { | ||
4675 | list_for_each_entry (brickinfo, &volinfo->bricks,for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*brickinfo ) *)0)->brick_list))); &brickinfo->brick_list != (& volinfo->bricks); brickinfo = ((typeof(*brickinfo) *)((char *)(brickinfo->brick_list.next)-(unsigned long)(&((typeof (*brickinfo) *)0)->brick_list)))) | ||
4676 | 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)))) { | ||
4677 | ret = func (volinfo, brickinfo, ctx); | ||
4678 | if (ret != status) { | ||
4679 | ret = -1; | ||
4680 | goto out; | ||
4681 | } | ||
4682 | } | ||
4683 | } | ||
4684 | ret = 0; | ||
4685 | out: | ||
4686 | gf_log ("", GF_LOG_DEBUG, "returning %d", ret)do { do { if (0) printf ("returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 4686, GF_LOG_DEBUG, "returning %d" , ret); } while (0); | ||
4687 | return ret; | ||
4688 | } | ||
4689 | |||
4690 | int | ||
4691 | glusterd_friend_find_by_uuid (uuid_t uuid, | ||
4692 | glusterd_peerinfo_t **peerinfo) | ||
4693 | { | ||
4694 | int ret = -1; | ||
4695 | glusterd_conf_t *priv = NULL((void*)0); | ||
4696 | glusterd_peerinfo_t *entry = NULL((void*)0); | ||
4697 | xlator_t *this = NULL((void*)0); | ||
4698 | |||
4699 | this = THIS(*__glusterfs_this_location()); | ||
4700 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4700, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4701 | GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: " "peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4701, GF_LOG_ERROR, "Assertion failed: " "peerinfo" ); } while (0); } } while (0); | ||
4702 | |||
4703 | *peerinfo = NULL((void*)0); | ||
4704 | priv = this->private; | ||
4705 | |||
4706 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4706, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
4707 | |||
4708 | if (uuid_is_null (uuid)) | ||
4709 | return -1; | ||
4710 | |||
4711 | list_for_each_entry (entry, &priv->peers, uuid_list)for (entry = ((typeof(*entry) *)((char *)((&priv->peers )->next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list ))); &entry->uuid_list != (&priv->peers); entry = ((typeof(*entry) *)((char *)(entry->uuid_list.next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list)))) { | ||
4712 | if (!uuid_compare (entry->uuid, uuid)) { | ||
4713 | |||
4714 | gf_log (this->name, GF_LOG_DEBUG,do { do { if (0) printf ("Friend found... state: %s", glusterd_friend_sm_state_name_get (entry->state.state)); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4716, GF_LOG_DEBUG, "Friend found... state: %s" , glusterd_friend_sm_state_name_get (entry->state.state)); } while (0) | ||
4715 | "Friend found... state: %s",do { do { if (0) printf ("Friend found... state: %s", glusterd_friend_sm_state_name_get (entry->state.state)); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4716, GF_LOG_DEBUG, "Friend found... state: %s" , glusterd_friend_sm_state_name_get (entry->state.state)); } while (0) | ||
4716 | glusterd_friend_sm_state_name_get (entry->state.state))do { do { if (0) printf ("Friend found... state: %s", glusterd_friend_sm_state_name_get (entry->state.state)); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4716, GF_LOG_DEBUG, "Friend found... state: %s" , glusterd_friend_sm_state_name_get (entry->state.state)); } while (0); | ||
4717 | *peerinfo = entry; | ||
4718 | return 0; | ||
4719 | } | ||
4720 | } | ||
4721 | |||
4722 | gf_log (this->name, GF_LOG_DEBUG, "Friend with uuid: %s, not found",do { do { if (0) printf ("Friend with uuid: %s, not found", uuid_utoa (uuid)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 4723, GF_LOG_DEBUG, "Friend with uuid: %s, not found" , uuid_utoa (uuid)); } while (0) | ||
4723 | uuid_utoa (uuid))do { do { if (0) printf ("Friend with uuid: %s, not found", uuid_utoa (uuid)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 4723, GF_LOG_DEBUG, "Friend with uuid: %s, not found" , uuid_utoa (uuid)); } while (0); | ||
4724 | return ret; | ||
4725 | } | ||
4726 | |||
4727 | |||
4728 | int | ||
4729 | glusterd_friend_find_by_hostname (const char *hoststr, | ||
4730 | glusterd_peerinfo_t **peerinfo) | ||
4731 | { | ||
4732 | int ret = -1; | ||
4733 | glusterd_conf_t *priv = NULL((void*)0); | ||
4734 | glusterd_peerinfo_t *entry = NULL((void*)0); | ||
4735 | struct addrinfo *addr = NULL((void*)0); | ||
4736 | struct addrinfo *p = NULL((void*)0); | ||
4737 | char *host = NULL((void*)0); | ||
4738 | struct sockaddr_in6 *s6 = NULL((void*)0); | ||
4739 | struct sockaddr_in *s4 = NULL((void*)0); | ||
4740 | struct in_addr *in_addr = NULL((void*)0); | ||
4741 | char hname[1024] = {0,}; | ||
4742 | xlator_t *this = NULL((void*)0); | ||
4743 | |||
4744 | |||
4745 | this = THIS(*__glusterfs_this_location()); | ||
4746 | GF_ASSERT (hoststr)do { if (!(hoststr)) { do { do { if (0) printf ("Assertion failed: " "hoststr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4746, GF_LOG_ERROR, "Assertion failed: " "hoststr" ); } while (0); } } while (0); | ||
4747 | GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: " "peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4747, GF_LOG_ERROR, "Assertion failed: " "peerinfo" ); } while (0); } } while (0); | ||
4748 | |||
4749 | *peerinfo = NULL((void*)0); | ||
4750 | priv = this->private; | ||
4751 | |||
4752 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4752, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
4753 | |||
4754 | list_for_each_entry (entry, &priv->peers, uuid_list)for (entry = ((typeof(*entry) *)((char *)((&priv->peers )->next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list ))); &entry->uuid_list != (&priv->peers); entry = ((typeof(*entry) *)((char *)(entry->uuid_list.next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list)))) { | ||
4755 | if (!strncasecmp (entry->hostname, hoststr, | ||
4756 | 1024)) { | ||
4757 | |||
4758 | gf_log (this->name, GF_LOG_DEBUG,do { do { if (0) printf ("Friend %s found.. state: %d", hoststr , entry->state.state); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4760, GF_LOG_DEBUG, "Friend %s found.. state: %d" , hoststr, entry->state.state); } while (0) | ||
4759 | "Friend %s found.. state: %d", hoststr,do { do { if (0) printf ("Friend %s found.. state: %d", hoststr , entry->state.state); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4760, GF_LOG_DEBUG, "Friend %s found.. state: %d" , hoststr, entry->state.state); } while (0) | ||
4760 | entry->state.state)do { do { if (0) printf ("Friend %s found.. state: %d", hoststr , entry->state.state); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4760, GF_LOG_DEBUG, "Friend %s found.. state: %d" , hoststr, entry->state.state); } while (0); | ||
4761 | *peerinfo = entry; | ||
4762 | return 0; | ||
4763 | } | ||
4764 | } | ||
4765 | |||
4766 | ret = getaddrinfo (hoststr, NULL((void*)0), NULL((void*)0), &addr); | ||
4767 | if (ret != 0) { | ||
4768 | gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 4770, GF_LOG_ERROR, "error in getaddrinfo: %s\n" , gai_strerror(ret)); } while (0) | ||
4769 | "error in getaddrinfo: %s\n",do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 4770, GF_LOG_ERROR, "error in getaddrinfo: %s\n" , gai_strerror(ret)); } while (0) | ||
4770 | gai_strerror(ret))do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (ret)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 4770, GF_LOG_ERROR, "error in getaddrinfo: %s\n" , gai_strerror(ret)); } while (0); | ||
4771 | goto out; | ||
4772 | } | ||
4773 | |||
4774 | for (p = addr; p != NULL((void*)0); p = p->ai_next) { | ||
4775 | switch (p->ai_family) { | ||
4776 | case AF_INET2: | ||
4777 | s4 = (struct sockaddr_in *) p->ai_addr; | ||
4778 | in_addr = &s4->sin_addr; | ||
4779 | break; | ||
4780 | case AF_INET610: | ||
4781 | s6 = (struct sockaddr_in6 *) p->ai_addr; | ||
4782 | in_addr =(struct in_addr *) &s6->sin6_addr; | ||
4783 | break; | ||
4784 | default: ret = -1; | ||
4785 | goto out; | ||
4786 | } | ||
4787 | host = inet_ntoa(*in_addr); | ||
4788 | |||
4789 | ret = getnameinfo (p->ai_addr, p->ai_addrlen, hname, | ||
4790 | 1024, NULL((void*)0), 0, 0); | ||
4791 | if (ret) | ||
4792 | goto out; | ||
4793 | |||
4794 | list_for_each_entry (entry, &priv->peers, uuid_list)for (entry = ((typeof(*entry) *)((char *)((&priv->peers )->next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list ))); &entry->uuid_list != (&priv->peers); entry = ((typeof(*entry) *)((char *)(entry->uuid_list.next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list)))) { | ||
4795 | if (!strncasecmp (entry->hostname, host, | ||
4796 | 1024) || !strncasecmp (entry->hostname,hname, | ||
4797 | 1024)) { | ||
4798 | gf_log (this->name, GF_LOG_DEBUG,do { do { if (0) printf ("Friend %s found.. state: %d", hoststr , entry->state.state); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4800, GF_LOG_DEBUG, "Friend %s found.. state: %d" , hoststr, entry->state.state); } while (0) | ||
4799 | "Friend %s found.. state: %d",do { do { if (0) printf ("Friend %s found.. state: %d", hoststr , entry->state.state); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4800, GF_LOG_DEBUG, "Friend %s found.. state: %d" , hoststr, entry->state.state); } while (0) | ||
4800 | hoststr, entry->state.state)do { do { if (0) printf ("Friend %s found.. state: %d", hoststr , entry->state.state); } while (0); _gf_log (this->name , "glusterd-utils.c", __FUNCTION__, 4800, GF_LOG_DEBUG, "Friend %s found.. state: %d" , hoststr, entry->state.state); } while (0); | ||
4801 | *peerinfo = entry; | ||
4802 | freeaddrinfo (addr); | ||
4803 | return 0; | ||
4804 | } | ||
4805 | } | ||
4806 | } | ||
4807 | |||
4808 | out: | ||
4809 | gf_log (this->name, GF_LOG_DEBUG, "Unable to find friend: %s", hoststr)do { do { if (0) printf ("Unable to find friend: %s", hoststr ); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 4809, GF_LOG_DEBUG, "Unable to find friend: %s", hoststr); } while (0); | ||
4810 | if (addr) | ||
4811 | freeaddrinfo (addr); | ||
4812 | return -1; | ||
4813 | } | ||
4814 | |||
4815 | int | ||
4816 | glusterd_hostname_to_uuid (char *hostname, uuid_t uuid) | ||
4817 | { | ||
4818 | GF_ASSERT (hostname)do { if (!(hostname)) { do { do { if (0) printf ("Assertion failed: " "hostname"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4818, GF_LOG_ERROR, "Assertion failed: " "hostname" ); } while (0); } } while (0); | ||
4819 | GF_ASSERT (uuid)do { if (!(uuid)) { do { do { if (0) printf ("Assertion failed: " "uuid"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4819, GF_LOG_ERROR, "Assertion failed: " "uuid" ); } while (0); } } while (0); | ||
4820 | |||
4821 | glusterd_peerinfo_t *peerinfo = NULL((void*)0); | ||
4822 | glusterd_conf_t *priv = NULL((void*)0); | ||
4823 | int ret = -1; | ||
4824 | xlator_t *this = NULL((void*)0); | ||
4825 | |||
4826 | this = THIS(*__glusterfs_this_location()); | ||
4827 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4827, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4828 | priv = this->private; | ||
4829 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4829, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
4830 | |||
4831 | ret = glusterd_friend_find_by_hostname (hostname, &peerinfo); | ||
4832 | if (ret) { | ||
4833 | if (glusterd_is_local_addr (hostname)) { | ||
4834 | uuid_copy (uuid, MY_UUID(__glusterd_uuid())); | ||
4835 | ret = 0; | ||
4836 | } else { | ||
4837 | goto out; | ||
4838 | } | ||
4839 | } else { | ||
4840 | uuid_copy (uuid, peerinfo->uuid); | ||
4841 | } | ||
4842 | |||
4843 | out: | ||
4844 | 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-utils.c", __FUNCTION__, 4844, GF_LOG_DEBUG , "returning %d", ret); } while (0); | ||
4845 | return ret; | ||
4846 | } | ||
4847 | |||
4848 | int | ||
4849 | glusterd_brick_stop (glusterd_volinfo_t *volinfo, | ||
4850 | glusterd_brickinfo_t *brickinfo, | ||
4851 | gf_boolean_t del_brick) | ||
4852 | { | ||
4853 | int ret = -1; | ||
4854 | xlator_t *this = NULL((void*)0); | ||
4855 | glusterd_conf_t *conf = NULL((void*)0); | ||
4856 | |||
4857 | if ((!brickinfo) || (!volinfo)) | ||
4858 | goto out; | ||
4859 | |||
4860 | this = THIS(*__glusterfs_this_location()); | ||
4861 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4861, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4862 | conf = this->private; | ||
4863 | GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: " "conf"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4863, GF_LOG_ERROR, "Assertion failed: " "conf" ); } while (0); } } while (0); | ||
4864 | |||
4865 | if (uuid_is_null (brickinfo->uuid)) { | ||
4866 | ret = glusterd_resolve_brick (brickinfo); | ||
4867 | if (ret) { | ||
4868 | gf_log (this->name, GF_LOG_ERROR, FMTSTR_RESOLVE_BRICK,do { do { if (0) printf ("Could not find peer on which brick %s:%s resides" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4869, GF_LOG_ERROR , "Could not find peer on which brick %s:%s resides", brickinfo ->hostname, brickinfo->path); } while (0) | ||
4869 | brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Could not find peer on which brick %s:%s resides" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4869, GF_LOG_ERROR , "Could not find peer on which brick %s:%s resides", brickinfo ->hostname, brickinfo->path); } while (0); | ||
4870 | goto out; | ||
4871 | } | ||
4872 | } | ||
4873 | |||
4874 | if (uuid_compare (brickinfo->uuid, MY_UUID(__glusterd_uuid()))) { | ||
4875 | ret = 0; | ||
4876 | if (del_brick) | ||
4877 | glusterd_delete_brick (volinfo, brickinfo); | ||
4878 | goto out; | ||
4879 | } | ||
4880 | |||
4881 | gf_log (this->name, GF_LOG_DEBUG, "About to stop glusterfs"do { do { if (0) printf ("About to stop glusterfs" " for brick %s:%s" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4883, GF_LOG_DEBUG , "About to stop glusterfs" " for brick %s:%s", brickinfo-> hostname, brickinfo->path); } while (0) | ||
4882 | " for brick %s:%s", brickinfo->hostname,do { do { if (0) printf ("About to stop glusterfs" " for brick %s:%s" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4883, GF_LOG_DEBUG , "About to stop glusterfs" " for brick %s:%s", brickinfo-> hostname, brickinfo->path); } while (0) | ||
4883 | brickinfo->path)do { do { if (0) printf ("About to stop glusterfs" " for brick %s:%s" , brickinfo->hostname, brickinfo->path); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4883, GF_LOG_DEBUG , "About to stop glusterfs" " for brick %s:%s", brickinfo-> hostname, brickinfo->path); } while (0); | ||
4884 | ret = glusterd_volume_stop_glusterfs (volinfo, brickinfo, del_brick); | ||
4885 | if (ret) { | ||
4886 | gf_log (this->name, GF_LOG_CRITICAL, "Unable to stop"do { do { if (0) printf ("Unable to stop" " brick: %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 4888, GF_LOG_CRITICAL , "Unable to stop" " brick: %s:%s", brickinfo->hostname, brickinfo ->path); } while (0) | ||
4887 | " brick: %s:%s", brickinfo->hostname,do { do { if (0) printf ("Unable to stop" " brick: %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 4888, GF_LOG_CRITICAL , "Unable to stop" " brick: %s:%s", brickinfo->hostname, brickinfo ->path); } while (0) | ||
4888 | brickinfo->path)do { do { if (0) printf ("Unable to stop" " brick: %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 4888, GF_LOG_CRITICAL , "Unable to stop" " brick: %s:%s", brickinfo->hostname, brickinfo ->path); } while (0); | ||
4889 | goto out; | ||
4890 | } | ||
4891 | |||
4892 | out: | ||
4893 | 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-utils.c", __FUNCTION__, 4893, GF_LOG_DEBUG , "returning %d ", ret); } while (0); | ||
4894 | return ret; | ||
4895 | } | ||
4896 | |||
4897 | int | ||
4898 | glusterd_is_defrag_on (glusterd_volinfo_t *volinfo) | ||
4899 | { | ||
4900 | return (volinfo->rebal.defrag != NULL((void*)0)); | ||
4901 | } | ||
4902 | |||
4903 | gf_boolean_t | ||
4904 | glusterd_is_rb_ongoing (glusterd_volinfo_t *volinfo) | ||
4905 | { | ||
4906 | gf_boolean_t ret = _gf_false; | ||
4907 | |||
4908 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4908, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
4909 | |||
4910 | if (glusterd_is_rb_started (volinfo) || | ||
4911 | glusterd_is_rb_paused (volinfo)) | ||
4912 | ret = _gf_true; | ||
4913 | |||
4914 | return ret; | ||
4915 | } | ||
4916 | |||
4917 | int | ||
4918 | glusterd_new_brick_validate (char *brick, glusterd_brickinfo_t *brickinfo, | ||
4919 | char *op_errstr, size_t len) | ||
4920 | { | ||
4921 | glusterd_brickinfo_t *newbrickinfo = NULL((void*)0); | ||
4922 | int ret = -1; | ||
4923 | gf_boolean_t is_allocated = _gf_false; | ||
4924 | glusterd_peerinfo_t *peerinfo = NULL((void*)0); | ||
4925 | glusterd_conf_t *priv = NULL((void*)0); | ||
4926 | xlator_t *this = NULL((void*)0); | ||
4927 | |||
4928 | this = THIS(*__glusterfs_this_location()); | ||
4929 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4929, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
4930 | priv = this->private; | ||
4931 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4931, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
4932 | |||
4933 | |||
4934 | GF_ASSERT (brick)do { if (!(brick)) { do { do { if (0) printf ("Assertion failed: " "brick"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4934, GF_LOG_ERROR, "Assertion failed: " "brick" ); } while (0); } } while (0); | ||
4935 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 4935, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | ||
4936 | |||
4937 | if (!brickinfo) { | ||
4938 | ret = glusterd_brickinfo_new_from_brick (brick, &newbrickinfo); | ||
4939 | if (ret) | ||
4940 | goto out; | ||
4941 | is_allocated = _gf_true; | ||
4942 | } else { | ||
4943 | newbrickinfo = brickinfo; | ||
4944 | } | ||
4945 | |||
4946 | ret = glusterd_resolve_brick (newbrickinfo); | ||
4947 | if (ret) { | ||
4948 | snprintf(op_errstr, len, "Host %s is not in \'Peer " | ||
4949 | "in Cluster\' state", newbrickinfo->hostname); | ||
4950 | goto out; | ||
4951 | } | ||
4952 | |||
4953 | if (!uuid_compare (MY_UUID(__glusterd_uuid()), newbrickinfo->uuid)) { | ||
4954 | /* brick is local */ | ||
4955 | if (!glusterd_is_brickpath_available (newbrickinfo->uuid, | ||
4956 | newbrickinfo->path)) { | ||
4957 | snprintf(op_errstr, len, "Brick: %s not available." | ||
4958 | " Brick may be containing or be contained " | ||
4959 | "by an existing brick", brick); | ||
4960 | ret = -1; | ||
4961 | goto out; | ||
4962 | } | ||
4963 | |||
4964 | } else { | ||
4965 | ret = glusterd_friend_find_by_uuid (newbrickinfo->uuid, | ||
4966 | &peerinfo); | ||
4967 | if (ret) { | ||
4968 | snprintf (op_errstr, len, "Failed to find host %s", | ||
4969 | newbrickinfo->hostname); | ||
4970 | goto out; | ||
4971 | } | ||
4972 | |||
4973 | if ((!peerinfo->connected)) { | ||
4974 | snprintf(op_errstr, len, "Host %s not connected", | ||
4975 | newbrickinfo->hostname); | ||
4976 | ret = -1; | ||
4977 | goto out; | ||
4978 | } | ||
4979 | |||
4980 | if (peerinfo->state.state != GD_FRIEND_STATE_BEFRIENDED) { | ||
4981 | snprintf(op_errstr, len, "Host %s is not in \'Peer " | ||
4982 | "in Cluster\' state", | ||
4983 | newbrickinfo->hostname); | ||
4984 | ret = -1; | ||
4985 | goto out; | ||
4986 | } | ||
4987 | } | ||
4988 | |||
4989 | ret = 0; | ||
4990 | out: | ||
4991 | if (is_allocated) | ||
4992 | glusterd_brickinfo_delete (newbrickinfo); | ||
4993 | if (op_errstr[0] != '\0') | ||
4994 | gf_log (this->name, GF_LOG_ERROR, "%s", op_errstr)do { do { if (0) printf ("%s", op_errstr); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 4994, GF_LOG_ERROR , "%s", op_errstr); } while (0); | ||
4995 | 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-utils.c", __FUNCTION__, 4995, GF_LOG_DEBUG , "returning %d ", ret); } while (0); | ||
4996 | return ret; | ||
4997 | } | ||
4998 | |||
4999 | int | ||
5000 | glusterd_is_rb_started(glusterd_volinfo_t *volinfo) | ||
5001 | { | ||
5002 | gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("is_rb_started:status=%d", volinfo-> rep_brick.rb_status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5003, GF_LOG_DEBUG, "is_rb_started:status=%d" , volinfo->rep_brick.rb_status); } while (0) | ||
5003 | "is_rb_started:status=%d", volinfo->rep_brick.rb_status)do { do { if (0) printf ("is_rb_started:status=%d", volinfo-> rep_brick.rb_status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5003, GF_LOG_DEBUG, "is_rb_started:status=%d" , volinfo->rep_brick.rb_status); } while (0); | ||
5004 | return (volinfo->rep_brick.rb_status == GF_RB_STATUS_STARTED); | ||
5005 | |||
5006 | } | ||
5007 | |||
5008 | int | ||
5009 | glusterd_is_rb_paused ( glusterd_volinfo_t *volinfo) | ||
5010 | { | ||
5011 | gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("is_rb_paused:status=%d", volinfo-> rep_brick.rb_status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5012, GF_LOG_DEBUG, "is_rb_paused:status=%d", volinfo->rep_brick.rb_status); } while (0) | ||
5012 | "is_rb_paused:status=%d", volinfo->rep_brick.rb_status)do { do { if (0) printf ("is_rb_paused:status=%d", volinfo-> rep_brick.rb_status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5012, GF_LOG_DEBUG, "is_rb_paused:status=%d", volinfo->rep_brick.rb_status); } while (0); | ||
5013 | |||
5014 | return (volinfo->rep_brick.rb_status == GF_RB_STATUS_PAUSED); | ||
5015 | } | ||
5016 | |||
5017 | inline int | ||
5018 | glusterd_set_rb_status (glusterd_volinfo_t *volinfo, gf_rb_status_t status) | ||
5019 | { | ||
5020 | gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("setting status from %d to %d", volinfo ->rep_brick.rb_status, status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5023, GF_LOG_DEBUG, "setting status from %d to %d" , volinfo->rep_brick.rb_status, status); } while (0) | ||
5021 | "setting status from %d to %d",do { do { if (0) printf ("setting status from %d to %d", volinfo ->rep_brick.rb_status, status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5023, GF_LOG_DEBUG, "setting status from %d to %d" , volinfo->rep_brick.rb_status, status); } while (0) | ||
5022 | volinfo->rep_brick.rb_status,do { do { if (0) printf ("setting status from %d to %d", volinfo ->rep_brick.rb_status, status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5023, GF_LOG_DEBUG, "setting status from %d to %d" , volinfo->rep_brick.rb_status, status); } while (0) | ||
5023 | status)do { do { if (0) printf ("setting status from %d to %d", volinfo ->rep_brick.rb_status, status); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5023, GF_LOG_DEBUG, "setting status from %d to %d" , volinfo->rep_brick.rb_status, status); } while (0); | ||
5024 | |||
5025 | volinfo->rep_brick.rb_status = status; | ||
5026 | return 0; | ||
5027 | } | ||
5028 | |||
5029 | inline int | ||
5030 | glusterd_rb_check_bricks (glusterd_volinfo_t *volinfo, | ||
5031 | glusterd_brickinfo_t *src, glusterd_brickinfo_t *dst) | ||
5032 | { | ||
5033 | glusterd_replace_brick_t *rb = NULL((void*)0); | ||
5034 | |||
5035 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5035, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
5036 | |||
5037 | rb = &volinfo->rep_brick; | ||
5038 | |||
5039 | if (!rb->src_brick || !rb->dst_brick) | ||
5040 | return -1; | ||
5041 | |||
5042 | if (strcmp (rb->src_brick->hostname, src->hostname) || | ||
5043 | strcmp (rb->src_brick->path, src->path)) { | ||
5044 | gf_log("", GF_LOG_ERROR, "Replace brick src bricks differ")do { do { if (0) printf ("Replace brick src bricks differ"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5044 , GF_LOG_ERROR, "Replace brick src bricks differ"); } while ( 0); | ||
5045 | return -1; | ||
5046 | } | ||
5047 | |||
5048 | if (strcmp (rb->dst_brick->hostname, dst->hostname) || | ||
5049 | strcmp (rb->dst_brick->path, dst->path)) { | ||
5050 | gf_log ("", GF_LOG_ERROR, "Replace brick dst bricks differ")do { do { if (0) printf ("Replace brick dst bricks differ"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5050 , GF_LOG_ERROR, "Replace brick dst bricks differ"); } while ( 0); | ||
5051 | return -1; | ||
5052 | } | ||
5053 | |||
5054 | return 0; | ||
5055 | } | ||
5056 | |||
5057 | /*path needs to be absolute; works only on gfid, volume-id*/ | ||
5058 | static int | ||
5059 | glusterd_is_uuid_present (char *path, char *xattr, gf_boolean_t *present) | ||
5060 | { | ||
5061 | GF_ASSERT (path)do { if (!(path)) { do { do { if (0) printf ("Assertion failed: " "path"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5061, GF_LOG_ERROR, "Assertion failed: " "path" ); } while (0); } } while (0); | ||
5062 | GF_ASSERT (xattr)do { if (!(xattr)) { do { do { if (0) printf ("Assertion failed: " "xattr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5062, GF_LOG_ERROR, "Assertion failed: " "xattr" ); } while (0); } } while (0); | ||
5063 | GF_ASSERT (present)do { if (!(present)) { do { do { if (0) printf ("Assertion failed: " "present"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5063, GF_LOG_ERROR, "Assertion failed: " "present" ); } while (0); } } while (0); | ||
5064 | |||
5065 | int ret = -1; | ||
5066 | uuid_t uid = {0,}; | ||
5067 | |||
5068 | if (!path || !xattr || !present) | ||
5069 | goto out; | ||
5070 | |||
5071 | ret = sys_lgetxattr (path, xattr, &uid, 16); | ||
5072 | |||
5073 | if (ret >= 0) { | ||
5074 | *present = _gf_true; | ||
5075 | ret = 0; | ||
5076 | goto out; | ||
5077 | } | ||
5078 | |||
5079 | switch (errno(*__errno_location ())) { | ||
5080 | #if defined(ENODATA61) | ||
5081 | case ENODATA61: /* FALLTHROUGH */ | ||
5082 | #endif | ||
5083 | #if defined(ENOATTR61) && (ENOATTR61 != ENODATA61) | ||
5084 | case ENOATTR61: /* FALLTHROUGH */ | ||
5085 | #endif | ||
5086 | case ENOTSUP95: | ||
5087 | *present = _gf_false; | ||
5088 | ret = 0; | ||
5089 | break; | ||
5090 | default: | ||
5091 | break; | ||
5092 | } | ||
5093 | out: | ||
5094 | return ret; | ||
5095 | } | ||
5096 | |||
5097 | /*path needs to be absolute*/ | ||
5098 | static int | ||
5099 | glusterd_is_path_in_use (char *path, gf_boolean_t *in_use, char **op_errstr) | ||
5100 | { | ||
5101 | int i = 0; | ||
5102 | int ret = -1; | ||
5103 | gf_boolean_t used = _gf_false; | ||
5104 | char dir[PATH_MAX4096] = {0,}; | ||
5105 | char *curdir = NULL((void*)0); | ||
5106 | char msg[2048] = {0}; | ||
5107 | char *keys[3] = {GFID_XATTR_KEY"trusted.gfid", | ||
5108 | GF_XATTR_VOL_ID_KEY"trusted.glusterfs.volume-id", | ||
5109 | NULL((void*)0)}; | ||
5110 | |||
5111 | GF_ASSERT (path)do { if (!(path)) { do { do { if (0) printf ("Assertion failed: " "path"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5111, GF_LOG_ERROR, "Assertion failed: " "path" ); } while (0); } } while (0); | ||
5112 | if (!path) | ||
5113 | goto out; | ||
5114 | |||
5115 | strcpy (dir, path); | ||
5116 | curdir = dir; | ||
5117 | do { | ||
5118 | for (i = 0; !used && keys[i]; i++) { | ||
5119 | ret = glusterd_is_uuid_present (curdir, keys[i], &used); | ||
5120 | if (ret) | ||
5121 | goto out; | ||
5122 | } | ||
5123 | |||
5124 | if (used) | ||
5125 | break; | ||
5126 | |||
5127 | curdir = dirname (curdir); | ||
5128 | if (!strcmp (curdir, ".")) | ||
5129 | goto out; | ||
5130 | |||
5131 | |||
5132 | } while (strcmp (curdir, "/")); | ||
5133 | |||
5134 | if (!strcmp (curdir, "/")) { | ||
5135 | for (i = 0; !used && keys[i]; i++) { | ||
5136 | ret = glusterd_is_uuid_present (curdir, keys[i], &used); | ||
5137 | if (ret) | ||
5138 | goto out; | ||
5139 | } | ||
5140 | } | ||
5141 | |||
5142 | ret = 0; | ||
5143 | *in_use = used; | ||
5144 | out: | ||
5145 | if (ret) { | ||
5146 | snprintf (msg, sizeof (msg), "Failed to get extended " | ||
5147 | "attribute %s, reason: %s", keys[i], | ||
5148 | strerror (errno(*__errno_location ()))); | ||
5149 | } | ||
5150 | |||
5151 | if (*in_use) { | ||
5152 | if (!strcmp (path, curdir)) { | ||
5153 | snprintf (msg, sizeof (msg), "%s is already part of a " | ||
5154 | "volume", path); | ||
5155 | } else { | ||
5156 | snprintf (msg, sizeof (msg), "parent directory %s is " | ||
5157 | "already part of a volume", curdir); | ||
5158 | } | ||
5159 | } | ||
5160 | |||
5161 | if (strlen (msg)) { | ||
5162 | gf_log (THIS->name, GF_LOG_ERROR, "%s", msg)do { do { if (0) printf ("%s", msg); } while (0); _gf_log ((* __glusterfs_this_location())->name, "glusterd-utils.c", __FUNCTION__ , 5162, GF_LOG_ERROR, "%s", msg); } while (0); | ||
5163 | *op_errstr = gf_strdup (msg); | ||
5164 | } | ||
5165 | |||
5166 | return ret; | ||
5167 | } | ||
5168 | |||
5169 | int | ||
5170 | glusterd_check_and_set_brick_xattr (char *host, char *path, uuid_t uuid, | ||
5171 | char **op_errstr) | ||
5172 | { | ||
5173 | int ret = -1; | ||
5174 | char msg[2048] = {0,}; | ||
5175 | gf_boolean_t in_use = _gf_false; | ||
5176 | |||
5177 | /* Check for xattr support in backend fs */ | ||
5178 | ret = sys_lsetxattr (path, "trusted.glusterfs.test", | ||
5179 | "working", 8, 0); | ||
5180 | if (ret) { | ||
5181 | snprintf (msg, sizeof (msg), "Glusterfs is not" | ||
5182 | " supported on brick: %s:%s.\nSetting" | ||
5183 | " extended attributes failed, reason:" | ||
5184 | " %s.", host, path, strerror(errno(*__errno_location ()))); | ||
5185 | goto out; | ||
5186 | |||
5187 | } else { | ||
5188 | sys_lremovexattr (path, "trusted.glusterfs.test"); | ||
5189 | } | ||
5190 | |||
5191 | ret = glusterd_is_path_in_use (path, &in_use, op_errstr); | ||
5192 | if (ret) | ||
5193 | goto out; | ||
5194 | |||
5195 | if (in_use) { | ||
5196 | ret = -1; | ||
5197 | goto out; | ||
5198 | } | ||
5199 | |||
5200 | ret = sys_lsetxattr (path, GF_XATTR_VOL_ID_KEY"trusted.glusterfs.volume-id", uuid, 16, | ||
5201 | XATTR_CREATEXATTR_CREATE); | ||
5202 | if (ret) { | ||
5203 | snprintf (msg, sizeof (msg), "Failed to set extended " | ||
5204 | "attributes %s, reason: %s", | ||
5205 | GF_XATTR_VOL_ID_KEY"trusted.glusterfs.volume-id", strerror (errno(*__errno_location ()))); | ||
5206 | goto out; | ||
5207 | } | ||
5208 | |||
5209 | ret = 0; | ||
5210 | out: | ||
5211 | if (strlen (msg)) | ||
5212 | *op_errstr = gf_strdup (msg); | ||
5213 | |||
5214 | return ret; | ||
5215 | } | ||
5216 | |||
5217 | int | ||
5218 | glusterd_sm_tr_log_transition_add_to_dict (dict_t *dict, | ||
5219 | glusterd_sm_tr_log_t *log, int i, | ||
5220 | int count) | ||
5221 | { | ||
5222 | int ret = -1; | ||
5223 | char key[512] = {0}; | ||
5224 | char timestr[64] = {0,}; | ||
5225 | char *str = NULL((void*)0); | ||
5226 | |||
5227 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5227, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | ||
5228 | GF_ASSERT (log)do { if (!(log)) { do { do { if (0) printf ("Assertion failed: " "log"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5228, GF_LOG_ERROR, "Assertion failed: " "log" ); } while (0); } } while (0); | ||
5229 | |||
5230 | memset (key, 0, sizeof (key)); | ||
5231 | snprintf (key, sizeof (key), "log%d-old-state", count); | ||
5232 | str = log->state_name_get (log->transitions[i].old_state); | ||
5233 | ret = dict_set_str (dict, key, str); | ||
5234 | if (ret) | ||
5235 | goto out; | ||
5236 | |||
5237 | memset (key, 0, sizeof (key)); | ||
5238 | snprintf (key, sizeof (key), "log%d-event", count); | ||
5239 | str = log->event_name_get (log->transitions[i].event); | ||
5240 | ret = dict_set_str (dict, key, str); | ||
5241 | if (ret) | ||
5242 | goto out; | ||
5243 | |||
5244 | memset (key, 0, sizeof (key)); | ||
5245 | snprintf (key, sizeof (key), "log%d-new-state", count); | ||
5246 | str = log->state_name_get (log->transitions[i].new_state); | ||
5247 | ret = dict_set_str (dict, key, str); | ||
5248 | if (ret) | ||
5249 | goto out; | ||
5250 | |||
5251 | |||
5252 | memset (key, 0, sizeof (key)); | ||
5253 | snprintf (key, sizeof (key), "log%d-time", count); | ||
5254 | gf_time_fmt (timestr, sizeof timestr, log->transitions[i].time, | ||
5255 | gf_timefmt_FT); | ||
5256 | str = gf_strdup (timestr); | ||
5257 | ret = dict_set_dynstr (dict, key, str); | ||
5258 | if (ret) | ||
5259 | goto out; | ||
5260 | |||
5261 | out: | ||
5262 | gf_log ("", GF_LOG_DEBUG, "returning %d", ret)do { do { if (0) printf ("returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5262, GF_LOG_DEBUG, "returning %d" , ret); } while (0); | ||
5263 | return ret; | ||
5264 | } | ||
5265 | |||
5266 | int | ||
5267 | glusterd_sm_tr_log_add_to_dict (dict_t *dict, | ||
5268 | glusterd_sm_tr_log_t *circular_log) | ||
5269 | { | ||
5270 | int ret = -1; | ||
5271 | int i = 0; | ||
5272 | int start = 0; | ||
5273 | int end = 0; | ||
5274 | int index = 0; | ||
5275 | char key[256] = {0}; | ||
5276 | glusterd_sm_tr_log_t *log = NULL((void*)0); | ||
5277 | int count = 0; | ||
5278 | |||
5279 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5279, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | ||
5280 | GF_ASSERT (circular_log)do { if (!(circular_log)) { do { do { if (0) printf ("Assertion failed: " "circular_log"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5280, GF_LOG_ERROR, "Assertion failed: " "circular_log" ); } while (0); } } while (0); | ||
5281 | |||
5282 | log = circular_log; | ||
5283 | if (!log->count) | ||
5284 | return 0; | ||
5285 | |||
5286 | if (log->count == log->size) | ||
5287 | start = log->current + 1; | ||
5288 | |||
5289 | end = start + log->count; | ||
5290 | for (i = start; i < end; i++, count++) { | ||
5291 | index = i % log->count; | ||
5292 | ret = glusterd_sm_tr_log_transition_add_to_dict (dict, log, index, | ||
5293 | count); | ||
5294 | if (ret) | ||
5295 | goto out; | ||
5296 | } | ||
5297 | |||
5298 | memset (key, 0, sizeof (key)); | ||
5299 | snprintf (key, sizeof (key), "count"); | ||
5300 | ret = dict_set_int32 (dict, key, log->count); | ||
5301 | |||
5302 | out: | ||
5303 | gf_log ("", GF_LOG_DEBUG, "returning %d", ret)do { do { if (0) printf ("returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5303, GF_LOG_DEBUG, "returning %d" , ret); } while (0); | ||
5304 | return ret; | ||
5305 | } | ||
5306 | |||
5307 | int | ||
5308 | glusterd_sm_tr_log_init (glusterd_sm_tr_log_t *log, | ||
5309 | char * (*state_name_get) (int), | ||
5310 | char * (*event_name_get) (int), | ||
5311 | size_t size) | ||
5312 | { | ||
5313 | glusterd_sm_transition_t *transitions = NULL((void*)0); | ||
5314 | int ret = -1; | ||
5315 | |||
5316 | GF_ASSERT (size > 0)do { if (!(size > 0)) { do { do { if (0) printf ("Assertion failed: " "size > 0"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5316, GF_LOG_ERROR, "Assertion failed: " "size > 0" ); } while (0); } } while (0); | ||
5317 | GF_ASSERT (log && state_name_get && event_name_get)do { if (!(log && state_name_get && event_name_get )) { do { do { if (0) printf ("Assertion failed: " "log && state_name_get && event_name_get" ); } while (0); _gf_log_callingfn ("", "glusterd-utils.c", __FUNCTION__ , 5317, GF_LOG_ERROR, "Assertion failed: " "log && state_name_get && event_name_get" ); } while (0); } } while (0); | ||
5318 | |||
5319 | if (!log || !state_name_get || !event_name_get || (size <= 0)) | ||
5320 | goto out; | ||
5321 | |||
5322 | transitions = GF_CALLOC (size, sizeof (*transitions),__gf_calloc (size, sizeof (*transitions), gf_gld_mt_sm_tr_log_t ) | ||
5323 | gf_gld_mt_sm_tr_log_t)__gf_calloc (size, sizeof (*transitions), gf_gld_mt_sm_tr_log_t ); | ||
5324 | if (!transitions) | ||
5325 | goto out; | ||
5326 | |||
5327 | log->transitions = transitions; | ||
5328 | log->size = size; | ||
5329 | log->state_name_get = state_name_get; | ||
5330 | log->event_name_get = event_name_get; | ||
5331 | ret = 0; | ||
5332 | |||
5333 | out: | ||
5334 | gf_log ("", GF_LOG_DEBUG, "returning %d", ret)do { do { if (0) printf ("returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5334, GF_LOG_DEBUG, "returning %d" , ret); } while (0); | ||
5335 | return ret; | ||
5336 | } | ||
5337 | |||
5338 | void | ||
5339 | glusterd_sm_tr_log_delete (glusterd_sm_tr_log_t *log) | ||
5340 | { | ||
5341 | if (!log) | ||
5342 | return; | ||
5343 | GF_FREE (log->transitions)__gf_free (log->transitions); | ||
5344 | return; | ||
5345 | } | ||
5346 | |||
5347 | int | ||
5348 | glusterd_sm_tr_log_transition_add (glusterd_sm_tr_log_t *log, | ||
5349 | int old_state, int new_state, | ||
5350 | int event) | ||
5351 | { | ||
5352 | glusterd_sm_transition_t *transitions = NULL((void*)0); | ||
5353 | int ret = -1; | ||
5354 | int next = 0; | ||
5355 | xlator_t *this = NULL((void*)0); | ||
5356 | |||
5357 | this = THIS(*__glusterfs_this_location()); | ||
5358 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5358, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
5359 | |||
5360 | GF_ASSERT (log)do { if (!(log)) { do { do { if (0) printf ("Assertion failed: " "log"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5360, GF_LOG_ERROR, "Assertion failed: " "log" ); } while (0); } } while (0); | ||
5361 | if (!log) | ||
5362 | goto out; | ||
5363 | |||
5364 | transitions = log->transitions; | ||
5365 | if (!transitions) | ||
5366 | goto out; | ||
5367 | |||
5368 | if (log->count) | ||
5369 | next = (log->current + 1) % log->size; | ||
5370 | else | ||
5371 | next = 0; | ||
5372 | |||
5373 | transitions[next].old_state = old_state; | ||
5374 | transitions[next].new_state = new_state; | ||
5375 | transitions[next].event = event; | ||
5376 | time (&transitions[next].time); | ||
5377 | log->current = next; | ||
5378 | if (log->count < log->size) | ||
5379 | log->count++; | ||
5380 | ret = 0; | ||
5381 | gf_log (this->name, GF_LOG_DEBUG, "Transitioning from '%s' to '%s' "do { do { if (0) printf ("Transitioning from '%s' to '%s' " "due to event '%s'" , log->state_name_get (old_state), log->state_name_get ( new_state), log->event_name_get (event)); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 5383, GF_LOG_DEBUG , "Transitioning from '%s' to '%s' " "due to event '%s'", log ->state_name_get (old_state), log->state_name_get (new_state ), log->event_name_get (event)); } while (0) | ||
5382 | "due to event '%s'", log->state_name_get (old_state),do { do { if (0) printf ("Transitioning from '%s' to '%s' " "due to event '%s'" , log->state_name_get (old_state), log->state_name_get ( new_state), log->event_name_get (event)); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 5383, GF_LOG_DEBUG , "Transitioning from '%s' to '%s' " "due to event '%s'", log ->state_name_get (old_state), log->state_name_get (new_state ), log->event_name_get (event)); } while (0) | ||
5383 | log->state_name_get (new_state), log->event_name_get (event))do { do { if (0) printf ("Transitioning from '%s' to '%s' " "due to event '%s'" , log->state_name_get (old_state), log->state_name_get ( new_state), log->event_name_get (event)); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 5383, GF_LOG_DEBUG , "Transitioning from '%s' to '%s' " "due to event '%s'", log ->state_name_get (old_state), log->state_name_get (new_state ), log->event_name_get (event)); } while (0); | ||
5384 | out: | ||
5385 | 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-utils.c", __FUNCTION__, 5385, GF_LOG_DEBUG , "returning %d", ret); } while (0); | ||
5386 | return ret; | ||
5387 | } | ||
5388 | |||
5389 | int | ||
5390 | glusterd_peerinfo_new (glusterd_peerinfo_t **peerinfo, | ||
5391 | glusterd_friend_sm_state_t state, uuid_t *uuid, | ||
5392 | const char *hostname, int port) | ||
5393 | { | ||
5394 | glusterd_peerinfo_t *new_peer = NULL((void*)0); | ||
5395 | int ret = -1; | ||
5396 | |||
5397 | GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: " "peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5397, GF_LOG_ERROR, "Assertion failed: " "peerinfo" ); } while (0); } } while (0); | ||
5398 | if (!peerinfo) | ||
5399 | goto out; | ||
5400 | |||
5401 | new_peer = GF_CALLOC (1, sizeof (*new_peer), gf_gld_mt_peerinfo_t)__gf_calloc (1, sizeof (*new_peer), gf_gld_mt_peerinfo_t); | ||
5402 | if (!new_peer) | ||
5403 | goto out; | ||
5404 | |||
5405 | new_peer->state.state = state; | ||
5406 | if (hostname) | ||
5407 | new_peer->hostname = gf_strdup (hostname); | ||
5408 | |||
5409 | INIT_LIST_HEAD (&new_peer->uuid_list)do { (&new_peer->uuid_list)->next = (&new_peer-> uuid_list)->prev = &new_peer->uuid_list; } while (0 ); | ||
5410 | |||
5411 | if (uuid) { | ||
5412 | uuid_copy (new_peer->uuid, *uuid); | ||
5413 | } | ||
5414 | |||
5415 | ret = glusterd_sm_tr_log_init (&new_peer->sm_log, | ||
5416 | glusterd_friend_sm_state_name_get, | ||
5417 | glusterd_friend_sm_event_name_get, | ||
5418 | GLUSTERD_TR_LOG_SIZE50); | ||
5419 | if (ret) | ||
5420 | goto out; | ||
5421 | |||
5422 | if (new_peer->state.state == GD_FRIEND_STATE_BEFRIENDED) | ||
5423 | new_peer->quorum_contrib = QUORUM_WAITING; | ||
5424 | new_peer->port = port; | ||
5425 | *peerinfo = new_peer; | ||
5426 | out: | ||
5427 | if (ret && new_peer) | ||
5428 | glusterd_friend_cleanup (new_peer); | ||
5429 | gf_log ("", GF_LOG_DEBUG, "returning %d", ret)do { do { if (0) printf ("returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5429, GF_LOG_DEBUG, "returning %d" , ret); } while (0); | ||
5430 | return ret; | ||
5431 | } | ||
5432 | |||
5433 | int32_t | ||
5434 | glusterd_peer_destroy (glusterd_peerinfo_t *peerinfo) | ||
5435 | { | ||
5436 | int32_t ret = -1; | ||
5437 | |||
5438 | if (!peerinfo) | ||
5439 | goto out; | ||
5440 | |||
5441 | ret = glusterd_store_delete_peerinfo (peerinfo); | ||
5442 | |||
5443 | if (ret) { | ||
5444 | gf_log ("", GF_LOG_ERROR, "Deleting peer info failed")do { do { if (0) printf ("Deleting peer info failed"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5444, GF_LOG_ERROR , "Deleting peer info failed"); } while (0); | ||
5445 | } | ||
5446 | |||
5447 | list_del_init (&peerinfo->uuid_list); | ||
5448 | GF_FREE (peerinfo->hostname)__gf_free (peerinfo->hostname); | ||
5449 | glusterd_sm_tr_log_delete (&peerinfo->sm_log); | ||
5450 | GF_FREE (peerinfo)__gf_free (peerinfo); | ||
5451 | peerinfo = NULL((void*)0); | ||
5452 | |||
5453 | ret = 0; | ||
5454 | |||
5455 | out: | ||
5456 | return ret; | ||
5457 | } | ||
5458 | |||
5459 | int | ||
5460 | glusterd_remove_pending_entry (struct list_head *list, void *elem) | ||
5461 | { | ||
5462 | glusterd_pending_node_t *pending_node = NULL((void*)0); | ||
5463 | glusterd_pending_node_t *tmp = NULL((void*)0); | ||
5464 | int ret = 0; | ||
5465 | |||
5466 | list_for_each_entry_safe (pending_node, tmp, list, list)for (pending_node = ((typeof(*pending_node) *)((char *)((list )->next)-(unsigned long)(&((typeof(*pending_node) *)0) ->list))), tmp = ((typeof(*pending_node) *)((char *)(pending_node ->list.next)-(unsigned long)(&((typeof(*pending_node) * )0)->list))); &pending_node->list != (list); pending_node = tmp, tmp = ((typeof(*tmp) *)((char *)(tmp->list.next)-( unsigned long)(&((typeof(*tmp) *)0)->list)))) { | ||
5467 | if (elem == pending_node->node) { | ||
5468 | list_del_init (&pending_node->list); | ||
5469 | GF_FREE (pending_node)__gf_free (pending_node); | ||
5470 | ret = 0; | ||
5471 | goto out; | ||
5472 | } | ||
5473 | } | ||
5474 | out: | ||
5475 | 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-utils.c" , __FUNCTION__, 5475, GF_LOG_DEBUG, "returning %d", ret); } while (0); | ||
5476 | return ret; | ||
5477 | |||
5478 | } | ||
5479 | |||
5480 | int | ||
5481 | glusterd_clear_pending_nodes (struct list_head *list) | ||
5482 | { | ||
5483 | glusterd_pending_node_t *pending_node = NULL((void*)0); | ||
5484 | glusterd_pending_node_t *tmp = NULL((void*)0); | ||
5485 | |||
5486 | list_for_each_entry_safe (pending_node, tmp, list, list)for (pending_node = ((typeof(*pending_node) *)((char *)((list )->next)-(unsigned long)(&((typeof(*pending_node) *)0) ->list))), tmp = ((typeof(*pending_node) *)((char *)(pending_node ->list.next)-(unsigned long)(&((typeof(*pending_node) * )0)->list))); &pending_node->list != (list); pending_node = tmp, tmp = ((typeof(*tmp) *)((char *)(tmp->list.next)-( unsigned long)(&((typeof(*tmp) *)0)->list)))) { | ||
5487 | list_del_init (&pending_node->list); | ||
5488 | GF_FREE (pending_node)__gf_free (pending_node); | ||
5489 | } | ||
5490 | |||
5491 | return 0; | ||
5492 | } | ||
5493 | |||
5494 | gf_boolean_t | ||
5495 | glusterd_peerinfo_is_uuid_unknown (glusterd_peerinfo_t *peerinfo) | ||
5496 | { | ||
5497 | GF_ASSERT (peerinfo)do { if (!(peerinfo)) { do { do { if (0) printf ("Assertion failed: " "peerinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5497, GF_LOG_ERROR, "Assertion failed: " "peerinfo" ); } while (0); } } while (0); | ||
5498 | |||
5499 | if (uuid_is_null (peerinfo->uuid)) | ||
5500 | return _gf_true; | ||
5501 | return _gf_false; | ||
5502 | } | ||
5503 | |||
5504 | int32_t | ||
5505 | glusterd_delete_volume (glusterd_volinfo_t *volinfo) | ||
5506 | { | ||
5507 | int ret = -1; | ||
5508 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5508, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
5509 | |||
5510 | ret = glusterd_store_delete_volume (volinfo); | ||
5511 | |||
5512 | if (ret) | ||
5513 | goto out; | ||
5514 | |||
5515 | ret = glusterd_volinfo_delete (volinfo); | ||
5516 | out: | ||
5517 | 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-utils.c" , __FUNCTION__, 5517, GF_LOG_DEBUG, "returning %d", ret); } while (0); | ||
5518 | return ret; | ||
5519 | } | ||
5520 | |||
5521 | int32_t | ||
5522 | glusterd_delete_brick (glusterd_volinfo_t* volinfo, | ||
5523 | glusterd_brickinfo_t *brickinfo) | ||
5524 | { | ||
5525 | int ret = 0; | ||
5526 | char voldir[PATH_MAX4096] = {0,}; | ||
5527 | glusterd_conf_t *priv = THIS(*__glusterfs_this_location())->private; | ||
5528 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5528, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
5529 | GF_ASSERT (brickinfo)do { if (!(brickinfo)) { do { do { if (0) printf ("Assertion failed: " "brickinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5529, GF_LOG_ERROR, "Assertion failed: " "brickinfo" ); } while (0); } } while (0); | ||
5530 | |||
5531 | GLUSTERD_GET_VOLUME_DIR(voldir, volinfo, priv)snprintf (voldir, 4096, "%s/vols/%s", priv->workdir, volinfo ->volname);; | ||
5532 | |||
5533 | glusterd_delete_volfile (volinfo, brickinfo); | ||
5534 | glusterd_store_delete_brick (brickinfo, voldir); | ||
5535 | glusterd_brickinfo_delete (brickinfo); | ||
5536 | volinfo->brick_count--; | ||
5537 | return ret; | ||
5538 | } | ||
5539 | |||
5540 | int32_t | ||
5541 | glusterd_delete_all_bricks (glusterd_volinfo_t* volinfo) | ||
5542 | { | ||
5543 | int ret = 0; | ||
5544 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
5545 | glusterd_brickinfo_t *tmp = NULL((void*)0); | ||
5546 | |||
5547 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5547, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
5548 | |||
5549 | list_for_each_entry_safe (brickinfo, tmp, &volinfo->bricks, brick_list)for (brickinfo = ((typeof(*brickinfo) *)((char *)((&volinfo ->bricks)->next)-(unsigned long)(&((typeof(*brickinfo ) *)0)->brick_list))), tmp = ((typeof(*brickinfo) *)((char *)(brickinfo->brick_list.next)-(unsigned long)(&((typeof (*brickinfo) *)0)->brick_list))); &brickinfo->brick_list != (&volinfo->bricks); brickinfo = tmp, tmp = ((typeof (*tmp) *)((char *)(tmp->brick_list.next)-(unsigned long)(& ((typeof(*tmp) *)0)->brick_list)))) { | ||
5550 | ret = glusterd_delete_brick (volinfo, brickinfo); | ||
5551 | } | ||
5552 | return ret; | ||
5553 | } | ||
5554 | |||
5555 | int | ||
5556 | glusterd_start_gsync (glusterd_volinfo_t *master_vol, char *slave, | ||
5557 | char *glusterd_uuid_str, char **op_errstr) | ||
5558 | { | ||
5559 | int32_t ret = 0; | ||
5560 | int32_t status = 0; | ||
5561 | char buf[PATH_MAX4096] = {0,}; | ||
5562 | char uuid_str [64] = {0}; | ||
5563 | runner_t runner = {0,}; | ||
5564 | xlator_t *this = NULL((void*)0); | ||
5565 | glusterd_conf_t *priv = NULL((void*)0); | ||
5566 | int errcode = 0; | ||
5567 | |||
5568 | this = THIS(*__glusterfs_this_location()); | ||
5569 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5569, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
5570 | priv = this->private; | ||
5571 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5571, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
5572 | |||
5573 | uuid_utoa_r (MY_UUID(__glusterd_uuid()), uuid_str); | ||
5574 | if (strcmp (uuid_str, glusterd_uuid_str)) | ||
5575 | goto out; | ||
5576 | |||
5577 | ret = gsync_status (master_vol->volname, slave, &status); | ||
5578 | if (status == 0) | ||
5579 | goto out; | ||
5580 | |||
5581 | snprintf (buf, PATH_MAX4096, "%s/"GEOREP"geo-replication""/%s", priv->workdir, master_vol->volname); | ||
5582 | ret = mkdir_p (buf, 0777, _gf_true); | ||
5583 | if (ret) { | ||
5584 | errcode = -1; | ||
5585 | goto out; | ||
5586 | } | ||
5587 | |||
5588 | snprintf (buf, PATH_MAX4096, DEFAULT_LOG_FILE_DIRECTORY"/usr/local/var" "/log/glusterfs""/"GEOREP"geo-replication""/%s", | ||
5589 | master_vol->volname); | ||
5590 | ret = mkdir_p (buf, 0777, _gf_true); | ||
5591 | if (ret) { | ||
5592 | errcode = -1; | ||
5593 | goto out; | ||
5594 | } | ||
5595 | |||
5596 | uuid_utoa_r (master_vol->volume_id, uuid_str); | ||
5597 | runinit (&runner); | ||
5598 | runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "-c", NULL((void*)0)); | ||
5599 | runner_argprintf (&runner, "%s/"GSYNC_CONF"geo-replication""/gsyncd.conf", priv->workdir); | ||
5600 | runner_argprintf (&runner, ":%s", master_vol->volname); | ||
5601 | runner_add_args (&runner, slave, "--config-set", "session-owner", | ||
5602 | uuid_str, NULL((void*)0)); | ||
5603 | synclock_unlock (&priv->big_lock); | ||
5604 | ret = runner_run (&runner); | ||
5605 | synclock_lock (&priv->big_lock); | ||
5606 | if (ret == -1) { | ||
5607 | errcode = -1; | ||
5608 | goto out; | ||
5609 | } | ||
5610 | |||
5611 | runinit (&runner); | ||
5612 | runner_add_args (&runner, GSYNCD_PREFIX"/usr/local/libexec/glusterfs""/gsyncd", "--monitor", "-c", NULL((void*)0)); | ||
5613 | runner_argprintf (&runner, "%s/"GSYNC_CONF"geo-replication""/gsyncd.conf", priv->workdir); | ||
5614 | runner_argprintf (&runner, ":%s", master_vol->volname); | ||
5615 | runner_add_arg (&runner, slave); | ||
5616 | synclock_unlock (&priv->big_lock); | ||
5617 | ret = runner_run (&runner); | ||
5618 | synclock_lock (&priv->big_lock); | ||
5619 | if (ret == -1) { | ||
5620 | gf_asprintf (op_errstr, GEOREP"geo-replication"" start failed for %s %s", | ||
5621 | master_vol->volname, slave); | ||
5622 | goto out; | ||
5623 | } | ||
5624 | |||
5625 | ret = 0; | ||
5626 | |||
5627 | out: | ||
5628 | if ((ret != 0) && errcode == -1) { | ||
5629 | if (op_errstr) | ||
5630 | *op_errstr = gf_strdup ("internal error, cannot start" | ||
5631 | "the " GEOREP"geo-replication" " session"); | ||
5632 | } | ||
5633 | |||
5634 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5634, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | ||
5635 | return ret; | ||
5636 | } | ||
5637 | |||
5638 | int32_t | ||
5639 | glusterd_recreate_bricks (glusterd_conf_t *conf) | ||
5640 | { | ||
5641 | |||
5642 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
5643 | int ret = 0; | ||
5644 | |||
5645 | GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: " "conf"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5645, GF_LOG_ERROR, "Assertion failed: " "conf" ); } while (0); } } while (0); | ||
5646 | list_for_each_entry (volinfo, &conf->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&conf-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&conf-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | ||
5647 | ret = generate_brick_volfiles (volinfo); | ||
5648 | } | ||
5649 | return ret; | ||
5650 | } | ||
5651 | |||
5652 | int32_t | ||
5653 | glusterd_handle_upgrade_downgrade (dict_t *options, glusterd_conf_t *conf) | ||
5654 | { | ||
5655 | int ret = 0; | ||
5656 | char *type = NULL((void*)0); | ||
5657 | gf_boolean_t upgrade = _gf_false; | ||
5658 | gf_boolean_t downgrade = _gf_false; | ||
5659 | gf_boolean_t regenerate_brick_volfiles = _gf_false; | ||
5660 | gf_boolean_t terminate = _gf_false; | ||
5661 | |||
5662 | ret = dict_get_str (options, "upgrade", &type); | ||
5663 | if (!ret) { | ||
5664 | ret = gf_string2boolean (type, &upgrade); | ||
5665 | if (ret) { | ||
5666 | gf_log ("glusterd", GF_LOG_ERROR, "upgrade option "do { do { if (0) printf ("upgrade option " "%s is not a valid boolean type" , type); } while (0); _gf_log ("glusterd", "glusterd-utils.c" , __FUNCTION__, 5667, GF_LOG_ERROR, "upgrade option " "%s is not a valid boolean type" , type); } while (0) | ||
5667 | "%s is not a valid boolean type", type)do { do { if (0) printf ("upgrade option " "%s is not a valid boolean type" , type); } while (0); _gf_log ("glusterd", "glusterd-utils.c" , __FUNCTION__, 5667, GF_LOG_ERROR, "upgrade option " "%s is not a valid boolean type" , type); } while (0); | ||
5668 | ret = -1; | ||
5669 | goto out; | ||
5670 | } | ||
5671 | if (_gf_true == upgrade) | ||
5672 | regenerate_brick_volfiles = _gf_true; | ||
5673 | } | ||
5674 | |||
5675 | ret = dict_get_str (options, "downgrade", &type); | ||
5676 | if (!ret) { | ||
5677 | ret = gf_string2boolean (type, &downgrade); | ||
5678 | if (ret) { | ||
5679 | gf_log ("glusterd", GF_LOG_ERROR, "downgrade option "do { do { if (0) printf ("downgrade option " "%s is not a valid boolean type" , type); } while (0); _gf_log ("glusterd", "glusterd-utils.c" , __FUNCTION__, 5680, GF_LOG_ERROR, "downgrade option " "%s is not a valid boolean type" , type); } while (0) | ||
5680 | "%s is not a valid boolean type", type)do { do { if (0) printf ("downgrade option " "%s is not a valid boolean type" , type); } while (0); _gf_log ("glusterd", "glusterd-utils.c" , __FUNCTION__, 5680, GF_LOG_ERROR, "downgrade option " "%s is not a valid boolean type" , type); } while (0); | ||
5681 | ret = -1; | ||
5682 | goto out; | ||
5683 | } | ||
5684 | } | ||
5685 | |||
5686 | if (upgrade && downgrade) { | ||
5687 | gf_log ("glusterd", GF_LOG_ERROR, "Both upgrade and downgrade"do { do { if (0) printf ("Both upgrade and downgrade" " options are set. Only one should be on" ); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__ , 5688, GF_LOG_ERROR, "Both upgrade and downgrade" " options are set. Only one should be on" ); } while (0) | ||
5688 | " options are set. Only one should be on")do { do { if (0) printf ("Both upgrade and downgrade" " options are set. Only one should be on" ); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__ , 5688, GF_LOG_ERROR, "Both upgrade and downgrade" " options are set. Only one should be on" ); } while (0); | ||
5689 | ret = -1; | ||
5690 | goto out; | ||
5691 | } | ||
5692 | |||
5693 | if (!upgrade && !downgrade) | ||
5694 | ret = 0; | ||
5695 | else | ||
5696 | terminate = _gf_true; | ||
5697 | if (regenerate_brick_volfiles) { | ||
5698 | ret = glusterd_recreate_bricks (conf); | ||
5699 | } | ||
5700 | out: | ||
5701 | if (terminate && (ret == 0)) | ||
5702 | kill (getpid(), SIGTERM15); | ||
5703 | return ret; | ||
5704 | } | ||
5705 | |||
5706 | gf_boolean_t | ||
5707 | glusterd_is_volume_replicate (glusterd_volinfo_t *volinfo) | ||
5708 | { | ||
5709 | gf_boolean_t replicates = _gf_false; | ||
5710 | if (volinfo && ((volinfo->type == GF_CLUSTER_TYPE_REPLICATE) || | ||
5711 | (volinfo->type == GF_CLUSTER_TYPE_STRIPE_REPLICATE))) | ||
5712 | replicates = _gf_true; | ||
5713 | return replicates; | ||
5714 | } | ||
5715 | |||
5716 | int | ||
5717 | glusterd_set_dump_options (char *dumpoptions_path, char *options, | ||
5718 | int option_cnt) | ||
5719 | { | ||
5720 | int ret = 0; | ||
5721 | char *dup_options = NULL((void*)0); | ||
5722 | char *option = NULL((void*)0); | ||
5723 | char *tmpptr = NULL((void*)0); | ||
5724 | FILE *fp = NULL((void*)0); | ||
5725 | int nfs_cnt = 0; | ||
5726 | |||
5727 | if (0 == option_cnt || | ||
5728 | (option_cnt == 1 && (!strcmp (options, "nfs ")))) { | ||
5729 | ret = 0; | ||
5730 | goto out; | ||
5731 | } | ||
5732 | |||
5733 | fp = fopen (dumpoptions_path, "w"); | ||
5734 | if (!fp) { | ||
5735 | ret = -1; | ||
5736 | goto out; | ||
5737 | } | ||
5738 | dup_options = gf_strdup (options); | ||
5739 | gf_log ("", GF_LOG_INFO, "Received following statedump options: %s",do { do { if (0) printf ("Received following statedump options: %s" , dup_options); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5740, GF_LOG_INFO, "Received following statedump options: %s" , dup_options); } while (0) | ||
5740 | dup_options)do { do { if (0) printf ("Received following statedump options: %s" , dup_options); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 5740, GF_LOG_INFO, "Received following statedump options: %s" , dup_options); } while (0); | ||
5741 | option = strtok_r (dup_options, " ", &tmpptr); | ||
5742 | while (option) { | ||
5743 | if (!strcmp (option, "nfs")) { | ||
5744 | if (nfs_cnt > 0) { | ||
5745 | unlink (dumpoptions_path); | ||
5746 | ret = 0; | ||
5747 | goto out; | ||
5748 | } | ||
5749 | nfs_cnt++; | ||
5750 | option = strtok_r (NULL((void*)0), " ", &tmpptr); | ||
5751 | continue; | ||
5752 | } | ||
5753 | fprintf (fp, "%s=yes\n", option); | ||
5754 | option = strtok_r (NULL((void*)0), " ", &tmpptr); | ||
5755 | } | ||
5756 | |||
5757 | out: | ||
5758 | if (fp) | ||
5759 | fclose (fp); | ||
5760 | GF_FREE (dup_options)__gf_free (dup_options); | ||
5761 | return ret; | ||
5762 | } | ||
5763 | |||
5764 | int | ||
5765 | glusterd_brick_statedump (glusterd_volinfo_t *volinfo, | ||
5766 | glusterd_brickinfo_t *brickinfo, | ||
5767 | char *options, int option_cnt, char **op_errstr) | ||
5768 | { | ||
5769 | int ret = -1; | ||
5770 | xlator_t *this = NULL((void*)0); | ||
5771 | glusterd_conf_t *conf = NULL((void*)0); | ||
5772 | char pidfile_path[PATH_MAX4096] = {0,}; | ||
5773 | char dumpoptions_path[PATH_MAX4096] = {0,}; | ||
5774 | FILE *pidfile = NULL((void*)0); | ||
5775 | pid_t pid = -1; | ||
5776 | |||
5777 | this = THIS(*__glusterfs_this_location()); | ||
5778 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5778, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
5779 | conf = this->private; | ||
5780 | GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: " "conf"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5780, GF_LOG_ERROR, "Assertion failed: " "conf" ); } while (0); } } while (0); | ||
5781 | |||
5782 | if (uuid_is_null (brickinfo->uuid)) { | ||
5783 | ret = glusterd_resolve_brick (brickinfo); | ||
5784 | if (ret) { | ||
5785 | gf_log ("glusterd", GF_LOG_ERROR,do { do { if (0) printf ("Cannot resolve brick %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 5787, GF_LOG_ERROR, "Cannot resolve brick %s:%s" , brickinfo->hostname, brickinfo->path); } while (0) | ||
5786 | "Cannot resolve brick %s:%s",do { do { if (0) printf ("Cannot resolve brick %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 5787, GF_LOG_ERROR, "Cannot resolve brick %s:%s" , brickinfo->hostname, brickinfo->path); } while (0) | ||
5787 | brickinfo->hostname, brickinfo->path)do { do { if (0) printf ("Cannot resolve brick %s:%s", brickinfo ->hostname, brickinfo->path); } while (0); _gf_log ("glusterd" , "glusterd-utils.c", __FUNCTION__, 5787, GF_LOG_ERROR, "Cannot resolve brick %s:%s" , brickinfo->hostname, brickinfo->path); } while (0); | ||
5788 | goto out; | ||
5789 | } | ||
5790 | } | ||
5791 | |||
5792 | if (uuid_compare (brickinfo->uuid, MY_UUID(__glusterd_uuid()))) { | ||
5793 | ret = 0; | ||
5794 | goto out; | ||
5795 | } | ||
5796 | |||
5797 | GLUSTERD_GET_BRICK_PIDFILE (pidfile_path, volinfo, brickinfo, conf)do { char exp_path[4096] = {0,}; char volpath[4096] = {0,}; snprintf (volpath, 4096, "%s/vols/%s", conf->workdir, volinfo-> volname);; do { int i = 0; for (i = 1; i < strlen (brickinfo ->path); i++) { exp_path[i-1] = brickinfo->path[i]; if ( exp_path[i-1] == '/') exp_path[i-1] = '-'; } } while (0); snprintf (pidfile_path, 4096, "%s/run/%s-%s.pid", volpath, brickinfo-> hostname, exp_path); } while (0); | ||
5798 | |||
5799 | pidfile = fopen (pidfile_path, "r"); | ||
5800 | if (!pidfile) { | ||
5801 | gf_log ("", GF_LOG_ERROR, "Unable to open pidfile: %s",do { do { if (0) printf ("Unable to open pidfile: %s", pidfile_path ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5802, GF_LOG_ERROR, "Unable to open pidfile: %s", pidfile_path ); } while (0) | ||
5802 | pidfile_path)do { do { if (0) printf ("Unable to open pidfile: %s", pidfile_path ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5802, GF_LOG_ERROR, "Unable to open pidfile: %s", pidfile_path ); } while (0); | ||
5803 | ret = -1; | ||
5804 | goto out; | ||
5805 | } | ||
5806 | |||
5807 | ret = fscanf (pidfile, "%d", &pid); | ||
5808 | if (ret <= 0) { | ||
5809 | gf_log ("", GF_LOG_ERROR, "Unable to get pid of brick process")do { do { if (0) printf ("Unable to get pid of brick process" ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5809, GF_LOG_ERROR, "Unable to get pid of brick process"); } while (0); | ||
5810 | ret = -1; | ||
5811 | goto out; | ||
5812 | } | ||
5813 | |||
5814 | snprintf (dumpoptions_path, sizeof (dumpoptions_path), | ||
5815 | DEFAULT_VAR_RUN_DIRECTORY"/usr/local/var" "/run/gluster""/glusterdump.%d.options", pid); | ||
5816 | ret = glusterd_set_dump_options (dumpoptions_path, options, option_cnt); | ||
5817 | if (ret < 0) { | ||
5818 | gf_log ("", GF_LOG_ERROR, "error while parsing the statedump "do { do { if (0) printf ("error while parsing the statedump " "options"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5819, GF_LOG_ERROR, "error while parsing the statedump " "options" ); } while (0) | ||
5819 | "options")do { do { if (0) printf ("error while parsing the statedump " "options"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5819, GF_LOG_ERROR, "error while parsing the statedump " "options" ); } while (0); | ||
5820 | ret = -1; | ||
5821 | goto out; | ||
5822 | } | ||
5823 | |||
5824 | gf_log ("", GF_LOG_INFO, "Performing statedump on brick with pid %d",do { do { if (0) printf ("Performing statedump on brick with pid %d" , pid); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5825, GF_LOG_INFO, "Performing statedump on brick with pid %d" , pid); } while (0) | ||
5825 | pid)do { do { if (0) printf ("Performing statedump on brick with pid %d" , pid); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5825, GF_LOG_INFO, "Performing statedump on brick with pid %d" , pid); } while (0); | ||
5826 | |||
5827 | kill (pid, SIGUSR110); | ||
5828 | |||
5829 | sleep (1); | ||
5830 | ret = 0; | ||
5831 | out: | ||
5832 | unlink (dumpoptions_path); | ||
5833 | if (pidfile) | ||
5834 | fclose (pidfile); | ||
5835 | return ret; | ||
5836 | } | ||
5837 | |||
5838 | int | ||
5839 | glusterd_nfs_statedump (char *options, int option_cnt, char **op_errstr) | ||
5840 | { | ||
5841 | int ret = -1; | ||
5842 | xlator_t *this = NULL((void*)0); | ||
5843 | glusterd_conf_t *conf = NULL((void*)0); | ||
5844 | char pidfile_path[PATH_MAX4096] = {0,}; | ||
5845 | char path[PATH_MAX4096] = {0,}; | ||
5846 | FILE *pidfile = NULL((void*)0); | ||
5847 | pid_t pid = -1; | ||
5848 | char dumpoptions_path[PATH_MAX4096] = {0,}; | ||
5849 | char *option = NULL((void*)0); | ||
5850 | char *tmpptr = NULL((void*)0); | ||
5851 | char *dup_options = NULL((void*)0); | ||
5852 | char msg[256] = {0,}; | ||
5853 | |||
5854 | this = THIS(*__glusterfs_this_location()); | ||
5855 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5855, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
5856 | conf = this->private; | ||
5857 | GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: " "conf"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5857, GF_LOG_ERROR, "Assertion failed: " "conf" ); } while (0); } } while (0); | ||
5858 | |||
5859 | dup_options = gf_strdup (options); | ||
5860 | option = strtok_r (dup_options, " ", &tmpptr); | ||
5861 | if (strcmp (option, "nfs")) { | ||
5862 | snprintf (msg, sizeof (msg), "for nfs statedump, options should" | ||
5863 | " be after the key nfs"); | ||
5864 | *op_errstr = gf_strdup (msg); | ||
5865 | ret = -1; | ||
5866 | goto out; | ||
5867 | } | ||
5868 | |||
5869 | GLUSTERD_GET_NFS_DIR (path, conf)snprintf (path, 4096, "%s/nfs", conf->workdir);; | ||
5870 | GLUSTERD_GET_NFS_PIDFILE (pidfile_path, path){ snprintf (pidfile_path, 4096, "%s/run/nfs.pid", path); }; | ||
5871 | |||
5872 | pidfile = fopen (pidfile_path, "r"); | ||
5873 | if (!pidfile) { | ||
5874 | gf_log ("", GF_LOG_ERROR, "Unable to open pidfile: %s",do { do { if (0) printf ("Unable to open pidfile: %s", pidfile_path ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5875, GF_LOG_ERROR, "Unable to open pidfile: %s", pidfile_path ); } while (0) | ||
5875 | pidfile_path)do { do { if (0) printf ("Unable to open pidfile: %s", pidfile_path ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5875, GF_LOG_ERROR, "Unable to open pidfile: %s", pidfile_path ); } while (0); | ||
5876 | ret = -1; | ||
5877 | goto out; | ||
5878 | } | ||
5879 | |||
5880 | ret = fscanf (pidfile, "%d", &pid); | ||
5881 | if (ret <= 0) { | ||
5882 | gf_log ("", GF_LOG_ERROR, "Unable to get pid of brick process")do { do { if (0) printf ("Unable to get pid of brick process" ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5882, GF_LOG_ERROR, "Unable to get pid of brick process"); } while (0); | ||
5883 | ret = -1; | ||
5884 | goto out; | ||
5885 | } | ||
5886 | |||
5887 | snprintf (dumpoptions_path, sizeof (dumpoptions_path), | ||
5888 | DEFAULT_VAR_RUN_DIRECTORY"/usr/local/var" "/run/gluster""/glusterdump.%d.options", pid); | ||
5889 | ret = glusterd_set_dump_options (dumpoptions_path, options, option_cnt); | ||
5890 | if (ret < 0) { | ||
5891 | gf_log ("", GF_LOG_ERROR, "error while parsing the statedump "do { do { if (0) printf ("error while parsing the statedump " "options"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5892, GF_LOG_ERROR, "error while parsing the statedump " "options" ); } while (0) | ||
5892 | "options")do { do { if (0) printf ("error while parsing the statedump " "options"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 5892, GF_LOG_ERROR, "error while parsing the statedump " "options" ); } while (0); | ||
5893 | ret = -1; | ||
5894 | goto out; | ||
5895 | } | ||
5896 | |||
5897 | gf_log ("", GF_LOG_INFO, "Performing statedump on nfs server with "do { do { if (0) printf ("Performing statedump on nfs server with " "pid %d", pid); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5898, GF_LOG_INFO, "Performing statedump on nfs server with " "pid %d", pid); } while (0) | ||
5898 | "pid %d", pid)do { do { if (0) printf ("Performing statedump on nfs server with " "pid %d", pid); } while (0); _gf_log ("", "glusterd-utils.c" , __FUNCTION__, 5898, GF_LOG_INFO, "Performing statedump on nfs server with " "pid %d", pid); } while (0); | ||
5899 | |||
5900 | kill (pid, SIGUSR110); | ||
5901 | |||
5902 | sleep (1); | ||
5903 | |||
5904 | ret = 0; | ||
5905 | out: | ||
5906 | if (pidfile) | ||
5907 | fclose (pidfile); | ||
5908 | unlink (dumpoptions_path); | ||
5909 | GF_FREE (dup_options)__gf_free (dup_options); | ||
5910 | return ret; | ||
5911 | } | ||
5912 | |||
5913 | /* Checks if the given peer contains all the bricks belonging to the | ||
5914 | * given volume. Returns true if it does else returns false | ||
5915 | */ | ||
5916 | gf_boolean_t | ||
5917 | glusterd_friend_contains_vol_bricks (glusterd_volinfo_t *volinfo, | ||
5918 | uuid_t friend_uuid) | ||
5919 | { | ||
5920 | gf_boolean_t ret = _gf_true; | ||
5921 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
5922 | |||
5923 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5923, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
5924 | |||
5925 | 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)))) { | ||
5926 | if (uuid_compare (friend_uuid, brickinfo->uuid)) { | ||
5927 | ret = _gf_false; | ||
5928 | break; | ||
5929 | } | ||
5930 | } | ||
5931 | 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-utils.c" , __FUNCTION__, 5931, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
5932 | return ret; | ||
5933 | } | ||
5934 | |||
5935 | /* Remove all volumes which completely belong to given friend | ||
5936 | */ | ||
5937 | int | ||
5938 | glusterd_friend_remove_cleanup_vols (uuid_t uuid) | ||
5939 | { | ||
5940 | int ret = -1; | ||
5941 | glusterd_conf_t *priv = NULL((void*)0); | ||
5942 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
5943 | glusterd_volinfo_t *tmp_volinfo = NULL((void*)0); | ||
5944 | |||
5945 | priv = THIS(*__glusterfs_this_location())->private; | ||
5946 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5946, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
5947 | |||
5948 | list_for_each_entry_safe (volinfo, tmp_volinfo,for (volinfo = ((typeof(*volinfo) *)((char *)((&priv-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))), tmp_volinfo = ((typeof(*volinfo) *)((char *)(volinfo->vol_list.next)-(unsigned long)(&((typeof( *volinfo) *)0)->vol_list))); &volinfo->vol_list != ( &priv->volumes); volinfo = tmp_volinfo, tmp_volinfo = ( (typeof(*tmp_volinfo) *)((char *)(tmp_volinfo->vol_list.next )-(unsigned long)(&((typeof(*tmp_volinfo) *)0)->vol_list )))) | ||
5949 | &priv->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&priv-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))), tmp_volinfo = ((typeof(*volinfo) *)((char *)(volinfo->vol_list.next)-(unsigned long)(&((typeof( *volinfo) *)0)->vol_list))); &volinfo->vol_list != ( &priv->volumes); volinfo = tmp_volinfo, tmp_volinfo = ( (typeof(*tmp_volinfo) *)((char *)(tmp_volinfo->vol_list.next )-(unsigned long)(&((typeof(*tmp_volinfo) *)0)->vol_list )))) { | ||
5950 | if (glusterd_friend_contains_vol_bricks (volinfo, uuid)) { | ||
5951 | gf_log (THIS->name, GF_LOG_INFO,do { do { if (0) printf ("Deleting stale volume %s", volinfo-> volname); } while (0); _gf_log ((*__glusterfs_this_location() )->name, "glusterd-utils.c", __FUNCTION__, 5952, GF_LOG_INFO , "Deleting stale volume %s", volinfo->volname); } while ( 0) | ||
5952 | "Deleting stale volume %s", volinfo->volname)do { do { if (0) printf ("Deleting stale volume %s", volinfo-> volname); } while (0); _gf_log ((*__glusterfs_this_location() )->name, "glusterd-utils.c", __FUNCTION__, 5952, GF_LOG_INFO , "Deleting stale volume %s", volinfo->volname); } while ( 0); | ||
5953 | ret = glusterd_delete_volume (volinfo); | ||
5954 | if (ret) { | ||
5955 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("Error deleting stale volume"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 5956, GF_LOG_ERROR, "Error deleting stale volume" ); } while (0) | ||
5956 | "Error deleting stale volume")do { do { if (0) printf ("Error deleting stale volume"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 5956, GF_LOG_ERROR, "Error deleting stale volume" ); } while (0); | ||
5957 | goto out; | ||
5958 | } | ||
5959 | } | ||
5960 | } | ||
5961 | ret = 0; | ||
5962 | out: | ||
5963 | 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-utils.c" , __FUNCTION__, 5963, GF_LOG_DEBUG, "Returning %d", ret); } while (0); | ||
5964 | return ret; | ||
5965 | } | ||
5966 | |||
5967 | /* Check if the all peers are connected and befriended, except the peer | ||
5968 | * specified (the peer being detached) | ||
5969 | */ | ||
5970 | gf_boolean_t | ||
5971 | glusterd_chk_peers_connected_befriended (uuid_t skip_uuid) | ||
5972 | { | ||
5973 | gf_boolean_t ret = _gf_true; | ||
5974 | glusterd_peerinfo_t *peerinfo = NULL((void*)0); | ||
5975 | glusterd_conf_t *priv = NULL((void*)0); | ||
5976 | |||
5977 | priv= THIS(*__glusterfs_this_location())->private; | ||
5978 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 5978, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
5979 | |||
5980 | 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)))) { | ||
5981 | |||
5982 | if (!uuid_is_null (skip_uuid) && !uuid_compare (skip_uuid, | ||
5983 | peerinfo->uuid)) | ||
5984 | continue; | ||
5985 | |||
5986 | if ((GD_FRIEND_STATE_BEFRIENDED != peerinfo->state.state) | ||
5987 | || !(peerinfo->connected)) { | ||
5988 | ret = _gf_false; | ||
5989 | break; | ||
5990 | } | ||
5991 | } | ||
5992 | gf_log (THIS->name, GF_LOG_DEBUG, "Returning %s",do { do { if (0) printf ("Returning %s", (ret?"TRUE":"FALSE") ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 5993, GF_LOG_DEBUG, "Returning %s" , (ret?"TRUE":"FALSE")); } while (0) | ||
5993 | (ret?"TRUE":"FALSE"))do { do { if (0) printf ("Returning %s", (ret?"TRUE":"FALSE") ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 5993, GF_LOG_DEBUG, "Returning %s" , (ret?"TRUE":"FALSE")); } while (0); | ||
5994 | return ret; | ||
5995 | } | ||
5996 | |||
5997 | void | ||
5998 | glusterd_get_client_filepath (char *filepath, glusterd_volinfo_t *volinfo, | ||
5999 | gf_transport_type type) | ||
6000 | { | ||
6001 | char path[PATH_MAX4096] = {0,}; | ||
6002 | glusterd_conf_t *priv = NULL((void*)0); | ||
6003 | |||
6004 | priv = THIS(*__glusterfs_this_location())->private; | ||
6005 | |||
6006 | GLUSTERD_GET_VOLUME_DIR (path, volinfo, priv)snprintf (path, 4096, "%s/vols/%s", priv->workdir, volinfo ->volname);; | ||
6007 | |||
6008 | if ((volinfo->transport_type == GF_TRANSPORT_BOTH_TCP_RDMA) && | ||
6009 | (type == GF_TRANSPORT_RDMA)) | ||
6010 | snprintf (filepath, PATH_MAX4096, "%s/%s.rdma-fuse.vol", | ||
6011 | path, volinfo->volname); | ||
6012 | else | ||
6013 | snprintf (filepath, PATH_MAX4096, "%s/%s-fuse.vol", | ||
6014 | path, volinfo->volname); | ||
6015 | } | ||
6016 | |||
6017 | void | ||
6018 | glusterd_get_trusted_client_filepath (char *filepath, | ||
6019 | glusterd_volinfo_t *volinfo, | ||
6020 | gf_transport_type type) | ||
6021 | { | ||
6022 | char path[PATH_MAX4096] = {0,}; | ||
6023 | glusterd_conf_t *priv = NULL((void*)0); | ||
6024 | |||
6025 | priv = THIS(*__glusterfs_this_location())->private; | ||
6026 | |||
6027 | GLUSTERD_GET_VOLUME_DIR (path, volinfo, priv)snprintf (path, 4096, "%s/vols/%s", priv->workdir, volinfo ->volname);; | ||
6028 | |||
6029 | if ((volinfo->transport_type == GF_TRANSPORT_BOTH_TCP_RDMA) && | ||
6030 | (type == GF_TRANSPORT_RDMA)) | ||
6031 | snprintf (filepath, PATH_MAX4096, | ||
6032 | "%s/trusted-%s.rdma-fuse.vol", | ||
6033 | path, volinfo->volname); | ||
6034 | else | ||
6035 | snprintf (filepath, PATH_MAX4096, | ||
6036 | "%s/trusted-%s-fuse.vol", | ||
6037 | path, volinfo->volname); | ||
6038 | } | ||
6039 | |||
6040 | int | ||
6041 | glusterd_volume_defrag_restart (glusterd_volinfo_t *volinfo, char *op_errstr, | ||
6042 | size_t len, int cmd, defrag_cbk_fn_t cbk) | ||
6043 | { | ||
6044 | glusterd_conf_t *priv = NULL((void*)0); | ||
6045 | char pidfile[PATH_MAX4096]; | ||
6046 | int ret = -1; | ||
6047 | pid_t pid; | ||
6048 | |||
6049 | priv = THIS(*__glusterfs_this_location())->private; | ||
6050 | if (!priv) | ||
6051 | return ret; | ||
6052 | |||
6053 | GLUSTERD_GET_DEFRAG_PID_FILE(pidfile, volinfo, priv)do { char defrag_path[4096]; do { char vol_path[4096]; snprintf (vol_path, 4096, "%s/vols/%s", priv->workdir, volinfo-> volname);; snprintf (defrag_path, 4096, "%s/rebalance",vol_path ); } while (0); snprintf (pidfile, 4096, "%s/%s.pid", defrag_path , uuid_utoa((__glusterd_uuid()))); } while (0); | ||
6054 | |||
6055 | if (!glusterd_is_service_running (pidfile, &pid)) { | ||
6056 | glusterd_handle_defrag_start (volinfo, op_errstr, len, cmd, | ||
6057 | cbk, volinfo->rebal.op); | ||
6058 | } else { | ||
6059 | glusterd_rebalance_rpc_create (volinfo, priv, cmd); | ||
6060 | } | ||
6061 | |||
6062 | return ret; | ||
6063 | } | ||
6064 | |||
6065 | int | ||
6066 | glusterd_restart_rebalance (glusterd_conf_t *conf) | ||
6067 | { | ||
6068 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
6069 | int ret = 0; | ||
6070 | char op_errstr[256]; | ||
6071 | |||
6072 | list_for_each_entry (volinfo, &conf->volumes, vol_list)for (volinfo = ((typeof(*volinfo) *)((char *)((&conf-> volumes)->next)-(unsigned long)(&((typeof(*volinfo) *) 0)->vol_list))); &volinfo->vol_list != (&conf-> volumes); volinfo = ((typeof(*volinfo) *)((char *)(volinfo-> vol_list.next)-(unsigned long)(&((typeof(*volinfo) *)0)-> vol_list)))) { | ||
6073 | if (!volinfo->rebal.defrag_cmd) | ||
6074 | continue; | ||
6075 | glusterd_volume_defrag_restart (volinfo, op_errstr, 256, | ||
6076 | volinfo->rebal.defrag_cmd, NULL((void*)0)); | ||
6077 | } | ||
6078 | return ret; | ||
6079 | } | ||
6080 | |||
6081 | void | ||
6082 | glusterd_volinfo_reset_defrag_stats (glusterd_volinfo_t *volinfo) | ||
6083 | { | ||
6084 | glusterd_rebalance_t *rebal = NULL((void*)0); | ||
6085 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6085, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
6086 | |||
6087 | rebal = &volinfo->rebal; | ||
6088 | rebal->rebalance_files = 0; | ||
6089 | rebal->rebalance_data = 0; | ||
6090 | rebal->lookedup_files = 0; | ||
6091 | rebal->rebalance_failures = 0; | ||
6092 | rebal->rebalance_time = 0; | ||
6093 | |||
6094 | } | ||
6095 | |||
6096 | /* Return hostname for given uuid if it exists | ||
6097 | * else return NULL | ||
6098 | */ | ||
6099 | char * | ||
6100 | glusterd_uuid_to_hostname (uuid_t uuid) | ||
6101 | { | ||
6102 | char *hostname = NULL((void*)0); | ||
6103 | glusterd_conf_t *priv = NULL((void*)0); | ||
6104 | glusterd_peerinfo_t *entry = NULL((void*)0); | ||
6105 | |||
6106 | priv = THIS(*__glusterfs_this_location())->private; | ||
6107 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6107, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
6108 | |||
6109 | if (!uuid_compare (MY_UUID(__glusterd_uuid()), uuid)) { | ||
6110 | hostname = gf_strdup ("localhost"); | ||
6111 | } | ||
6112 | if (!list_empty (&priv->peers)) { | ||
6113 | list_for_each_entry (entry, &priv->peers, uuid_list)for (entry = ((typeof(*entry) *)((char *)((&priv->peers )->next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list ))); &entry->uuid_list != (&priv->peers); entry = ((typeof(*entry) *)((char *)(entry->uuid_list.next)-(unsigned long)(&((typeof(*entry) *)0)->uuid_list)))) { | ||
6114 | if (!uuid_compare (entry->uuid, uuid)) { | ||
6115 | hostname = gf_strdup (entry->hostname); | ||
6116 | break; | ||
6117 | } | ||
6118 | } | ||
6119 | } | ||
6120 | |||
6121 | return hostname; | ||
6122 | } | ||
6123 | |||
6124 | gf_boolean_t | ||
6125 | glusterd_is_local_brick (xlator_t *this, glusterd_volinfo_t *volinfo, | ||
6126 | glusterd_brickinfo_t *brickinfo) | ||
6127 | { | ||
6128 | gf_boolean_t local = _gf_false; | ||
6129 | int ret = 0; | ||
6130 | glusterd_conf_t *conf = NULL((void*)0); | ||
6131 | |||
6132 | if (uuid_is_null (brickinfo->uuid)) { | ||
6133 | ret = glusterd_resolve_brick (brickinfo); | ||
6134 | if (ret) | ||
6135 | goto out; | ||
6136 | } | ||
6137 | conf = this->private; | ||
6138 | local = !uuid_compare (brickinfo->uuid, MY_UUID(__glusterd_uuid())); | ||
6139 | out: | ||
6140 | return local; | ||
6141 | } | ||
6142 | int | ||
6143 | glusterd_validate_volume_id (dict_t *op_dict, glusterd_volinfo_t *volinfo) | ||
6144 | { | ||
6145 | int ret = -1; | ||
6146 | char *volid_str = NULL((void*)0); | ||
6147 | uuid_t vol_uid = {0, }; | ||
6148 | xlator_t *this = NULL((void*)0); | ||
6149 | |||
6150 | this = THIS(*__glusterfs_this_location()); | ||
6151 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6151, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
6152 | |||
6153 | ret = dict_get_str (op_dict, "vol-id", &volid_str); | ||
6154 | if (ret) { | ||
6155 | gf_log (this->name, GF_LOG_ERROR, "Failed to get volume id for "do { do { if (0) printf ("Failed to get volume id for " "volume %s" , volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6156, GF_LOG_ERROR, "Failed to get volume id for " "volume %s", volinfo->volname); } while (0) | ||
6156 | "volume %s", volinfo->volname)do { do { if (0) printf ("Failed to get volume id for " "volume %s" , volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6156, GF_LOG_ERROR, "Failed to get volume id for " "volume %s", volinfo->volname); } while (0); | ||
6157 | goto out; | ||
6158 | } | ||
6159 | ret = uuid_parse (volid_str, vol_uid); | ||
6160 | if (ret) { | ||
6161 | gf_log (this->name, GF_LOG_ERROR, "Failed to parse volume id "do { do { if (0) printf ("Failed to parse volume id " "for volume %s" , volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6162, GF_LOG_ERROR, "Failed to parse volume id " "for volume %s", volinfo->volname); } while (0) | ||
6162 | "for volume %s", volinfo->volname)do { do { if (0) printf ("Failed to parse volume id " "for volume %s" , volinfo->volname); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6162, GF_LOG_ERROR, "Failed to parse volume id " "for volume %s", volinfo->volname); } while (0); | ||
6163 | goto out; | ||
6164 | } | ||
6165 | |||
6166 | if (uuid_compare (vol_uid, volinfo->volume_id)) { | ||
6167 | gf_log (this->name, GF_LOG_ERROR, "Volume ids of volume %s - %s"do { do { if (0) printf ("Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers.", volinfo->volname, volid_str, uuid_utoa (volinfo ->volume_id)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6170, GF_LOG_ERROR, "Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers." , volinfo->volname, volid_str, uuid_utoa (volinfo->volume_id )); } while (0) | ||
6168 | " and %s - are different. Possibly a split brain among "do { do { if (0) printf ("Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers.", volinfo->volname, volid_str, uuid_utoa (volinfo ->volume_id)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6170, GF_LOG_ERROR, "Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers." , volinfo->volname, volid_str, uuid_utoa (volinfo->volume_id )); } while (0) | ||
6169 | "peers.", volinfo->volname, volid_str,do { do { if (0) printf ("Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers.", volinfo->volname, volid_str, uuid_utoa (volinfo ->volume_id)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6170, GF_LOG_ERROR, "Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers." , volinfo->volname, volid_str, uuid_utoa (volinfo->volume_id )); } while (0) | ||
6170 | uuid_utoa (volinfo->volume_id))do { do { if (0) printf ("Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers.", volinfo->volname, volid_str, uuid_utoa (volinfo ->volume_id)); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 6170, GF_LOG_ERROR, "Volume ids of volume %s - %s" " and %s - are different. Possibly a split brain among " "peers." , volinfo->volname, volid_str, uuid_utoa (volinfo->volume_id )); } while (0); | ||
6171 | ret = -1; | ||
6172 | goto out; | ||
6173 | } | ||
6174 | |||
6175 | out: | ||
6176 | return ret; | ||
6177 | } | ||
6178 | |||
6179 | int | ||
6180 | glusterd_defrag_volume_status_update (glusterd_volinfo_t *volinfo, | ||
6181 | dict_t *rsp_dict) | ||
6182 | { | ||
6183 | int ret = 0; | ||
6184 | uint64_t files = 0; | ||
6185 | uint64_t size = 0; | ||
6186 | uint64_t lookup = 0; | ||
6187 | gf_defrag_status_t status = GF_DEFRAG_STATUS_NOT_STARTED; | ||
6188 | uint64_t failures = 0; | ||
6189 | xlator_t *this = NULL((void*)0); | ||
6190 | double run_time = 0; | ||
6191 | |||
6192 | this = THIS(*__glusterfs_this_location()); | ||
6193 | |||
6194 | ret = dict_get_uint64 (rsp_dict, "files", &files); | ||
6195 | if (ret) | ||
6196 | gf_log (this->name, GF_LOG_TRACE,do { do { if (0) printf ("failed to get file count"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6197, GF_LOG_TRACE, "failed to get file count"); } while (0 ) | ||
6197 | "failed to get file count")do { do { if (0) printf ("failed to get file count"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6197, GF_LOG_TRACE, "failed to get file count"); } while (0 ); | ||
6198 | |||
6199 | ret = dict_get_uint64 (rsp_dict, "size", &size); | ||
6200 | if (ret) | ||
6201 | gf_log (this->name, GF_LOG_TRACE,do { do { if (0) printf ("failed to get size of xfer"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6202, GF_LOG_TRACE, "failed to get size of xfer"); } while ( 0) | ||
6202 | "failed to get size of xfer")do { do { if (0) printf ("failed to get size of xfer"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6202, GF_LOG_TRACE, "failed to get size of xfer"); } while ( 0); | ||
6203 | |||
6204 | ret = dict_get_uint64 (rsp_dict, "lookups", &lookup); | ||
6205 | if (ret) | ||
6206 | gf_log (this->name, GF_LOG_TRACE,do { do { if (0) printf ("failed to get lookedup file count") ; } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6207, GF_LOG_TRACE, "failed to get lookedup file count"); } while (0) | ||
6207 | "failed to get lookedup file count")do { do { if (0) printf ("failed to get lookedup file count") ; } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6207, GF_LOG_TRACE, "failed to get lookedup file count"); } while (0); | ||
6208 | |||
6209 | ret = dict_get_int32 (rsp_dict, "status", (int32_t *)&status); | ||
6210 | if (ret) | ||
6211 | gf_log (this->name, GF_LOG_TRACE,do { do { if (0) printf ("failed to get status"); } while (0) ; _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 6212 , GF_LOG_TRACE, "failed to get status"); } while (0) | ||
6212 | "failed to get status")do { do { if (0) printf ("failed to get status"); } while (0) ; _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 6212 , GF_LOG_TRACE, "failed to get status"); } while (0); | ||
6213 | |||
6214 | ret = dict_get_uint64 (rsp_dict, "failures", &failures); | ||
6215 | if (ret) | ||
6216 | gf_log (this->name, GF_LOG_TRACE,do { do { if (0) printf ("failed to get failure count"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6217, GF_LOG_TRACE, "failed to get failure count"); } while (0) | ||
6217 | "failed to get failure count")do { do { if (0) printf ("failed to get failure count"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6217, GF_LOG_TRACE, "failed to get failure count"); } while (0); | ||
6218 | |||
6219 | ret = dict_get_double (rsp_dict, "run-time", &run_time); | ||
6220 | if (ret) | ||
6221 | gf_log (this->name, GF_LOG_TRACE,do { do { if (0) printf ("failed to get run-time"); } while ( 0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 6222, GF_LOG_TRACE, "failed to get run-time"); } while (0) | ||
6222 | "failed to get run-time")do { do { if (0) printf ("failed to get run-time"); } while ( 0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__, 6222, GF_LOG_TRACE, "failed to get run-time"); } while (0); | ||
6223 | |||
6224 | if (files) | ||
6225 | volinfo->rebal.rebalance_files = files; | ||
6226 | if (size) | ||
6227 | volinfo->rebal.rebalance_data = size; | ||
6228 | if (lookup) | ||
6229 | volinfo->rebal.lookedup_files = lookup; | ||
6230 | if (status) | ||
6231 | volinfo->rebal.defrag_status = status; | ||
6232 | if (failures) | ||
6233 | volinfo->rebal.rebalance_failures = failures; | ||
6234 | if (run_time) | ||
6235 | volinfo->rebal.rebalance_time = run_time; | ||
6236 | |||
6237 | return ret; | ||
6238 | } | ||
6239 | |||
6240 | int | ||
6241 | glusterd_check_files_identical (char *filename1, char *filename2, | ||
6242 | gf_boolean_t *identical) | ||
6243 | { | ||
6244 | int ret = -1; | ||
6245 | struct stat buf1 = {0,}; | ||
6246 | struct stat buf2 = {0,}; | ||
6247 | uint32_t cksum1 = 0; | ||
6248 | uint32_t cksum2 = 0; | ||
6249 | xlator_t *this = NULL((void*)0); | ||
6250 | |||
6251 | GF_ASSERT (filename1)do { if (!(filename1)) { do { do { if (0) printf ("Assertion failed: " "filename1"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6251, GF_LOG_ERROR, "Assertion failed: " "filename1" ); } while (0); } } while (0); | ||
6252 | GF_ASSERT (filename2)do { if (!(filename2)) { do { do { if (0) printf ("Assertion failed: " "filename2"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6252, GF_LOG_ERROR, "Assertion failed: " "filename2" ); } while (0); } } while (0); | ||
6253 | GF_ASSERT (identical)do { if (!(identical)) { do { do { if (0) printf ("Assertion failed: " "identical"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6253, GF_LOG_ERROR, "Assertion failed: " "identical" ); } while (0); } } while (0); | ||
6254 | |||
6255 | this = THIS(*__glusterfs_this_location()); | ||
6256 | |||
6257 | ret = stat (filename1, &buf1); | ||
6258 | |||
6259 | if (ret) { | ||
6260 | gf_log (this->name, GF_LOG_ERROR, "stat on file: %s failed "do { do { if (0) printf ("stat on file: %s failed " "(%s)", filename1 , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 6261, GF_LOG_ERROR , "stat on file: %s failed " "(%s)", filename1, strerror ((*__errno_location ()))); } while (0) | ||
6261 | "(%s)", filename1, strerror (errno))do { do { if (0) printf ("stat on file: %s failed " "(%s)", filename1 , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 6261, GF_LOG_ERROR , "stat on file: %s failed " "(%s)", filename1, strerror ((*__errno_location ()))); } while (0); | ||
6262 | goto out; | ||
6263 | } | ||
6264 | |||
6265 | ret = stat (filename2, &buf2); | ||
6266 | |||
6267 | if (ret) { | ||
6268 | gf_log (this->name, GF_LOG_ERROR, "stat on file: %s failed "do { do { if (0) printf ("stat on file: %s failed " "(%s)", filename2 , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 6269, GF_LOG_ERROR , "stat on file: %s failed " "(%s)", filename2, strerror ((*__errno_location ()))); } while (0) | ||
6269 | "(%s)", filename2, strerror (errno))do { do { if (0) printf ("stat on file: %s failed " "(%s)", filename2 , strerror ((*__errno_location ()))); } while (0); _gf_log (this ->name, "glusterd-utils.c", __FUNCTION__, 6269, GF_LOG_ERROR , "stat on file: %s failed " "(%s)", filename2, strerror ((*__errno_location ()))); } while (0); | ||
6270 | goto out; | ||
6271 | } | ||
6272 | |||
6273 | if (buf1.st_size != buf2.st_size) { | ||
6274 | *identical = _gf_false; | ||
6275 | goto out; | ||
6276 | } | ||
6277 | |||
6278 | ret = get_checksum_for_path (filename1, &cksum1); | ||
6279 | if (ret) | ||
6280 | goto out; | ||
6281 | |||
6282 | |||
6283 | ret = get_checksum_for_path (filename2, &cksum2); | ||
6284 | if (ret) | ||
6285 | goto out; | ||
6286 | |||
6287 | if (cksum1 != cksum2) | ||
6288 | *identical = _gf_false; | ||
6289 | else | ||
6290 | *identical = _gf_true; | ||
6291 | |||
6292 | out: | ||
6293 | 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-utils.c", __FUNCTION__, 6293, GF_LOG_DEBUG, "Returning with %d", ret); } while (0); | ||
6294 | return ret; | ||
6295 | } | ||
6296 | |||
6297 | int | ||
6298 | glusterd_volset_help (dict_t *dict, char **op_errstr) | ||
6299 | { | ||
6300 | int ret = -1; | ||
6301 | gf_boolean_t xml_out = _gf_false; | ||
6302 | xlator_t *this = NULL((void*)0); | ||
6303 | |||
6304 | this = THIS(*__glusterfs_this_location()); | ||
6305 | |||
6306 | if (!dict) { | ||
6307 | if (!(dict = glusterd_op_get_ctx ())) { | ||
6308 | ret = 0; | ||
6309 | goto out; | ||
6310 | } | ||
6311 | } | ||
6312 | |||
6313 | if (dict_get (dict, "help" )) { | ||
6314 | xml_out = _gf_false; | ||
6315 | |||
6316 | } else if (dict_get (dict, "help-xml" )) { | ||
6317 | xml_out = _gf_true; | ||
6318 | #if (HAVE_LIB_XML1) | ||
6319 | ret = 0; | ||
6320 | #else | ||
6321 | gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("libxml not present in the system"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6322, GF_LOG_ERROR, "libxml not present in the system"); } while (0) | ||
6322 | "libxml not present in the system")do { do { if (0) printf ("libxml not present in the system"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6322, GF_LOG_ERROR, "libxml not present in the system"); } while (0); | ||
6323 | if (op_errstr) | ||
6324 | *op_errstr = gf_strdup ("Error: xml libraries not " | ||
6325 | "present to produce " | ||
6326 | "xml-output"); | ||
6327 | goto out; | ||
6328 | #endif | ||
6329 | |||
6330 | } else { | ||
6331 | goto out; | ||
6332 | } | ||
6333 | |||
6334 | ret = glusterd_get_volopt_content (dict, xml_out); | ||
6335 | if (ret && op_errstr) | ||
6336 | *op_errstr = gf_strdup ("Failed to get volume options help"); | ||
6337 | out: | ||
6338 | |||
6339 | gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 6339, GF_LOG_DEBUG , "Returning %d", ret); } while (0); | ||
6340 | return ret; | ||
6341 | } | ||
6342 | |||
6343 | int | ||
6344 | glusterd_to_cli (rpcsvc_request_t *req, gf_cli_rsp *arg, struct iovec *payload, | ||
6345 | int payloadcount, struct iobref *iobref, xdrproc_t xdrproc, | ||
6346 | dict_t *dict) | ||
6347 | { | ||
6348 | int ret = -1; | ||
6349 | char *cmd = NULL((void*)0); | ||
6350 | int op_ret = 0; | ||
6351 | char *op_errstr = NULL((void*)0); | ||
6352 | int op_errno = 0; | ||
6353 | xlator_t *this = NULL((void*)0); | ||
6354 | |||
6355 | this = THIS(*__glusterfs_this_location()); | ||
6356 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6356, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
6357 | |||
6358 | op_ret = arg->op_ret; | ||
6359 | op_errstr = arg->op_errstr; | ||
6360 | op_errno = arg->op_errno; | ||
6361 | |||
6362 | ret = dict_get_str (dict, "cmd-str", &cmd); | ||
6363 | if (ret) | ||
6364 | gf_log (this->name, GF_LOG_ERROR, "Failed to get command "do { do { if (0) printf ("Failed to get command " "string"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6365, GF_LOG_ERROR, "Failed to get command " "string"); } while (0) | ||
6365 | "string")do { do { if (0) printf ("Failed to get command " "string"); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 6365, GF_LOG_ERROR, "Failed to get command " "string"); } while (0); | ||
6366 | |||
6367 | if (cmd) { | ||
6368 | if (op_ret) | ||
6369 | gf_cmd_log ("", "%s : FAILED %s %s", cmd, | ||
6370 | (op_errstr)? ":" : " ", | ||
6371 | (op_errstr)? op_errstr : " "); | ||
6372 | else | ||
6373 | gf_cmd_log ("", "%s : SUCCESS", cmd); | ||
6374 | } | ||
6375 | |||
6376 | glusterd_submit_reply (req, arg, payload, payloadcount, iobref, | ||
6377 | (xdrproc_t) xdrproc); | ||
6378 | if (dict) | ||
6379 | dict_unref (dict); | ||
6380 | |||
6381 | return ret; | ||
6382 | } | ||
6383 | |||
6384 | static int32_t | ||
6385 | glusterd_append_gsync_status (dict_t *dst, dict_t *src) | ||
6386 | { | ||
6387 | int ret = 0; | ||
6388 | char *stop_msg = NULL((void*)0); | ||
6389 | |||
6390 | ret = dict_get_str (src, "gsync-status", &stop_msg); | ||
6391 | if (ret) { | ||
6392 | ret = 0; | ||
6393 | goto out; | ||
6394 | } | ||
6395 | |||
6396 | ret = dict_set_dynstr (dst, "gsync-status", gf_strdup (stop_msg)); | ||
6397 | if (ret) { | ||
6398 | gf_log ("glusterd", GF_LOG_WARNING, "Unable to set the stop"do { do { if (0) printf ("Unable to set the stop" "message in the ctx dictionary" ); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__ , 6399, GF_LOG_WARNING, "Unable to set the stop" "message in the ctx dictionary" ); } while (0) | ||
6399 | "message in the ctx dictionary")do { do { if (0) printf ("Unable to set the stop" "message in the ctx dictionary" ); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__ , 6399, GF_LOG_WARNING, "Unable to set the stop" "message in the ctx dictionary" ); } while (0); | ||
6400 | goto out; | ||
6401 | } | ||
6402 | |||
6403 | ret = 0; | ||
6404 | out: | ||
6405 | gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("glusterd", "glusterd-utils.c", __FUNCTION__, 6405, GF_LOG_DEBUG , "Returning %d", ret); } while (0); | ||
6406 | return ret; | ||
6407 | |||
6408 | } | ||
6409 | |||
6410 | static int32_t | ||
6411 | glusterd_append_status_dicts (dict_t *dst, dict_t *src) | ||
6412 | { | ||
6413 | int dst_count = 0; | ||
6414 | int src_count = 0; | ||
6415 | int i = 0; | ||
6416 | int ret = 0; | ||
6417 | char mst[PATH_MAX4096] = {0,}; | ||
6418 | char slv[PATH_MAX4096] = {0, }; | ||
6419 | char sts[PATH_MAX4096] = {0, }; | ||
6420 | char nds[PATH_MAX4096] = {0, }; | ||
6421 | char *mst_val = NULL((void*)0); | ||
6422 | char *slv_val = NULL((void*)0); | ||
6423 | char *sts_val = NULL((void*)0); | ||
6424 | char *nds_val = NULL((void*)0); | ||
6425 | |||
6426 | GF_ASSERT (dst)do { if (!(dst)) { do { do { if (0) printf ("Assertion failed: " "dst"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6426, GF_LOG_ERROR, "Assertion failed: " "dst" ); } while (0); } } while (0); | ||
6427 | |||
6428 | if (src == NULL((void*)0)) | ||
6429 | goto out; | ||
6430 | |||
6431 | ret = dict_get_int32 (dst, "gsync-count", &dst_count); | ||
6432 | if (ret) | ||
6433 | dst_count = 0; | ||
6434 | |||
6435 | ret = dict_get_int32 (src, "gsync-count", &src_count); | ||
6436 | if (ret || !src_count) { | ||
6437 | gf_log ("", GF_LOG_DEBUG, "Source brick empty")do { do { if (0) printf ("Source brick empty"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6437, GF_LOG_DEBUG, "Source brick empty" ); } while (0); | ||
6438 | ret = 0; | ||
6439 | goto out; | ||
6440 | } | ||
6441 | |||
6442 | for (i = 1; i <= src_count; i++) { | ||
6443 | snprintf (nds, sizeof(nds), "node%d", i); | ||
6444 | snprintf (mst, sizeof(mst), "master%d", i); | ||
6445 | snprintf (slv, sizeof(slv), "slave%d", i); | ||
6446 | snprintf (sts, sizeof(sts), "status%d", i); | ||
6447 | |||
6448 | ret = dict_get_str (src, nds, &nds_val); | ||
6449 | if (ret) | ||
6450 | goto out; | ||
6451 | |||
6452 | ret = dict_get_str (src, mst, &mst_val); | ||
6453 | if (ret) | ||
6454 | goto out; | ||
6455 | |||
6456 | ret = dict_get_str (src, slv, &slv_val); | ||
6457 | if (ret) | ||
6458 | goto out; | ||
6459 | |||
6460 | ret = dict_get_str (src, sts, &sts_val); | ||
6461 | if (ret) | ||
6462 | goto out; | ||
6463 | |||
6464 | snprintf (nds, sizeof(nds), "node%d", i+dst_count); | ||
6465 | snprintf (mst, sizeof(mst), "master%d", i+dst_count); | ||
6466 | snprintf (slv, sizeof(slv), "slave%d", i+dst_count); | ||
6467 | snprintf (sts, sizeof(sts), "status%d", i+dst_count); | ||
6468 | |||
6469 | ret = dict_set_dynstr (dst, nds, gf_strdup (nds_val)); | ||
6470 | if (ret) | ||
6471 | goto out; | ||
6472 | |||
6473 | ret = dict_set_dynstr (dst, mst, gf_strdup (mst_val)); | ||
6474 | if (ret) | ||
6475 | goto out; | ||
6476 | |||
6477 | ret = dict_set_dynstr (dst, slv, gf_strdup (slv_val)); | ||
6478 | if (ret) | ||
6479 | goto out; | ||
6480 | |||
6481 | ret = dict_set_dynstr (dst, sts, gf_strdup (sts_val)); | ||
6482 | if (ret) | ||
6483 | goto out; | ||
6484 | |||
6485 | } | ||
6486 | |||
6487 | ret = dict_set_int32 (dst, "gsync-count", dst_count+src_count); | ||
6488 | |||
6489 | out: | ||
6490 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6490, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | ||
6491 | return ret; | ||
6492 | |||
6493 | } | ||
6494 | |||
6495 | int32_t | ||
6496 | glusterd_gsync_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict, char *op_errstr) | ||
6497 | { | ||
6498 | dict_t *ctx = NULL((void*)0); | ||
6499 | int ret = 0; | ||
6500 | |||
6501 | if (aggr) { | ||
6502 | ctx = aggr; | ||
6503 | |||
6504 | } else { | ||
6505 | ctx = glusterd_op_get_ctx (); | ||
6506 | if (!ctx) { | ||
6507 | gf_log ("", GF_LOG_ERROR,do { do { if (0) printf ("Operation Context is not present"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6508 , GF_LOG_ERROR, "Operation Context is not present"); } while ( 0) | ||
6508 | "Operation Context is not present")do { do { if (0) printf ("Operation Context is not present"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6508 , GF_LOG_ERROR, "Operation Context is not present"); } while ( 0); | ||
6509 | GF_ASSERT (0)do { if (!(0)) { do { do { if (0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6509, GF_LOG_ERROR, "Assertion failed: " "0") ; } while (0); } } while (0); | ||
6510 | } | ||
6511 | } | ||
6512 | |||
6513 | if (rsp_dict) { | ||
6514 | ret = glusterd_append_status_dicts (ctx, rsp_dict); | ||
6515 | if (ret) | ||
6516 | goto out; | ||
6517 | |||
6518 | ret = glusterd_append_gsync_status (ctx, rsp_dict); | ||
6519 | if (ret) | ||
6520 | goto out; | ||
6521 | } | ||
6522 | if ((op_errstr) && (strcmp ("", op_errstr))) { | ||
6523 | ret = dict_set_dynstr (ctx, "errstr", gf_strdup(op_errstr)); | ||
6524 | if (ret) | ||
6525 | goto out; | ||
6526 | } | ||
6527 | |||
6528 | ret = 0; | ||
6529 | out: | ||
6530 | gf_log ("", GF_LOG_DEBUG, "Returning %d ", ret)do { do { if (0) printf ("Returning %d ", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6530, GF_LOG_DEBUG, "Returning %d " , ret); } while (0); | ||
6531 | return ret; | ||
6532 | } | ||
6533 | |||
6534 | int32_t | ||
6535 | glusterd_rb_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict) | ||
6536 | { | ||
6537 | int32_t src_port = 0; | ||
6538 | int32_t dst_port = 0; | ||
6539 | int ret = 0; | ||
6540 | dict_t *ctx = NULL((void*)0); | ||
6541 | |||
6542 | |||
6543 | if (aggr) { | ||
6544 | ctx = aggr; | ||
6545 | |||
6546 | } else { | ||
6547 | ctx = glusterd_op_get_ctx (); | ||
6548 | if (!ctx) { | ||
6549 | gf_log ("", GF_LOG_ERROR,do { do { if (0) printf ("Operation Context is not present"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6550 , GF_LOG_ERROR, "Operation Context is not present"); } while ( 0) | ||
6550 | "Operation Context is not present")do { do { if (0) printf ("Operation Context is not present"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6550 , GF_LOG_ERROR, "Operation Context is not present"); } while ( 0); | ||
6551 | GF_ASSERT (0)do { if (!(0)) { do { do { if (0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6551, GF_LOG_ERROR, "Assertion failed: " "0") ; } while (0); } } while (0); | ||
6552 | } | ||
6553 | } | ||
6554 | |||
6555 | if (rsp_dict) { | ||
6556 | ret = dict_get_int32 (rsp_dict, "src-brick-port", &src_port); | ||
6557 | if (ret == 0) { | ||
6558 | gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("src-brick-port=%d found", src_port) ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6559, GF_LOG_DEBUG, "src-brick-port=%d found", src_port); } while (0) | ||
6559 | "src-brick-port=%d found", src_port)do { do { if (0) printf ("src-brick-port=%d found", src_port) ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6559, GF_LOG_DEBUG, "src-brick-port=%d found", src_port); } while (0); | ||
6560 | } | ||
6561 | |||
6562 | ret = dict_get_int32 (rsp_dict, "dst-brick-port", &dst_port); | ||
6563 | if (ret == 0) { | ||
6564 | gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("dst-brick-port=%d found", dst_port) ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6565, GF_LOG_DEBUG, "dst-brick-port=%d found", dst_port); } while (0) | ||
6565 | "dst-brick-port=%d found", dst_port)do { do { if (0) printf ("dst-brick-port=%d found", dst_port) ; } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6565, GF_LOG_DEBUG, "dst-brick-port=%d found", dst_port); } while (0); | ||
6566 | } | ||
6567 | |||
6568 | } | ||
6569 | |||
6570 | if (src_port) { | ||
6571 | ret = dict_set_int32 (ctx, "src-brick-port", | ||
6572 | src_port); | ||
6573 | if (ret) { | ||
6574 | gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("Could not set src-brick"); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6575, GF_LOG_DEBUG , "Could not set src-brick"); } while (0) | ||
6575 | "Could not set src-brick")do { do { if (0) printf ("Could not set src-brick"); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6575, GF_LOG_DEBUG , "Could not set src-brick"); } while (0); | ||
6576 | goto out; | ||
6577 | } | ||
6578 | } | ||
6579 | |||
6580 | if (dst_port) { | ||
6581 | ret = dict_set_int32 (ctx, "dst-brick-port", | ||
6582 | dst_port); | ||
6583 | if (ret) { | ||
6584 | gf_log ("", GF_LOG_DEBUG,do { do { if (0) printf ("Could not set dst-brick"); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6585, GF_LOG_DEBUG , "Could not set dst-brick"); } while (0) | ||
6585 | "Could not set dst-brick")do { do { if (0) printf ("Could not set dst-brick"); } while ( 0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6585, GF_LOG_DEBUG , "Could not set dst-brick"); } while (0); | ||
6586 | goto out; | ||
6587 | } | ||
6588 | |||
6589 | } | ||
6590 | |||
6591 | out: | ||
6592 | return ret; | ||
6593 | |||
6594 | } | ||
6595 | |||
6596 | int32_t | ||
6597 | glusterd_sync_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict) | ||
6598 | { | ||
6599 | int ret = 0; | ||
6600 | |||
6601 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6601, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
6602 | |||
6603 | if (!rsp_dict) { | ||
6604 | goto out; | ||
6605 | } | ||
6606 | |||
6607 | ret = glusterd_import_friend_volumes (rsp_dict); | ||
6608 | out: | ||
6609 | return ret; | ||
6610 | |||
6611 | } | ||
6612 | |||
6613 | static int | ||
6614 | _profile_volume_add_friend_rsp (dict_t *this, char *key, data_t *value, | ||
6615 | void *data) | ||
6616 | { | ||
6617 | char new_key[256] = {0}; | ||
6618 | glusterd_pr_brick_rsp_conv_t *rsp_ctx = NULL((void*)0); | ||
6619 | data_t *new_value = NULL((void*)0); | ||
6620 | int brick_count = 0; | ||
6621 | char brick_key[256]; | ||
6622 | |||
6623 | if (strcmp (key, "count") == 0) | ||
6624 | return 0; | ||
6625 | sscanf (key, "%d%s", &brick_count, brick_key); | ||
6626 | rsp_ctx = data; | ||
6627 | new_value = data_copy (value); | ||
6628 | GF_ASSERT (new_value)do { if (!(new_value)) { do { do { if (0) printf ("Assertion failed: " "new_value"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6628, GF_LOG_ERROR, "Assertion failed: " "new_value" ); } while (0); } } while (0); | ||
6629 | snprintf (new_key, sizeof (new_key), "%d%s", | ||
6630 | rsp_ctx->count + brick_count, brick_key); | ||
6631 | dict_set (rsp_ctx->dict, new_key, new_value); | ||
6632 | return 0; | ||
6633 | } | ||
6634 | |||
6635 | int | ||
6636 | glusterd_profile_volume_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict) | ||
6637 | { | ||
6638 | int ret = 0; | ||
6639 | glusterd_pr_brick_rsp_conv_t rsp_ctx = {0}; | ||
6640 | int32_t brick_count = 0; | ||
6641 | int32_t count = 0; | ||
6642 | dict_t *ctx_dict = NULL((void*)0); | ||
6643 | glusterd_op_t op = GD_OP_NONE; | ||
6644 | |||
6645 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6645, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
6646 | |||
6647 | ret = dict_get_int32 (rsp_dict, "count", &brick_count); | ||
6648 | if (ret) { | ||
6649 | ret = 0; //no bricks in the rsp | ||
6650 | goto out; | ||
6651 | } | ||
6652 | |||
6653 | op = glusterd_op_get_op (); | ||
6654 | GF_ASSERT (GD_OP_PROFILE_VOLUME == op)do { if (!(GD_OP_PROFILE_VOLUME == op)) { do { do { if (0) printf ("Assertion failed: " "GD_OP_PROFILE_VOLUME == op"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c", __FUNCTION__ , 6654, GF_LOG_ERROR, "Assertion failed: " "GD_OP_PROFILE_VOLUME == op" ); } while (0); } } while (0); | ||
6655 | if (aggr) { | ||
6656 | ctx_dict = aggr; | ||
6657 | |||
6658 | } else { | ||
6659 | ctx_dict = glusterd_op_get_ctx (); | ||
6660 | } | ||
6661 | |||
6662 | ret = dict_get_int32 (ctx_dict, "count", &count); | ||
6663 | rsp_ctx.count = count; | ||
6664 | rsp_ctx.dict = ctx_dict; | ||
6665 | dict_foreach (rsp_dict, _profile_volume_add_friend_rsp, &rsp_ctx); | ||
6666 | dict_del (ctx_dict, "count"); | ||
6667 | ret = dict_set_int32 (ctx_dict, "count", count + brick_count); | ||
6668 | out: | ||
6669 | return ret; | ||
6670 | } | ||
6671 | |||
6672 | static int | ||
6673 | glusterd_volume_status_add_peer_rsp (dict_t *this, char *key, data_t *value, | ||
6674 | void *data) | ||
6675 | { | ||
6676 | glusterd_status_rsp_conv_t *rsp_ctx = NULL((void*)0); | ||
6677 | data_t *new_value = NULL((void*)0); | ||
6678 | char brick_key[1024] = {0,}; | ||
6679 | char new_key[1024] = {0,}; | ||
6680 | int32_t index = 0; | ||
6681 | int32_t ret = 0; | ||
6682 | |||
6683 | /* Skip the following keys, they are already present in the ctx_dict */ | ||
6684 | if (!strcmp (key, "count") || !strcmp (key, "cmd") || | ||
6685 | !strcmp (key, "brick-index-max") || !strcmp (key, "other-count")) | ||
6686 | return 0; | ||
6687 | |||
6688 | rsp_ctx = data; | ||
6689 | new_value = data_copy (value); | ||
6690 | GF_ASSERT (new_value)do { if (!(new_value)) { do { do { if (0) printf ("Assertion failed: " "new_value"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6690, GF_LOG_ERROR, "Assertion failed: " "new_value" ); } while (0); } } while (0); | ||
6691 | |||
6692 | sscanf (key, "brick%d.%s", &index, brick_key); | ||
6693 | |||
6694 | if (index > rsp_ctx->brick_index_max) { | ||
6695 | snprintf (new_key, sizeof (new_key), "brick%d.%s", | ||
6696 | index + rsp_ctx->other_count, brick_key); | ||
6697 | } else { | ||
6698 | strncpy (new_key, key, sizeof (new_key)); | ||
6699 | new_key[sizeof (new_key) - 1] = 0; | ||
6700 | } | ||
6701 | |||
6702 | ret = dict_set (rsp_ctx->dict, new_key, new_value); | ||
6703 | if (ret) | ||
6704 | gf_log ("", GF_LOG_ERROR, "Unable to set key: %s in dict",do { do { if (0) printf ("Unable to set key: %s in dict", key ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 6705, GF_LOG_ERROR, "Unable to set key: %s in dict", key); } while (0) | ||
6705 | key)do { do { if (0) printf ("Unable to set key: %s in dict", key ); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__ , 6705, GF_LOG_ERROR, "Unable to set key: %s in dict", key); } while (0); | ||
6706 | |||
6707 | return 0; | ||
6708 | } | ||
6709 | |||
6710 | int | ||
6711 | glusterd_volume_status_copy_to_op_ctx_dict (dict_t *aggr, dict_t *rsp_dict) | ||
6712 | { | ||
6713 | int ret = 0; | ||
6714 | glusterd_status_rsp_conv_t rsp_ctx = {0}; | ||
6715 | int32_t cmd = GF_CLI_STATUS_NONE; | ||
6716 | int32_t node_count = 0; | ||
6717 | int32_t other_count = 0; | ||
6718 | int32_t brick_index_max = -1; | ||
6719 | int32_t rsp_node_count = 0; | ||
6720 | int32_t rsp_other_count = 0; | ||
6721 | int vol_count = -1; | ||
6722 | int i = 0; | ||
6723 | dict_t *ctx_dict = NULL((void*)0); | ||
6724 | char key[PATH_MAX4096] = {0,}; | ||
6725 | char *volname = NULL((void*)0); | ||
6726 | |||
6727 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6727, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
6728 | |||
6729 | if (aggr) { | ||
6730 | ctx_dict = aggr; | ||
6731 | |||
6732 | } else { | ||
6733 | ctx_dict = glusterd_op_get_ctx (GD_OP_STATUS_VOLUME); | ||
6734 | |||
6735 | } | ||
6736 | |||
6737 | ret = dict_get_int32 (ctx_dict, "cmd", &cmd); | ||
6738 | if (ret) | ||
6739 | goto out; | ||
6740 | |||
6741 | if (cmd & GF_CLI_STATUS_ALL && is_origin_glusterd ()) { | ||
6742 | ret = dict_get_int32 (rsp_dict, "vol_count", &vol_count); | ||
6743 | if (ret == 0) { | ||
6744 | ret = dict_set_int32 (ctx_dict, "vol_count", | ||
6745 | vol_count); | ||
6746 | if (ret) | ||
6747 | goto out; | ||
6748 | |||
6749 | for (i = 0; i < vol_count; i++) { | ||
6750 | memset (key, 0, sizeof (key)); | ||
6751 | snprintf (key, sizeof (key), "vol%d", i); | ||
6752 | ret = dict_get_str (rsp_dict, key, &volname); | ||
6753 | if (ret) | ||
6754 | goto out; | ||
6755 | |||
6756 | ret = dict_set_str (ctx_dict, key, volname); | ||
6757 | if (ret) | ||
6758 | goto out; | ||
6759 | } | ||
6760 | } | ||
6761 | } | ||
6762 | |||
6763 | ret = dict_get_int32 (rsp_dict, "count", &rsp_node_count); | ||
6764 | if (ret) { | ||
6765 | ret = 0; //no bricks in the rsp | ||
6766 | goto out; | ||
6767 | } | ||
6768 | |||
6769 | ret = dict_get_int32 (rsp_dict, "other-count", &rsp_other_count); | ||
6770 | if (ret) { | ||
6771 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("Failed to get other count from rsp_dict" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 6772, GF_LOG_ERROR, "Failed to get other count from rsp_dict" ); } while (0) | ||
6772 | "Failed to get other count from rsp_dict")do { do { if (0) printf ("Failed to get other count from rsp_dict" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 6772, GF_LOG_ERROR, "Failed to get other count from rsp_dict" ); } while (0); | ||
6773 | goto out; | ||
6774 | } | ||
6775 | |||
6776 | ret = dict_get_int32 (ctx_dict, "count", &node_count); | ||
6777 | ret = dict_get_int32 (ctx_dict, "other-count", &other_count); | ||
6778 | if (!dict_get (ctx_dict, "brick-index-max")) { | ||
6779 | ret = dict_get_int32 (rsp_dict, "brick-index-max", &brick_index_max); | ||
6780 | if (ret) | ||
6781 | goto out; | ||
6782 | ret = dict_set_int32 (ctx_dict, "brick-index-max", brick_index_max); | ||
6783 | if (ret) | ||
6784 | goto out; | ||
6785 | |||
6786 | } else { | ||
6787 | ret = dict_get_int32 (ctx_dict, "brick-index-max", &brick_index_max); | ||
6788 | } | ||
6789 | |||
6790 | rsp_ctx.count = node_count; | ||
6791 | rsp_ctx.brick_index_max = brick_index_max; | ||
6792 | rsp_ctx.other_count = other_count; | ||
6793 | rsp_ctx.dict = ctx_dict; | ||
6794 | |||
6795 | dict_foreach (rsp_dict, glusterd_volume_status_add_peer_rsp, &rsp_ctx); | ||
6796 | |||
6797 | ret = dict_set_int32 (ctx_dict, "count", node_count + rsp_node_count); | ||
6798 | if (ret) { | ||
6799 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("Failed to update node count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6800, GF_LOG_ERROR, "Failed to update node count" ); } while (0) | ||
6800 | "Failed to update node count")do { do { if (0) printf ("Failed to update node count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6800, GF_LOG_ERROR, "Failed to update node count" ); } while (0); | ||
6801 | goto out; | ||
6802 | } | ||
6803 | |||
6804 | ret = dict_set_int32 (ctx_dict, "other-count", | ||
6805 | (other_count + rsp_other_count)); | ||
6806 | if (ret) | ||
6807 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("Failed to update other-count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6808, GF_LOG_ERROR, "Failed to update other-count" ); } while (0) | ||
6808 | "Failed to update other-count")do { do { if (0) printf ("Failed to update other-count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6808, GF_LOG_ERROR, "Failed to update other-count" ); } while (0); | ||
6809 | out: | ||
6810 | return ret; | ||
6811 | } | ||
6812 | |||
6813 | int | ||
6814 | glusterd_volume_rebalance_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict) | ||
6815 | { | ||
6816 | char key[256] = {0,}; | ||
6817 | char *node_uuid = NULL((void*)0); | ||
6818 | char *node_uuid_str = NULL((void*)0); | ||
6819 | char *volname = NULL((void*)0); | ||
6820 | dict_t *ctx_dict = NULL((void*)0); | ||
6821 | double elapsed_time = 0; | ||
6822 | glusterd_conf_t *conf = NULL((void*)0); | ||
6823 | glusterd_op_t op = GD_OP_NONE; | ||
6824 | glusterd_peerinfo_t *peerinfo = NULL((void*)0); | ||
6825 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
6826 | int ret = 0; | ||
6827 | int32_t index = 0; | ||
6828 | int32_t count = 0; | ||
6829 | int32_t current_index = 2; | ||
6830 | int32_t value32 = 0; | ||
6831 | uint64_t value = 0; | ||
6832 | |||
6833 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6833, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
6834 | conf = THIS(*__glusterfs_this_location())->private; | ||
6835 | |||
6836 | op = glusterd_op_get_op (); | ||
6837 | GF_ASSERT ((GD_OP_REBALANCE == op) ||do { if (!((GD_OP_REBALANCE == op) || (GD_OP_DEFRAG_BRICK_VOLUME == op))) { do { do { if (0) printf ("Assertion failed: " "(GD_OP_REBALANCE == op) || (GD_OP_DEFRAG_BRICK_VOLUME == op)" ); } while (0); _gf_log_callingfn ("", "glusterd-utils.c", __FUNCTION__ , 6838, GF_LOG_ERROR, "Assertion failed: " "(GD_OP_REBALANCE == op) || (GD_OP_DEFRAG_BRICK_VOLUME == op)" ); } while (0); } } while (0) | ||
6838 | (GD_OP_DEFRAG_BRICK_VOLUME == op))do { if (!((GD_OP_REBALANCE == op) || (GD_OP_DEFRAG_BRICK_VOLUME == op))) { do { do { if (0) printf ("Assertion failed: " "(GD_OP_REBALANCE == op) || (GD_OP_DEFRAG_BRICK_VOLUME == op)" ); } while (0); _gf_log_callingfn ("", "glusterd-utils.c", __FUNCTION__ , 6838, GF_LOG_ERROR, "Assertion failed: " "(GD_OP_REBALANCE == op) || (GD_OP_DEFRAG_BRICK_VOLUME == op)" ); } while (0); } } while (0); | ||
6839 | |||
6840 | if (aggr) { | ||
6841 | ctx_dict = aggr; | ||
6842 | |||
6843 | } else { | ||
6844 | ctx_dict = glusterd_op_get_ctx (op); | ||
6845 | |||
6846 | } | ||
6847 | |||
6848 | if (!ctx_dict) | ||
6849 | goto out; | ||
6850 | |||
6851 | ret = dict_get_str (ctx_dict, "volname", &volname); | ||
6852 | if (ret) { | ||
6853 | gf_log ("", GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6853, GF_LOG_ERROR , "Unable to get volume name"); } while (0); | ||
6854 | goto out; | ||
6855 | } | ||
6856 | |||
6857 | ret = glusterd_volinfo_find (volname, &volinfo); | ||
6858 | |||
6859 | if (ret) | ||
6860 | goto out; | ||
6861 | |||
6862 | ret = dict_get_int32 (rsp_dict, "count", &index); | ||
6863 | if (ret) | ||
6864 | gf_log ("", GF_LOG_ERROR, "failed to get index")do { do { if (0) printf ("failed to get index"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6864, GF_LOG_ERROR , "failed to get index"); } while (0); | ||
6865 | |||
6866 | memset (key, 0, 256); | ||
6867 | snprintf (key, 256, "node-uuid-%d", index); | ||
6868 | ret = dict_get_str (rsp_dict, key, &node_uuid); | ||
6869 | if (!ret) { | ||
6870 | node_uuid_str = gf_strdup (node_uuid); | ||
6871 | |||
6872 | /* Finding the index of the node-uuid in the peer-list */ | ||
6873 | list_for_each_entry (peerinfo, &conf->peers, uuid_list)for (peerinfo = ((typeof(*peerinfo) *)((char *)((&conf-> peers)->next)-(unsigned long)(&((typeof(*peerinfo) *)0 )->uuid_list))); &peerinfo->uuid_list != (&conf ->peers); peerinfo = ((typeof(*peerinfo) *)((char *)(peerinfo ->uuid_list.next)-(unsigned long)(&((typeof(*peerinfo) *)0)->uuid_list)))) { | ||
6874 | if (!strcmp(peerinfo->uuid_str, node_uuid_str)){ | ||
6875 | break; | ||
6876 | } | ||
6877 | current_index++; | ||
6878 | } | ||
6879 | |||
6880 | /* Setting the largest index value as the total count. */ | ||
6881 | ret = dict_get_int32 (ctx_dict, "count", &count); | ||
6882 | if (count < current_index) { | ||
6883 | ret = dict_set_int32 (ctx_dict, "count", current_index); | ||
6884 | if (ret) | ||
6885 | gf_log ("", GF_LOG_ERROR, "Failed to set count")do { do { if (0) printf ("Failed to set count"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 6885, GF_LOG_ERROR , "Failed to set count"); } while (0); | ||
6886 | } | ||
6887 | |||
6888 | /* Setting the same index for the node, as is in the peerlist.*/ | ||
6889 | memset (key, 0, 256); | ||
6890 | snprintf (key, 256, "node-uuid-%d", current_index); | ||
6891 | ret = dict_set_dynstr (ctx_dict, key, node_uuid_str); | ||
6892 | if (ret) { | ||
6893 | gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("failed to set node-uuid"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6894, GF_LOG_DEBUG, "failed to set node-uuid" ); } while (0) | ||
6894 | "failed to set node-uuid")do { do { if (0) printf ("failed to set node-uuid"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6894, GF_LOG_DEBUG, "failed to set node-uuid" ); } while (0); | ||
6895 | } | ||
6896 | } | ||
6897 | |||
6898 | snprintf (key, 256, "files-%d", index); | ||
6899 | ret = dict_get_uint64 (rsp_dict, key, &value); | ||
6900 | if (!ret) { | ||
6901 | memset (key, 0, 256); | ||
6902 | snprintf (key, 256, "files-%d", current_index); | ||
6903 | ret = dict_set_uint64 (ctx_dict, key, value); | ||
6904 | if (ret) { | ||
6905 | gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("failed to set the file count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6906, GF_LOG_DEBUG, "failed to set the file count" ); } while (0) | ||
6906 | "failed to set the file count")do { do { if (0) printf ("failed to set the file count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6906, GF_LOG_DEBUG, "failed to set the file count" ); } while (0); | ||
6907 | } | ||
6908 | } | ||
6909 | |||
6910 | memset (key, 0, 256); | ||
6911 | snprintf (key, 256, "size-%d", index); | ||
6912 | ret = dict_get_uint64 (rsp_dict, key, &value); | ||
6913 | if (!ret) { | ||
6914 | memset (key, 0, 256); | ||
6915 | snprintf (key, 256, "size-%d", current_index); | ||
6916 | ret = dict_set_uint64 (ctx_dict, key, value); | ||
6917 | if (ret) { | ||
6918 | gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("failed to set the size of migration" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 6919, GF_LOG_DEBUG, "failed to set the size of migration" ); } while (0) | ||
6919 | "failed to set the size of migration")do { do { if (0) printf ("failed to set the size of migration" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 6919, GF_LOG_DEBUG, "failed to set the size of migration" ); } while (0); | ||
6920 | } | ||
6921 | } | ||
6922 | |||
6923 | memset (key, 0, 256); | ||
6924 | snprintf (key, 256, "lookups-%d", index); | ||
6925 | ret = dict_get_uint64 (rsp_dict, key, &value); | ||
6926 | if (!ret) { | ||
6927 | memset (key, 0, 256); | ||
6928 | snprintf (key, 256, "lookups-%d", current_index); | ||
6929 | ret = dict_set_uint64 (ctx_dict, key, value); | ||
6930 | if (ret) { | ||
6931 | gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("failed to set lookuped file count") ; } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 6932, GF_LOG_DEBUG, "failed to set lookuped file count" ); } while (0) | ||
6932 | "failed to set lookuped file count")do { do { if (0) printf ("failed to set lookuped file count") ; } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 6932, GF_LOG_DEBUG, "failed to set lookuped file count" ); } while (0); | ||
6933 | } | ||
6934 | } | ||
6935 | |||
6936 | memset (key, 0, 256); | ||
6937 | snprintf (key, 256, "status-%d", index); | ||
6938 | ret = dict_get_int32 (rsp_dict, key, &value32); | ||
6939 | if (!ret) { | ||
6940 | memset (key, 0, 256); | ||
6941 | snprintf (key, 256, "status-%d", current_index); | ||
6942 | ret = dict_set_int32 (ctx_dict, key, value32); | ||
6943 | if (ret) { | ||
6944 | gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("failed to set status"); } while (0) ; _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6945, GF_LOG_DEBUG, "failed to set status"); } while (0) | ||
6945 | "failed to set status")do { do { if (0) printf ("failed to set status"); } while (0) ; _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6945, GF_LOG_DEBUG, "failed to set status"); } while (0); | ||
6946 | } | ||
6947 | } | ||
6948 | |||
6949 | memset (key, 0, 256); | ||
6950 | snprintf (key, 256, "failures-%d", index); | ||
6951 | ret = dict_get_uint64 (rsp_dict, key, &value); | ||
6952 | if (!ret) { | ||
6953 | memset (key, 0, 256); | ||
6954 | snprintf (key, 256, "failures-%d", current_index); | ||
6955 | ret = dict_set_uint64 (ctx_dict, key, value); | ||
6956 | if (ret) { | ||
6957 | gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("failed to set failure count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6958, GF_LOG_DEBUG, "failed to set failure count" ); } while (0) | ||
6958 | "failed to set failure count")do { do { if (0) printf ("failed to set failure count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6958, GF_LOG_DEBUG, "failed to set failure count" ); } while (0); | ||
6959 | } | ||
6960 | } | ||
6961 | |||
6962 | memset (key, 0, 256); | ||
6963 | snprintf (key, 256, "run-time-%d", index); | ||
6964 | ret = dict_get_double (rsp_dict, key, &elapsed_time); | ||
6965 | if (!ret) { | ||
6966 | memset (key, 0, 256); | ||
6967 | snprintf (key, 256, "run-time-%d", current_index); | ||
6968 | ret = dict_set_double (ctx_dict, key, elapsed_time); | ||
6969 | if (ret) { | ||
6970 | gf_log (THIS->name, GF_LOG_DEBUG,do { do { if (0) printf ("failed to set run-time"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6971, GF_LOG_DEBUG, "failed to set run-time") ; } while (0) | ||
6971 | "failed to set run-time")do { do { if (0) printf ("failed to set run-time"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 6971, GF_LOG_DEBUG, "failed to set run-time") ; } while (0); | ||
6972 | } | ||
6973 | } | ||
6974 | |||
6975 | ret = 0; | ||
6976 | |||
6977 | out: | ||
6978 | return ret; | ||
6979 | } | ||
6980 | |||
6981 | int | ||
6982 | glusterd_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict) | ||
6983 | { | ||
6984 | int ret = 0; | ||
6985 | glusterd_op_t op = GD_OP_NONE; | ||
6986 | |||
6987 | op = glusterd_op_get_op (); | ||
6988 | GF_ASSERT (aggr)do { if (!(aggr)) { do { do { if (0) printf ("Assertion failed: " "aggr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6988, GF_LOG_ERROR, "Assertion failed: " "aggr" ); } while (0); } } while (0); | ||
6989 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 6989, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
6990 | |||
6991 | if (!aggr) | ||
6992 | goto out; | ||
6993 | dict_copy (rsp_dict, aggr); | ||
6994 | out: | ||
6995 | return ret; | ||
6996 | } | ||
6997 | |||
6998 | int | ||
6999 | glusterd_volume_heal_use_rsp_dict (dict_t *aggr, dict_t *rsp_dict) | ||
7000 | { | ||
7001 | int ret = 0; | ||
7002 | dict_t *ctx_dict = NULL((void*)0); | ||
7003 | glusterd_op_t op = GD_OP_NONE; | ||
7004 | |||
7005 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7005, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
7006 | |||
7007 | op = glusterd_op_get_op (); | ||
7008 | GF_ASSERT (GD_OP_HEAL_VOLUME == op)do { if (!(GD_OP_HEAL_VOLUME == op)) { do { do { if (0) printf ("Assertion failed: " "GD_OP_HEAL_VOLUME == op"); } while (0 ); _gf_log_callingfn ("", "glusterd-utils.c", __FUNCTION__, 7008 , GF_LOG_ERROR, "Assertion failed: " "GD_OP_HEAL_VOLUME == op" ); } while (0); } } while (0); | ||
7009 | |||
7010 | if (aggr) { | ||
7011 | ctx_dict = aggr; | ||
7012 | |||
7013 | } else { | ||
7014 | ctx_dict = glusterd_op_get_ctx (op); | ||
7015 | } | ||
7016 | |||
7017 | if (!ctx_dict) | ||
7018 | goto out; | ||
7019 | dict_copy (rsp_dict, ctx_dict); | ||
7020 | out: | ||
7021 | return ret; | ||
7022 | } | ||
7023 | |||
7024 | int | ||
7025 | _profile_volume_add_brick_rsp (dict_t *this, char *key, data_t *value, | ||
7026 | void *data) | ||
7027 | { | ||
7028 | char new_key[256] = {0}; | ||
7029 | glusterd_pr_brick_rsp_conv_t *rsp_ctx = NULL((void*)0); | ||
7030 | data_t *new_value = NULL((void*)0); | ||
7031 | |||
7032 | rsp_ctx = data; | ||
7033 | new_value = data_copy (value); | ||
7034 | GF_ASSERT (new_value)do { if (!(new_value)) { do { do { if (0) printf ("Assertion failed: " "new_value"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7034, GF_LOG_ERROR, "Assertion failed: " "new_value" ); } while (0); } } while (0); | ||
7035 | snprintf (new_key, sizeof (new_key), "%d-%s", rsp_ctx->count, key); | ||
7036 | dict_set (rsp_ctx->dict, new_key, new_value); | ||
7037 | return 0; | ||
7038 | } | ||
7039 | |||
7040 | int | ||
7041 | glusterd_profile_volume_brick_rsp (void *pending_entry, | ||
7042 | dict_t *rsp_dict, dict_t *op_ctx, | ||
7043 | char **op_errstr, gd_node_type type) | ||
7044 | { | ||
7045 | int ret = 0; | ||
7046 | glusterd_pr_brick_rsp_conv_t rsp_ctx = {0}; | ||
7047 | int32_t count = 0; | ||
7048 | char brick[PATH_MAX4096+1024] = {0}; | ||
7049 | char key[256] = {0}; | ||
7050 | char *full_brick = NULL((void*)0); | ||
7051 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
7052 | xlator_t *this = NULL((void*)0); | ||
7053 | glusterd_conf_t *priv = NULL((void*)0); | ||
7054 | |||
7055 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7055, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
7056 | GF_ASSERT (op_ctx)do { if (!(op_ctx)) { do { do { if (0) printf ("Assertion failed: " "op_ctx"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7056, GF_LOG_ERROR, "Assertion failed: " "op_ctx" ); } while (0); } } while (0); | ||
7057 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7057, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | ||
7058 | GF_ASSERT (pending_entry)do { if (!(pending_entry)) { do { do { if (0) printf ("Assertion failed: " "pending_entry"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7058, GF_LOG_ERROR, "Assertion failed: " "pending_entry" ); } while (0); } } while (0); | ||
7059 | |||
7060 | this = THIS(*__glusterfs_this_location()); | ||
7061 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7061, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
7062 | priv = this->private; | ||
7063 | GF_ASSERT (priv)do { if (!(priv)) { do { do { if (0) printf ("Assertion failed: " "priv"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7063, GF_LOG_ERROR, "Assertion failed: " "priv" ); } while (0); } } while (0); | ||
7064 | |||
7065 | ret = dict_get_int32 (op_ctx, "count", &count); | ||
7066 | if (ret) { | ||
7067 | count = 1; | ||
7068 | } else { | ||
7069 | count++; | ||
7070 | } | ||
7071 | snprintf (key, sizeof (key), "%d-brick", count); | ||
7072 | if (type == GD_NODE_BRICK) { | ||
7073 | brickinfo = pending_entry; | ||
7074 | snprintf (brick, sizeof (brick), "%s:%s", brickinfo->hostname, | ||
7075 | brickinfo->path); | ||
7076 | } else if (type == GD_NODE_NFS) { | ||
7077 | snprintf (brick, sizeof (brick), "%s", uuid_utoa (MY_UUID(__glusterd_uuid()))); | ||
7078 | } | ||
7079 | full_brick = gf_strdup (brick); | ||
7080 | GF_ASSERT (full_brick)do { if (!(full_brick)) { do { do { if (0) printf ("Assertion failed: " "full_brick"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7080, GF_LOG_ERROR, "Assertion failed: " "full_brick" ); } while (0); } } while (0); | ||
7081 | ret = dict_set_dynstr (op_ctx, key, full_brick); | ||
7082 | |||
7083 | rsp_ctx.count = count; | ||
7084 | rsp_ctx.dict = op_ctx; | ||
7085 | dict_foreach (rsp_dict, _profile_volume_add_brick_rsp, &rsp_ctx); | ||
7086 | dict_del (op_ctx, "count"); | ||
7087 | ret = dict_set_int32 (op_ctx, "count", count); | ||
7088 | return ret; | ||
7089 | } | ||
7090 | |||
7091 | //input-key: <replica-id>:<child-id>-* | ||
7092 | //output-key: <brick-id>-* | ||
7093 | int | ||
7094 | _heal_volume_add_shd_rsp (dict_t *this, char *key, data_t *value, void *data) | ||
7095 | { | ||
7096 | char new_key[256] = {0,}; | ||
7097 | char int_str[16] = {0}; | ||
7098 | data_t *new_value = NULL((void*)0); | ||
7099 | char *rxl_end = NULL((void*)0); | ||
7100 | char *rxl_child_end = NULL((void*)0); | ||
7101 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
7102 | int rxl_id = 0; | ||
7103 | int rxl_child_id = 0; | ||
7104 | int brick_id = 0; | ||
7105 | int int_len = 0; | ||
7106 | int ret = 0; | ||
7107 | glusterd_heal_rsp_conv_t *rsp_ctx = NULL((void*)0); | ||
7108 | glusterd_brickinfo_t *brickinfo = NULL((void*)0); | ||
7109 | |||
7110 | rsp_ctx = data; | ||
7111 | rxl_end = strchr (key, '-'); | ||
7112 | if (!rxl_end) | ||
7113 | goto out; | ||
7114 | |||
7115 | int_len = strlen (key) - strlen (rxl_end); | ||
7116 | strncpy (int_str, key, int_len); | ||
7117 | int_str[int_len] = '\0'; | ||
7118 | ret = gf_string2int (int_str, &rxl_id); | ||
7119 | if (ret) | ||
7120 | goto out; | ||
7121 | |||
7122 | rxl_child_end = strchr (rxl_end + 1, '-'); | ||
7123 | if (!rxl_child_end) | ||
7124 | goto out; | ||
7125 | |||
7126 | int_len = strlen (rxl_end) - strlen (rxl_child_end) - 1; | ||
7127 | strncpy (int_str, rxl_end + 1, int_len); | ||
7128 | int_str[int_len] = '\0'; | ||
7129 | ret = gf_string2int (int_str, &rxl_child_id); | ||
7130 | if (ret) | ||
7131 | goto out; | ||
7132 | |||
7133 | volinfo = rsp_ctx->volinfo; | ||
7134 | brick_id = rxl_id * volinfo->replica_count + rxl_child_id; | ||
7135 | |||
7136 | if (!strcmp (rxl_child_end, "-status")) { | ||
7137 | brickinfo = glusterd_get_brickinfo_by_position (volinfo, | ||
7138 | brick_id); | ||
7139 | if (!brickinfo) | ||
7140 | goto out; | ||
7141 | if (!glusterd_is_local_brick (rsp_ctx->this, volinfo, | ||
7142 | brickinfo)) | ||
7143 | goto out; | ||
7144 | } | ||
7145 | new_value = data_copy (value); | ||
7146 | snprintf (new_key, sizeof (new_key), "%d%s", brick_id, rxl_child_end); | ||
7147 | dict_set (rsp_ctx->dict, new_key, new_value); | ||
7148 | |||
7149 | out: | ||
7150 | return 0; | ||
7151 | } | ||
7152 | |||
7153 | int | ||
7154 | glusterd_heal_volume_brick_rsp (dict_t *req_dict, dict_t *rsp_dict, | ||
7155 | dict_t *op_ctx, char **op_errstr) | ||
7156 | { | ||
7157 | int ret = 0; | ||
7158 | glusterd_heal_rsp_conv_t rsp_ctx = {0}; | ||
7159 | char *volname = NULL((void*)0); | ||
7160 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
7161 | |||
7162 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7162, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
7163 | GF_ASSERT (op_ctx)do { if (!(op_ctx)) { do { do { if (0) printf ("Assertion failed: " "op_ctx"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7163, GF_LOG_ERROR, "Assertion failed: " "op_ctx" ); } while (0); } } while (0); | ||
7164 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7164, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | ||
7165 | |||
7166 | ret = dict_get_str (req_dict, "volname", &volname); | ||
7167 | if (ret) { | ||
7168 | gf_log ("", GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 7168, GF_LOG_ERROR , "Unable to get volume name"); } while (0); | ||
7169 | goto out; | ||
7170 | } | ||
7171 | |||
7172 | ret = glusterd_volinfo_find (volname, &volinfo); | ||
7173 | |||
7174 | if (ret) | ||
7175 | goto out; | ||
7176 | |||
7177 | rsp_ctx.dict = op_ctx; | ||
7178 | rsp_ctx.volinfo = volinfo; | ||
7179 | rsp_ctx.this = THIS(*__glusterfs_this_location()); | ||
7180 | dict_foreach (rsp_dict, _heal_volume_add_shd_rsp, &rsp_ctx); | ||
7181 | |||
7182 | out: | ||
7183 | return ret; | ||
7184 | } | ||
7185 | |||
7186 | int | ||
7187 | _status_volume_add_brick_rsp (dict_t *this, char *key, data_t *value, | ||
7188 | void *data) | ||
7189 | { | ||
7190 | char new_key[256] = {0,}; | ||
7191 | data_t *new_value = 0; | ||
7192 | glusterd_pr_brick_rsp_conv_t *rsp_ctx = NULL((void*)0); | ||
7193 | |||
7194 | rsp_ctx = data; | ||
7195 | new_value = data_copy (value); | ||
7196 | snprintf (new_key, sizeof (new_key), "brick%d.%s", rsp_ctx->count, key); | ||
7197 | dict_set (rsp_ctx->dict, new_key, new_value); | ||
7198 | |||
7199 | return 0; | ||
7200 | } | ||
7201 | |||
7202 | int | ||
7203 | glusterd_status_volume_brick_rsp (dict_t *rsp_dict, dict_t *op_ctx, | ||
7204 | char **op_errstr) | ||
7205 | { | ||
7206 | int ret = 0; | ||
7207 | glusterd_pr_brick_rsp_conv_t rsp_ctx = {0}; | ||
7208 | int32_t count = 0; | ||
7209 | int index = 0; | ||
7210 | |||
7211 | GF_ASSERT (rsp_dict)do { if (!(rsp_dict)) { do { do { if (0) printf ("Assertion failed: " "rsp_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7211, GF_LOG_ERROR, "Assertion failed: " "rsp_dict" ); } while (0); } } while (0); | ||
7212 | GF_ASSERT (op_ctx)do { if (!(op_ctx)) { do { do { if (0) printf ("Assertion failed: " "op_ctx"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7212, GF_LOG_ERROR, "Assertion failed: " "op_ctx" ); } while (0); } } while (0); | ||
7213 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7213, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | ||
7214 | |||
7215 | ret = dict_get_int32 (op_ctx, "count", &count); | ||
7216 | if (ret) { | ||
7217 | count = 0; | ||
7218 | } else { | ||
7219 | count++; | ||
7220 | } | ||
7221 | ret = dict_get_int32 (rsp_dict, "index", &index); | ||
7222 | if (ret) { | ||
7223 | gf_log (THIS->name, GF_LOG_ERROR, "Couldn't get node index")do { do { if (0) printf ("Couldn't get node index"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7223, GF_LOG_ERROR, "Couldn't get node index" ); } while (0); | ||
7224 | goto out; | ||
7225 | } | ||
7226 | dict_del (rsp_dict, "index"); | ||
7227 | |||
7228 | rsp_ctx.count = index; | ||
7229 | rsp_ctx.dict = op_ctx; | ||
7230 | dict_foreach (rsp_dict, _status_volume_add_brick_rsp, &rsp_ctx); | ||
7231 | ret = dict_set_int32 (op_ctx, "count", count); | ||
7232 | |||
7233 | out: | ||
7234 | return ret; | ||
7235 | } | ||
7236 | |||
7237 | int | ||
7238 | glusterd_defrag_volume_node_rsp (dict_t *req_dict, dict_t *rsp_dict, | ||
7239 | dict_t *op_ctx) | ||
7240 | { | ||
7241 | int ret = 0; | ||
7242 | char *volname = NULL((void*)0); | ||
7243 | glusterd_volinfo_t *volinfo = NULL((void*)0); | ||
7244 | char key[256] = {0,}; | ||
7245 | int32_t i = 0; | ||
7246 | char buf[1024] = {0,}; | ||
7247 | char *node_str = NULL((void*)0); | ||
7248 | glusterd_conf_t *priv = NULL((void*)0); | ||
7249 | |||
7250 | priv = THIS(*__glusterfs_this_location())->private; | ||
7251 | GF_ASSERT (req_dict)do { if (!(req_dict)) { do { do { if (0) printf ("Assertion failed: " "req_dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7251, GF_LOG_ERROR, "Assertion failed: " "req_dict" ); } while (0); } } while (0); | ||
7252 | |||
7253 | ret = dict_get_str (req_dict, "volname", &volname); | ||
7254 | if (ret) { | ||
7255 | gf_log ("", GF_LOG_ERROR, "Unable to get volume name")do { do { if (0) printf ("Unable to get volume name"); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 7255, GF_LOG_ERROR , "Unable to get volume name"); } while (0); | ||
7256 | goto out; | ||
7257 | } | ||
7258 | |||
7259 | ret = glusterd_volinfo_find (volname, &volinfo); | ||
7260 | |||
7261 | if (ret) | ||
7262 | goto out; | ||
7263 | |||
7264 | if (rsp_dict) { | ||
7265 | ret = glusterd_defrag_volume_status_update (volinfo, | ||
7266 | rsp_dict); | ||
7267 | } | ||
7268 | |||
7269 | if (!op_ctx) { | ||
7270 | dict_copy (rsp_dict, op_ctx); | ||
7271 | goto out; | ||
7272 | } | ||
7273 | |||
7274 | ret = dict_get_int32 (op_ctx, "count", &i); | ||
7275 | i++; | ||
7276 | |||
7277 | ret = dict_set_int32 (op_ctx, "count", i); | ||
7278 | if (ret) | ||
7279 | gf_log (THIS->name, GF_LOG_ERROR, "Failed to set count")do { do { if (0) printf ("Failed to set count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7279, GF_LOG_ERROR, "Failed to set count"); } while (0); | ||
7280 | |||
7281 | snprintf (buf, 1024, "%s", uuid_utoa (MY_UUID(__glusterd_uuid()))); | ||
7282 | node_str = gf_strdup (buf); | ||
7283 | |||
7284 | snprintf (key, 256, "node-uuid-%d",i); | ||
7285 | ret = dict_set_dynstr (op_ctx, key, node_str); | ||
7286 | if (ret) | ||
7287 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to set node-uuid"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7288, GF_LOG_ERROR, "failed to set node-uuid" ); } while (0) | ||
7288 | "failed to set node-uuid")do { do { if (0) printf ("failed to set node-uuid"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7288, GF_LOG_ERROR, "failed to set node-uuid" ); } while (0); | ||
7289 | |||
7290 | memset (key, 0 , 256); | ||
7291 | snprintf (key, 256, "files-%d", i); | ||
7292 | ret = dict_set_uint64 (op_ctx, key, volinfo->rebal.rebalance_files); | ||
7293 | if (ret) | ||
7294 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to set file count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7295, GF_LOG_ERROR, "failed to set file count" ); } while (0) | ||
7295 | "failed to set file count")do { do { if (0) printf ("failed to set file count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7295, GF_LOG_ERROR, "failed to set file count" ); } while (0); | ||
7296 | |||
7297 | memset (key, 0 , 256); | ||
7298 | snprintf (key, 256, "size-%d", i); | ||
7299 | ret = dict_set_uint64 (op_ctx, key, volinfo->rebal.rebalance_data); | ||
7300 | if (ret) | ||
7301 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to set size of xfer"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7302, GF_LOG_ERROR, "failed to set size of xfer" ); } while (0) | ||
7302 | "failed to set size of xfer")do { do { if (0) printf ("failed to set size of xfer"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7302, GF_LOG_ERROR, "failed to set size of xfer" ); } while (0); | ||
7303 | |||
7304 | memset (key, 0 , 256); | ||
7305 | snprintf (key, 256, "lookups-%d", i); | ||
7306 | ret = dict_set_uint64 (op_ctx, key, volinfo->rebal.lookedup_files); | ||
7307 | if (ret) | ||
7308 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to set lookedup file count") ; } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 7309, GF_LOG_ERROR, "failed to set lookedup file count" ); } while (0) | ||
7309 | "failed to set lookedup file count")do { do { if (0) printf ("failed to set lookedup file count") ; } while (0); _gf_log ((*__glusterfs_this_location())->name , "glusterd-utils.c", __FUNCTION__, 7309, GF_LOG_ERROR, "failed to set lookedup file count" ); } while (0); | ||
7310 | |||
7311 | memset (key, 0 , 256); | ||
7312 | snprintf (key, 256, "status-%d", i); | ||
7313 | ret = dict_set_int32 (op_ctx, key, volinfo->rebal.defrag_status); | ||
7314 | if (ret) | ||
7315 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to set status"); } while (0) ; _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7316, GF_LOG_ERROR, "failed to set status"); } while (0) | ||
7316 | "failed to set status")do { do { if (0) printf ("failed to set status"); } while (0) ; _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7316, GF_LOG_ERROR, "failed to set status"); } while (0); | ||
7317 | |||
7318 | memset (key, 0 , 256); | ||
7319 | snprintf (key, 256, "failures-%d", i); | ||
7320 | ret = dict_set_uint64 (op_ctx, key, volinfo->rebal.rebalance_failures); | ||
7321 | if (ret) | ||
7322 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to set failure count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7323, GF_LOG_ERROR, "failed to set failure count" ); } while (0) | ||
7323 | "failed to set failure count")do { do { if (0) printf ("failed to set failure count"); } while (0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7323, GF_LOG_ERROR, "failed to set failure count" ); } while (0); | ||
7324 | |||
7325 | memset (key, 0, 256); | ||
7326 | snprintf (key, 256, "run-time-%d", i); | ||
7327 | ret = dict_set_double (op_ctx, key, volinfo->rebal.rebalance_time); | ||
7328 | if (ret) | ||
7329 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("failed to set run-time"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7330, GF_LOG_ERROR, "failed to set run-time") ; } while (0) | ||
7330 | "failed to set run-time")do { do { if (0) printf ("failed to set run-time"); } while ( 0); _gf_log ((*__glusterfs_this_location())->name, "glusterd-utils.c" , __FUNCTION__, 7330, GF_LOG_ERROR, "failed to set run-time") ; } while (0); | ||
7331 | |||
7332 | out: | ||
7333 | return ret; | ||
7334 | } | ||
7335 | int32_t | ||
7336 | glusterd_handle_node_rsp (dict_t *req_dict, void *pending_entry, | ||
7337 | glusterd_op_t op, dict_t *rsp_dict, dict_t *op_ctx, | ||
7338 | char **op_errstr, gd_node_type type) | ||
7339 | { | ||
7340 | int ret = 0; | ||
7341 | |||
7342 | GF_ASSERT (op_errstr)do { if (!(op_errstr)) { do { do { if (0) printf ("Assertion failed: " "op_errstr"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7342, GF_LOG_ERROR, "Assertion failed: " "op_errstr" ); } while (0); } } while (0); | ||
7343 | |||
7344 | switch (op) { | ||
7345 | case GD_OP_PROFILE_VOLUME: | ||
7346 | ret = glusterd_profile_volume_brick_rsp (pending_entry, | ||
7347 | rsp_dict, op_ctx, | ||
7348 | op_errstr, type); | ||
7349 | break; | ||
7350 | case GD_OP_STATUS_VOLUME: | ||
7351 | ret = glusterd_status_volume_brick_rsp (rsp_dict, op_ctx, | ||
7352 | op_errstr); | ||
7353 | break; | ||
7354 | |||
7355 | case GD_OP_DEFRAG_BRICK_VOLUME: | ||
7356 | glusterd_defrag_volume_node_rsp (req_dict, | ||
7357 | rsp_dict, op_ctx); | ||
7358 | break; | ||
7359 | |||
7360 | case GD_OP_HEAL_VOLUME: | ||
7361 | ret = glusterd_heal_volume_brick_rsp (req_dict, rsp_dict, | ||
7362 | op_ctx, op_errstr); | ||
7363 | break; | ||
7364 | default: | ||
7365 | break; | ||
7366 | } | ||
7367 | |||
7368 | gf_log ("", GF_LOG_DEBUG, "Returning %d", ret)do { do { if (0) printf ("Returning %d", ret); } while (0); _gf_log ("", "glusterd-utils.c", __FUNCTION__, 7368, GF_LOG_DEBUG, "Returning %d" , ret); } while (0); | ||
7369 | return ret; | ||
7370 | } | ||
7371 | |||
7372 | /* Should be used only when an operation is in progress, as that is the only | ||
7373 | * time a lock_owner is set | ||
7374 | */ | ||
7375 | gf_boolean_t | ||
7376 | is_origin_glusterd () | ||
7377 | { | ||
7378 | int ret = 0; | ||
7379 | uuid_t lock_owner = {0,}; | ||
7380 | |||
7381 | ret = glusterd_get_lock_owner (&lock_owner); | ||
7382 | if (ret) | ||
7383 | return _gf_false; | ||
7384 | |||
7385 | return (uuid_compare (MY_UUID(__glusterd_uuid()), lock_owner) == 0); | ||
7386 | } | ||
7387 | |||
7388 | int | ||
7389 | glusterd_generate_and_set_task_id (dict_t *dict, char *key) | ||
7390 | { | ||
7391 | int ret = -1; | ||
7392 | uuid_t task_id = {0,}; | ||
7393 | char *uuid_str = NULL((void*)0); | ||
7394 | xlator_t *this = NULL((void*)0); | ||
7395 | |||
7396 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7396, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | ||
7397 | |||
7398 | this = THIS(*__glusterfs_this_location()); | ||
7399 | GF_ASSERT (this)do { if (!(this)) { do { do { if (0) printf ("Assertion failed: " "this"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7399, GF_LOG_ERROR, "Assertion failed: " "this" ); } while (0); } } while (0); | ||
7400 | |||
7401 | uuid_generate (task_id); | ||
7402 | uuid_str = gf_strdup (uuid_utoa (task_id)); | ||
7403 | if (!uuid_str) { | ||
7404 | ret = -1; | ||
7405 | goto out; | ||
7406 | } | ||
7407 | |||
7408 | ret = dict_set_dynstr (dict, key, uuid_str); | ||
7409 | if (ret) { | ||
7410 | gf_log (this->name, GF_LOG_ERROR, "Failed to set %s in dict",do { do { if (0) printf ("Failed to set %s in dict", key); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 7411, GF_LOG_ERROR, "Failed to set %s in dict", key); } while (0) | ||
7411 | key)do { do { if (0) printf ("Failed to set %s in dict", key); } while (0); _gf_log (this->name, "glusterd-utils.c", __FUNCTION__ , 7411, GF_LOG_ERROR, "Failed to set %s in dict", key); } while (0); | ||
7412 | goto out; | ||
7413 | } | ||
7414 | gf_log (this->name, GF_LOG_INFO, "Generated task-id %s for key %s",do { do { if (0) printf ("Generated task-id %s for key %s", uuid_str , key); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 7415, GF_LOG_INFO, "Generated task-id %s for key %s" , uuid_str, key); } while (0) | ||
7415 | uuid_str, key)do { do { if (0) printf ("Generated task-id %s for key %s", uuid_str , key); } while (0); _gf_log (this->name, "glusterd-utils.c" , __FUNCTION__, 7415, GF_LOG_INFO, "Generated task-id %s for key %s" , uuid_str, key); } while (0); | ||
7416 | |||
7417 | out: | ||
7418 | if (ret) | ||
7419 | GF_FREE (uuid_str)__gf_free (uuid_str); | ||
7420 | return ret; | ||
7421 | } | ||
7422 | |||
7423 | int | ||
7424 | glusterd_copy_uuid_to_dict (uuid_t uuid, dict_t *dict, char *key) | ||
7425 | { | ||
7426 | int ret = -1; | ||
7427 | char tmp_str[40] = {0,}; | ||
7428 | char *task_id_str = NULL((void*)0); | ||
7429 | |||
7430 | GF_ASSERT (dict)do { if (!(dict)) { do { do { if (0) printf ("Assertion failed: " "dict"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7430, GF_LOG_ERROR, "Assertion failed: " "dict" ); } while (0); } } while (0); | ||
7431 | GF_ASSERT (key)do { if (!(key)) { do { do { if (0) printf ("Assertion failed: " "key"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7431, GF_LOG_ERROR, "Assertion failed: " "key" ); } while (0); } } while (0); | ||
7432 | |||
7433 | uuid_unparse (uuid, tmp_str); | ||
7434 | task_id_str = gf_strdup (tmp_str); | ||
7435 | if (!task_id_str) | ||
7436 | return -1; | ||
7437 | |||
7438 | ret = dict_set_dynstr (dict, key, task_id_str); | ||
7439 | if (ret) { | ||
7440 | GF_FREE (task_id_str)__gf_free (task_id_str); | ||
7441 | gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("Error setting uuid in dict with key %s" , key); } while (0); _gf_log ((*__glusterfs_this_location())-> name, "glusterd-utils.c", __FUNCTION__, 7442, GF_LOG_ERROR, "Error setting uuid in dict with key %s" , key); } while (0) | ||
7442 | "Error setting uuid in dict with key %s", key)do { do { if (0) printf ("Error setting uuid in dict with key %s" , key); } while (0); _gf_log ((*__glusterfs_this_location())-> name, "glusterd-utils.c", __FUNCTION__, 7442, GF_LOG_ERROR, "Error setting uuid in dict with key %s" , key); } while (0); | ||
7443 | } | ||
7444 | |||
7445 | return 0; | ||
7446 | } | ||
7447 | |||
7448 | gf_boolean_t | ||
7449 | glusterd_is_same_address (char *name1, char *name2) | ||
7450 | { | ||
7451 | struct addrinfo *addr1 = NULL((void*)0); | ||
7452 | struct addrinfo *addr2 = NULL((void*)0); | ||
7453 | struct addrinfo *p = NULL((void*)0); | ||
7454 | struct addrinfo *q = NULL((void*)0); | ||
7455 | gf_boolean_t ret = _gf_false; | ||
7456 | int gai_err = 0; | ||
7457 | |||
7458 | gai_err = getaddrinfo(name1,NULL((void*)0),NULL((void*)0),&addr1); | ||
7459 | if (gai_err != 0) { | ||
7460 | gf_log (name1, GF_LOG_WARNING,do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0); _gf_log (name1, "glusterd-utils.c", __FUNCTION__ , 7461, GF_LOG_WARNING, "error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0) | ||
7461 | "error in getaddrinfo: %s\n", gai_strerror(gai_err))do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0); _gf_log (name1, "glusterd-utils.c", __FUNCTION__ , 7461, GF_LOG_WARNING, "error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0); | ||
7462 | goto out; | ||
7463 | } | ||
7464 | |||
7465 | gai_err = getaddrinfo(name2,NULL((void*)0),NULL((void*)0),&addr2); | ||
7466 | if (gai_err != 0) { | ||
7467 | gf_log (name2, GF_LOG_WARNING,do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0); _gf_log (name2, "glusterd-utils.c", __FUNCTION__ , 7468, GF_LOG_WARNING, "error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0) | ||
7468 | "error in getaddrinfo: %s\n", gai_strerror(gai_err))do { do { if (0) printf ("error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0); _gf_log (name2, "glusterd-utils.c", __FUNCTION__ , 7468, GF_LOG_WARNING, "error in getaddrinfo: %s\n", gai_strerror (gai_err)); } while (0); | ||
7469 | goto out; | ||
7470 | } | ||
7471 | |||
7472 | for (p = addr1; p; p = p->ai_next) { | ||
7473 | for (q = addr2; q; q = q->ai_next) { | ||
7474 | if (p->ai_addrlen != q->ai_addrlen) { | ||
7475 | continue; | ||
7476 | } | ||
7477 | if (memcmp(p->ai_addr,q->ai_addr,p->ai_addrlen)) { | ||
7478 | continue; | ||
7479 | } | ||
7480 | ret = _gf_true; | ||
7481 | goto out; | ||
7482 | } | ||
7483 | } | ||
7484 | |||
7485 | out: | ||
7486 | if (addr1) { | ||
7487 | freeaddrinfo(addr1); | ||
7488 | } | ||
7489 | if (addr2) { | ||
7490 | freeaddrinfo(addr2); | ||
7491 | } | ||
7492 | return ret; | ||
7493 | |||
7494 | } | ||
7495 | |||
7496 | int | ||
7497 | _update_volume_op_versions (dict_t *this, char *key, data_t *value, void *data) | ||
7498 | { | ||
7499 | int op_version = 0; | ||
7500 | glusterd_volinfo_t *ctx = NULL((void*)0); | ||
7501 | |||
7502 | GF_ASSERT (data)do { if (!(data)) { do { do { if (0) printf ("Assertion failed: " "data"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7502, GF_LOG_ERROR, "Assertion failed: " "data" ); } while (0); } } while (0); | ||
7503 | ctx = data; | ||
7504 | |||
7505 | op_version = glusterd_get_op_version_for_key (key); | ||
7506 | |||
7507 | if (op_version > ctx->op_version) | ||
7508 | ctx->op_version = op_version; | ||
7509 | |||
7510 | if (gd_is_client_option (key) && | ||
7511 | (op_version > ctx->client_op_version)) | ||
7512 | ctx->client_op_version = op_version; | ||
7513 | |||
7514 | return 0; | ||
7515 | } | ||
7516 | |||
7517 | void | ||
7518 | gd_update_volume_op_versions (glusterd_volinfo_t *volinfo) | ||
7519 | { | ||
7520 | glusterd_conf_t *conf = NULL((void*)0); | ||
7521 | |||
7522 | GF_ASSERT (volinfo)do { if (!(volinfo)) { do { do { if (0) printf ("Assertion failed: " "volinfo"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7522, GF_LOG_ERROR, "Assertion failed: " "volinfo" ); } while (0); } } while (0); | ||
7523 | |||
7524 | conf = THIS(*__glusterfs_this_location())->private; | ||
7525 | GF_ASSERT (conf)do { if (!(conf)) { do { do { if (0) printf ("Assertion failed: " "conf"); } while (0); _gf_log_callingfn ("", "glusterd-utils.c" , __FUNCTION__, 7525, GF_LOG_ERROR, "Assertion failed: " "conf" ); } while (0); } } while (0); | ||
7526 | |||
7527 | /* Reset op-versions to minimum */ | ||
7528 | volinfo->op_version = 1; | ||
7529 | volinfo->client_op_version = 1; | ||
7530 | |||
7531 | dict_foreach (volinfo->dict, _update_volume_op_versions, volinfo); | ||
7532 | |||
7533 | return; | ||
7534 | } |