libglusterfs/src/*.c: whitespace cleanup

Signed-off-by: Amar Tumballi <amar@gluster.com>
Signed-off-by: Vijay Bellur <vijay@dev.gluster.com>

BUG: 2346 (Log message enhancements in GlusterFS - phase 1)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=2346

1 files changed, 758 insertions, 758 deletions

diff --git a/libglusterfs/src/event.c b/libglusterfs/src/event.c
index cb6abd4180e..4f64966b2d9 100644
--- a/libglusterfs/src/event.c
+++ b/libglusterfs/src/event.c
@@ -1,20 +1,20 @@
 /*
-   Copyright (c) 2008-2010 Gluster, Inc. <http://www.gluster.com>
-   This file is part of GlusterFS.
-
-   GlusterFS is free software; you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published
-   by the Free Software Foundation; either version 3 of the License,
-   or (at your option) any later version.
-
-   GlusterFS is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Affero General Public License for more details.
-
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see
-   <http://www.gnu.org/licenses/>.
+  Copyright (c) 2008-2010 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Affero General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Affero General Public License for more details.
+
+  You should have received a copy of the GNU Affero General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
 */
 
 #include <sys/poll.h>
@@ -37,440 +37,440 @@
 
 static int
 event_register_poll (struct event_pool *event_pool, int fd,
-		     event_handler_t handler,
-		     void *data, int poll_in, int poll_out);
+                     event_handler_t handler,
+                     void *data, int poll_in, int poll_out);
 
 
 static int
 __flush_fd (int fd, int idx, void *data,
-	    int poll_in, int poll_out, int poll_err)
+            int poll_in, int poll_out, int poll_err)
 {
-	char buf[64];
-	int ret = -1;
-
-	if (!poll_in)
-		return ret;
-
-	do {
-		ret = read (fd, buf, 64);
-		if (ret == -1 && errno != EAGAIN) {
-			gf_log ("poll", GF_LOG_ERROR,
-				"read on %d returned error (%s)",
-				fd, strerror (errno));
-		}
-	} while (ret == 64);
-
-	return ret;
+        char buf[64];
+        int ret = -1;
+
+        if (!poll_in)
+                return ret;
+
+        do {
+                ret = read (fd, buf, 64);
+                if (ret == -1 && errno != EAGAIN) {
+                        gf_log ("poll", GF_LOG_ERROR,
+                                "read on %d returned error (%s)",
+                                fd, strerror (errno));
+                }
+        } while (ret == 64);
+
+        return ret;
 }
 
 
 static int
 __event_getindex (struct event_pool *event_pool, int fd, int idx)
 {
-	int  ret = -1;
-	int  i = 0;
-  
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	if (idx > -1 && idx < event_pool->used) {
-		if (event_pool->reg[idx].fd == fd)
-			ret = idx;
-	}
-
-	for (i=0; ret == -1 && i<event_pool->used; i++) {
-		if (event_pool->reg[i].fd == fd) {
-			ret = i;
-			break;
-		}
-	}
-
-	return ret;
+        int  ret = -1;
+        int  i = 0;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        if (idx > -1 && idx < event_pool->used) {
+                if (event_pool->reg[idx].fd == fd)
+                        ret = idx;
+        }
+
+        for (i=0; ret == -1 && i<event_pool->used; i++) {
+                if (event_pool->reg[i].fd == fd) {
+                        ret = i;
+                        break;
+                }
+        }
+
+        return ret;
 }
 
 
 static struct event_pool *
 event_pool_new_poll (int count)
 {
-	struct event_pool *event_pool = NULL;
-	int                ret = -1;
+        struct event_pool *event_pool = NULL;
+        int                ret = -1;
 
-	event_pool = GF_CALLOC (1, sizeof (*event_pool),
+        event_pool = GF_CALLOC (1, sizeof (*event_pool),
                                 gf_common_mt_event_pool);
 
-	if (!event_pool)
-		return NULL;
-
-	event_pool->count = count;
-	event_pool->reg = GF_CALLOC (event_pool->count,
-				  sizeof (*event_pool->reg),
-                                  gf_common_mt_reg);
-
-	if (!event_pool->reg) {
-		gf_log ("poll", GF_LOG_CRITICAL,
-			"failed to allocate event registry");
-		GF_FREE (event_pool);
-		return NULL;
-	}
-
-	pthread_mutex_init (&event_pool->mutex, NULL);
-
-	ret = pipe (event_pool->breaker);
-
-	if (ret == -1) {
-		gf_log ("poll", GF_LOG_ERROR,
-			"pipe creation failed (%s)", strerror (errno));
-		GF_FREE (event_pool->reg);
-		GF_FREE (event_pool);
-		return NULL;
-	}
-
-	ret = fcntl (event_pool->breaker[0], F_SETFL, O_NONBLOCK);
-	if (ret == -1) {
-		gf_log ("poll", GF_LOG_ERROR,
-			"could not set pipe to non blocking mode (%s)",
-			strerror (errno));
-		close (event_pool->breaker[0]);
-		close (event_pool->breaker[1]);
-		event_pool->breaker[0] = event_pool->breaker[1] = -1;
-
-		GF_FREE (event_pool->reg);
-		GF_FREE (event_pool);
-		return NULL;
-	}
-
-	ret = fcntl (event_pool->breaker[1], F_SETFL, O_NONBLOCK);
-	if (ret == -1) {
-		gf_log ("poll", GF_LOG_ERROR,
-			"could not set pipe to non blocking mode (%s)",
-			strerror (errno));
-
-		close (event_pool->breaker[0]);
-		close (event_pool->breaker[1]);
-		event_pool->breaker[0] = event_pool->breaker[1] = -1;
-
-		GF_FREE (event_pool->reg);
-		GF_FREE (event_pool);
-		return NULL;
-	}
-
-	ret = event_register_poll (event_pool, event_pool->breaker[0],
-				   __flush_fd, NULL, 1, 0);
-	if (ret == -1) {
-		gf_log ("poll", GF_LOG_ERROR,
-			"could not register pipe fd with poll event loop");
-		close (event_pool->breaker[0]);
-		close (event_pool->breaker[1]);
-		event_pool->breaker[0] = event_pool->breaker[1] = -1;
-
-		GF_FREE (event_pool->reg);
-		GF_FREE (event_pool);
-		return NULL;
-	}
-
-	return event_pool;
+        if (!event_pool)
+                return NULL;
+
+        event_pool->count = count;
+        event_pool->reg = GF_CALLOC (event_pool->count,
+                                     sizeof (*event_pool->reg),
+                                     gf_common_mt_reg);
+
+        if (!event_pool->reg) {
+                gf_log ("poll", GF_LOG_CRITICAL,
+                        "failed to allocate event registry");
+                GF_FREE (event_pool);
+                return NULL;
+        }
+
+        pthread_mutex_init (&event_pool->mutex, NULL);
+
+        ret = pipe (event_pool->breaker);
+
+        if (ret == -1) {
+                gf_log ("poll", GF_LOG_ERROR,
+                        "pipe creation failed (%s)", strerror (errno));
+                GF_FREE (event_pool->reg);
+                GF_FREE (event_pool);
+                return NULL;
+        }
+
+        ret = fcntl (event_pool->breaker[0], F_SETFL, O_NONBLOCK);
+        if (ret == -1) {
+                gf_log ("poll", GF_LOG_ERROR,
+                        "could not set pipe to non blocking mode (%s)",
+                        strerror (errno));
+                close (event_pool->breaker[0]);
+                close (event_pool->breaker[1]);
+                event_pool->breaker[0] = event_pool->breaker[1] = -1;
+
+                GF_FREE (event_pool->reg);
+                GF_FREE (event_pool);
+                return NULL;
+        }
+
+        ret = fcntl (event_pool->breaker[1], F_SETFL, O_NONBLOCK);
+        if (ret == -1) {
+                gf_log ("poll", GF_LOG_ERROR,
+                        "could not set pipe to non blocking mode (%s)",
+                        strerror (errno));
+
+                close (event_pool->breaker[0]);
+                close (event_pool->breaker[1]);
+                event_pool->breaker[0] = event_pool->breaker[1] = -1;
+
+                GF_FREE (event_pool->reg);
+                GF_FREE (event_pool);
+                return NULL;
+        }
+
+        ret = event_register_poll (event_pool, event_pool->breaker[0],
+                                   __flush_fd, NULL, 1, 0);
+        if (ret == -1) {
+                gf_log ("poll", GF_LOG_ERROR,
+                        "could not register pipe fd with poll event loop");
+                close (event_pool->breaker[0]);
+                close (event_pool->breaker[1]);
+                event_pool->breaker[0] = event_pool->breaker[1] = -1;
+
+                GF_FREE (event_pool->reg);
+                GF_FREE (event_pool);
+                return NULL;
+        }
+
+        return event_pool;
 }
 
 
 static int
 event_register_poll (struct event_pool *event_pool, int fd,
-		     event_handler_t handler,
-		     void *data, int poll_in, int poll_out)
+                     event_handler_t handler,
+                     void *data, int poll_in, int poll_out)
 {
-	int idx = -1;
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		if (event_pool->count == event_pool->used)
-		{
-			event_pool->count += 256;
-
-			event_pool->reg = GF_REALLOC (event_pool->reg,
-					        event_pool->count *
-						sizeof (*event_pool->reg));
+        int idx = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                if (event_pool->count == event_pool->used)
+                {
+                        event_pool->count += 256;
+
+                        event_pool->reg = GF_REALLOC (event_pool->reg,
+                                                      event_pool->count *
+                                                      sizeof (*event_pool->reg));
                         if (!event_pool->reg)
                                 goto unlock;
-		}
-
-		idx = event_pool->used++;
-
-		event_pool->reg[idx].fd = fd;
-		event_pool->reg[idx].events = POLLPRI;
-		event_pool->reg[idx].handler = handler;
-		event_pool->reg[idx].data = data;
-
-		switch (poll_in) {
-		case 1:
-			event_pool->reg[idx].events |= POLLIN;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~POLLIN;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			gf_log ("poll", GF_LOG_ERROR,
-				"invalid poll_in value %d", poll_in);
-			break;
-		}
-
-		switch (poll_out) {
-		case 1:
-			event_pool->reg[idx].events |= POLLOUT;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~POLLOUT;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			gf_log ("poll", GF_LOG_ERROR,
-				"invalid poll_out value %d", poll_out);
-			break;
-		}
-
-		event_pool->changed = 1;
-
-	}
+                }
+
+                idx = event_pool->used++;
+
+                event_pool->reg[idx].fd = fd;
+                event_pool->reg[idx].events = POLLPRI;
+                event_pool->reg[idx].handler = handler;
+                event_pool->reg[idx].data = data;
+
+                switch (poll_in) {
+                case 1:
+                        event_pool->reg[idx].events |= POLLIN;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~POLLIN;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        gf_log ("poll", GF_LOG_ERROR,
+                                "invalid poll_in value %d", poll_in);
+                        break;
+                }
+
+                switch (poll_out) {
+                case 1:
+                        event_pool->reg[idx].events |= POLLOUT;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~POLLOUT;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        gf_log ("poll", GF_LOG_ERROR,
+                                "invalid poll_out value %d", poll_out);
+                        break;
+                }
+
+                event_pool->changed = 1;
+
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	return idx;
+        return idx;
 }
 
 
 static int
 event_unregister_poll (struct event_pool *event_pool, int fd, int idx_hint)
 {
-	int idx = -1;
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_getindex (event_pool, fd, idx_hint);
-
-		if (idx == -1) {
-			gf_log ("poll", GF_LOG_ERROR,
-				"index not found for fd=%d (idx_hint=%d)",
-				fd, idx_hint);
-			errno = ENOENT;
-			goto unlock;
-		}
-
-		event_pool->reg[idx] = 	event_pool->reg[--event_pool->used];
-		event_pool->changed = 1;
-	}
+        int idx = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                idx = __event_getindex (event_pool, fd, idx_hint);
+
+                if (idx == -1) {
+                        gf_log ("poll", GF_LOG_ERROR,
+                                "index not found for fd=%d (idx_hint=%d)",
+                                fd, idx_hint);
+                        errno = ENOENT;
+                        goto unlock;
+                }
+
+                event_pool->reg[idx] =  event_pool->reg[--event_pool->used];
+                event_pool->changed = 1;
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	return idx;
+        return idx;
 }
 
 
 static int
 event_select_on_poll (struct event_pool *event_pool, int fd, int idx_hint,
-		      int poll_in, int poll_out)
+                      int poll_in, int poll_out)
 {
-	int idx = -1;
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_getindex (event_pool, fd, idx_hint);
-
-		if (idx == -1) {
-			gf_log ("poll", GF_LOG_ERROR,
-				"index not found for fd=%d (idx_hint=%d)",
-				fd, idx_hint);
-			errno = ENOENT;
-			goto unlock;
-		}
-
-		switch (poll_in) {
-		case 1:
-			event_pool->reg[idx].events |= POLLIN;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~POLLIN;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			/* TODO: log error */
-			break;
-		}
-
-		switch (poll_out) {
-		case 1:
-			event_pool->reg[idx].events |= POLLOUT;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~POLLOUT;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			/* TODO: log error */
-			break;
-		}
-
-		if (poll_in + poll_out > -2)
-			event_pool->changed = 1;
-	}
+        int idx = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                idx = __event_getindex (event_pool, fd, idx_hint);
+
+                if (idx == -1) {
+                        gf_log ("poll", GF_LOG_ERROR,
+                                "index not found for fd=%d (idx_hint=%d)",
+                                fd, idx_hint);
+                        errno = ENOENT;
+                        goto unlock;
+                }
+
+                switch (poll_in) {
+                case 1:
+                        event_pool->reg[idx].events |= POLLIN;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~POLLIN;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        /* TODO: log error */
+                        break;
+                }
+
+                switch (poll_out) {
+                case 1:
+                        event_pool->reg[idx].events |= POLLOUT;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~POLLOUT;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        /* TODO: log error */
+                        break;
+                }
+
+                if (poll_in + poll_out > -2)
+                        event_pool->changed = 1;
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	return idx;
+        return idx;
 }
 
 
 static int
 event_dispatch_poll_handler (struct event_pool *event_pool,
-			     struct pollfd *ufds, int i)
+                             struct pollfd *ufds, int i)
 {
-	event_handler_t  handler = NULL;
-	void            *data = NULL;
-	int              idx = -1;
-	int              ret = 0;
-
-	handler = NULL;
-	data    = NULL;
-
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_getindex (event_pool, ufds[i].fd, i);
-
-		if (idx == -1) {
-			gf_log ("poll", GF_LOG_ERROR,
-				"index not found for fd=%d (idx_hint=%d)",
-				ufds[i].fd, i);
-			goto unlock;
-		}
-
-		handler = event_pool->reg[idx].handler;
-		data = event_pool->reg[idx].data;
-	}
+        event_handler_t  handler = NULL;
+        void            *data = NULL;
+        int              idx = -1;
+        int              ret = 0;
+
+        handler = NULL;
+        data    = NULL;
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                idx = __event_getindex (event_pool, ufds[i].fd, i);
+
+                if (idx == -1) {
+                        gf_log ("poll", GF_LOG_ERROR,
+                                "index not found for fd=%d (idx_hint=%d)",
+                                ufds[i].fd, i);
+                        goto unlock;
+                }
+
+                handler = event_pool->reg[idx].handler;
+                data = event_pool->reg[idx].data;
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	if (handler)
-		ret = handler (ufds[i].fd, idx, data,
-			       (ufds[i].revents & (POLLIN|POLLPRI)),
-			       (ufds[i].revents & (POLLOUT)),
-			       (ufds[i].revents & (POLLERR|POLLHUP|POLLNVAL)));
+        if (handler)
+                ret = handler (ufds[i].fd, idx, data,
+                               (ufds[i].revents & (POLLIN|POLLPRI)),
+                               (ufds[i].revents & (POLLOUT)),
+                               (ufds[i].revents & (POLLERR|POLLHUP|POLLNVAL)));
 
