Bug Summary

File:libglusterfs/src/stack.c
Location:line 304, column 17
Description:Value stored to 'ret' is never read

Annotated Source Code

1/*
2 Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
3 This file is part of GlusterFS.
4
5 This file is licensed to you under your choice of the GNU Lesser
6 General Public License, version 3 or any later version (LGPLv3 or
7 later), or the GNU General Public License, version 2 (GPLv2), in all
8 cases as published by the Free Software Foundation.
9*/
10
11#include "statedump.h"
12#include "stack.h"
13
14static inline
15int call_frames_count (call_frame_t *call_frame)
16{
17 call_frame_t *pos;
18 int32_t count = 0;
19
20 if (!call_frame)
21 return count;
22
23 for (pos = call_frame; pos != NULL((void*)0); pos = pos->next)
24 count++;
25
26 return count;
27}
28
29call_frame_t *
30create_frame (xlator_t *xl, call_pool_t *pool)
31{
32 call_stack_t *stack = NULL((void*)0);
33
34 if (!xl || !pool) {
35 return NULL((void*)0);
36 }
37
38 stack = mem_get0 (pool->stack_mem_pool);
39 if (!stack)
40 return NULL((void*)0);
41
42 stack->pool = pool;
43 stack->frames.root = stack;
44 stack->frames.this = xl;
45 stack->ctx = xl->ctx;
46
47 if (stack->ctx->measure_latency) {
48 if (gettimeofday (&stack->tv, NULL((void*)0)) == -1)
49 gf_log ("stack", GF_LOG_ERROR, "gettimeofday () failed."do { do { if (0) printf ("gettimeofday () failed." " (%s)", strerror
((*__errno_location ()))); } while (0); _gf_log ("stack", "stack.c"
, __FUNCTION__, 50, GF_LOG_ERROR, "gettimeofday () failed." " (%s)"
, strerror ((*__errno_location ()))); } while (0)
50 " (%s)", strerror (errno))do { do { if (0) printf ("gettimeofday () failed." " (%s)", strerror
((*__errno_location ()))); } while (0); _gf_log ("stack", "stack.c"
, __FUNCTION__, 50, GF_LOG_ERROR, "gettimeofday () failed." " (%s)"
, strerror ((*__errno_location ()))); } while (0)
;
51 memcpy (&stack->frames.begin, &stack->tv, sizeof (stack->tv));
52 }
53
54 LOCK (&pool->lock)pthread_spin_lock (&pool->lock);
55 {
56 list_add (&stack->all_frames, &pool->all_frames);
57 pool->cnt++;
58 }
59 UNLOCK (&pool->lock)pthread_spin_unlock (&pool->lock);
60
61 LOCK_INIT (&stack->frames.lock)pthread_spin_init (&stack->frames.lock, 0);
62 LOCK_INIT (&stack->stack_lock)pthread_spin_init (&stack->stack_lock, 0);
63
64 return &stack->frames;
65}
66
67void
68gf_proc_dump_call_frame (call_frame_t *call_frame, const char *key_buf,...)
69{
70
71 char prefix[GF_DUMP_MAX_BUF_LEN4096];
72 va_list ap;
73 call_frame_t my_frame;
74 int ret = -1;
75 char timestr[256] = {0,};
76
77 if (!call_frame)
78 return;
79
80 GF_ASSERT (key_buf)do { if (!(key_buf)) { do { do { if (0) printf ("Assertion failed: "
"key_buf"); } while (0); _gf_log_callingfn ("", "stack.c", __FUNCTION__
, 80, GF_LOG_ERROR, "Assertion failed: " "key_buf"); } while (
0); } } while (0)
;
81
82 memset(prefix, 0, sizeof(prefix));
83 memset(&my_frame, 0, sizeof(my_frame));
84 va_start(ap, key_buf)__builtin_va_start(ap, key_buf);
85 vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN4096, key_buf, ap);
86 va_end(ap)__builtin_va_end(ap);
87
88 ret = TRY_LOCK(&call_frame->lock)pthread_spin_trylock (&call_frame->lock);
89 if (ret)
90 goto out;
91
92 memcpy(&my_frame, call_frame, sizeof(my_frame));
93 UNLOCK(&call_frame->lock)pthread_spin_unlock (&call_frame->lock);
94
95 if (my_frame.this->ctx->measure_latency) {
96 gf_time_fmt (timestr, sizeof timestr, my_frame.begin.tv_sec,
97 gf_timefmt_FT);
98 snprintf (timestr + strlen (timestr),
99 sizeof timestr - strlen (timestr),
100 ".%"GF_PRI_SUSECONDS"06ld", my_frame.begin.tv_usec);
101 gf_proc_dump_write("frame-creation-time", "%s", timestr);
102 }
103
104 gf_proc_dump_write("ref_count", "%d", my_frame.ref_count);
105 gf_proc_dump_write("translator", "%s", my_frame.this->name);
106 gf_proc_dump_write("complete", "%d", my_frame.complete);
107 if (my_frame.parent)
108 gf_proc_dump_write("parent", "%s", my_frame.parent->this->name);
109
110 if (my_frame.wind_from)
111 gf_proc_dump_write("wind_from", "%s", my_frame.wind_from);
112
113 if (my_frame.wind_to)
114 gf_proc_dump_write("wind_to", "%s", my_frame.wind_to);
115
116 if (my_frame.unwind_from)
117 gf_proc_dump_write("unwind_from", "%s", my_frame.unwind_from);
118
119 if (my_frame.unwind_to)
120 gf_proc_dump_write("unwind_to", "%s", my_frame.unwind_to);
121
122 ret = 0;
123out:
124 if (ret) {
125 gf_proc_dump_write("Unable to dump the frame information",
126 "(Lock acquisition failed) %p", my_frame);
127 return;
128 }
129}
130
131
132void
133gf_proc_dump_call_stack (call_stack_t *call_stack, const char *key_buf,...)
134{
135 char prefix[GF_DUMP_MAX_BUF_LEN4096];
136 va_list ap;
137 call_frame_t *trav;
138 int32_t cnt, i;
139 char timestr[256] = {0,};
140
141 if (!call_stack)
142 return;
143
144 GF_ASSERT (key_buf)do { if (!(key_buf)) { do { do { if (0) printf ("Assertion failed: "
"key_buf"); } while (0); _gf_log_callingfn ("", "stack.c", __FUNCTION__
, 144, GF_LOG_ERROR, "Assertion failed: " "key_buf"); } while
(0); } } while (0)
;
145
146 cnt = call_frames_count(&call_stack->frames);
147
148 memset(prefix, 0, sizeof(prefix));
149 va_start(ap, key_buf)__builtin_va_start(ap, key_buf);
150 vsnprintf(prefix, GF_DUMP_MAX_BUF_LEN4096, key_buf, ap);
151 va_end(ap)__builtin_va_end(ap);
152
153 if (call_stack->ctx->measure_latency) {
154 gf_time_fmt (timestr, sizeof timestr, call_stack->tv.tv_sec,
155 gf_timefmt_FT);
156 snprintf (timestr + strlen (timestr),
157 sizeof timestr - strlen (timestr),
158 ".%"GF_PRI_SUSECONDS"06ld", call_stack->tv.tv_usec);
159 gf_proc_dump_write("callstack-creation-time", "%s", timestr);
160 }
161
162 gf_proc_dump_write("uid", "%d", call_stack->uid);
163 gf_proc_dump_write("gid", "%d", call_stack->gid);
164 gf_proc_dump_write("pid", "%d", call_stack->pid);
165 gf_proc_dump_write("unique", "%Ld", call_stack->unique);
166 gf_proc_dump_write("lk-owner", "%s", lkowner_utoa (&call_stack->lk_owner));
167
168 if (call_stack->type == GF_OP_TYPE_FOP)
169 gf_proc_dump_write("op", "%s",
170 (char *)gf_fop_list[call_stack->op]);
171 else
172 gf_proc_dump_write("op", "stack");
173
174 gf_proc_dump_write("type", "%d", call_stack->type);
175 gf_proc_dump_write("cnt", "%d", cnt);
176
177 trav = &call_stack->frames;
178
179 for (i = 1; i <= cnt; i++) {
180 if (trav) {
181 gf_proc_dump_add_section("%s.frame.%d", prefix, i);
182 gf_proc_dump_call_frame(trav, "%s.frame.%d", prefix, i);
183 trav = trav->next;
184 }
185 }
186}
187
188void
189gf_proc_dump_pending_frames (call_pool_t *call_pool)
190{
191
192 call_stack_t *trav = NULL((void*)0);
193 int i = 1;
194 int ret = -1;
195 gf_boolean_t section_added = _gf_true;
196
197 if (!call_pool)
198 return;
199
200 ret = TRY_LOCK (&(call_pool->lock))pthread_spin_trylock (&(call_pool->lock));
201 if (ret)
202 goto out;
203
204
205 gf_proc_dump_add_section("global.callpool");
206 section_added = _gf_true;
207 gf_proc_dump_write("callpool_address","%p", call_pool);
208 gf_proc_dump_write("callpool.cnt","%d", call_pool->cnt);
209
210
211 list_for_each_entry (trav, &call_pool->all_frames, all_frames)for (trav = ((typeof(*trav) *)((char *)((&call_pool->all_frames
)->next)-(unsigned long)(&((typeof(*trav) *)0)->all_frames
))); &trav->all_frames != (&call_pool->all_frames
); trav = ((typeof(*trav) *)((char *)(trav->all_frames.next
)-(unsigned long)(&((typeof(*trav) *)0)->all_frames)))
)
{
212 gf_proc_dump_add_section("global.callpool.stack.%d",i);
213 gf_proc_dump_call_stack(trav, "global.callpool.stack.%d", i);
214 i++;
215 }
216 UNLOCK (&(call_pool->lock))pthread_spin_unlock (&(call_pool->lock));
217
218 ret = 0;
219out:
220 if (ret) {
221 if (_gf_false == section_added)
222 gf_proc_dump_add_section("global.callpool");
223 gf_proc_dump_write("Unable to dump the callpool",
224 "(Lock acquisition failed) %p",
225 call_pool);
226 }
227 return;
228}
229
230void
231gf_proc_dump_call_frame_to_dict (call_frame_t *call_frame,
232 char *prefix, dict_t *dict)
233{
234 int ret = -1;
235 char key[GF_DUMP_MAX_BUF_LEN4096] = {0,};
236 call_frame_t tmp_frame = {0,};
237
238 if (!call_frame || !dict)
239 return;
240
241 ret = TRY_LOCK (&call_frame->lock)pthread_spin_trylock (&call_frame->lock);
242 if (ret)
243 return;
244 memcpy (&tmp_frame, call_frame, sizeof (tmp_frame));
245 UNLOCK (&call_frame->lock)pthread_spin_unlock (&call_frame->lock);
246
247 memset (key, 0, sizeof (key));
248 snprintf (key, sizeof (key), "%s.refcount", prefix);
249 ret = dict_set_int32 (dict, key, tmp_frame.ref_count);
250 if (ret)
251 return;
252
253 memset (key, 0, sizeof (key));
254 snprintf (key, sizeof (key), "%s.translator", prefix);
255 ret = dict_set_dynstr (dict, key, gf_strdup (tmp_frame.this->name));
256 if (ret)
257 return;
258
259 memset (key, 0, sizeof (key));
260 snprintf (key, sizeof (key), "%s.complete", prefix);
261 ret = dict_set_int32 (dict, key, tmp_frame.complete);
262 if (ret)
263 return;
264
265 if (tmp_frame.parent) {
266 memset (key, 0, sizeof (key));
267 snprintf (key, sizeof (key), "%s.parent", prefix);
268 ret = dict_set_dynstr (dict, key,
269 gf_strdup (tmp_frame.parent->this->name));
270 if (ret)
271 return;
272 }
273
274 if (tmp_frame.wind_from) {
275 memset (key, 0, sizeof (key));
276 snprintf (key, sizeof (key), "%s.windfrom", prefix);
277 ret = dict_set_dynstr (dict, key,
278 gf_strdup (tmp_frame.wind_from));
279 if (ret)
280 return;
281 }
282
283 if (tmp_frame.wind_to) {
284 memset (key, 0, sizeof (key));
285 snprintf (key, sizeof (key), "%s.windto", prefix);
286 ret = dict_set_dynstr (dict, key,
287 gf_strdup (tmp_frame.wind_to));
288 if (ret)
289 return;
290 }
291
292 if (tmp_frame.unwind_from) {
293 memset (key, 0, sizeof (key));
294 snprintf (key, sizeof (key), "%s.unwindfrom", prefix);
295 ret = dict_set_dynstr (dict, key,
296 gf_strdup (tmp_frame.unwind_from));
297 if (ret)
298 return;
299 }
300
301 if (tmp_frame.unwind_to) {
302 memset (key, 0, sizeof (key));
303 snprintf (key, sizeof (key), "%s.unwind_to", prefix);
304 ret = dict_set_dynstr (dict, key,
Value stored to 'ret' is never read
305 gf_strdup (tmp_frame.unwind_to));
306 }
307
308 return;
309}
310
311void
312gf_proc_dump_call_stack_to_dict (call_stack_t *call_stack,
313 char *prefix, dict_t *dict)
314{
315 int ret = -1;
316 char key[GF_DUMP_MAX_BUF_LEN4096] = {0,};
317 call_frame_t *trav = NULL((void*)0);
318 int count = 0;
319 int i = 0;
320
321 if (!call_stack || !dict)
322 return;
323
324 count = call_frames_count (&call_stack->frames);
325
326 memset (key, 0, sizeof (key));
327 snprintf (key, sizeof (key), "%s.uid", prefix);
328 ret = dict_set_int32 (dict, key, call_stack->uid);
329 if (ret)
330 return;
331
332 memset (key, 0, sizeof (key));
333 snprintf (key, sizeof (key), "%s.gid", prefix);
334 ret = dict_set_int32 (dict, key, call_stack->gid);
335 if (ret)
336 return;
337
338 memset (key, 0, sizeof (key));
339 snprintf (key, sizeof (key), "%s.pid", prefix);
340 ret = dict_set_int32 (dict, key, call_stack->pid);
341 if (ret)
342 return;
343
344 memset (key, 0, sizeof (key));
345 snprintf (key, sizeof (key), "%s.unique", prefix);
346 ret = dict_set_uint64 (dict, key, call_stack->unique);
347 if (ret)
348 return;
349
350 memset (key, 0, sizeof (key));
351 snprintf (key, sizeof (key), "%s.op", prefix);
352 if (call_stack->type == GF_OP_TYPE_FOP)
353 ret = dict_set_str (dict, key,
354 (char *)gf_fop_list[call_stack->op]);
355 else
356 ret = dict_set_str (dict, key, "other");
357
358 if (ret)
359 return;
360
361 memset (key, 0, sizeof (key));
362 snprintf (key, sizeof (key), "%s.type", prefix);
363 ret = dict_set_int32 (dict, key, call_stack->type);
364 if (ret)
365 return;
366
367 memset (key, 0, sizeof (key));
368 snprintf (key, sizeof (key), "%s.count", prefix);
369 ret = dict_set_int32 (dict, key, count);
370 if (ret)
371 return;
372
373 trav = &call_stack->frames;
374 for (i = 0; i < count; i++) {
375 if (trav) {
376 memset (key, 0, sizeof (key));
377 snprintf (key, sizeof (key), "%s.frame%d",
378 prefix, i);
379 gf_proc_dump_call_frame_to_dict (trav, key, dict);
380 trav = trav->next;
381 }
382 }
383
384 return;
385}
386
387void
388gf_proc_dump_pending_frames_to_dict (call_pool_t *call_pool, dict_t *dict)
389{
390 int ret = -1;
391 call_stack_t *trav = NULL((void*)0);
392 char key[GF_DUMP_MAX_BUF_LEN4096] = {0,};
393 int i = 0;
394
395 if (!call_pool || !dict)
396 return;
397
398 ret = TRY_LOCK (&call_pool->lock)pthread_spin_trylock (&call_pool->lock);
399 if (ret) {
400 gf_log (THIS->name, GF_LOG_WARNING, "Unable to dump call pool"do { do { if (0) printf ("Unable to dump call pool" " to dict. errno: %d"
, (*__errno_location ())); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "stack.c", __FUNCTION__, 401, GF_LOG_WARNING, "Unable to dump call pool"
" to dict. errno: %d", (*__errno_location ())); } while (0)
401 " to dict. errno: %d", errno)do { do { if (0) printf ("Unable to dump call pool" " to dict. errno: %d"
, (*__errno_location ())); } while (0); _gf_log ((*__glusterfs_this_location
())->name, "stack.c", __FUNCTION__, 401, GF_LOG_WARNING, "Unable to dump call pool"
" to dict. errno: %d", (*__errno_location ())); } while (0)
;
402 return;
403 }
404
405 ret = dict_set_int32 (dict, "callpool.count", call_pool->cnt);
406 if (ret)
407 goto out;
408
409 list_for_each_entry (trav, &call_pool->all_frames, all_frames)for (trav = ((typeof(*trav) *)((char *)((&call_pool->all_frames
)->next)-(unsigned long)(&((typeof(*trav) *)0)->all_frames
))); &trav->all_frames != (&call_pool->all_frames
); trav = ((typeof(*trav) *)((char *)(trav->all_frames.next
)-(unsigned long)(&((typeof(*trav) *)0)->all_frames)))
)
{
410 memset (key, 0, sizeof (key));
411 snprintf (key, sizeof (key), "callpool.stack%d", i);
412 gf_proc_dump_call_stack_to_dict (trav, key, dict);
413 i++;
414 }
415
416out:
417 UNLOCK (&call_pool->lock)pthread_spin_unlock (&call_pool->lock);
418
419 return;
420}
421
422gf_boolean_t
423__is_fuse_call (call_frame_t *frame)
424{
425 gf_boolean_t is_fuse_call = _gf_false;
426 GF_ASSERT (frame)do { if (!(frame)) { do { do { if (0) printf ("Assertion failed: "
"frame"); } while (0); _gf_log_callingfn ("", "stack.c", __FUNCTION__
, 426, GF_LOG_ERROR, "Assertion failed: " "frame"); } while (
0); } } while (0)
;
427 GF_ASSERT (frame->root)do { if (!(frame->root)) { do { do { if (0) printf ("Assertion failed: "
"frame->root"); } while (0); _gf_log_callingfn ("", "stack.c"
, __FUNCTION__, 427, GF_LOG_ERROR, "Assertion failed: " "frame->root"
); } while (0); } } while (0)
;
428
429 if (NFS_PID1 != frame->root->pid)
430 is_fuse_call = _gf_true;
431 return is_fuse_call;
432}