Bug Summary

File:xlators/features/index/src/index.c
Location:line 842, column 15
Description:Access to field 'dir' results in a dereference of a null pointer (loaded from variable 'fctx')

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#ifndef _CONFIG_H
11#define _CONFIG_H
12#include "config.h"
13#endif
14
15#include "index.h"
16#include "options.h"
17#include "glusterfs3-xdr.h"
18
19#define XATTROP_SUBDIR"xattrop" "xattrop"
20
21call_stub_t *
22__index_dequeue (struct list_head *callstubs)
23{
24 call_stub_t *stub = NULL((void*)0);
25
26 if (!list_empty (callstubs)) {
27 stub = list_entry (callstubs->next, call_stub_t, list)((call_stub_t *)((char *)(callstubs->next)-(unsigned long)
(&((call_stub_t *)0)->list)));
28 list_del_init (&stub->list);
29 }
30
31 return stub;
32}
33
34inline static void
35__index_enqueue (struct list_head *callstubs, call_stub_t *stub)
36{
37 list_add_tail (&stub->list, callstubs);
38}
39
40static void
41worker_enqueue (xlator_t *this, call_stub_t *stub)
42{
43 index_priv_t *priv = NULL((void*)0);
44
45 priv = this->private;
46 pthread_mutex_lock (&priv->mutex);
47 {
48 __index_enqueue (&priv->callstubs, stub);
49 pthread_cond_signal (&priv->cond);
50 }
51 pthread_mutex_unlock (&priv->mutex);
52}
53
54void *
55index_worker (void *data)
56{
57 index_priv_t *priv = NULL((void*)0);
58 xlator_t *this = NULL((void*)0);
59 call_stub_t *stub = NULL((void*)0);
60 int ret = 0;
61
62 THIS(*__glusterfs_this_location()) = data;
63 this = data;
64 priv = this->private;
65
66 for (;;) {
67 pthread_mutex_lock (&priv->mutex);
68 {
69 while (list_empty (&priv->callstubs)) {
70 ret = pthread_cond_wait (&priv->cond,
71 &priv->mutex);
72 }
73
74 stub = __index_dequeue (&priv->callstubs);
75 }
76 pthread_mutex_unlock (&priv->mutex);
77
78 if (stub) /* guard against spurious wakeups */
79 call_resume (stub);
80 }
81
82 return NULL((void*)0);
83}
84int
85__index_inode_ctx_get (inode_t *inode, xlator_t *this, index_inode_ctx_t **ctx)
86{
87 int ret = 0;
88 index_inode_ctx_t *ictx = NULL((void*)0);
89 uint64_t tmpctx = 0;
90
91 ret = __inode_ctx_get (inode, this, &tmpctx)__inode_ctx_get2(inode,this,&tmpctx,0);
92 if (!ret) {
93 ictx = (index_inode_ctx_t*) (long) tmpctx;
94 goto out;
95 }
96 ictx = GF_CALLOC (1, sizeof (*ictx), gf_index_inode_ctx_t)__gf_calloc (1, sizeof (*ictx), gf_index_inode_ctx_t);
97 if (!ictx) {
98 ret = -1;
99 goto out;
100 }
101
102 INIT_LIST_HEAD (&ictx->callstubs)do { (&ictx->callstubs)->next = (&ictx->callstubs
)->prev = &ictx->callstubs; } while (0);
103 ret = __inode_ctx_put (inode, this, (uint64_t)ictx);
104 if (ret) {
105 GF_FREE (ictx)__gf_free (ictx);
106 ictx = NULL((void*)0);
107 goto out;
108 }
109out:
110 if (ictx)
111 *ctx = ictx;
112 return ret;
113}
114
115int
116index_inode_ctx_get (inode_t *inode, xlator_t *this, index_inode_ctx_t **ctx)
117{
118 int ret = 0;
119
120 LOCK (&inode->lock)pthread_spin_lock (&inode->lock);
121 {
122 ret = __index_inode_ctx_get (inode, this, ctx);
123 }
124 UNLOCK (&inode->lock)pthread_spin_unlock (&inode->lock);
125
126 return ret;
127}
128
129static void
130make_index_dir_path (char *base, const char *subdir,
131 char *index_dir, size_t len)
132{
133 snprintf (index_dir, len, "%s/%s", base, subdir);
134}
135
136int
137index_dir_create (xlator_t *this, const char *subdir)
138{
139 int ret = 0;
140 struct stat st = {0};
141 char fullpath[PATH_MAX4096] = {0};
142 char path[PATH_MAX4096] = {0};
143 char *dir = NULL((void*)0);
144 index_priv_t *priv = NULL((void*)0);
145 size_t len = 0;
146 size_t pathlen = 0;
147
148 priv = this->private;
149 make_index_dir_path (priv->index_basepath, subdir, fullpath,
150 sizeof (fullpath));
151 ret = stat (fullpath, &st);
152 if (!ret) {
153 if (!S_ISDIR (st.st_mode)((((st.st_mode)) & 0170000) == (0040000)))
154 ret = -2;
155 goto out;
156 }
157
158 pathlen = strlen (fullpath);
159 if ((pathlen > 1) && fullpath[pathlen - 1] == '/')
160 fullpath[pathlen - 1] = '\0';
161 dir = strchr (fullpath, '/');
162 while (dir) {
163 dir = strchr (dir + 1, '/');
164 if (dir)
165 len = pathlen - strlen (dir);
166 else
167 len = pathlen;
168 strncpy (path, fullpath, len);
169 path[len] = '\0';
170 ret = mkdir (path, 0600);
171 if (ret && (errno(*__errno_location ()) != EEXIST17))
172 goto out;
173 }
174 ret = 0;
175out:
176 if (ret == -1) {
177 gf_log (this->name, GF_LOG_ERROR, "%s/%s: Failed to "do { do { if (0) printf ("%s/%s: Failed to " "create (%s)", priv
->index_basepath, subdir, strerror ((*__errno_location ())
)); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 179, GF_LOG_ERROR, "%s/%s: Failed to " "create (%s)", priv->
index_basepath, subdir, strerror ((*__errno_location ()))); }
while (0)
178 "create (%s)", priv->index_basepath, subdir,do { do { if (0) printf ("%s/%s: Failed to " "create (%s)", priv
->index_basepath, subdir, strerror ((*__errno_location ())
)); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 179, GF_LOG_ERROR, "%s/%s: Failed to " "create (%s)", priv->
index_basepath, subdir, strerror ((*__errno_location ()))); }
while (0)
179 strerror (errno))do { do { if (0) printf ("%s/%s: Failed to " "create (%s)", priv
->index_basepath, subdir, strerror ((*__errno_location ())
)); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 179, GF_LOG_ERROR, "%s/%s: Failed to " "create (%s)", priv->
index_basepath, subdir, strerror ((*__errno_location ()))); }
while (0);
180 } else if (ret == -2) {
181 gf_log (this->name, GF_LOG_ERROR, "%s/%s: Failed to create, "do { do { if (0) printf ("%s/%s: Failed to create, " "path exists, not a directory "
, priv->index_basepath, subdir); } while (0); _gf_log (this
->name, "index.c", __FUNCTION__, 183, GF_LOG_ERROR, "%s/%s: Failed to create, "
"path exists, not a directory ", priv->index_basepath, subdir
); } while (0)
182 "path exists, not a directory ", priv->index_basepath,do { do { if (0) printf ("%s/%s: Failed to create, " "path exists, not a directory "
, priv->index_basepath, subdir); } while (0); _gf_log (this
->name, "index.c", __FUNCTION__, 183, GF_LOG_ERROR, "%s/%s: Failed to create, "
"path exists, not a directory ", priv->index_basepath, subdir
); } while (0)
183 subdir)do { do { if (0) printf ("%s/%s: Failed to create, " "path exists, not a directory "
, priv->index_basepath, subdir); } while (0); _gf_log (this
->name, "index.c", __FUNCTION__, 183, GF_LOG_ERROR, "%s/%s: Failed to create, "
"path exists, not a directory ", priv->index_basepath, subdir
); } while (0);
184 }
185 return ret;
186}
187
188void
189index_get_index (index_priv_t *priv, uuid_t index)
190{
191 LOCK (&priv->lock)pthread_spin_lock (&priv->lock);
192 {
193 uuid_copy (index, priv->index);
194 }
195 UNLOCK (&priv->lock)pthread_spin_unlock (&priv->lock);
196}
197
198void
199index_generate_index (index_priv_t *priv, uuid_t index)
200{
201 LOCK (&priv->lock)pthread_spin_lock (&priv->lock);
202 {
203 //To prevent duplicate generates.
204 //This method fails if number of contending threads is greater
205 //than MAX_LINK count of the fs
206 if (!uuid_compare (priv->index, index))
207 uuid_generate (priv->index);
208 uuid_copy (index, priv->index);
209 }
210 UNLOCK (&priv->lock)pthread_spin_unlock (&priv->lock);
211}
212
213static void
214make_index_path (char *base, const char *subdir, uuid_t index,
215 char *index_path, size_t len)
216{
217 make_index_dir_path (base, subdir, index_path, len);
218 snprintf (index_path + strlen (index_path), len - strlen (index_path),
219 "/%s-%s", subdir, uuid_utoa (index));
220}
221
222static void
223make_gfid_path (char *base, const char *subdir, uuid_t gfid,
224 char *gfid_path, size_t len)
225{
226 make_index_dir_path (base, subdir, gfid_path, len);
227 snprintf (gfid_path + strlen (gfid_path), len - strlen (gfid_path),
228 "/%s", uuid_utoa (gfid));
229}
230
231static void
232make_file_path (char *base, const char *subdir, const char *filename,
233 char *file_path, size_t len)
234{
235 make_index_dir_path (base, subdir, file_path, len);
236 snprintf (file_path + strlen (file_path), len - strlen (file_path),
237 "/%s", filename);
238}
239
240static void
241check_delete_stale_index_file (xlator_t *this, char *filename)
242{
243 int ret = 0;
244 struct stat st = {0};
245 char filepath[PATH_MAX4096] = {0};
246 index_priv_t *priv = NULL((void*)0);
247
248 priv = this->private;
249 make_file_path (priv->index_basepath, XATTROP_SUBDIR"xattrop",
250 filename, filepath, sizeof (filepath));
251 ret = stat (filepath, &st);
252 if (!ret && st.st_nlink == 1)
253 unlink (filepath);
254}
255
256static int
257index_fill_readdir (fd_t *fd, DIR *dir, off_t off,
258 size_t size, gf_dirent_t *entries)
259{
260 off_t in_case = -1;
261 size_t filled = 0;
262 int count = 0;
263 char entrybuf[sizeof(struct dirent) + 256 + 8];
264 struct dirent *entry = NULL((void*)0);
265 int32_t this_size = -1;
266 gf_dirent_t *this_entry = NULL((void*)0);
267 xlator_t *this = NULL((void*)0);
268
269 this = THIS(*__glusterfs_this_location());
270 if (!off) {
271 rewinddir (dir);
272 } else {
273 seekdir (dir, off);
274 }
275
276 while (filled <= size) {
277 in_case = telldir (dir);
278
279 if (in_case == -1) {
280 gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("telldir failed on dir=%p: %s", dir,
strerror ((*__errno_location ()))); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "index.c", __FUNCTION__
, 282, GF_LOG_ERROR, "telldir failed on dir=%p: %s", dir, strerror
((*__errno_location ()))); } while (0)
281 "telldir failed on dir=%p: %s",do { do { if (0) printf ("telldir failed on dir=%p: %s", dir,
strerror ((*__errno_location ()))); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "index.c", __FUNCTION__
, 282, GF_LOG_ERROR, "telldir failed on dir=%p: %s", dir, strerror
((*__errno_location ()))); } while (0)
282 dir, strerror (errno))do { do { if (0) printf ("telldir failed on dir=%p: %s", dir,
strerror ((*__errno_location ()))); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "index.c", __FUNCTION__
, 282, GF_LOG_ERROR, "telldir failed on dir=%p: %s", dir, strerror
((*__errno_location ()))); } while (0);
283 goto out;
284 }
285
286 errno(*__errno_location ()) = 0;
287 entry = NULL((void*)0);
288 readdir_r (dir, (struct dirent *)entrybuf, &entry);
289
290 if (!entry) {
291 if (errno(*__errno_location ()) == EBADF9) {
292 gf_log (THIS->name, GF_LOG_WARNING,do { do { if (0) printf ("readdir failed on dir=%p: %s", dir,
strerror ((*__errno_location ()))); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "index.c", __FUNCTION__
, 294, GF_LOG_WARNING, "readdir failed on dir=%p: %s", dir, strerror
((*__errno_location ()))); } while (0)
293 "readdir failed on dir=%p: %s",do { do { if (0) printf ("readdir failed on dir=%p: %s", dir,
strerror ((*__errno_location ()))); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "index.c", __FUNCTION__
, 294, GF_LOG_WARNING, "readdir failed on dir=%p: %s", dir, strerror
((*__errno_location ()))); } while (0)
294 dir, strerror (errno))do { do { if (0) printf ("readdir failed on dir=%p: %s", dir,
strerror ((*__errno_location ()))); } while (0); _gf_log ((*
__glusterfs_this_location())->name, "index.c", __FUNCTION__
, 294, GF_LOG_WARNING, "readdir failed on dir=%p: %s", dir, strerror
((*__errno_location ()))); } while (0);
295 goto out;
296 }
297 break;
298 }
299
300 if (!strncmp (entry->d_name, XATTROP_SUBDIR"xattrop""-",
301 strlen (XATTROP_SUBDIR"xattrop""-"))) {
302 check_delete_stale_index_file (this, entry->d_name);
303 continue;
304 }
305
306 this_size = max (sizeof (gf_dirent_t),((sizeof (gf_dirent_t))>(sizeof (gfs3_dirplist))?(sizeof (
gf_dirent_t)):(sizeof (gfs3_dirplist)))
307 sizeof (gfs3_dirplist))((sizeof (gf_dirent_t))>(sizeof (gfs3_dirplist))?(sizeof (
gf_dirent_t)):(sizeof (gfs3_dirplist)))
308 + strlen (entry->d_name) + 1;
309
310 if (this_size + filled > size) {
311 seekdir (dir, in_case);
312 break;
313 }
314
315 this_entry = gf_dirent_for_name (entry->d_name);
316
317 if (!this_entry) {
318 gf_log (THIS->name, GF_LOG_ERROR,do { do { if (0) printf ("could not create gf_dirent for entry %s: (%s)"
, entry->d_name, strerror ((*__errno_location ()))); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "index.c"
, __FUNCTION__, 320, GF_LOG_ERROR, "could not create gf_dirent for entry %s: (%s)"
, entry->d_name, strerror ((*__errno_location ()))); } while
(0)
319 "could not create gf_dirent for entry %s: (%s)",do { do { if (0) printf ("could not create gf_dirent for entry %s: (%s)"
, entry->d_name, strerror ((*__errno_location ()))); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "index.c"
, __FUNCTION__, 320, GF_LOG_ERROR, "could not create gf_dirent for entry %s: (%s)"
, entry->d_name, strerror ((*__errno_location ()))); } while
(0)
320 entry->d_name, strerror (errno))do { do { if (0) printf ("could not create gf_dirent for entry %s: (%s)"
, entry->d_name, strerror ((*__errno_location ()))); } while
(0); _gf_log ((*__glusterfs_this_location())->name, "index.c"
, __FUNCTION__, 320, GF_LOG_ERROR, "could not create gf_dirent for entry %s: (%s)"
, entry->d_name, strerror ((*__errno_location ()))); } while
(0);
321 goto out;
322 }
323 this_entry->d_off = telldir (dir);
324 this_entry->d_ino = entry->d_ino;
325
326 list_add_tail (&this_entry->list, &entries->list);
327
328 filled += this_size;
329 count ++;
330 }
331
332 if ((!readdir (dir) && (errno(*__errno_location ()) == 0)))
333 /* Indicate EOF */
334 errno(*__errno_location ()) = ENOENT2;
335out:
336 return count;
337}
338
339int
340index_add (xlator_t *this, uuid_t gfid, const char *subdir)
341{
342 int32_t op_errno = 0;
343 char gfid_path[PATH_MAX4096] = {0};
344 char index_path[PATH_MAX4096] = {0};
345 int ret = 0;
346 uuid_t index = {0};
347 index_priv_t *priv = NULL((void*)0);
348 struct stat st = {0};
349 int fd = 0;
350
351 priv = this->private;
352 GF_ASSERT_AND_GOTO_WITH_ERROR (this->name, !uuid_is_null (gfid),do { if (!!uuid_is_null (gfid)) { do { if (!(0)) { do { do { if
(0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn
("", "index.c", __FUNCTION__, 353, GF_LOG_ERROR, "Assertion failed: "
"0"); } while (0); } } while (0); op_errno = 22; goto out; }
}while (0)
353 out, op_errno, EINVAL)do { if (!!uuid_is_null (gfid)) { do { if (!(0)) { do { do { if
(0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn
("", "index.c", __FUNCTION__, 353, GF_LOG_ERROR, "Assertion failed: "
"0"); } while (0); } } while (0); op_errno = 22; goto out; }
}while (0);
354
355 make_gfid_path (priv->index_basepath, subdir, gfid,
356 gfid_path, sizeof (gfid_path));
357
358 ret = stat (gfid_path, &st);
359 if (!ret)
360 goto out;
361 index_get_index (priv, index);
362 make_index_path (priv->index_basepath, subdir,
363 index, index_path, sizeof (index_path));
364 ret = link (index_path, gfid_path);
365 if (!ret || (errno(*__errno_location ()) == EEXIST17)) {
366 ret = 0;
367 goto out;
368 }
369
370 op_errno = errno(*__errno_location ());
371 if (op_errno == ENOENT2) {
372 ret = index_dir_create (this, subdir);
373 if (ret)
374 goto out;
375 } else if (op_errno == EMLINK31) {
376 index_generate_index (priv, index);
377 make_index_path (priv->index_basepath, subdir,
378 index, index_path, sizeof (index_path));
379 } else {
380 goto out;
381 }
382
383 fd = creat (index_path, 0);
384 if ((fd < 0) && (errno(*__errno_location ()) != EEXIST17)) {
385 ret = -1;
386 gf_log (this->name, GF_LOG_ERROR, "%s: Not able to "do { do { if (0) printf ("%s: Not able to " "create index (%s)"
, uuid_utoa (gfid), strerror ((*__errno_location ()))); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 388, GF_LOG_ERROR
, "%s: Not able to " "create index (%s)", uuid_utoa (gfid), strerror
((*__errno_location ()))); } while (0)
387 "create index (%s)", uuid_utoa (gfid),do { do { if (0) printf ("%s: Not able to " "create index (%s)"
, uuid_utoa (gfid), strerror ((*__errno_location ()))); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 388, GF_LOG_ERROR
, "%s: Not able to " "create index (%s)", uuid_utoa (gfid), strerror
((*__errno_location ()))); } while (0)
388 strerror (errno))do { do { if (0) printf ("%s: Not able to " "create index (%s)"
, uuid_utoa (gfid), strerror ((*__errno_location ()))); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 388, GF_LOG_ERROR
, "%s: Not able to " "create index (%s)", uuid_utoa (gfid), strerror
((*__errno_location ()))); } while (0);
389 goto out;
390 }
391
392 if (fd >= 0)
393 close (fd);
394
395 ret = link (index_path, gfid_path);
396 if (ret && (errno(*__errno_location ()) != EEXIST17)) {
397 gf_log (this->name, GF_LOG_ERROR, "%s: Not able to "do { do { if (0) printf ("%s: Not able to " "add to index (%s)"
, uuid_utoa (gfid), strerror ((*__errno_location ()))); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 399, GF_LOG_ERROR
, "%s: Not able to " "add to index (%s)", uuid_utoa (gfid), strerror
((*__errno_location ()))); } while (0)
398 "add to index (%s)", uuid_utoa (gfid),do { do { if (0) printf ("%s: Not able to " "add to index (%s)"
, uuid_utoa (gfid), strerror ((*__errno_location ()))); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 399, GF_LOG_ERROR
, "%s: Not able to " "add to index (%s)", uuid_utoa (gfid), strerror
((*__errno_location ()))); } while (0)
399 strerror (errno))do { do { if (0) printf ("%s: Not able to " "add to index (%s)"
, uuid_utoa (gfid), strerror ((*__errno_location ()))); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 399, GF_LOG_ERROR
, "%s: Not able to " "add to index (%s)", uuid_utoa (gfid), strerror
((*__errno_location ()))); } while (0);
400 goto out;
401 }
402
403 ret = 0;
404out:
405 return ret;
406}
407
408int
409index_del (xlator_t *this, uuid_t gfid, const char *subdir)
410{
411 int32_t op_errno __attribute__((unused)) = 0;
412 index_priv_t *priv = NULL((void*)0);
413 int ret = 0;
414 char gfid_path[PATH_MAX4096] = {0};
415
416 priv = this->private;
417 GF_ASSERT_AND_GOTO_WITH_ERROR (this->name, !uuid_is_null (gfid),do { if (!!uuid_is_null (gfid)) { do { if (!(0)) { do { do { if
(0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn
("", "index.c", __FUNCTION__, 418, GF_LOG_ERROR, "Assertion failed: "
"0"); } while (0); } } while (0); op_errno = 22; goto out; }
}while (0)
418 out, op_errno, EINVAL)do { if (!!uuid_is_null (gfid)) { do { if (!(0)) { do { do { if
(0) printf ("Assertion failed: " "0"); } while (0); _gf_log_callingfn
("", "index.c", __FUNCTION__, 418, GF_LOG_ERROR, "Assertion failed: "
"0"); } while (0); } } while (0); op_errno = 22; goto out; }
}while (0);
419 make_gfid_path (priv->index_basepath, subdir, gfid,
420 gfid_path, sizeof (gfid_path));
421 ret = unlink (gfid_path);
422 if (ret && (errno(*__errno_location ()) != ENOENT2)) {
423 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("%s: failed to delete from index (%s)"
, gfid_path, strerror ((*__errno_location ()))); } while (0);
_gf_log (this->name, "index.c", __FUNCTION__, 425, GF_LOG_ERROR
, "%s: failed to delete from index (%s)", gfid_path, strerror
((*__errno_location ()))); } while (0)
424 "%s: failed to delete from index (%s)",do { do { if (0) printf ("%s: failed to delete from index (%s)"
, gfid_path, strerror ((*__errno_location ()))); } while (0);
_gf_log (this->name, "index.c", __FUNCTION__, 425, GF_LOG_ERROR
, "%s: failed to delete from index (%s)", gfid_path, strerror
((*__errno_location ()))); } while (0)
425 gfid_path, strerror (errno))do { do { if (0) printf ("%s: failed to delete from index (%s)"
, gfid_path, strerror ((*__errno_location ()))); } while (0);
_gf_log (this->name, "index.c", __FUNCTION__, 425, GF_LOG_ERROR
, "%s: failed to delete from index (%s)", gfid_path, strerror
((*__errno_location ()))); } while (0);
426 ret = -errno(*__errno_location ());
427 goto out;
428 }
429 ret = 0;
430out:
431 return ret;
432}
433
434static int
435_check_key_is_zero_filled (dict_t *d, char *k, data_t *v,
436 void *tmp)
437{
438 if (mem_0filled ((const char*)v->data, v->len)) {
439 /* -1 means, no more iterations, treat as 'break' */
440 return -1;
441 }
442 return 0;
443}
444
445
446void
447_xattrop_index_action (xlator_t *this, inode_t *inode, dict_t *xattr)
448{
449 gf_boolean_t zero_xattr = _gf_true;
450 index_inode_ctx_t *ctx = NULL((void*)0);
451 int ret = 0;
452
453 ret = dict_foreach (xattr, _check_key_is_zero_filled, NULL((void*)0));
454 if (ret == -1)
455 zero_xattr = _gf_false;
456
457 ret = index_inode_ctx_get (inode, this, &ctx);
458 if (ret) {
459 gf_log (this->name, GF_LOG_ERROR, "Not able to %s %s -> index",do { do { if (0) printf ("Not able to %s %s -> index", zero_xattr
?"add":"del", uuid_utoa (inode->gfid)); } while (0); _gf_log
(this->name, "index.c", __FUNCTION__, 460, GF_LOG_ERROR, "Not able to %s %s -> index"
, zero_xattr?"add":"del", uuid_utoa (inode->gfid)); } while
(0)
460 zero_xattr?"add":"del", uuid_utoa (inode->gfid))do { do { if (0) printf ("Not able to %s %s -> index", zero_xattr
?"add":"del", uuid_utoa (inode->gfid)); } while (0); _gf_log
(this->name, "index.c", __FUNCTION__, 460, GF_LOG_ERROR, "Not able to %s %s -> index"
, zero_xattr?"add":"del", uuid_utoa (inode->gfid)); } while
(0);
461 goto out;
462 }
463 if (zero_xattr) {
464 if (ctx->state == NOTIN)
465 goto out;
466 ret = index_del (this, inode->gfid, XATTROP_SUBDIR"xattrop");
467 if (!ret)
468 ctx->state = NOTIN;
469 } else {
470 if (ctx->state == IN)
471 goto out;
472 ret = index_add (this, inode->gfid, XATTROP_SUBDIR"xattrop");
473 if (!ret)
474 ctx->state = IN;
475 }
476out:
477 return;
478}
479
480void
481fop_xattrop_index_action (xlator_t *this, inode_t *inode, dict_t *xattr)
482{
483 _xattrop_index_action (this, inode, xattr);
484}
485
486void
487fop_fxattrop_index_action (xlator_t *this, inode_t *inode, dict_t *xattr)
488{
489 _xattrop_index_action (this, inode, xattr);
490}
491
492inline gf_boolean_t
493index_xattrop_track (loc_t *loc, gf_xattrop_flags_t flags, dict_t *dict)
494{
495 return (flags == GF_XATTROP_ADD_ARRAY);
496}
497
498inline gf_boolean_t
499index_fxattrop_track (fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict)
500{
501 return (flags == GF_XATTROP_ADD_ARRAY);
502}
503
504int
505__index_fd_ctx_get (fd_t *fd, xlator_t *this, index_fd_ctx_t **ctx)
506{
507 int ret = 0;
508 index_fd_ctx_t *fctx = NULL((void*)0);
509 uint64_t tmpctx = 0;
510 char index_dir[PATH_MAX4096] = {0};
511 index_priv_t *priv = NULL((void*)0);
512
513 priv = this->private;
514 if (uuid_compare (fd->inode->gfid, priv->xattrop_vgfid)) {
4
←
Taking false branch
→
515 ret = -EINVAL22;
516 goto out;
517 }
518
519 ret = __fd_ctx_get (fd, this, &tmpctx);
520 if (!ret) {
5
←
Assuming 'ret' is 0
→
6
←
Taking true branch
→
521 fctx = (index_fd_ctx_t*) (long) tmpctx;
522 goto out;
7
←
Control jumps to line 549
→
523 }
524
525 fctx = GF_CALLOC (1, sizeof (*fctx), gf_index_fd_ctx_t)__gf_calloc (1, sizeof (*fctx), gf_index_fd_ctx_t);
526 if (!fctx) {
527 ret = -ENOMEM12;
528 goto out;
529 }
530
531 make_index_dir_path (priv->index_basepath, XATTROP_SUBDIR"xattrop",
532 index_dir, sizeof (index_dir));
533 fctx->dir = opendir (index_dir);
534 if (!fctx->dir) {
535 ret = -errno(*__errno_location ());
536 GF_FREE (fctx)__gf_free (fctx);
537 fctx = NULL((void*)0);
538 goto out;
539 }
540
541 ret = __fd_ctx_set (fd, this, (uint64_t)(long)fctx);
542 if (ret) {
543 GF_FREE (fctx)__gf_free (fctx);
544 fctx = NULL((void*)0);
545 ret = -EINVAL22;
546 goto out;
547 }
548out:
549 if (fctx)
8
←
Assuming 'fctx' is null
→
9
←
Taking false branch
→
550 *ctx = fctx;
551 return ret;
552}
553
554int
555index_fd_ctx_get (fd_t *fd, xlator_t *this, index_fd_ctx_t **ctx)
556{
557 int ret = 0;
558 LOCK (&fd->lock)pthread_spin_lock (&fd->lock);
559 {
560 ret = __index_fd_ctx_get (fd, this, ctx);
3
←
Calling '__index_fd_ctx_get'
→
10
←
Returning from '__index_fd_ctx_get'
→
561 }
562 UNLOCK (&fd->lock)pthread_spin_unlock (&fd->lock);
563 return ret;
564}
565
566//new - Not NULL means start a fop
567//new - NULL means done processing the fop
568void
569index_queue_process (xlator_t *this, inode_t *inode, call_stub_t *new)
570{
571 call_stub_t *stub = NULL((void*)0);
572 index_inode_ctx_t *ctx = NULL((void*)0);
573 int ret = 0;
574 call_frame_t *frame = NULL((void*)0);
575
576 LOCK (&inode->lock)pthread_spin_lock (&inode->lock);
577 {
578 ret = __index_inode_ctx_get (inode, this, &ctx);
579 if (ret)
580 goto unlock;
581
582 if (new) {
583 __index_enqueue (&ctx->callstubs, new);
584 new = NULL((void*)0);
585 } else {
586 ctx->processing = _gf_false;
587 }
588
589 if (!ctx->processing) {
590 stub = __index_dequeue (&ctx->callstubs);
591 if (stub)
592 ctx->processing = _gf_true;
593 else
594 ctx->processing = _gf_false;
595 }
596 }
597unlock:
598 UNLOCK (&inode->lock)pthread_spin_unlock (&inode->lock);
599
600 if (ret && new) {
601 frame = new->frame;
602 if (new->fop == GF_FOP_XATTROP) {
603 INDEX_STACK_UNWIND (xattrop, frame, -1, ENOMEM,do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_xattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 604, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_xattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, -1, 12, ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0)
604 NULL, NULL)do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_xattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 604, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_xattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, -1, 12, ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0);
605 } else if (new->fop == GF_FOP_FXATTROP) {
606 INDEX_STACK_UNWIND (fxattrop, frame, -1, ENOMEM,do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_fxattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 607, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_fxattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, -1, 12, ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0)
607 NULL, NULL)do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_fxattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 607, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_fxattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, -1, 12, ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0);
608 }
609 call_stub_destroy (new);
610 } else if (stub) {
611 call_resume (stub);
612 }
613 return;
614}
615
616int32_t
617index_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
618 int32_t op_ret, int32_t op_errno, dict_t *xattr, dict_t *xdata)
619{
620 inode_t *inode = NULL((void*)0);
621
622 inode = inode_ref (frame->local);
623 if (op_ret < 0)
624 goto out;
625 fop_xattrop_index_action (this, frame->local, xattr);
626out:
627 INDEX_STACK_UNWIND (xattrop, frame, op_ret, op_errno, xattr, xdata)do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_xattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 627, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_xattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, op_ret, op_errno, xattr, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0);
628 index_queue_process (this, inode, NULL((void*)0));
629 inode_unref (inode);
630
631 return 0;
632}
633
634int32_t
635index_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
636 int32_t op_ret, int32_t op_errno, dict_t *xattr,
637 dict_t *xdata)
638{
639 inode_t *inode = NULL((void*)0);
640
641 inode = inode_ref (frame->local);
642 if (op_ret < 0)
643 goto out;
644
645 fop_fxattrop_index_action (this, frame->local, xattr);
646out:
647 INDEX_STACK_UNWIND (fxattrop, frame, op_ret, op_errno, xattr, xdata)do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_fxattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 647, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_fxattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, op_ret, op_errno, xattr, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0);
648 index_queue_process (this, inode, NULL((void*)0));
649 inode_unref (inode);
650
651 return 0;
652}
653
654int
655index_xattrop_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc,
656 gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
657{
658 STACK_WIND (frame, index_xattrop_cbk, FIRST_CHILD (this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 660, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->xattrop_cbk) tmp_cbk = index_xattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->xattrop"
; _new->unwind_to = "index_xattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->xattrop); (this->children->xlator
)->fops->xattrop (_new, (this->children->xlator),
loc, optype, xattr, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
659 FIRST_CHILD (this)->fops->xattrop, loc, optype, xattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 660, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->xattrop_cbk) tmp_cbk = index_xattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->xattrop"
; _new->unwind_to = "index_xattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->xattrop); (this->children->xlator
)->fops->xattrop (_new, (this->children->xlator),
loc, optype, xattr, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
660 xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 660, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->xattrop_cbk) tmp_cbk = index_xattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->xattrop"
; _new->unwind_to = "index_xattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->xattrop); (this->children->xlator
)->fops->xattrop (_new, (this->children->xlator),
loc, optype, xattr, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0);
661 return 0;
662}
663
664int
665index_fxattrop_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd,
666 gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
667{
668 STACK_WIND (frame, index_fxattrop_cbk, FIRST_CHILD (this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 670, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fxattrop_cbk) tmp_cbk = index_fxattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->fxattrop"
; _new->unwind_to = "index_fxattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fxattrop); (this->children->xlator
)->fops->fxattrop (_new, (this->children->xlator)
, fd, optype, xattr, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
669 FIRST_CHILD (this)->fops->fxattrop, fd, optype, xattr,do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 670, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fxattrop_cbk) tmp_cbk = index_fxattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->fxattrop"
; _new->unwind_to = "index_fxattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fxattrop); (this->children->xlator
)->fops->fxattrop (_new, (this->children->xlator)
, fd, optype, xattr, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0)
670 xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 670, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fxattrop_cbk) tmp_cbk = index_fxattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD (this)->fops->fxattrop"
; _new->unwind_to = "index_fxattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fxattrop); (this->children->xlator
)->fops->fxattrop (_new, (this->children->xlator)
, fd, optype, xattr, xdata); (*__glusterfs_this_location()) =
old_THIS; } while (0);
671 return 0;
672}
673
674int32_t
675index_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
676 gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
677{
678 call_stub_t *stub = NULL((void*)0);
679
680 if (!index_xattrop_track (loc, flags, dict))
681 goto out;
682
683 frame->local = inode_ref (loc->inode);
684 stub = fop_xattrop_stub (frame, index_xattrop_wrapper,
685 loc, flags, dict, xdata);
686 if (!stub) {
687 INDEX_STACK_UNWIND (xattrop, frame, -1, ENOMEM, NULL, NULL)do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_xattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 687, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_xattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, -1, 12, ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0);
688 return 0;
689 }
690
691 index_queue_process (this, loc->inode, stub);
692 return 0;
693out:
694 STACK_WIND (frame, default_xattrop_cbk, FIRST_CHILD(this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 695, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->xattrop_cbk) tmp_cbk = default_xattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->xattrop"
; _new->unwind_to = "default_xattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->xattrop); (this->children->xlator
)->fops->xattrop (_new, (this->children->xlator),
loc, flags, dict, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
695 FIRST_CHILD(this)->fops->xattrop, loc, flags, dict, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 695, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->xattrop_cbk) tmp_cbk = default_xattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->xattrop"
; _new->unwind_to = "default_xattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->xattrop); (this->children->xlator
)->fops->xattrop (_new, (this->children->xlator),
loc, flags, dict, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0);
696 return 0;
697}
698
699int32_t
700index_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
701 gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
702{
703 call_stub_t *stub = NULL((void*)0);
704
705 if (!index_fxattrop_track (fd, flags, dict))
706 goto out;
707
708 frame->local = inode_ref (fd->inode);
709 stub = fop_fxattrop_stub (frame, index_fxattrop_wrapper,
710 fd, flags, dict, xdata);
711 if (!stub) {
712 INDEX_STACK_UNWIND (fxattrop, frame, -1, ENOMEM, NULL, xdata)do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_fxattrop_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 712, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_fxattrop_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, -1, 12, ((void*)0), xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0); } while (0);
713 return 0;
714 }
715
716 index_queue_process (this, fd->inode, stub);
717 return 0;
718out:
719 STACK_WIND (frame, default_fxattrop_cbk, FIRST_CHILD(this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 720, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fxattrop_cbk) tmp_cbk = default_fxattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fxattrop"
; _new->unwind_to = "default_fxattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fxattrop); (this->children->xlator
)->fops->fxattrop (_new, (this->children->xlator)
, fd, flags, dict, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
720 FIRST_CHILD(this)->fops->fxattrop, fd, flags, dict, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 720, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->fxattrop_cbk) tmp_cbk = default_fxattrop_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->fxattrop"
; _new->unwind_to = "default_fxattrop_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->fxattrop); (this->children->xlator
)->fops->fxattrop (_new, (this->children->xlator)
, fd, flags, dict, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0);
721 return 0;
722}
723
724int32_t
725index_getxattr_wrapper (call_frame_t *frame, xlator_t *this,
726 loc_t *loc, const char *name, dict_t *xdata)
727{
728 index_priv_t *priv = NULL((void*)0);
729 dict_t *xattr = NULL((void*)0);
730 int ret = 0;
731
732 priv = this->private;
733
734 xattr = dict_new ();
735 if (!xattr) {
736 ret = -ENOMEM12;
737 goto done;
738 }
739
740 ret = dict_set_static_bin (xattr, (char*)name, priv->xattrop_vgfid,
741 sizeof (priv->xattrop_vgfid));
742 if (ret) {
743 ret = -ENOMEM12;
744 gf_log (THIS->name, GF_LOG_ERROR, "xattrop index "do { do { if (0) printf ("xattrop index " "gfid set failed");
} while (0); _gf_log ((*__glusterfs_this_location())->name
, "index.c", __FUNCTION__, 745, GF_LOG_ERROR, "xattrop index "
"gfid set failed"); } while (0)
745 "gfid set failed")do { do { if (0) printf ("xattrop index " "gfid set failed");
} while (0); _gf_log ((*__glusterfs_this_location())->name
, "index.c", __FUNCTION__, 745, GF_LOG_ERROR, "xattrop index "
"gfid set failed"); } while (0);
746 goto done;
747 }
748done:
749 if (ret)
750 STACK_UNWIND_STRICT (getxattr, frame, -1, -ret, xattr, xdata)do { fop_getxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 750, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_getxattr_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, -ret, xattr, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0);
751 else
752 STACK_UNWIND_STRICT (getxattr, frame, 0, 0, xattr, xdata)do { fop_getxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 752, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_getxattr_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, 0,
0, xattr, xdata); (*__glusterfs_this_location()) = old_THIS;
} while (0);
753
754 if (xattr)
755 dict_unref (xattr);
756
757 return 0;
758}
759
760int32_t
761index_lookup_wrapper (call_frame_t *frame, xlator_t *this,
762 loc_t *loc, dict_t *xattr_req)
763{
764 index_priv_t *priv = NULL((void*)0);
765 struct stat lstatbuf = {0};
766 int ret = 0;
767 int32_t op_errno = EINVAL22;
768 int32_t op_ret = -1;
769 char path[PATH_MAX4096] = {0};
770 struct iatt stbuf = {0, };
771 struct iatt postparent = {0,};
772 dict_t *xattr = NULL((void*)0);
773 gf_boolean_t is_dir = _gf_false;
774
775 priv = this->private;
776
777 VALIDATE_OR_GOTO (loc, done)do { if (!loc) { (*__errno_location ()) = 22; do { do { if (0
) printf ("invalid argument: " "loc"); } while (0); _gf_log_callingfn
((this ? (this->name) : "(Govinda! Govinda!)"), "index.c"
, __FUNCTION__, 777, GF_LOG_WARNING, "invalid argument: " "loc"
); } while (0); goto done; } } while (0);
778 if (!uuid_compare (loc->gfid, priv->xattrop_vgfid)) {
779 make_index_dir_path (priv->index_basepath, XATTROP_SUBDIR"xattrop",
780 path, sizeof (path));
781 is_dir = _gf_true;
782 } else if (!uuid_compare (loc->pargfid, priv->xattrop_vgfid)) {
783 make_file_path (priv->index_basepath, XATTROP_SUBDIR"xattrop",
784 loc->name, path, sizeof (path));
785 }
786
787 ret = lstat (path, &lstatbuf);
788 if (ret) {
789 gf_log (this->name, GF_LOG_DEBUG, "Stat failed on index dir "do { do { if (0) printf ("Stat failed on index dir " "(%s)", strerror
((*__errno_location ()))); } while (0); _gf_log (this->name
, "index.c", __FUNCTION__, 790, GF_LOG_DEBUG, "Stat failed on index dir "
"(%s)", strerror ((*__errno_location ()))); } while (0)
790 "(%s)", strerror (errno))do { do { if (0) printf ("Stat failed on index dir " "(%s)", strerror
((*__errno_location ()))); } while (0); _gf_log (this->name
, "index.c", __FUNCTION__, 790, GF_LOG_DEBUG, "Stat failed on index dir "
"(%s)", strerror ((*__errno_location ()))); } while (0);
791 op_errno = errno(*__errno_location ());
792 goto done;
793 } else if (!S_ISDIR (lstatbuf.st_mode)((((lstatbuf.st_mode)) & 0170000) == (0040000)) && is_dir) {
794 gf_log (this->name, GF_LOG_DEBUG, "Stat failed on index dir, "do { do { if (0) printf ("Stat failed on index dir, " "not a directory"
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 795, GF_LOG_DEBUG, "Stat failed on index dir, " "not a directory"
); } while (0)
795 "not a directory")do { do { if (0) printf ("Stat failed on index dir, " "not a directory"
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 795, GF_LOG_DEBUG, "Stat failed on index dir, " "not a directory"
); } while (0);
796 op_errno = ENOENT2;
797 goto done;
798 }
799 xattr = dict_new ();
800 if (!xattr) {
801 op_errno = ENOMEM12;
802 goto done;
803 }
804
805 iatt_from_stat (&stbuf, &lstatbuf);
806 if (is_dir)
807 uuid_copy (stbuf.ia_gfid, priv->xattrop_vgfid);
808 else
809 uuid_generate (stbuf.ia_gfid);
810 stbuf.ia_ino = -1;
811 op_ret = 0;
812done:
813 STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno,do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 814, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_lookup_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, loc->inode, &stbuf, xattr, &postparent
); (*__glusterfs_this_location()) = old_THIS; } while (0)
814 loc->inode, &stbuf, xattr, &postparent)do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 814, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_lookup_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, loc->inode, &stbuf, xattr, &postparent
); (*__glusterfs_this_location()) = old_THIS; } while (0);
815 if (xattr)
816 dict_unref (xattr);
817 return 0;
818}
819
820int32_t
821index_readdir_wrapper (call_frame_t *frame, xlator_t *this,
822 fd_t *fd, size_t size, off_t off, dict_t *xdata)
823{
824 index_fd_ctx_t *fctx = NULL((void*)0);
1
'fctx' initialized to a null pointer value
→
825 DIR *dir = NULL((void*)0);
826 int ret = -1;
827 int32_t op_ret = -1;
828 int32_t op_errno = 0;
829 int count = 0;
830 gf_dirent_t entries;
831
832 INIT_LIST_HEAD (&entries.list)do { (&entries.list)->next = (&entries.list)->prev
= &entries.list; } while (0);
833
834 ret = index_fd_ctx_get (fd, this, &fctx);
2
←
Calling 'index_fd_ctx_get'
→
11
←
Returning from 'index_fd_ctx_get'
→
835 if (ret < 0) {
12
←
Taking false branch
→
836 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("pfd is NULL, fd=%p", fd); } while (
0); _gf_log (this->name, "index.c", __FUNCTION__, 837, GF_LOG_WARNING
, "pfd is NULL, fd=%p", fd); } while (0)
837 "pfd is NULL, fd=%p", fd)do { do { if (0) printf ("pfd is NULL, fd=%p", fd); } while (
0); _gf_log (this->name, "index.c", __FUNCTION__, 837, GF_LOG_WARNING
, "pfd is NULL, fd=%p", fd); } while (0);
838 op_errno = -ret;
839 goto done;
840 }
841
842 dir = fctx->dir;
13
←
Access to field 'dir' results in a dereference of a null pointer (loaded from variable 'fctx')
843
844 if (!dir) {
845 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("dir is NULL for fd=%p", fd); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 846, GF_LOG_WARNING
, "dir is NULL for fd=%p", fd); } while (0)
846 "dir is NULL for fd=%p", fd)do { do { if (0) printf ("dir is NULL for fd=%p", fd); } while
(0); _gf_log (this->name, "index.c", __FUNCTION__, 846, GF_LOG_WARNING
, "dir is NULL for fd=%p", fd); } while (0);
847 op_errno = EINVAL22;
848 goto done;
849 }
850
851 count = index_fill_readdir (fd, dir, off, size, &entries);
852
853 /* pick ENOENT to indicate EOF */
854 op_errno = errno(*__errno_location ());
855 op_ret = count;
856done:
857 STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, &entries, xdata)do { fop_readdir_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 857, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_readdir_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, op_ret
, op_errno, &entries, xdata); (*__glusterfs_this_location
()) = old_THIS; } while (0);
858 gf_dirent_free (&entries);
859 return 0;
860}
861
862int
863index_unlink_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, int flag,
864 dict_t *xdata)
865{
866 index_priv_t *priv = NULL((void*)0);
867 int32_t op_ret = 0;
868 int32_t op_errno = 0;
869 int ret = 0;
870 struct iatt preparent = {0};
871 struct iatt postparent = {0};
872 char index_dir[PATH_MAX4096] = {0};
873 struct stat lstatbuf = {0};
874 uuid_t gfid = {0};
875
876 priv = this->private;
877 make_index_dir_path (priv->index_basepath, XATTROP_SUBDIR"xattrop",
878 index_dir, sizeof (index_dir));
879 ret = lstat (index_dir, &lstatbuf);
880 if (ret < 0) {
881 op_ret = -1;
882 op_errno = errno(*__errno_location ());
883 goto done;
884 }
885
886 iatt_from_stat (&preparent, &lstatbuf);
887 uuid_copy (preparent.ia_gfid, priv->xattrop_vgfid);
888 preparent.ia_ino = -1;
889 uuid_parse (loc->name, gfid);
890 ret = index_del (this, gfid, XATTROP_SUBDIR"xattrop");
891 if (ret < 0) {
892 op_ret = -1;
893 op_errno = -ret;
894 goto done;
895 }
896 memset (&lstatbuf, 0, sizeof (lstatbuf));
897 ret = lstat (index_dir, &lstatbuf);
898 if (ret < 0) {
899 op_ret = -1;
900 op_errno = errno(*__errno_location ());
901 goto done;
902 }
903 iatt_from_stat (&postparent, &lstatbuf);
904 uuid_copy (postparent.ia_gfid, priv->xattrop_vgfid);
905 postparent.ia_ino = -1;
906done:
907 INDEX_STACK_UNWIND (unlink, frame, op_ret, op_errno, &preparent,do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_unlink_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 908, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_unlink_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, op_ret, op_errno, &preparent, &postparent,
xdata); (*__glusterfs_this_location()) = old_THIS; } while (
0); } while (0)
908 &postparent, xdata)do { if (frame) { inode_t *_inode = frame->local; frame->
local = ((void*)0); inode_unref (_inode); } do { fop_unlink_cbk_t
fn = ((void*)0); call_frame_t *_parent = ((void*)0); xlator_t
*old_THIS = ((void*)0); if (!frame) { do { do { if (0) printf
("!frame"); } while (0); _gf_log ("stack", "index.c", __FUNCTION__
, 908, GF_LOG_CRITICAL, "!frame"); } while (0); break; } fn =
(fop_unlink_cbk_t )frame->ret; _parent = frame->parent
; pthread_spin_lock (&frame->root->stack_lock); { _parent
->ref_count--; } pthread_spin_unlock (&frame->root->
stack_lock); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = _parent->this; frame->complete = _gf_true; frame->
unwind_from = __FUNCTION__; if (frame->this->ctx->measure_latency
) gf_latency_end (frame); fn (_parent, frame->cookie, _parent
->this, op_ret, op_errno, &preparent, &postparent,
xdata); (*__glusterfs_this_location()) = old_THIS; } while (
0); } while (0);
909 return 0;
910}
911
912int32_t
913index_getxattr (call_frame_t *frame, xlator_t *this,
914 loc_t *loc, const char *name, dict_t *xdata)
915{
916 call_stub_t *stub = NULL((void*)0);
917
918 if (!name || strcmp (GF_XATTROP_INDEX_GFID"glusterfs.xattrop_index_gfid", name))
919 goto out;
920
921 stub = fop_getxattr_stub (frame, index_getxattr_wrapper, loc, name,
922 xdata);
923 if (!stub) {
924 STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM, NULL, NULL)do { fop_getxattr_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 924, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_getxattr_cbk_t )frame->ret;
_parent = frame->parent; pthread_spin_lock (&frame->
root->stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 12, ((void*)0), ((void*)0)); (*__glusterfs_this_location())
= old_THIS; } while (0);
925 return 0;
926 }
927 worker_enqueue (this, stub);
928 return 0;
929out:
930 STACK_WIND (frame, default_getxattr_cbk, FIRST_CHILD(this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 931, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->getxattr_cbk) tmp_cbk = default_getxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->getxattr"
; _new->unwind_to = "default_getxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->getxattr); (this->children->xlator
)->fops->getxattr (_new, (this->children->xlator)
, loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
931 FIRST_CHILD(this)->fops->getxattr, loc, name, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 931, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->getxattr_cbk) tmp_cbk = default_getxattr_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->getxattr"
; _new->unwind_to = "default_getxattr_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->getxattr); (this->children->xlator
)->fops->getxattr (_new, (this->children->xlator)
, loc, name, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0);
932 return 0;
933}
934
935int32_t
936index_lookup (call_frame_t *frame, xlator_t *this,
937 loc_t *loc, dict_t *xattr_req)
938{
939 call_stub_t *stub = NULL((void*)0);
940 index_priv_t *priv = NULL((void*)0);
941
942 priv = this->private;
943
944 if (uuid_compare (loc->gfid, priv->xattrop_vgfid) &&
945 uuid_compare (loc->pargfid, priv->xattrop_vgfid))
946 goto normal;
947
948 stub = fop_lookup_stub (frame, index_lookup_wrapper, loc, xattr_req);
949 if (!stub) {
950 STACK_UNWIND_STRICT (lookup, frame, -1, ENOMEM, loc->inode,do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 951, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_lookup_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 12, loc->inode, ((void*)0), ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0)
951 NULL, NULL, NULL)do { fop_lookup_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 951, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_lookup_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 12, loc->inode, ((void*)0), ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0);
952 return 0;
953 }
954 worker_enqueue (this, stub);
955 return 0;
956normal:
957 STACK_WIND (frame, default_lookup_cbk, FIRST_CHILD(this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 958, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->lookup_cbk) tmp_cbk = default_lookup_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->lookup";
_new->unwind_to = "default_lookup_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->lookup); (this->children->xlator
)->fops->lookup (_new, (this->children->xlator), loc
, xattr_req); (*__glusterfs_this_location()) = old_THIS; } while
(0)
958 FIRST_CHILD(this)->fops->lookup, loc, xattr_req)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 958, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->lookup_cbk) tmp_cbk = default_lookup_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->lookup";
_new->unwind_to = "default_lookup_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->lookup); (this->children->xlator
)->fops->lookup (_new, (this->children->xlator), loc
, xattr_req); (*__glusterfs_this_location()) = old_THIS; } while
(0);
959
960 return 0;
961}
962
963int32_t
964index_readdir (call_frame_t *frame, xlator_t *this,
965 fd_t *fd, size_t size, off_t off, dict_t *xdata)
966{
967 call_stub_t *stub = NULL((void*)0);
968 index_priv_t *priv = NULL((void*)0);
969
970 priv = this->private;
971 if (uuid_compare (fd->inode->gfid, priv->xattrop_vgfid))
972 goto out;
973 stub = fop_readdir_stub (frame, index_readdir_wrapper, fd, size, off,
974 xdata);
975 if (!stub) {
976 STACK_UNWIND_STRICT (readdir, frame, -1, ENOMEM, NULL, NULL)do { fop_readdir_cbk_t fn = ((void*)0); call_frame_t *_parent
= ((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) {
do { do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 976, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_readdir_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 12, ((void*)0), ((void*)0)); (*__glusterfs_this_location())
= old_THIS; } while (0);
977 return 0;
978 }
979 worker_enqueue (this, stub);
980 return 0;
981out:
982 STACK_WIND (frame, default_readdir_cbk, FIRST_CHILD(this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 983, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdir_cbk) tmp_cbk = default_readdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdir"
; _new->unwind_to = "default_readdir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdir); (this->children->xlator
)->fops->readdir (_new, (this->children->xlator),
fd, size, off, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0)
983 FIRST_CHILD(this)->fops->readdir, fd, size, off, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 983, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->readdir_cbk) tmp_cbk = default_readdir_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->readdir"
; _new->unwind_to = "default_readdir_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->readdir); (this->children->xlator
)->fops->readdir (_new, (this->children->xlator),
fd, size, off, xdata); (*__glusterfs_this_location()) = old_THIS
; } while (0);
984 return 0;
985}
986
987int
988index_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
989 dict_t *xdata)
990{
991 call_stub_t *stub = NULL((void*)0);
992 index_priv_t *priv = NULL((void*)0);
993
994 priv = this->private;
995 if (uuid_compare (loc->pargfid, priv->xattrop_vgfid))
996 goto out;
997
998 stub = fop_unlink_stub (frame, index_unlink_wrapper, loc, xflag, xdata);
999 if (!stub) {
1000 STACK_UNWIND_STRICT (unlink, frame, -1, ENOMEM, NULL, NULL,do { fop_unlink_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 1001, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_unlink_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 12, ((void*)0), ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0)
1001 NULL)do { fop_unlink_cbk_t fn = ((void*)0); call_frame_t *_parent =
((void*)0); xlator_t *old_THIS = ((void*)0); if (!frame) { do
{ do { if (0) printf ("!frame"); } while (0); _gf_log ("stack"
, "index.c", __FUNCTION__, 1001, GF_LOG_CRITICAL, "!frame"); }
while (0); break; } fn = (fop_unlink_cbk_t )frame->ret; _parent
= frame->parent; pthread_spin_lock (&frame->root->
stack_lock); { _parent->ref_count--; } pthread_spin_unlock
(&frame->root->stack_lock); old_THIS = (*__glusterfs_this_location
()); (*__glusterfs_this_location()) = _parent->this; frame
->complete = _gf_true; frame->unwind_from = __FUNCTION__
; if (frame->this->ctx->measure_latency) gf_latency_end
(frame); fn (_parent, frame->cookie, _parent->this, -1
, 12, ((void*)0), ((void*)0), ((void*)0)); (*__glusterfs_this_location
()) = old_THIS; } while (0);
1002 return 0;
1003 }
1004 worker_enqueue (this, stub);
1005 return 0;
1006out:
1007 STACK_WIND (frame, default_unlink_cbk, FIRST_CHILD(this),do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 1008, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->unlink_cbk) tmp_cbk = default_unlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->unlink";
_new->unwind_to = "default_unlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->unlink); (this->children->xlator
)->fops->unlink (_new, (this->children->xlator), loc
, xflag, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0)
1008 FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata)do { call_frame_t *_new = ((void*)0); xlator_t *old_THIS = ((
void*)0); _new = mem_get0 (frame->root->pool->frame_mem_pool
); if (!_new) { do { do { if (0) printf ("alloc failed"); } while
(0); _gf_log ("stack", "index.c", __FUNCTION__, 1008, GF_LOG_ERROR
, "alloc failed"); } while (0); break; } typeof( (this->children
->xlator)->fops->unlink_cbk) tmp_cbk = default_unlink_cbk
; _new->root = frame->root; _new->this = (this->children
->xlator); _new->ret = (ret_fn_t) tmp_cbk; _new->parent
= frame; _new->cookie = _new; _new->wind_from = __FUNCTION__
; _new->wind_to = "FIRST_CHILD(this)->fops->unlink";
_new->unwind_to = "default_unlink_cbk"; pthread_spin_init
(&_new->lock, 0); pthread_spin_lock (&frame->root
->stack_lock); { _new->next = frame->root->frames
.next; _new->prev = &frame->root->frames; if (frame
->root->frames.next) frame->root->frames.next->
prev = _new; frame->root->frames.next = _new; frame->
ref_count++; } pthread_spin_unlock (&frame->root->stack_lock
); old_THIS = (*__glusterfs_this_location()); (*__glusterfs_this_location
()) = (this->children->xlator); if (frame->this->
ctx->measure_latency) gf_latency_begin (_new, (this->children
->xlator)->fops->unlink); (this->children->xlator
)->fops->unlink (_new, (this->children->xlator), loc
, xflag, xdata); (*__glusterfs_this_location()) = old_THIS; }
while (0);
1009 return 0;
1010}
1011
1012int32_t
1013mem_acct_init (xlator_t *this)
1014{
1015 int ret = -1;
1016
1017 ret = xlator_mem_acct_init (this, gf_index_mt_end + 1);
1018
1019 return ret;
1020}
1021
1022int
1023init (xlator_t *this)
1024{
1025 int ret = -1;
1026 index_priv_t *priv = NULL((void*)0);
1027 pthread_t thread;
1028 pthread_attr_t w_attr;
1029 gf_boolean_t mutex_inited = _gf_false;
1030 gf_boolean_t cond_inited = _gf_false;
1031 gf_boolean_t attr_inited = _gf_false;
1032
1033 if (!this->children || this->children->next) {
1034 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("'index' not configured with exactly one child"
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1035, GF_LOG_ERROR, "'index' not configured with exactly one child"
); } while (0)
1035 "'index' not configured with exactly one child")do { do { if (0) printf ("'index' not configured with exactly one child"
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1035, GF_LOG_ERROR, "'index' not configured with exactly one child"
); } while (0);
1036 goto out;
1037 }
1038
1039 if (!this->parents) {
1040 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("dangling volume. check volfile "); }
while (0); _gf_log (this->name, "index.c", __FUNCTION__, 1041
, GF_LOG_WARNING, "dangling volume. check volfile "); } while
(0)
1041 "dangling volume. check volfile ")do { do { if (0) printf ("dangling volume. check volfile "); }
while (0); _gf_log (this->name, "index.c", __FUNCTION__, 1041
, GF_LOG_WARNING, "dangling volume. check volfile "); } while
(0);
1042 }
1043
1044 priv = GF_CALLOC (1, sizeof (*priv), gf_index_mt_priv_t)__gf_calloc (1, sizeof (*priv), gf_index_mt_priv_t);
1045 if (!priv)
1046 goto out;
1047
1048 LOCK_INIT (&priv->lock)pthread_spin_init (&priv->lock, 0);
1049 if ((ret = pthread_cond_init(&priv->cond, NULL((void*)0))) != 0) {
1050 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("pthread_cond_init failed (%d)", ret
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1051, GF_LOG_ERROR, "pthread_cond_init failed (%d)", ret); }
while (0)
1051 "pthread_cond_init failed (%d)", ret)do { do { if (0) printf ("pthread_cond_init failed (%d)", ret
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1051, GF_LOG_ERROR, "pthread_cond_init failed (%d)", ret); }
while (0);
1052 goto out;
1053 }
1054 cond_inited = _gf_true;
1055
1056 if ((ret = pthread_mutex_init(&priv->mutex, NULL((void*)0))) != 0) {
1057 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("pthread_mutex_init failed (%d)", ret
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1058, GF_LOG_ERROR, "pthread_mutex_init failed (%d)", ret);
} while (0)
1058 "pthread_mutex_init failed (%d)", ret)do { do { if (0) printf ("pthread_mutex_init failed (%d)", ret
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1058, GF_LOG_ERROR, "pthread_mutex_init failed (%d)", ret);
} while (0);
1059 goto out;
1060 }
1061 mutex_inited = _gf_true;
1062
1063 if ((ret = pthread_attr_init (&w_attr)) != 0) {
1064 gf_log (this->name, GF_LOG_ERROR,do { do { if (0) printf ("pthread_attr_init failed (%d)", ret
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1065, GF_LOG_ERROR, "pthread_attr_init failed (%d)", ret); }
while (0)
1065 "pthread_attr_init failed (%d)", ret)do { do { if (0) printf ("pthread_attr_init failed (%d)", ret
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1065, GF_LOG_ERROR, "pthread_attr_init failed (%d)", ret); }
while (0);
1066 goto out;
1067 }
1068 attr_inited = _gf_true;
1069
1070 ret = pthread_attr_setstacksize (&w_attr, INDEX_THREAD_STACK_SIZE((size_t)(1024*1024)));
1071 if (ret == EINVAL22) {
1072 gf_log (this->name, GF_LOG_WARNING,do { do { if (0) printf ("Using default thread stack size"); }
while (0); _gf_log (this->name, "index.c", __FUNCTION__, 1073
, GF_LOG_WARNING, "Using default thread stack size"); } while
(0)
1073 "Using default thread stack size")do { do { if (0) printf ("Using default thread stack size"); }
while (0); _gf_log (this->name, "index.c", __FUNCTION__, 1073
, GF_LOG_WARNING, "Using default thread stack size"); } while
(0);
1074 }
1075 GF_OPTION_INIT ("index-base", priv->index_basepath, path, out)do { int val_ret = 0; val_ret = xlator_option_init_path ((*__glusterfs_this_location
()), (*__glusterfs_this_location())->options, "index-base"
, &(priv->index_basepath)); if (val_ret) goto out; } while
(0);
1076 uuid_generate (priv->index);
1077 uuid_generate (priv->xattrop_vgfid);
1078 INIT_LIST_HEAD (&priv->callstubs)do { (&priv->callstubs)->next = (&priv->callstubs
)->prev = &priv->callstubs; } while (0);
1079
1080 this->private = priv;
1081 ret = pthread_create (&thread, &w_attr, index_worker, this);
1082 if (ret) {
1083 gf_log (this->name, GF_LOG_WARNING, "Failed to create "do { do { if (0) printf ("Failed to create " "worker thread, aborting"
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1084, GF_LOG_WARNING, "Failed to create " "worker thread, aborting"
); } while (0)
1084 "worker thread, aborting")do { do { if (0) printf ("Failed to create " "worker thread, aborting"
); } while (0); _gf_log (this->name, "index.c", __FUNCTION__
, 1084, GF_LOG_WARNING, "Failed to create " "worker thread, aborting"
); } while (0);
1085 goto out;
1086 }
1087 ret = 0;
1088out:
1089 if (ret) {
1090 if (cond_inited)
1091 pthread_cond_destroy (&priv->cond);
1092 if (mutex_inited)
1093 pthread_mutex_destroy (&priv->mutex);
1094 if (priv)
1095 GF_FREE (priv)__gf_free (priv);
1096 this->private = NULL((void*)0);
1097 }
1098 if (attr_inited)
1099 pthread_attr_destroy (&w_attr);
1100 return ret;
1101}
1102
1103void
1104fini (xlator_t *this)
1105{
1106 index_priv_t *priv = NULL((void*)0);
1107
1108 priv = this->private;
1109 if (!priv)
1110 goto out;
1111 this->private = NULL((void*)0);
1112 LOCK_DESTROY (&priv->lock)pthread_spin_destroy (&priv->lock);
1113 pthread_cond_destroy (&priv->cond);
1114 pthread_mutex_destroy (&priv->mutex);
1115 GF_FREE (priv)__gf_free (priv);
1116out:
1117 return;
1118}
1119
1120int
1121index_forget (xlator_t *this, inode_t *inode)
1122{
1123 uint64_t tmp_cache = 0;
1124 if (!inode_ctx_del (inode, this, &tmp_cache)inode_ctx_del2(inode,this,&tmp_cache,0))
1125 GF_FREE ((index_inode_ctx_t*) (long)tmp_cache)__gf_free ((index_inode_ctx_t*) (long)tmp_cache);
1126
1127 return 0;
1128}
1129
1130int32_t
1131index_releasedir (xlator_t *this, fd_t *fd)
1132{
1133 index_fd_ctx_t *fctx = NULL((void*)0);
1134 uint64_t ctx = 0;
1135 int ret = 0;
1136
1137 ret = fd_ctx_del (fd, this, &ctx);
1138 if (ret < 0)
1139 goto out;
1140
1141 fctx = (index_fd_ctx_t*) (long) ctx;
1142 if (fctx->dir)
1143 closedir (fctx->dir);
1144
1145 GF_FREE (fctx)__gf_free (fctx);
1146out:
1147 return 0;
1148}
1149
1150int32_t
1151index_release (xlator_t *this, fd_t *fd)
1152{
1153 index_fd_ctx_t *fctx = NULL((void*)0);
1154 uint64_t ctx = 0;
1155 int ret = 0;
1156
1157 ret = fd_ctx_del (fd, this, &ctx);
1158 if (ret < 0)
1159 goto out;
1160
1161 fctx = (index_fd_ctx_t*) (long) ctx;
1162 GF_FREE (fctx)__gf_free (fctx);
1163out:
1164 return 0;
1165}
1166
1167int
1168notify (xlator_t *this, int event, void *data, ...)
1169{
1170 int ret = 0;
1171 ret = default_notify (this, event, data);
1172 return ret;
1173}
1174
1175struct xlator_fops fops = {
1176 .xattrop = index_xattrop,
1177 .fxattrop = index_fxattrop,
1178
1179 //interface functions follow
1180 .getxattr = index_getxattr,
1181 .lookup = index_lookup,
1182 .readdir = index_readdir,
1183 .unlink = index_unlink
1184};
1185
1186struct xlator_dumpops dumpops;
1187
1188struct xlator_cbks cbks = {
1189 .forget = index_forget,
1190 .release = index_release,
1191 .releasedir = index_releasedir
1192};
1193
1194struct volume_options options[] = {
1195 { .key = {"index-base" },
1196 .type = GF_OPTION_TYPE_PATH,
1197 .description = "path where the index files need to be stored",
1198 },
1199 { .key = {NULL((void*)0)} },
1200};