performance/io-cache: whitespace related changes to adhere to coding guidelines.

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, 131 insertions, 131 deletions

diff --git a/xlators/performance/io-cache/src/io-cache.h b/xlators/performance/io-cache/src/io-cache.h
index e9cb56e0a1c..5d05264404a 100644
--- a/xlators/performance/io-cache/src/io-cache.h
+++ b/xlators/performance/io-cache/src/io-cache.h
@@ -49,132 +49,132 @@ struct ioc_page;
 struct ioc_inode;
 
 struct ioc_priority {
-	struct list_head list;
-	char             *pattern;
-	uint32_t         priority;
+        struct list_head list;
+        char             *pattern;
+        uint32_t         priority;
 };
 
 /*
- * ioc_waitq - this structure is used to represents the waiting 
+ * ioc_waitq - this structure is used to represents the waiting
  *             frames on a page
  *
  * @next: pointer to next object in waitq
  * @data: pointer to the frame which is waiting
  */
 struct ioc_waitq {
-	struct ioc_waitq *next;
-	void             *data;
-	off_t            pending_offset;
-	size_t           pending_size;
+        struct ioc_waitq *next;
+        void             *data;
+        off_t            pending_offset;
+        size_t           pending_size;
 };
 
 /*
- * ioc_fill - 
+ * ioc_fill -
  *
  */
 struct ioc_fill {
-	struct list_head list;  /* list of ioc_fill structures of a frame */
-	off_t            offset;          
-	size_t           size;           
-	struct iovec     *vector;  
-	int32_t          count;
-	struct iobref    *iobref;
+        struct list_head list;  /* list of ioc_fill structures of a frame */
+        off_t            offset;
+        size_t           size;
+        struct iovec     *vector;
+        int32_t          count;
+        struct iobref    *iobref;
 };
 
 struct ioc_local {
-	mode_t           mode;
-	int32_t          flags;
+        mode_t           mode;
+        int32_t          flags;
         int32_t          wbflags;
-	loc_t            file_loc;
-	off_t            offset;
-	size_t           size;
-	int32_t          op_ret;
-	int32_t          op_errno;
-	struct list_head fill_list;      /* list of ioc_fill structures */
-	off_t            pending_offset; /* 
+        loc_t            file_loc;
+        off_t            offset;
+        size_t           size;
+        int32_t          op_ret;
+        int32_t          op_errno;
+        struct list_head fill_list;      /* list of ioc_fill structures */
+        off_t            pending_offset; /*
                                           * offset from this frame should
                                           * continue
                                           */
-	size_t           pending_size;   /* 
+        size_t           pending_size;   /*
                                           * size of data this frame is waiting
                                           * on
                                           */
-	struct ioc_inode *inode;
-	int32_t          wait_count;
-	pthread_mutex_t  local_lock;
-	struct ioc_waitq *waitq;
-	void             *stub;
-	fd_t             *fd;
-	int32_t          need_xattr;
-	dict_t           *xattr_req;
+        struct ioc_inode *inode;
+        int32_t          wait_count;
+        pthread_mutex_t  local_lock;
+        struct ioc_waitq *waitq;
+        void             *stub;
+        fd_t             *fd;
+        int32_t          need_xattr;
+        dict_t           *xattr_req;
 };
 
 /*
- * ioc_page - structure to store page of data from file 
+ * ioc_page - structure to store page of data from file
  *
  */
 struct ioc_page {
-	struct list_head    page_lru;
-	struct ioc_inode    *inode;   /* inode this page belongs to */
-	struct ioc_priority *priority;
-	char                dirty;
-	char                ready;
-	struct iovec        *vector;
-	int32_t             count;
-	off_t               offset;
-	size_t              size;
-	struct ioc_waitq    *waitq;
-	struct iobref       *iobref;
-	pthread_mutex_t     page_lock;
+        struct list_head    page_lru;
+        struct ioc_inode    *inode;   /* inode this page belongs to */
+        struct ioc_priority *priority;
+        char                dirty;
+        char                ready;
+        struct iovec        *vector;
+        int32_t             count;
+        off_t               offset;
+        size_t              size;
+        struct ioc_waitq    *waitq;
+        struct iobref       *iobref;
+        pthread_mutex_t     page_lock;
 };
 
 struct ioc_cache {
         rbthash_table_t  *page_table;
         struct list_head  page_lru;
-	time_t            mtime;       /*
+        time_t            mtime;       /*
                                         * seconds component of file mtime
                                         */
         time_t            mtime_nsec;  /*
                                         * nanosecond component of file mtime
                                         */
-	struct timeval    tv;          /*
+        struct timeval    tv;          /*
                                         * time-stamp at last re-validate
                                         */
 };
 
 struct ioc_inode {
-	struct ioc_table      *table;
+        struct ioc_table      *table;
         off_t                  ia_size;
-        struct ioc_cache       cache;        
-	struct list_head       inode_list; /*
+        struct ioc_cache       cache;
+        struct list_head       inode_list; /*
                                             * list of inodes, maintained by
                                             * io-cache translator
                                             */
-	struct list_head       inode_lru;
-	struct ioc_waitq      *waitq;
-	pthread_mutex_t        inode_lock;
-	uint32_t               weight;      /*
+        struct list_head       inode_lru;
+        struct ioc_waitq      *waitq;
+        pthread_mutex_t        inode_lock;
+        uint32_t               weight;      /*
                                              * weight of the inode, increases
                                              * on each read
                                              */
 };
 
 struct ioc_table {
-	uint64_t         page_size;
-	uint64_t         cache_size;
-	uint64_t         cache_used;
+        uint64_t         page_size;
+        uint64_t         cache_size;
+        uint64_t         cache_used;
         int64_t          min_file_size;
         int64_t          max_file_size;
-	struct list_head inodes; /* list of inodes cached */
-	struct list_head active; 
-	struct list_head *inode_lru;
-	struct list_head priority_list;
-	int32_t          readv_count;
-	pthread_mutex_t  table_lock;
-	xlator_t         *xl;
-	uint32_t         inode_count;
-	int32_t          cache_timeout;
-	int32_t          max_pri;
+        struct list_head inodes; /* list of inodes cached */
+        struct list_head active;
+        struct list_head *inode_lru;
+        struct list_head priority_list;
+        int32_t          readv_count;
+        pthread_mutex_t  table_lock;
+        xlator_t         *xl;
+        uint32_t         inode_count;
+        int32_t          cache_timeout;
+        int32_t          max_pri;
         struct mem_pool  *mem_pool;
 };
 