-	return ret;
+        return ret;
 }
 
 
 static int
 event_dispatch_poll_resize (struct event_pool *event_pool,
-			    struct pollfd *ufds, int size)
+                            struct pollfd *ufds, int size)
 {
-	int              i = 0;
+        int              i = 0;
 
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		if (event_pool->changed == 0) {
-			goto unlock;
-		}
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                if (event_pool->changed == 0) {
+                        goto unlock;
+                }
 
-		if (event_pool->used > event_pool->evcache_size) {
-			if (event_pool->evcache)
-				GF_FREE (event_pool->evcache);
+                if (event_pool->used > event_pool->evcache_size) {
+                        if (event_pool->evcache)
+                                GF_FREE (event_pool->evcache);
 
-			event_pool->evcache = ufds = NULL;
+                        event_pool->evcache = ufds = NULL;
 
-			event_pool->evcache_size = event_pool->used;
+                        event_pool->evcache_size = event_pool->used;
 
-			ufds = GF_CALLOC (sizeof (struct pollfd),
-					  event_pool->evcache_size,
+                        ufds = GF_CALLOC (sizeof (struct pollfd),
+                                          event_pool->evcache_size,
                                           gf_common_mt_pollfd);
                         if (!ufds)
                                 goto unlock;
-			event_pool->evcache = ufds;
-		}
+                        event_pool->evcache = ufds;
+                }
 
-		for (i = 0; i < event_pool->used; i++) {
-			ufds[i].fd = event_pool->reg[i].fd;
-			ufds[i].events = event_pool->reg[i].events;
-			ufds[i].revents = 0;
-		}
+                for (i = 0; i < event_pool->used; i++) {
+                        ufds[i].fd = event_pool->reg[i].fd;
+                        ufds[i].events = event_pool->reg[i].events;
+                        ufds[i].revents = 0;
+                }
 
-		size = i;
-	}
+                size = i;
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	return size;
+        return size;
 }
 
 
 static int
 event_dispatch_poll (struct event_pool *event_pool)
 {
-	struct pollfd   *ufds = NULL;
-	int              size = 0;
-	int              i = 0;
-	int              ret = -1;
+        struct pollfd   *ufds = NULL;
+        int              size = 0;
+        int              i = 0;
+        int              ret = -1;
 
 
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	while (1) {
-		size = event_dispatch_poll_resize (event_pool, ufds, size);
-		ufds = event_pool->evcache;
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
 
-		ret = poll (ufds, size, 1);
+        while (1) {
+                size = event_dispatch_poll_resize (event_pool, ufds, size);
+                ufds = event_pool->evcache;
 
-		if (ret == 0)
-			/* timeout */
-			continue;
+                ret = poll (ufds, size, 1);
 
-		if (ret == -1 && errno == EINTR)
-			/* sys call */
-			continue;
+                if (ret == 0)
+                        /* timeout */
+                        continue;
 
-		for (i = 0; i < size; i++) {
-			if (!ufds[i].revents)
-				continue;
+                if (ret == -1 && errno == EINTR)
+                        /* sys call */
+                        continue;
 
-			event_dispatch_poll_handler (event_pool, ufds, i);
-		}
-	}
+                for (i = 0; i < size; i++) {
+                        if (!ufds[i].revents)
+                                continue;
 
-	return -1;
+                        event_dispatch_poll_handler (event_pool, ufds, i);
+                }
+        }
+
+        return -1;
 }
 
 
 static struct event_ops event_ops_poll = {
-	.new              = event_pool_new_poll,
-	.event_register   = event_register_poll,
-	.event_select_on  = event_select_on_poll,
-	.event_unregister = event_unregister_poll,
-	.event_dispatch   = event_dispatch_poll
+        .new              = event_pool_new_poll,
+        .event_register   = event_register_poll,
+        .event_select_on  = event_select_on_poll,
+        .event_unregister = event_unregister_poll,
+        .event_dispatch   = event_dispatch_poll
 };
 
 