@@ -191,10 +191,10 @@ str_to_ptr (char *string);
 char *
 ptr_to_str (void *ptr);
 
-int32_t 
+int32_t
 ioc_readv_disabled_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret,	int32_t op_errno, struct iovec *vector,
-			int32_t count, struct iatt *stbuf,
+                        int32_t op_ret, int32_t op_errno, struct iovec *vector,
+                        int32_t count, struct iatt *stbuf,
                         struct iobref *iobref);
 
 ioc_page_t *
@@ -204,11 +204,11 @@ ioc_page_t *
 ioc_page_create (ioc_inode_t *ioc_inode, off_t offset);
 
 void
-ioc_page_fault (ioc_inode_t *ioc_inode,	call_frame_t *frame, fd_t *fd,
-		off_t offset);
+ioc_page_fault (ioc_inode_t *ioc_inode, call_frame_t *frame, fd_t *fd,
+                off_t offset);
 void
 ioc_wait_on_page (ioc_page_t *page, call_frame_t *frame, off_t offset,
-		  size_t size);
+                  size_t size);
 
 ioc_waitq_t *
 ioc_page_wakeup (ioc_page_t *page);
@@ -230,94 +230,94 @@ ioc_waitq_return (ioc_waitq_t *waitq);
 
 int32_t
 ioc_frame_fill (ioc_page_t *page, call_frame_t *frame, off_t offset,
-		size_t size);
+                size_t size);
 