@@ -482,412 +482,412 @@ static struct event_ops event_ops_poll = {
 static struct event_pool *
 event_pool_new_epoll (int count)
 {
-	struct event_pool *event_pool = NULL;
-	int                epfd = -1;
+        struct event_pool *event_pool = NULL;
+        int                epfd = -1;
 
-	event_pool = GF_CALLOC (1, sizeof (*event_pool),
+        event_pool = GF_CALLOC (1, sizeof (*event_pool),
                                 gf_common_mt_event_pool);
 
-	if (!event_pool)
-		return NULL;
+        if (!event_pool)
+                return NULL;
 
-	event_pool->count = count;
-	event_pool->reg = GF_CALLOC (event_pool->count,
-				  sizeof (*event_pool->reg),
-                                  gf_common_mt_reg);
+        event_pool->count = count;
+        event_pool->reg = GF_CALLOC (event_pool->count,
+                                     sizeof (*event_pool->reg),
+                                     gf_common_mt_reg);
 
-	if (!event_pool->reg) {
-		gf_log ("epoll", GF_LOG_CRITICAL,
-			"event registry allocation failed");
-		GF_FREE (event_pool);
-		return NULL;
-	}
+        if (!event_pool->reg) {
+                gf_log ("epoll", GF_LOG_CRITICAL,
+                        "event registry allocation failed");
+                GF_FREE (event_pool);
+                return NULL;
+        }
 
-	epfd = epoll_create (count);
+        epfd = epoll_create (count);
 
-	if (epfd == -1) {
-		gf_log ("epoll", GF_LOG_ERROR, "epoll fd creation failed (%s)",
-			strerror (errno));
-		GF_FREE (event_pool->reg);
-		GF_FREE (event_pool);
-		return NULL;
-	}
+        if (epfd == -1) {
+                gf_log ("epoll", GF_LOG_ERROR, "epoll fd creation failed (%s)",
+                        strerror (errno));
+                GF_FREE (event_pool->reg);
+                GF_FREE (event_pool);
+                return NULL;
+        }
 
-	event_pool->fd = epfd;
+        event_pool->fd = epfd;
 
-	event_pool->count = count;
+        event_pool->count = count;
 
-	pthread_mutex_init (&event_pool->mutex, NULL);
-	pthread_cond_init (&event_pool->cond, NULL);
+        pthread_mutex_init (&event_pool->mutex, NULL);
+        pthread_cond_init (&event_pool->cond, NULL);
 
-	return event_pool;
+        return event_pool;
 }
 
 
 int
 event_register_epoll (struct event_pool *event_pool, int fd,
-		      event_handler_t handler,
-		      void *data, int poll_in, int poll_out)
+                      event_handler_t handler,
+                      void *data, int poll_in, int poll_out)
 {
-	int                 idx = -1;
-	int                 ret = -1;
-	struct epoll_event  epoll_event = {0, };
-	struct event_data  *ev_data = (void *)&epoll_event.data;
-
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		if (event_pool->count == event_pool->used) {
-			event_pool->count *= 2;
-
-			event_pool->reg = GF_REALLOC (event_pool->reg,
-						   event_pool->count *
-						   sizeof (*event_pool->reg));
-
-			if (!event_pool->reg) {
-				gf_log ("epoll", GF_LOG_ERROR,
-					"event registry re-allocation failed");
-				goto unlock;
-			}
-		}
-
-		idx = event_pool->used;
-		event_pool->used++;
-
-		event_pool->reg[idx].fd = fd;
-		event_pool->reg[idx].events = EPOLLPRI;
-		event_pool->reg[idx].handler = handler;
-		event_pool->reg[idx].data = data;
-
-		switch (poll_in) {
-		case 1:
-			event_pool->reg[idx].events |= EPOLLIN;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~EPOLLIN;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			gf_log ("epoll", GF_LOG_ERROR,
-				"invalid poll_in value %d", poll_in);
-			break;
-		}
-
-		switch (poll_out) {
-		case 1:
-			event_pool->reg[idx].events |= EPOLLOUT;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~EPOLLOUT;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			gf_log ("epoll", GF_LOG_ERROR,
-				"invalid poll_out value %d", poll_out);
-			break;
-		}
-
-		event_pool->changed = 1;
-
-		epoll_event.events = event_pool->reg[idx].events;
-		ev_data->fd = fd;
-		ev_data->idx = idx;
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_ADD, fd,
-				 &epoll_event);
-
-		if (ret == -1) {
-			gf_log ("epoll", GF_LOG_ERROR,
-				"failed to add fd(=%d) to epoll fd(=%d) (%s)",
-				fd, event_pool->fd, strerror (errno));
-			goto unlock;
-		}
-
-		pthread_cond_broadcast (&event_pool->cond);
-	}
+        int                 idx = -1;
+        int                 ret = -1;
+        struct epoll_event  epoll_event = {0, };
+        struct event_data  *ev_data = (void *)&epoll_event.data;
+
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                if (event_pool->count == event_pool->used) {
+                        event_pool->count *= 2;
+
+                        event_pool->reg = GF_REALLOC (event_pool->reg,
+                                                      event_pool->count *
+                                                      sizeof (*event_pool->reg));
+
+                        if (!event_pool->reg) {
+                                gf_log ("epoll", GF_LOG_ERROR,
+                                        "event registry re-allocation failed");
+                                goto unlock;
+                        }
+                }
+
+                idx = event_pool->used;
+                event_pool->used++;
+
+                event_pool->reg[idx].fd = fd;
+                event_pool->reg[idx].events = EPOLLPRI;
+                event_pool->reg[idx].handler = handler;
+                event_pool->reg[idx].data = data;
+
+                switch (poll_in) {
+                case 1:
+                        event_pool->reg[idx].events |= EPOLLIN;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~EPOLLIN;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "invalid poll_in value %d", poll_in);
+                        break;
+                }
+
+                switch (poll_out) {
+                case 1:
+                        event_pool->reg[idx].events |= EPOLLOUT;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~EPOLLOUT;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "invalid poll_out value %d", poll_out);
+                        break;
+                }
+
+                event_pool->changed = 1;
+
+                epoll_event.events = event_pool->reg[idx].events;
+                ev_data->fd = fd;
+                ev_data->idx = idx;
+
+                ret = epoll_ctl (event_pool->fd, EPOLL_CTL_ADD, fd,
+                                 &epoll_event);
+
+                if (ret == -1) {
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "failed to add fd(=%d) to epoll fd(=%d) (%s)",
+                                fd, event_pool->fd, strerror (errno));
+                        goto unlock;
+                }
+
+                pthread_cond_broadcast (&event_pool->cond);
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	return ret;
+        return ret;
 }
 
 
 static int
 event_unregister_epoll (struct event_pool *event_pool, int fd, int idx_hint)
 {
-	int  idx = -1;
-	int  ret = -1;
-
-	struct epoll_event epoll_event = {0, };
-	struct event_data *ev_data = (void *)&epoll_event.data;
-	int                lastidx = -1;
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_getindex (event_pool, fd, idx_hint);
-
-		if (idx == -1) {
-			gf_log ("epoll", GF_LOG_ERROR,
-				"index not found for fd=%d (idx_hint=%d)",
-				fd, idx_hint);
-			errno = ENOENT;
-			goto unlock;
-		}
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_DEL, fd, NULL);
-
-		/* if ret is -1, this array member should never be accessed */
-		/* if it is 0, the array member might be used by idx_cache
-		 * in which case the member should not be accessed till
-		 * it is reallocated
-		 */
-
-		event_pool->reg[idx].fd = -1;
-
-		if (ret == -1) {
-			gf_log ("epoll", GF_LOG_ERROR,
-				"fail to del fd(=%d) from epoll fd(=%d) (%s)",
-				fd, event_pool->fd, strerror (errno));
-			goto unlock;
-		}
-
-		lastidx = event_pool->used - 1;
-		if (lastidx == idx) {
-			event_pool->used--;
-			goto unlock;
-		}
-
-		epoll_event.events = event_pool->reg[lastidx].events;
-		ev_data->fd = event_pool->reg[lastidx].fd;
-		ev_data->idx = idx;
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, ev_data->fd,
-				 &epoll_event);
-		if (ret == -1) {
-			gf_log ("epoll", GF_LOG_ERROR,
-				"fail to modify fd(=%d) index %d to %d (%s)",
-				ev_data->fd, event_pool->used, idx,
-				strerror (errno));
-			goto unlock;
-		}
-
-		/* just replace the unregistered idx by last one */
-		event_pool->reg[idx] = event_pool->reg[lastidx];
-		event_pool->used--;
-	}
+        int  idx = -1;
+        int  ret = -1;
+
+        struct epoll_event epoll_event = {0, };
+        struct event_data *ev_data = (void *)&epoll_event.data;
+        int                lastidx = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                idx = __event_getindex (event_pool, fd, idx_hint);
+
+                if (idx == -1) {
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "index not found for fd=%d (idx_hint=%d)",
+                                fd, idx_hint);
+                        errno = ENOENT;
+                        goto unlock;
+                }
+
+                ret = epoll_ctl (event_pool->fd, EPOLL_CTL_DEL, fd, NULL);
+
+                /* if ret is -1, this array member should never be accessed */
+                /* if it is 0, the array member might be used by idx_cache
+                 * in which case the member should not be accessed till
+                 * it is reallocated
+                 */
+
+                event_pool->reg[idx].fd = -1;
+
+                if (ret == -1) {
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "fail to del fd(=%d) from epoll fd(=%d) (%s)",
+                                fd, event_pool->fd, strerror (errno));
+                        goto unlock;
+                }
+
+                lastidx = event_pool->used - 1;
+                if (lastidx == idx) {
+                        event_pool->used--;
+                        goto unlock;
+                }
+
+                epoll_event.events = event_pool->reg[lastidx].events;
+                ev_data->fd = event_pool->reg[lastidx].fd;
+                ev_data->idx = idx;
+
+                ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, ev_data->fd,
+                                 &epoll_event);
+                if (ret == -1) {
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "fail to modify fd(=%d) index %d to %d (%s)",
+                                ev_data->fd, event_pool->used, idx,
+                                strerror (errno));
+                        goto unlock;
+                }
+
+                /* just replace the unregistered idx by last one */
+                event_pool->reg[idx] = event_pool->reg[lastidx];
+                event_pool->used--;
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	return ret;
+        return ret;
 }
 
 
 static int
 event_select_on_epoll (struct event_pool *event_pool, int fd, int idx_hint,
-		       int poll_in, int poll_out)
+                       int poll_in, int poll_out)
 {
-	int idx = -1;
-	int ret = -1;
-
-	struct epoll_event epoll_event = {0, };
-	struct event_data *ev_data = (void *)&epoll_event.data;
-
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_getindex (event_pool, fd, idx_hint);
-
-		if (idx == -1) {
-			gf_log ("epoll", GF_LOG_ERROR,
-				"index not found for fd=%d (idx_hint=%d)",
-				fd, idx_hint);
-			errno = ENOENT;
-			goto unlock;
-		}
-
-		switch (poll_in) {
-		case 1:
-			event_pool->reg[idx].events |= EPOLLIN;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~EPOLLIN;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			gf_log ("epoll", GF_LOG_ERROR,
-				"invalid poll_in value %d", poll_in);
-			break;
-		}
-
-		switch (poll_out) {
-		case 1:
-			event_pool->reg[idx].events |= EPOLLOUT;
-			break;
-		case 0:
-			event_pool->reg[idx].events &= ~EPOLLOUT;
-			break;
-		case -1:
-			/* do nothing */
-			break;
-		default:
-			gf_log ("epoll", GF_LOG_ERROR,
-				"invalid poll_out value %d", poll_out);
-			break;
-		}
-
-		epoll_event.events = event_pool->reg[idx].events;
-		ev_data->fd = fd;
-		ev_data->idx = idx;
-
-		ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, fd,
-				 &epoll_event);
-		if (ret == -1) {
-			gf_log ("epoll", GF_LOG_ERROR,
-				"failed to modify fd(=%d) events to %d",
-				fd, epoll_event.events);
-		}
-	}
+        int idx = -1;
+        int ret = -1;
+
+        struct epoll_event epoll_event = {0, };
+        struct event_data *ev_data = (void *)&epoll_event.data;
+
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                idx = __event_getindex (event_pool, fd, idx_hint);
+
+                if (idx == -1) {
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "index not found for fd=%d (idx_hint=%d)",
+                                fd, idx_hint);
+                        errno = ENOENT;
+                        goto unlock;
+                }
+
+                switch (poll_in) {
+                case 1:
+                        event_pool->reg[idx].events |= EPOLLIN;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~EPOLLIN;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "invalid poll_in value %d", poll_in);
+                        break;
+                }
+
+                switch (poll_out) {
+                case 1:
+                        event_pool->reg[idx].events |= EPOLLOUT;
+                        break;
+                case 0:
+                        event_pool->reg[idx].events &= ~EPOLLOUT;
+                        break;
+                case -1:
+                        /* do nothing */
+                        break;
+                default:
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "invalid poll_out value %d", poll_out);
+                        break;
+                }
+
+                epoll_event.events = event_pool->reg[idx].events;
+                ev_data->fd = fd;
+                ev_data->idx = idx;
+
+                ret = epoll_ctl (event_pool->fd, EPOLL_CTL_MOD, fd,
+                                 &epoll_event);
+                if (ret == -1) {
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "failed to modify fd(=%d) events to %d",
+                                fd, epoll_event.events);
+                }
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
+        pthread_mutex_unlock (&event_pool->mutex);
 
-	return ret;
+        return ret;
 }
 
 
 static int
 event_dispatch_epoll_handler (struct event_pool *event_pool,
-			      struct epoll_event *events, int i)
+                              struct epoll_event *events, int i)
 {
-	struct event_data  *event_data = NULL;
-	event_handler_t     handler = NULL;
-	void               *data = NULL;
-	int                 idx = -1;
-	int                 ret = -1;
-
-
-	event_data = (void *)&events[i].data;
-	handler = NULL;
-	data = NULL;
-
-	pthread_mutex_lock (&event_pool->mutex);
-	{
-		idx = __event_getindex (event_pool, event_data->fd,
-					event_data->idx);
-
-		if (idx == -1) {
-			gf_log ("epoll", GF_LOG_ERROR,
-				"index not found for fd(=%d) (idx_hint=%d)",
-				event_data->fd, event_data->idx);
-			goto unlock;
-		}
-
-		handler = event_pool->reg[idx].handler;
-		data = event_pool->reg[idx].data;
-	}
+        struct event_data  *event_data = NULL;
+        event_handler_t     handler = NULL;
+        void               *data = NULL;
+        int                 idx = -1;
+        int                 ret = -1;
+
+
+        event_data = (void *)&events[i].data;
+        handler = NULL;
+        data = NULL;
+
+        pthread_mutex_lock (&event_pool->mutex);
+        {
+                idx = __event_getindex (event_pool, event_data->fd,
+                                        event_data->idx);
+
+                if (idx == -1) {
+                        gf_log ("epoll", GF_LOG_ERROR,
+                                "index not found for fd(=%d) (idx_hint=%d)",
+                                event_data->fd, event_data->idx);
+                        goto unlock;
+                }
+
+                handler = event_pool->reg[idx].handler;
+                data = event_pool->reg[idx].data;
+        }
 unlock:
-	pthread_mutex_unlock (&event_pool->mutex);
-
-	if (handler)
-		ret = handler (event_data->fd, event_data->idx, data,
-			       (events[i].events & (EPOLLIN|EPOLLPRI)),
-			       (events[i].events & (EPOLLOUT)),
-			       (events[i].events & (EPOLLERR|EPOLLHUP)));
-	return ret;
+        pthread_mutex_unlock (&event_pool->mutex);
+
+        if (handler)
+                ret = handler (event_data->fd, event_data->idx, data,
+                               (events[i].events & (EPOLLIN|EPOLLPRI)),
+                               (events[i].events & (EPOLLOUT)),
+                               (events[i].events & (EPOLLERR|EPOLLHUP)));
+        return ret;
 }
 
 
 static int
 event_dispatch_epoll (struct event_pool *event_pool)
 {
-	struct epoll_event *events = NULL;
-	int                 size = 0;
-	int                 i = 0;
-	int                 ret = -1;
-
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	while (1) {
-		pthread_mutex_lock (&event_pool->mutex);
-		{
-			while (event_pool->used == 0)
-				pthread_cond_wait (&event_pool->cond,
-						   &event_pool->mutex);
-
-			if (event_pool->used > event_pool->evcache_size) {
-				if (event_pool->evcache)
-					GF_FREE (event_pool->evcache);
-
-				event_pool->evcache = events = NULL;
-
-				event_pool->evcache_size =
-					event_pool->used + 256;
-
-				events = GF_CALLOC (event_pool->evcache_size,
-					            sizeof (struct epoll_event),
+        struct epoll_event *events = NULL;
+        int                 size = 0;
+        int                 i = 0;
+        int                 ret = -1;
+
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        while (1) {
+                pthread_mutex_lock (&event_pool->mutex);
+                {
+                        while (event_pool->used == 0)
+                                pthread_cond_wait (&event_pool->cond,
+                                                   &event_pool->mutex);
+
+                        if (event_pool->used > event_pool->evcache_size) {
+                                if (event_pool->evcache)
+                                        GF_FREE (event_pool->evcache);
+
+                                event_pool->evcache = events = NULL;
+
+                                event_pool->evcache_size =
+                                        event_pool->used + 256;
+
+                                events = GF_CALLOC (event_pool->evcache_size,
+                                                    sizeof (struct epoll_event),
                                                     gf_common_mt_epoll_event);
 
-				event_pool->evcache = events;
-			}
-		}
-		pthread_mutex_unlock (&event_pool->mutex);
+                                event_pool->evcache = events;
+                        }
+                }
+                pthread_mutex_unlock (&event_pool->mutex);
 
-		ret = epoll_wait (event_pool->fd, event_pool->evcache,
-				  event_pool->evcache_size, -1);
+                ret = epoll_wait (event_pool->fd, event_pool->evcache,
+                                  event_pool->evcache_size, -1);
 
-		if (ret == 0)
-			/* timeout */
-			continue;
+                if (ret == 0)
+                        /* timeout */
+                        continue;
 
-		if (ret == -1 && errno == EINTR)
-			/* sys call */
-			continue;
+                if (ret == -1 && errno == EINTR)
+                        /* sys call */
+                        continue;
 
-		size = ret;
+                size = ret;
 
-		for (i = 0; i < size; i++) {
-			if (!events || !events[i].events)
-				continue;
+                for (i = 0; i < size; i++) {
+                        if (!events || !events[i].events)
+                                continue;
 
-			ret = event_dispatch_epoll_handler (event_pool,
-							    events, i);
-		}
-	}
+                        ret = event_dispatch_epoll_handler (event_pool,
+                                                            events, i);
+                }
+        }
 
-	return -1;
+        return -1;
 }
 
 
 static struct event_ops event_ops_epoll = {
-	.new              = event_pool_new_epoll,
-	.event_register   = event_register_epoll,
-	.event_select_on  = event_select_on_epoll,
-	.event_unregister = event_unregister_epoll,
-	.event_dispatch   = event_dispatch_epoll
+        .new              = event_pool_new_epoll,
+        .event_register   = event_register_epoll,
+        .event_select_on  = event_select_on_epoll,
+        .event_unregister = event_unregister_epoll,
+        .event_dispatch   = event_dispatch_epoll
 };
 
 #endif
@@ -896,92 +896,92 @@ static struct event_ops event_ops_epoll = {
 struct event_pool *
 event_pool_new (int count)
 {
-	struct event_pool *event_pool = NULL;
+        struct event_pool *event_pool = NULL;
 
 #ifdef HAVE_SYS_EPOLL_H
-	event_pool = event_ops_epoll.new (count);
-
-	if (event_pool) {
-		event_pool->ops = &event_ops_epoll;
-	} else {
-		gf_log ("event", GF_LOG_WARNING,
-			"failing back to poll based event handling");
-	}
+        event_pool = event_ops_epoll.new (count);
+
+        if (event_pool) {
+                event_pool->ops = &event_ops_epoll;
+        } else {
+                gf_log ("event", GF_LOG_WARNING,
+                        "failing back to poll based event handling");
+        }
 #endif
 
-	if (!event_pool) {
-		event_pool = event_ops_poll.new (count);
+        if (!event_pool) {
+                event_pool = event_ops_poll.new (count);
 
-		if (event_pool)
-			event_pool->ops = &event_ops_poll;
-	}
+                if (event_pool)
+                        event_pool->ops = &event_ops_poll;
+        }
 
-	return event_pool;
+        return event_pool;
 }
 
 
 int
 event_register (struct event_pool *event_pool, int fd,
-		event_handler_t handler,
-		void *data, int poll_in, int poll_out)
+                event_handler_t handler,
+                void *data, int poll_in, int poll_out)
 {
-	int ret = -1;
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	ret = event_pool->ops->event_register (event_pool, fd, handler, data,
-					       poll_in, poll_out);
-	return ret;
+        int ret = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        ret = event_pool->ops->event_register (event_pool, fd, handler, data,
+                                               poll_in, poll_out);
+        return ret;
 }
 
 
 int
 event_unregister (struct event_pool *event_pool, int fd, int idx)
 {
-	int ret = -1;
+        int ret = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
 
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	ret = event_pool->ops->event_unregister (event_pool, fd, idx);
+        ret = event_pool->ops->event_unregister (event_pool, fd, idx);
 
-	return ret;
+        return ret;
 }
 
 
 int
 event_select_on (struct event_pool *event_pool, int fd, int idx_hint,
-		 int poll_in, int poll_out)
+                 int poll_in, int poll_out)
 {
-	int ret = -1;
-
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	ret = event_pool->ops->event_select_on (event_pool, fd, idx_hint,
-						poll_in, poll_out);
-	return ret;
+        int ret = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
+
+        ret = event_pool->ops->event_select_on (event_pool, fd, idx_hint,
+                                                poll_in, poll_out);
+        return ret;
 }
 
 
 int
 event_dispatch (struct event_pool *event_pool)
 {
-	int ret = -1;
+        int ret = -1;
+
+        if (event_pool == NULL) {
+                gf_log ("event", GF_LOG_ERROR, "invalid argument");
+                return -1;
+        }
 
-	if (event_pool == NULL) {
-		gf_log ("event", GF_LOG_ERROR, "invalid argument");
-		return -1;
-	}
-  
-	ret = event_pool->ops->event_dispatch (event_pool);
+        ret = event_pool->ops->event_dispatch (event_pool);
 
-	return ret;
+        return ret;
 }