-#define ioc_inode_lock(ioc_inode)					\
-	do {								\
-		gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,	\
-			"locked inode(%p)", ioc_inode);			\
-		pthread_mutex_lock (&ioc_inode->inode_lock);		\
-	} while (0)
+#define ioc_inode_lock(ioc_inode)                                       \
+        do {                                                            \
+                gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,       \
+                        "locked inode(%p)", ioc_inode);                 \
+                pthread_mutex_lock (&ioc_inode->inode_lock);            \
+        } while (0)
 
 
-#define ioc_inode_unlock(ioc_inode)					\
-	do {								\
-		gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,	\
-			"unlocked inode(%p)", ioc_inode);		\
-		pthread_mutex_unlock (&ioc_inode->inode_lock);		\
-	} while (0)
+#define ioc_inode_unlock(ioc_inode)                                     \
+        do {                                                            \
+                gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,       \
+                        "unlocked inode(%p)", ioc_inode);               \
+                pthread_mutex_unlock (&ioc_inode->inode_lock);          \
+        } while (0)
 
 
-#define ioc_table_lock(table)					\
-	do {							\
-		gf_log (table->xl->name, GF_LOG_TRACE,		\
-			"locked table(%p)", table);		\
-		pthread_mutex_lock (&table->table_lock);	\
-	} while (0)
+#define ioc_table_lock(table)                                   \
+        do {                                                    \
+                gf_log (table->xl->name, GF_LOG_TRACE,          \
+                        "locked table(%p)", table);             \
+                pthread_mutex_lock (&table->table_lock);        \
+        } while (0)
 
 
-#define ioc_table_unlock(table)					\
-	do {							\
-		gf_log (table->xl->name, GF_LOG_TRACE,		\
-			"unlocked table(%p)", table);		\
-		pthread_mutex_unlock (&table->table_lock);	\
-	} while (0)
+#define ioc_table_unlock(table)                                 \
+        do {                                                    \
+                gf_log (table->xl->name, GF_LOG_TRACE,          \
+                        "unlocked table(%p)", table);           \
+                pthread_mutex_unlock (&table->table_lock);      \
+        } while (0)
 
 
-#define ioc_local_lock(local)						\
-	do {								\
-		gf_log (local->inode->table->xl->name, GF_LOG_TRACE,	\
-			"locked local(%p)", local);			\
-		pthread_mutex_lock (&local->local_lock);		\
-	} while (0)
+#define ioc_local_lock(local)                                           \
+        do {                                                            \
+                gf_log (local->inode->table->xl->name, GF_LOG_TRACE,    \
+                        "locked local(%p)", local);                     \
+                pthread_mutex_lock (&local->local_lock);                \
+        } while (0)
 
 
-#define ioc_local_unlock(local)						\
-	do {								\
-		gf_log (local->inode->table->xl->name, GF_LOG_TRACE,	\
-			"unlocked local(%p)", local);			\
-		pthread_mutex_unlock (&local->local_lock);		\
-	} while (0)
+#define ioc_local_unlock(local)                                         \
+        do {                                                            \
+                gf_log (local->inode->table->xl->name, GF_LOG_TRACE,    \
+                        "unlocked local(%p)", local);                   \
+                pthread_mutex_unlock (&local->local_lock);              \
+        } while (0)
 
 
-#define ioc_page_lock(page)						\
-	do {								\
-		gf_log (page->inode->table->xl->name, GF_LOG_TRACE,	\
-			"locked page(%p)", page);			\
-		pthread_mutex_lock (&page->page_lock);			\
-	} while (0)
+#define ioc_page_lock(page)                                             \
+        do {                                                            \
+                gf_log (page->inode->table->xl->name, GF_LOG_TRACE,     \
+                        "locked page(%p)", page);                       \
+                pthread_mutex_lock (&page->page_lock);                  \
+        } while (0)
 
 
-#define ioc_page_unlock(page)						\
-	do {								\
-		gf_log (page->inode->table->xl->name, GF_LOG_TRACE,	\
-			"unlocked page(%p)", page);			\
-		pthread_mutex_unlock (&page->page_lock);		\
-	} while (0)
+#define ioc_page_unlock(page)                                           \
+        do {                                                            \
+                gf_log (page->inode->table->xl->name, GF_LOG_TRACE,     \
+                        "unlocked page(%p)", page);                     \
+                pthread_mutex_unlock (&page->page_lock);                \
+        } while (0)
 
 
 static inline uint64_t
 time_elapsed (struct timeval *now,
-	      struct timeval *then)
+              struct timeval *then)
 {
-	uint64_t sec = now->tv_sec - then->tv_sec;
+        uint64_t sec = now->tv_sec - then->tv_sec;
+
+        if (sec)
+                return sec;
 
-	if (sec)
-		return sec;
-  
-	return 0;
+        return 0;
 }
 
 ioc_inode_t *
 ioc_inode_search (ioc_table_t *table, inode_t *inode);
 
-void 
+void
 ioc_inode_destroy (ioc_inode_t *ioc_inode);
 
 ioc_inode_t *
 ioc_inode_update (ioc_table_t *table, inode_t *inode, uint32_t weight);
 
-int64_t 
+int64_t
 ioc_page_destroy (ioc_page_t *page);
 
 int64_t