From d0b82760dc06b16f323d65506337c8373ce6ceb1 Mon Sep 17 00:00:00 2001 From: Raghavendra G Date: Wed, 16 Mar 2011 09:41:09 +0000 Subject: performance/read-ahead: white space related changes to adhere to coding guidelines. Signed-off-by: Raghavendra G Signed-off-by: Amar Tumballi Signed-off-by: Vijay Bellur BUG: 2346 (Log message enhancements in GlusterFS - phase 1) URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=2346 --- xlators/performance/read-ahead/src/page.c | 574 +++++----- .../read-ahead/src/read-ahead-mem-types.h | 33 +- xlators/performance/read-ahead/src/read-ahead.c | 1103 ++++++++++---------- xlators/performance/read-ahead/src/read-ahead.h | 126 +-- 4 files changed, 924 insertions(+), 912 deletions(-) (limited to 'xlators/performance/read-ahead/src') diff --git a/xlators/performance/read-ahead/src/page.c b/xlators/performance/read-ahead/src/page.c index 925bc253d65..d410986513a 100644 --- a/xlators/performance/read-ahead/src/page.c +++ b/xlators/performance/read-ahead/src/page.c @@ -32,81 +32,81 @@ ra_page_t * ra_page_get (ra_file_t *file, off_t offset) { - ra_page_t *page = NULL; - off_t rounded_offset = 0; + ra_page_t *page = NULL; + off_t rounded_offset = 0; - page = file->pages.next; - rounded_offset = floor (offset, file->page_size); + page = file->pages.next; + rounded_offset = floor (offset, file->page_size); - while (page != &file->pages && page->offset < rounded_offset) - page = page->next; + while (page != &file->pages && page->offset < rounded_offset) + page = page->next; - if (page == &file->pages || page->offset != rounded_offset) - page = NULL; + if (page == &file->pages || page->offset != rounded_offset) + page = NULL; - return page; + return page; } ra_page_t * ra_page_create (ra_file_t *file, off_t offset) { - ra_page_t *page = NULL; - off_t rounded_offset = 0; - ra_page_t *newpage = NULL; + ra_page_t *page = NULL; + off_t rounded_offset = 0; + ra_page_t *newpage = NULL; - page = file->pages.next; - rounded_offset = floor (offset, file->page_size); + page = file->pages.next; + rounded_offset = floor (offset, file->page_size); - while (page != &file->pages && page->offset < rounded_offset) - page = page->next; + while (page != &file->pages && page->offset < rounded_offset) + page = page->next; - if (page == &file->pages || page->offset != rounded_offset) { - newpage = GF_CALLOC (1, sizeof (*newpage), + if (page == &file->pages || page->offset != rounded_offset) { + newpage = GF_CALLOC (1, sizeof (*newpage), gf_ra_mt_ra_page_t); - if (!newpage) - return NULL; + if (!newpage) + return NULL; - newpage->offset = rounded_offset; - newpage->prev = page->prev; - newpage->next = page; - newpage->file = file; - page->prev->next = newpage; - page->prev = newpage; + newpage->offset = rounded_offset; + newpage->prev = page->prev; + newpage->next = page; + newpage->file = file; + page->prev->next = newpage; + page->prev = newpage; - page = newpage; - } + page = newpage; + } - return page; + return page; } void ra_wait_on_page (ra_page_t *page, call_frame_t *frame) { - ra_waitq_t *waitq = NULL; - ra_local_t *local = NULL; + ra_waitq_t *waitq = NULL; + ra_local_t *local = NULL; - local = frame->local; - waitq = GF_CALLOC (1, sizeof (*waitq), + local = frame->local; + waitq = GF_CALLOC (1, sizeof (*waitq), gf_ra_mt_ra_waitq_t); - if (!waitq) { - gf_log (frame->this->name, GF_LOG_ERROR, - "out of memory"); + if (!waitq) { + gf_log (frame->this->name, GF_LOG_ERROR, + "out of memory"); local->op_ret = -1; local->op_errno = ENOMEM; goto out; - } + } - waitq->data = frame; - waitq->next = page->waitq; - page->waitq = waitq; + waitq->data = frame; + waitq->next = page->waitq; + page->waitq = waitq; - ra_local_lock (local); - { - local->wait_count++; - } - ra_local_unlock (local); + ra_local_lock (local); + { + local->wait_count++; + } + ra_local_unlock (local); out: return; @@ -116,112 +116,112 @@ out: void ra_waitq_return (ra_waitq_t *waitq) { - ra_waitq_t *trav = NULL; - ra_waitq_t *next = NULL; - call_frame_t *frame = NULL; + ra_waitq_t *trav = NULL; + ra_waitq_t *next = NULL; + call_frame_t *frame = NULL; - for (trav = waitq; trav; trav = next) { - next = trav->next; + for (trav = waitq; trav; trav = next) { + next = trav->next; - frame = trav->data; - ra_frame_return (frame); - GF_FREE (trav); - } + frame = trav->data; + ra_frame_return (frame); + GF_FREE (trav); + } } int ra_fault_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, struct iobref *iobref) + int32_t op_ret, int32_t op_errno, struct iovec *vector, + int32_t count, struct iatt *stbuf, struct iobref *iobref) { - ra_local_t *local = NULL; - off_t pending_offset = 0; - ra_file_t *file = NULL; - ra_page_t *page = NULL; - ra_waitq_t *waitq = NULL; - fd_t *fd = NULL; - uint64_t tmp_file = 0; - - local = frame->local; - fd = local->fd; - - fd_ctx_get (fd, this, &tmp_file); - - file = (ra_file_t *)(long)tmp_file; - pending_offset = local->pending_offset; - - ra_file_lock (file); - { - if (op_ret >= 0) - file->stbuf = *stbuf; - - if (op_ret < 0) { - page = ra_page_get (file, pending_offset); - if (page) - waitq = ra_page_error (page, op_ret, op_errno); - goto unlock; - } - - page = ra_page_get (file, pending_offset); - if (!page) { - gf_log (this->name, GF_LOG_DEBUG, - "wasted copy: %"PRId64"[+%"PRId64"] file=%p", - pending_offset, file->page_size, file); - goto unlock; - } - - if (page->vector) { - iobref_unref (page->iobref); - GF_FREE (page->vector); - } - - page->vector = iov_dup (vector, count); + ra_local_t *local = NULL; + off_t pending_offset = 0; + ra_file_t *file = NULL; + ra_page_t *page = NULL; + ra_waitq_t *waitq = NULL; + fd_t *fd = NULL; + uint64_t tmp_file = 0; + + local = frame->local; + fd = local->fd; + + fd_ctx_get (fd, this, &tmp_file); + + file = (ra_file_t *)(long)tmp_file; + pending_offset = local->pending_offset; + + ra_file_lock (file); + { + if (op_ret >= 0) + file->stbuf = *stbuf; + + if (op_ret < 0) { + page = ra_page_get (file, pending_offset); + if (page) + waitq = ra_page_error (page, op_ret, op_errno); + goto unlock; + } + + page = ra_page_get (file, pending_offset); + if (!page) { + gf_log (this->name, GF_LOG_DEBUG, + "wasted copy: %"PRId64"[+%"PRId64"] file=%p", + pending_offset, file->page_size, file); + goto unlock; + } + + if (page->vector) { + iobref_unref (page->iobref); + GF_FREE (page->vector); + } + + page->vector = iov_dup (vector, count); if (page->vector == NULL) { waitq = ra_page_error (page, -1, ENOMEM); goto unlock; } - page->count = count; - page->iobref = iobref_ref (iobref); - page->ready = 1; + page->count = count; + page->iobref = iobref_ref (iobref); + page->ready = 1; - page->size = iov_length (vector, count); + page->size = iov_length (vector, count); - waitq = ra_page_wakeup (page); - } + waitq = ra_page_wakeup (page); + } unlock: - ra_file_unlock (file); + ra_file_unlock (file); - ra_waitq_return (waitq); + ra_waitq_return (waitq); - fd_unref (local->fd); + fd_unref (local->fd); - GF_FREE (frame->local); - frame->local = NULL; + GF_FREE (frame->local); + frame->local = NULL; - STACK_DESTROY (frame->root); - return 0; + STACK_DESTROY (frame->root); + return 0; } void ra_page_fault (ra_file_t *file, call_frame_t *frame, off_t offset) { - call_frame_t *fault_frame = NULL; - ra_local_t *fault_local = NULL; - ra_page_t *page = NULL; - ra_waitq_t *waitq = NULL; - int32_t op_ret = -1, op_errno = -1; + call_frame_t *fault_frame = NULL; + ra_local_t *fault_local = NULL; + ra_page_t *page = NULL; + ra_waitq_t *waitq = NULL; + int32_t op_ret = -1, op_errno = -1; - fault_frame = copy_frame (frame); + fault_frame = copy_frame (frame); if (fault_frame == NULL) { op_ret = -1; op_errno = ENOMEM; goto err; } - fault_local = GF_CALLOC (1, sizeof (ra_local_t), + fault_local = GF_CALLOC (1, sizeof (ra_local_t), gf_ra_mt_ra_local_t); if (fault_local == NULL) { STACK_DESTROY (fault_frame->root); @@ -230,18 +230,18 @@ ra_page_fault (ra_file_t *file, call_frame_t *frame, off_t offset) goto err; } - fault_frame->local = fault_local; - fault_local->pending_offset = offset; - fault_local->pending_size = file->page_size; + fault_frame->local = fault_local; + fault_local->pending_offset = offset; + fault_local->pending_size = file->page_size; - fault_local->fd = fd_ref (file->fd); + fault_local->fd = fd_ref (file->fd); - STACK_WIND (fault_frame, ra_fault_cbk, - FIRST_CHILD (fault_frame->this), - FIRST_CHILD (fault_frame->this)->fops->readv, - file->fd, file->page_size, offset); + STACK_WIND (fault_frame, ra_fault_cbk, + FIRST_CHILD (fault_frame->this), + FIRST_CHILD (fault_frame->this)->fops->readv, + file->fd, file->page_size, offset); - return; + return; err: ra_file_lock (file); @@ -252,7 +252,7 @@ err: op_errno); } ra_file_unlock (file); - + if (waitq != NULL) { ra_waitq_return (waitq); } @@ -261,54 +261,54 @@ err: void ra_frame_fill (ra_page_t *page, call_frame_t *frame) { - ra_local_t *local = NULL; - ra_fill_t *fill = NULL; - off_t src_offset = 0; - off_t dst_offset = 0; - ssize_t copy_size = 0; - ra_fill_t *new = NULL; - - local = frame->local; - fill = &local->fill; - - if (local->op_ret != -1 && page->size) { - if (local->offset > page->offset) - src_offset = local->offset - page->offset; - else - dst_offset = page->offset - local->offset; - - copy_size = min (page->size - src_offset, - local->size - dst_offset); - - if (copy_size < 0) { - /* if page contains fewer bytes and the required offset - is beyond the page size in the page */ - copy_size = src_offset = 0; - } - - fill = fill->next; - while (fill != &local->fill) { - if (fill->offset > page->offset) { - break; - } - fill = fill->next; - } - - new = GF_CALLOC (1, sizeof (*new), - gf_ra_mt_ra_fill_t); + ra_local_t *local = NULL; + ra_fill_t *fill = NULL; + off_t src_offset = 0; + off_t dst_offset = 0; + ssize_t copy_size = 0; + ra_fill_t *new = NULL; + + local = frame->local; + fill = &local->fill; + + if (local->op_ret != -1 && page->size) { + if (local->offset > page->offset) + src_offset = local->offset - page->offset; + else + dst_offset = page->offset - local->offset; + + copy_size = min (page->size - src_offset, + local->size - dst_offset); + + if (copy_size < 0) { + /* if page contains fewer bytes and the required offset + is beyond the page size in the page */ + copy_size = src_offset = 0; + } + + fill = fill->next; + while (fill != &local->fill) { + if (fill->offset > page->offset) { + break; + } + fill = fill->next; + } + + new = GF_CALLOC (1, sizeof (*new), + gf_ra_mt_ra_fill_t); if (new == NULL) { local->op_ret = -1; local->op_errno = ENOMEM; goto out; } - new->offset = page->offset; - new->size = copy_size; - new->iobref = iobref_ref (page->iobref); - new->count = iov_subset (page->vector, page->count, - src_offset, src_offset+copy_size, - NULL); - new->vector = GF_CALLOC (new->count, sizeof (struct iovec), + new->offset = page->offset; + new->size = copy_size; + new->iobref = iobref_ref (page->iobref); + new->count = iov_subset (page->vector, page->count, + src_offset, src_offset+copy_size, + NULL); + new->vector = GF_CALLOC (new->count, sizeof (struct iovec), gf_ra_mt_iovec); if (new->vector == NULL) { local->op_ret = -1; @@ -317,17 +317,17 @@ ra_frame_fill (ra_page_t *page, call_frame_t *frame) goto out; } - new->count = iov_subset (page->vector, page->count, - src_offset, src_offset+copy_size, - new->vector); + new->count = iov_subset (page->vector, page->count, + src_offset, src_offset+copy_size, + new->vector); - new->next = fill; - new->prev = new->next->prev; - new->next->prev = new; - new->prev->next = new; + new->next = fill; + new->prev = new->next->prev; + new->next->prev = new; + new->prev->next = new; - local->op_ret += copy_size; - } + local->op_ret += copy_size; + } out: return; @@ -337,34 +337,34 @@ out: void ra_frame_unwind (call_frame_t *frame) { - ra_local_t *local = NULL; - ra_fill_t *fill = NULL; - int32_t count = 0; - struct iovec *vector; - int32_t copied = 0; - struct iobref *iobref = NULL; - ra_fill_t *next = NULL; - fd_t *fd = NULL; - ra_file_t *file = NULL; - uint64_t tmp_file = 0; - - local = frame->local; - fill = local->fill.next; - - iobref = iobref_new (); + ra_local_t *local = NULL; + ra_fill_t *fill = NULL; + int32_t count = 0; + struct iovec *vector = NULL; + int32_t copied = 0; + struct iobref *iobref = NULL; + ra_fill_t *next = NULL; + fd_t *fd = NULL; + ra_file_t *file = NULL; + uint64_t tmp_file = 0; + + local = frame->local; + fill = local->fill.next; + + iobref = iobref_new (); if (iobref == NULL) { local->op_ret = -1; local->op_errno = ENOMEM; } - frame->local = NULL; + frame->local = NULL; - while (fill != &local->fill) { - count += fill->count; - fill = fill->next; - } + while (fill != &local->fill) { + count += fill->count; + fill = fill->next; + } - vector = GF_CALLOC (count, sizeof (*vector), + vector = GF_CALLOC (count, sizeof (*vector), gf_ra_mt_iovec); if (vector == NULL) { local->op_ret = -1; @@ -373,42 +373,42 @@ ra_frame_unwind (call_frame_t *frame) iobref = NULL; } - fill = local->fill.next; + fill = local->fill.next; - while (fill != &local->fill) { - next = fill->next; + while (fill != &local->fill) { + next = fill->next; if ((vector != NULL) && (iobref != NULL)) { memcpy (((char *)vector) + copied, fill->vector, fill->count * sizeof (*vector)); - + copied += (fill->count * sizeof (*vector)); iobref_merge (iobref, fill->iobref); } - fill->next->prev = fill->prev; - fill->prev->next = fill->prev; + fill->next->prev = fill->prev; + fill->prev->next = fill->prev; - iobref_unref (fill->iobref); - GF_FREE (fill->vector); - GF_FREE (fill); + iobref_unref (fill->iobref); + GF_FREE (fill->vector); + GF_FREE (fill); - fill = next; - } + fill = next; + } - fd = local->fd; - fd_ctx_get (fd, frame->this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + fd = local->fd; + fd_ctx_get (fd, frame->this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; - STACK_UNWIND_STRICT (readv, frame, local->op_ret, local->op_errno, + STACK_UNWIND_STRICT (readv, frame, local->op_ret, local->op_errno, vector, count, &file->stbuf, iobref); - iobref_unref (iobref); - pthread_mutex_destroy (&local->local_lock); - GF_FREE (local); - GF_FREE (vector); + iobref_unref (iobref); + pthread_mutex_destroy (&local->local_lock); + GF_FREE (local); + GF_FREE (vector); - return; + return; } /* @@ -419,25 +419,25 @@ ra_frame_unwind (call_frame_t *frame) void ra_frame_return (call_frame_t *frame) { - ra_local_t *local = NULL; - int32_t wait_count = 0; + ra_local_t *local = NULL; + int32_t wait_count = 0; - local = frame->local; - GF_ASSERT (local->wait_count > 0); + local = frame->local; + GF_ASSERT (local->wait_count > 0); - ra_local_lock (local); - { - wait_count = --local->wait_count; - } - ra_local_unlock (local); + ra_local_lock (local); + { + wait_count = --local->wait_count; + } + ra_local_unlock (local); - if (!wait_count) - ra_frame_unwind (frame); + if (!wait_count) + ra_frame_unwind (frame); - return; + return; } -/* +/* * ra_page_wakeup - * @page: * @@ -445,18 +445,18 @@ ra_frame_return (call_frame_t *frame) ra_waitq_t * ra_page_wakeup (ra_page_t *page) { - ra_waitq_t *waitq = NULL, *trav = NULL; - call_frame_t *frame; + ra_waitq_t *waitq = NULL, *trav = NULL; + call_frame_t *frame = NULL; - waitq = page->waitq; - page->waitq = NULL; + waitq = page->waitq; + page->waitq = NULL; - for (trav = waitq; trav; trav = trav->next) { - frame = trav->data; - ra_frame_fill (page, frame); - } + for (trav = waitq; trav; trav = trav->next) { + frame = trav->data; + ra_frame_fill (page, frame); + } - return waitq; + return waitq; } /* @@ -467,14 +467,14 @@ ra_page_wakeup (ra_page_t *page) void ra_page_purge (ra_page_t *page) { - page->prev->next = page->next; - page->next->prev = page->prev; - - if (page->iobref) { - iobref_unref (page->iobref); - } - GF_FREE (page->vector); - GF_FREE (page); + page->prev->next = page->next; + page->next->prev = page->prev; + + if (page->iobref) { + iobref_unref (page->iobref); + } + GF_FREE (page->vector); + GF_FREE (page); } /* @@ -488,30 +488,30 @@ ra_waitq_t * ra_page_error (ra_page_t *page, int32_t op_ret, int32_t op_errno) { - ra_waitq_t *waitq = NULL; - ra_waitq_t *trav = NULL; - call_frame_t *frame = NULL; - ra_local_t *local = NULL; + ra_waitq_t *waitq = NULL; + ra_waitq_t *trav = NULL; + call_frame_t *frame = NULL; + ra_local_t *local = NULL; - waitq = page->waitq; - page->waitq = NULL; + waitq = page->waitq; + page->waitq = NULL; - for (trav = waitq; trav; trav = trav->next) { - frame = trav->data; + for (trav = waitq; trav; trav = trav->next) { + frame = trav->data; - local = frame->local; - if (local->op_ret != -1) { - local->op_ret = op_ret; - local->op_errno = op_errno; - } - } + local = frame->local; + if (local->op_ret != -1) { + local->op_ret = op_ret; + local->op_errno = op_errno; + } + } - ra_page_purge (page); + ra_page_purge (page); - return waitq; + return waitq; } -/* +/* * ra_file_destroy - * @file: * @@ -519,24 +519,24 @@ ra_page_error (ra_page_t *page, int32_t op_ret, int32_t op_errno) void ra_file_destroy (ra_file_t *file) { - ra_conf_t *conf = NULL; - ra_page_t *trav = NULL; - - conf = file->conf; - - ra_conf_lock (conf); - { - file->prev->next = file->next; - file->next->prev = file->prev; - } - ra_conf_unlock (conf); - - trav = file->pages.next; - while (trav != &file->pages) { - ra_page_error (trav, -1, EINVAL); - trav = file->pages.next; - } - - pthread_mutex_destroy (&file->file_lock); - GF_FREE (file); + ra_conf_t *conf = NULL; + ra_page_t *trav = NULL; + + conf = file->conf; + + ra_conf_lock (conf); + { + file->prev->next = file->next; + file->next->prev = file->prev; + } + ra_conf_unlock (conf); + + trav = file->pages.next; + while (trav != &file->pages) { + ra_page_error (trav, -1, EINVAL); + trav = file->pages.next; + } + + pthread_mutex_destroy (&file->file_lock); + GF_FREE (file); } diff --git a/xlators/performance/read-ahead/src/read-ahead-mem-types.h b/xlators/performance/read-ahead/src/read-ahead-mem-types.h index 3b76069bced..1c703a059d0 100644 --- a/xlators/performance/read-ahead/src/read-ahead-mem-types.h +++ b/xlators/performance/read-ahead/src/read-ahead-mem-types.h @@ -1,20 +1,20 @@ /* - Copyright (c) 2008-2010 Gluster, Inc. - 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 - . + Copyright (c) 2008-2010 Gluster, Inc. + 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 + . */ @@ -34,4 +34,3 @@ enum gf_ra_mem_types_ { gf_ra_mt_end }; #endif - diff --git a/xlators/performance/read-ahead/src/read-ahead.c b/xlators/performance/read-ahead/src/read-ahead.c index f16e59c4237..8317be4a7d3 100644 --- a/xlators/performance/read-ahead/src/read-ahead.c +++ b/xlators/performance/read-ahead/src/read-ahead.c @@ -17,11 +17,11 @@ . */ -/* - TODO: - - handle O_DIRECT - - maintain offset, flush on lseek - - ensure efficient memory managment in case of random seek +/* + TODO: + - handle O_DIRECT + - maintain offset, flush on lseek + - ensure efficient memory managment in case of random seek */ #ifndef _CONFIG_H @@ -46,75 +46,75 @@ int ra_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, fd_t *fd) { - ra_conf_t *conf = NULL; - ra_file_t *file = NULL; - int ret = 0; + ra_conf_t *conf = NULL; + ra_file_t *file = NULL; + int ret = 0; long wbflags = 0; - conf = this->private; + conf = this->private; - if (op_ret == -1) { - goto unwind; - } + if (op_ret == -1) { + goto unwind; + } wbflags = (long)frame->local; - file = GF_CALLOC (1, sizeof (*file), gf_ra_mt_ra_file_t); - if (!file) { + file = GF_CALLOC (1, sizeof (*file), gf_ra_mt_ra_file_t); + if (!file) { op_ret = -1; op_errno = ENOMEM; - gf_log (this->name, GF_LOG_ERROR, - "out of memory"); - goto unwind; - } + gf_log (this->name, GF_LOG_ERROR, + "out of memory"); + goto unwind; + } - /* If O_DIRECT open, we disable caching on it */ + /* If O_DIRECT open, we disable caching on it */ - if ((fd->flags & O_DIRECT) || ((fd->flags & O_ACCMODE) == O_WRONLY)) - file->disabled = 1; + if ((fd->flags & O_DIRECT) || ((fd->flags & O_ACCMODE) == O_WRONLY)) + file->disabled = 1; if (wbflags & GF_OPEN_NOWB) { file->disabled = 1; } - file->offset = (unsigned long long) 0; - file->conf = conf; - file->pages.next = &file->pages; - file->pages.prev = &file->pages; - file->pages.offset = (unsigned long long) 0; - file->pages.file = file; - - ra_conf_lock (conf); - { - file->next = conf->files.next; - conf->files.next = file; - file->next->prev = file; - file->prev = &conf->files; - } - ra_conf_unlock (conf); - - file->fd = fd; - file->page_count = conf->page_count; - file->page_size = conf->page_size; - pthread_mutex_init (&file->file_lock, NULL); - - if (!file->disabled) { - file->page_count = 1; - } - - ret = fd_ctx_set (fd, this, (uint64_t)(long)file); + file->offset = (unsigned long long) 0; + file->conf = conf; + file->pages.next = &file->pages; + file->pages.prev = &file->pages; + file->pages.offset = (unsigned long long) 0; + file->pages.file = file; + + ra_conf_lock (conf); + { + file->next = conf->files.next; + conf->files.next = file; + file->next->prev = file; + file->prev = &conf->files; + } + ra_conf_unlock (conf); + + file->fd = fd; + file->page_count = conf->page_count; + file->page_size = conf->page_size; + pthread_mutex_init (&file->file_lock, NULL); + + if (!file->disabled) { + file->page_count = 1; + } + + ret = fd_ctx_set (fd, this, (uint64_t)(long)file); if (ret == -1) { ra_file_destroy (file); op_ret = -1; op_errno = ENOMEM; } - + unwind: frame->local = NULL; - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); + STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); - return 0; + return 0; } @@ -124,53 +124,53 @@ ra_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, struct iatt *buf, struct iatt *preparent, struct iatt *postparent) { - ra_conf_t *conf = NULL; - ra_file_t *file = NULL; - int ret = 0; + ra_conf_t *conf = NULL; + ra_file_t *file = NULL; + int ret = 0; - conf = this->private; + conf = this->private; - if (op_ret == -1) { - goto unwind; - } + if (op_ret == -1) { + goto unwind; + } - file = GF_CALLOC (1, sizeof (*file), gf_ra_mt_ra_file_t); - if (!file) { + file = GF_CALLOC (1, sizeof (*file), gf_ra_mt_ra_file_t); + if (!file) { op_ret = -1; op_errno = ENOMEM; - gf_log (this->name, GF_LOG_ERROR, - "out of memory"); - goto unwind; - } - - /* If O_DIRECT open, we disable caching on it */ - - if ((fd->flags & O_DIRECT) || ((fd->flags & O_ACCMODE) == O_WRONLY)) - file->disabled = 1; - - file->offset = (unsigned long long) 0; - //file->size = fd->inode->buf.ia_size; - file->conf = conf; - file->pages.next = &file->pages; - file->pages.prev = &file->pages; - file->pages.offset = (unsigned long long) 0; - file->pages.file = file; - - ra_conf_lock (conf); - { - file->next = conf->files.next; - conf->files.next = file; - file->next->prev = file; - file->prev = &conf->files; - } - ra_conf_unlock (conf); - - file->fd = fd; - file->page_count = conf->page_count; - file->page_size = conf->page_size; - pthread_mutex_init (&file->file_lock, NULL); - - ret = fd_ctx_set (fd, this, (uint64_t)(long)file); + gf_log (this->name, GF_LOG_ERROR, + "out of memory"); + goto unwind; + } + + /* If O_DIRECT open, we disable caching on it */ + + if ((fd->flags & O_DIRECT) || ((fd->flags & O_ACCMODE) == O_WRONLY)) + file->disabled = 1; + + file->offset = (unsigned long long) 0; + //file->size = fd->inode->buf.ia_size; + file->conf = conf; + file->pages.next = &file->pages; + file->pages.prev = &file->pages; + file->pages.offset = (unsigned long long) 0; + file->pages.file = file; + + ra_conf_lock (conf); + { + file->next = conf->files.next; + conf->files.next = file; + file->next->prev = file; + file->prev = &conf->files; + } + ra_conf_unlock (conf); + + file->fd = fd; + file->page_count = conf->page_count; + file->page_size = conf->page_size; + pthread_mutex_init (&file->file_lock, NULL); + + ret = fd_ctx_set (fd, this, (uint64_t)(long)file); if (ret == -1) { ra_file_destroy (file); op_ret = -1; @@ -178,10 +178,10 @@ ra_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, } unwind: - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, + STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, preparent, postparent); - return 0; + return 0; } @@ -191,24 +191,25 @@ ra_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, { frame->local = (void *)(long)wbflags; - STACK_WIND (frame, ra_open_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->open, - loc, flags, fd, wbflags); + STACK_WIND (frame, ra_open_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->open, + loc, flags, fd, wbflags); - return 0; + return 0; } + int ra_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, mode_t mode, fd_t *fd, dict_t *params) { - STACK_WIND (frame, ra_create_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->create, - loc, flags, mode, fd, params); + STACK_WIND (frame, ra_create_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, + loc, flags, mode, fd, params); - return 0; + return 0; } /* free cache pages between offset and offset+size, @@ -218,109 +219,110 @@ ra_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, static void flush_region (call_frame_t *frame, ra_file_t *file, off_t offset, off_t size) { - ra_page_t *trav = NULL; - ra_page_t *next = NULL; - - ra_file_lock (file); - { - trav = file->pages.next; - while (trav != &file->pages - && trav->offset < (offset + size)) { - - next = trav->next; - if (trav->offset >= offset && !trav->waitq) { - ra_page_purge (trav); - } - trav = next; - } - } - ra_file_unlock (file); + ra_page_t *trav = NULL; + ra_page_t *next = NULL; + + ra_file_lock (file); + { + trav = file->pages.next; + while (trav != &file->pages + && trav->offset < (offset + size)) { + + next = trav->next; + if (trav->offset >= offset && !trav->waitq) { + ra_page_purge (trav); + } + trav = next; + } + } + ra_file_unlock (file); } int ra_release (xlator_t *this, fd_t *fd) { - uint64_t tmp_file = 0; - int ret = 0; + uint64_t tmp_file = 0; + int ret = 0; - ret = fd_ctx_del (fd, this, &tmp_file); - - if (!ret) { - ra_file_destroy ((ra_file_t *)(long)tmp_file); - } + ret = fd_ctx_del (fd, this, &tmp_file); - return 0; + if (!ret) { + ra_file_destroy ((ra_file_t *)(long)tmp_file); + } + + return 0; } void read_ahead (call_frame_t *frame, ra_file_t *file) { - off_t ra_offset = 0; - size_t ra_size = 0; - off_t trav_offset = 0; - ra_page_t *trav = NULL; - off_t cap = 0; - char fault = 0; - - if (!file->page_count) - return; - - ra_size = file->page_size * file->page_count; - ra_offset = floor (file->offset, file->page_size); - cap = file->size ? file->size : file->offset + ra_size; - - while (ra_offset < min (file->offset + ra_size, cap)) { - - ra_file_lock (file); - { - trav = ra_page_get (file, ra_offset); - } - ra_file_unlock (file); - - if (!trav) - break; - - ra_offset += file->page_size; - } - - if (trav) - /* comfortable enough */ - return; - - trav_offset = ra_offset; - - cap = file->size ? file->size : ra_offset + ra_size; - - while (trav_offset < min(ra_offset + ra_size, cap)) { - fault = 0; - ra_file_lock (file); - { - trav = ra_page_get (file, trav_offset); - if (!trav) { - fault = 1; - trav = ra_page_create (file, trav_offset); - if (trav) - trav->dirty = 1; - } - } - ra_file_unlock (file); - - if (!trav) { - /* OUT OF MEMORY */ - break; - } - - if (fault) { - gf_log (frame->this->name, GF_LOG_TRACE, - "RA at offset=%"PRId64, trav_offset); - ra_page_fault (file, frame, trav_offset); - } - trav_offset += file->page_size; - } - - return; + off_t ra_offset = 0; + size_t ra_size = 0; + off_t trav_offset = 0; + ra_page_t *trav = NULL; + off_t cap = 0; + char fault = 0; + + if (!file->page_count) + return; + + ra_size = file->page_size * file->page_count; + ra_offset = floor (file->offset, file->page_size); + cap = file->size ? file->size : file->offset + ra_size; + + while (ra_offset < min (file->offset + ra_size, cap)) { + + ra_file_lock (file); + { + trav = ra_page_get (file, ra_offset); + } + ra_file_unlock (file); + + if (!trav) + break; + + ra_offset += file->page_size; + } + + if (trav) { + /* comfortable enough */ + return; + } + + trav_offset = ra_offset; + + cap = file->size ? file->size : ra_offset + ra_size; + + while (trav_offset < min(ra_offset + ra_size, cap)) { + fault = 0; + ra_file_lock (file); + { + trav = ra_page_get (file, trav_offset); + if (!trav) { + fault = 1; + trav = ra_page_create (file, trav_offset); + if (trav) + trav->dirty = 1; + } + } + ra_file_unlock (file); + + if (!trav) { + /* OUT OF MEMORY */ + break; + } + + if (fault) { + gf_log (frame->this->name, GF_LOG_TRACE, + "RA at offset=%"PRId64, trav_offset); + ra_page_fault (file, frame, trav_offset); + } + trav_offset += file->page_size; + } + + return; } @@ -329,92 +331,92 @@ ra_need_atime_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, struct iobref *iobref) { - STACK_DESTROY (frame->root); - return 0; + STACK_DESTROY (frame->root); + return 0; } static void dispatch_requests (call_frame_t *frame, ra_file_t *file) { - ra_local_t *local = NULL; - ra_conf_t *conf = NULL; - off_t rounded_offset = 0; - off_t rounded_end = 0; - off_t trav_offset = 0; - ra_page_t *trav = NULL; - call_frame_t *ra_frame = NULL; - char need_atime_update = 1; - char fault = 0; - - local = frame->local; - conf = file->conf; - - rounded_offset = floor (local->offset, file->page_size); - rounded_end = roof (local->offset + local->size, file->page_size); - - trav_offset = rounded_offset; - - while (trav_offset < rounded_end) { - fault = 0; - - ra_file_lock (file); - { - trav = ra_page_get (file, trav_offset); - if (!trav) { - trav = ra_page_create (file, trav_offset); - fault = 1; - need_atime_update = 0; - } - - if (!trav) { + ra_local_t *local = NULL; + ra_conf_t *conf = NULL; + off_t rounded_offset = 0; + off_t rounded_end = 0; + off_t trav_offset = 0; + ra_page_t *trav = NULL; + call_frame_t *ra_frame = NULL; + char need_atime_update = 1; + char fault = 0; + + local = frame->local; + conf = file->conf; + + rounded_offset = floor (local->offset, file->page_size); + rounded_end = roof (local->offset + local->size, file->page_size); + + trav_offset = rounded_offset; + + while (trav_offset < rounded_end) { + fault = 0; + + ra_file_lock (file); + { + trav = ra_page_get (file, trav_offset); + if (!trav) { + trav = ra_page_create (file, trav_offset); + fault = 1; + need_atime_update = 0; + } + + if (!trav) { local->op_ret = -1; local->op_errno = ENOMEM; - goto unlock; + goto unlock; + } + + if (trav->ready) { + gf_log (frame->this->name, GF_LOG_TRACE, + "HIT at offset=%"PRId64".", + trav_offset); + ra_frame_fill (trav, frame); + } else { + gf_log (frame->this->name, GF_LOG_TRACE, + "IN-TRANSIT at offset=%"PRId64".", + trav_offset); + ra_wait_on_page (trav, frame); + need_atime_update = 0; } + } + unlock: + ra_file_unlock (file); + + if (fault) { + gf_log (frame->this->name, GF_LOG_TRACE, + "MISS at offset=%"PRId64".", + trav_offset); + ra_page_fault (file, frame, trav_offset); + } + + trav_offset += file->page_size; + } - if (trav->ready) { - gf_log (frame->this->name, GF_LOG_TRACE, - "HIT at offset=%"PRId64".", - trav_offset); - ra_frame_fill (trav, frame); - } else { - gf_log (frame->this->name, GF_LOG_TRACE, - "IN-TRANSIT at offset=%"PRId64".", - trav_offset); - ra_wait_on_page (trav, frame); - need_atime_update = 0; - } - } - unlock: - ra_file_unlock (file); - - if (fault) { - gf_log (frame->this->name, GF_LOG_TRACE, - "MISS at offset=%"PRId64".", - trav_offset); - ra_page_fault (file, frame, trav_offset); - } - - trav_offset += file->page_size; - } - - if (need_atime_update && conf->force_atime_update) { - /* TODO: use untimens() since readv() can confuse underlying - io-cache and others */ - ra_frame = copy_frame (frame); + if (need_atime_update && conf->force_atime_update) { + /* TODO: use untimens() since readv() can confuse underlying + io-cache and others */ + ra_frame = copy_frame (frame); if (ra_frame == NULL) { goto out; } - STACK_WIND (ra_frame, ra_need_atime_cbk, - FIRST_CHILD (frame->this), - FIRST_CHILD (frame->this)->fops->readv, - file->fd, 1, 1); - } + STACK_WIND (ra_frame, ra_need_atime_cbk, + FIRST_CHILD (frame->this), + FIRST_CHILD (frame->this)->fops->readv, + file->fd, 1, 1); + } out: - return ; + return ; } @@ -423,10 +425,10 @@ ra_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, struct iobref *iobref) { - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count, + STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count, stbuf, iobref); - return 0; + return 0; } @@ -434,21 +436,21 @@ int ra_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, off_t offset) { - ra_file_t *file = NULL; - ra_local_t *local = NULL; - ra_conf_t *conf = NULL; - int op_errno = 0; - char expected_offset = 1; - uint64_t tmp_file = 0; + ra_file_t *file = NULL; + ra_local_t *local = NULL; + ra_conf_t *conf = NULL; + int op_errno = 0; + char expected_offset = 1; + uint64_t tmp_file = 0; - conf = this->private; + conf = this->private; - gf_log (this->name, GF_LOG_TRACE, - "NEW REQ at offset=%"PRId64" for size=%"GF_PRI_SIZET"", - offset, size); + gf_log (this->name, GF_LOG_TRACE, + "NEW REQ at offset=%"PRId64" for size=%"GF_PRI_SIZET"", + offset, size); - fd_ctx_get (fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + fd_ctx_get (fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; if (file == NULL) { op_errno = EBADF; @@ -457,73 +459,74 @@ ra_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, goto unwind; } - if (file->offset != offset) { - gf_log (this->name, GF_LOG_DEBUG, - "unexpected offset (%"PRId64" != %"PRId64") resetting", - file->offset, offset); - - expected_offset = file->expected = file->page_count = 0; - } else { - gf_log (this->name, GF_LOG_TRACE, - "expected offset (%"PRId64") when page_count=%d", - offset, file->page_count); - - if (file->expected < (conf->page_size * conf->page_count)) { - file->expected += size; - file->page_count = min ((file->expected / file->page_size), - conf->page_count); - } - } - - if (!expected_offset) { - flush_region (frame, file, 0, file->pages.prev->offset + 1); - } - - if (file->disabled) { - STACK_WIND (frame, ra_readv_disabled_cbk, - FIRST_CHILD (frame->this), - FIRST_CHILD (frame->this)->fops->readv, - file->fd, size, offset); - return 0; - } - - local = (void *) GF_CALLOC (1, sizeof (*local), + if (file->offset != offset) { + gf_log (this->name, GF_LOG_DEBUG, + "unexpected offset (%"PRId64" != %"PRId64") resetting", + file->offset, offset); + + expected_offset = file->expected = file->page_count = 0; + } else { + gf_log (this->name, GF_LOG_TRACE, + "expected offset (%"PRId64") when page_count=%d", + offset, file->page_count); + + if (file->expected < (conf->page_size * conf->page_count)) { + file->expected += size; + file->page_count = min ((file->expected + / file->page_size), + conf->page_count); + } + } + + if (!expected_offset) { + flush_region (frame, file, 0, file->pages.prev->offset + 1); + } + + if (file->disabled) { + STACK_WIND (frame, ra_readv_disabled_cbk, + FIRST_CHILD (frame->this), + FIRST_CHILD (frame->this)->fops->readv, + file->fd, size, offset); + return 0; + } + + local = (void *) GF_CALLOC (1, sizeof (*local), gf_ra_mt_ra_local_t); - if (!local) { - gf_log (this->name, GF_LOG_ERROR, - "out of memory"); - op_errno = ENOMEM; - goto unwind; - } + if (!local) { + gf_log (this->name, GF_LOG_ERROR, + "out of memory"); + op_errno = ENOMEM; + goto unwind; + } - local->fd = fd; - local->offset = offset; - local->size = size; - local->wait_count = 1; + local->fd = fd; + local->offset = offset; + local->size = size; + local->wait_count = 1; - local->fill.next = &local->fill; - local->fill.prev = &local->fill; + local->fill.next = &local->fill; + local->fill.prev = &local->fill; - pthread_mutex_init (&local->local_lock, NULL); + pthread_mutex_init (&local->local_lock, NULL); - frame->local = local; + frame->local = local; - dispatch_requests (frame, file); + dispatch_requests (frame, file); - flush_region (frame, file, 0, floor (offset, file->page_size)); + flush_region (frame, file, 0, floor (offset, file->page_size)); read_ahead (frame, file); - ra_frame_return (frame); + ra_frame_return (frame); - file->offset = offset + size; + file->offset = offset + size; - return 0; + return 0; unwind: - STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0, NULL, NULL); + STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0, NULL, NULL); - return 0; + return 0; } @@ -531,8 +534,8 @@ int ra_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno) { - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); + return 0; } @@ -541,20 +544,21 @@ int ra_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf) { - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf); + return 0; } int ra_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) { - ra_file_t *file = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = 0; + ra_file_t *file = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = 0; + + fd_ctx_get (fd, this, &tmp_file); - fd_ctx_get (fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + file = (ra_file_t *)(long)tmp_file; if (file == NULL) { op_errno = EBADF; gf_log (this->name, GF_LOG_DEBUG, "flush received on fd with no" @@ -564,14 +568,14 @@ ra_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) flush_region (frame, file, 0, file->pages.prev->offset+1); - STACK_WIND (frame, ra_flush_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->flush, - fd); - return 0; + STACK_WIND (frame, ra_flush_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->flush, + fd); + return 0; unwind: - STACK_UNWIND_STRICT (flush, frame, -1, op_errno); + STACK_UNWIND_STRICT (flush, frame, -1, op_errno); return 0; } @@ -579,12 +583,13 @@ unwind: int ra_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync) { - ra_file_t *file = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = 0; + ra_file_t *file = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = 0; - fd_ctx_get (fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + fd_ctx_get (fd, this, &tmp_file); + + file = (ra_file_t *)(long)tmp_file; if (file == NULL) { op_errno = EBADF; gf_log (this->name, GF_LOG_DEBUG, "fsync received on fd with no" @@ -592,18 +597,18 @@ ra_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync) goto unwind; } - if (file) { - flush_region (frame, file, 0, file->pages.prev->offset+1); - } + if (file) { + flush_region (frame, file, 0, file->pages.prev->offset+1); + } - STACK_WIND (frame, ra_fsync_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fsync, - fd, datasync); - return 0; + STACK_WIND (frame, ra_fsync_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->fsync, + fd, datasync); + return 0; unwind: - STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL); + STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL); return 0; } @@ -613,20 +618,20 @@ ra_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf) { - fd_t *fd = NULL; - ra_file_t *file = NULL; - uint64_t tmp_file = 0; + fd_t *fd = NULL; + ra_file_t *file = NULL; + uint64_t tmp_file = 0; - fd = frame->local; + fd = frame->local; - fd_ctx_get (fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + fd_ctx_get (fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; flush_region (frame, file, 0, file->pages.prev->offset+1); - frame->local = NULL; - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); + return 0; } @@ -634,12 +639,12 @@ int ra_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, int32_t count, off_t offset, struct iobref *iobref) { - ra_file_t *file = NULL; - uint64_t tmp_file = 0; + ra_file_t *file = NULL; + uint64_t tmp_file = 0; int32_t op_errno = 0; - fd_ctx_get (fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + fd_ctx_get (fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; if (file == NULL) { op_errno = EBADF; gf_log (this->name, GF_LOG_DEBUG, "writev received on fd with" @@ -652,17 +657,17 @@ ra_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, /* reset the read-ahead counters too */ file->expected = file->page_count = 0; - frame->local = fd; + frame->local = fd; - STACK_WIND (frame, ra_writev_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, iobref); + STACK_WIND (frame, ra_writev_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, + fd, vector, count, offset, iobref); - return 0; + return 0; unwind: - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL); + STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL); return 0; } @@ -672,122 +677,123 @@ ra_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf) { - STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf, + STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + return 0; } int ra_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf) { - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf); - return 0; + STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf); + return 0; } int ra_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - - inode = loc->inode; - - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - - if (!file) - continue; - flush_region (frame, file, 0, - file->pages.prev->offset + 1); - } - } - UNLOCK (&inode->lock); - - STACK_WIND (frame, ra_truncate_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->truncate, - loc, offset); - return 0; + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + + inode = loc->inode; + + LOCK (&inode->lock); + { + list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { + fd_ctx_get (iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + + if (!file) + continue; + flush_region (frame, file, 0, + file->pages.prev->offset + 1); + } + } + UNLOCK (&inode->lock); + + STACK_WIND (frame, ra_truncate_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->truncate, + loc, offset); + return 0; } int ra_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - - inode = fd->inode; - - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - - if (!file) - continue; - flush_region (frame, file, 0, - file->pages.prev->offset + 1); - } - } - UNLOCK (&inode->lock); - - STACK_WIND (frame, ra_attr_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fstat, - fd); - return 0; + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + + inode = fd->inode; + + LOCK (&inode->lock); + { + list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { + fd_ctx_get (iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + + if (!file) + continue; + flush_region (frame, file, 0, + file->pages.prev->offset + 1); + } + } + UNLOCK (&inode->lock); + + STACK_WIND (frame, ra_attr_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->fstat, + fd); + return 0; } int ra_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - - inode = fd->inode; - - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - if (!file) - continue; - flush_region (frame, file, 0, - file->pages.prev->offset + 1); - } - } - UNLOCK (&inode->lock); - - STACK_WIND (frame, ra_truncate_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->ftruncate, - fd, offset); - return 0; + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + + inode = fd->inode; + + LOCK (&inode->lock); + { + list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { + fd_ctx_get (iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + if (!file) + continue; + flush_region (frame, file, 0, + file->pages.prev->offset + 1); + } + } + UNLOCK (&inode->lock); + + STACK_WIND (frame, ra_truncate_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->ftruncate, + fd, offset); + return 0; } + int ra_priv_dump (xlator_t *this) { - ra_conf_t *conf = NULL; - int ret = -1; - char key[GF_DUMP_MAX_BUF_LEN]; - char key_prefix[GF_DUMP_MAX_BUF_LEN]; + ra_conf_t *conf = NULL; + int ret = -1; + char key[GF_DUMP_MAX_BUF_LEN] = {0, }; + char key_prefix[GF_DUMP_MAX_BUF_LEN] = {0, }; if (!this) return -1; @@ -806,9 +812,7 @@ ra_priv_dump (xlator_t *this) return -1; } - - gf_proc_dump_build_key (key_prefix, - "xlator.performance.read-ahead", + gf_proc_dump_build_key (key_prefix, "xlator.performance.read-ahead", "priv"); gf_proc_dump_add_section (key_prefix); @@ -824,19 +828,21 @@ ra_priv_dump (xlator_t *this) return 0; } + int32_t mem_acct_init (xlator_t *this) { int ret = -1; - if (!this) + if (!this) { return ret; + } ret = xlator_mem_acct_init (this, gf_ra_mt_end + 1); - + if (ret != 0) { gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" - "failed"); + "failed"); return ret; } @@ -846,24 +852,24 @@ mem_acct_init (xlator_t *this) int init (xlator_t *this) { - ra_conf_t *conf = NULL; - dict_t *options = this->options; - char *page_count_string = NULL; - int32_t ret = -1; - - if (!this->children || this->children->next) { - gf_log (this->name, GF_LOG_ERROR, - "FATAL: read-ahead not configured with exactly one" + ra_conf_t *conf = NULL; + dict_t *options = this->options; + char *page_count_string = NULL; + int32_t ret = -1; + + if (!this->children || this->children->next) { + gf_log (this->name, GF_LOG_ERROR, + "FATAL: read-ahead not configured with exactly one" " child"); goto out; - } - - if (!this->parents) { - gf_log (this->name, GF_LOG_WARNING, - "dangling volume. check volfile "); - } - - conf = (void *) GF_CALLOC (1, sizeof (*conf), + } + + if (!this->parents) { + gf_log (this->name, GF_LOG_WARNING, + "dangling volume. check volfile "); + } + + conf = (void *) GF_CALLOC (1, sizeof (*conf), gf_ra_mt_ra_conf_t); if (conf == NULL) { gf_log (this->name, GF_LOG_ERROR, @@ -871,48 +877,54 @@ init (xlator_t *this) goto out; } - conf->page_size = this->ctx->page_size; - conf->page_count = 4; - - if (dict_get (options, "page-count")) - page_count_string = data_to_str (dict_get (options, - "page-count")); - if (page_count_string) - { - if (gf_string2uint_base10 (page_count_string, &conf->page_count) - != 0) - { - gf_log ("read-ahead", - GF_LOG_ERROR, - "invalid number format \"%s\" of \"option " - "page-count\"", - page_count_string); + conf->page_size = this->ctx->page_size; + conf->page_count = 4; + + if (dict_get (options, "page-count")) { + page_count_string = data_to_str (dict_get (options, + "page-count")); + } + + if (page_count_string) { + if (gf_string2uint_base10 (page_count_string, &conf->page_count) + != 0) { + gf_log ("read-ahead", GF_LOG_ERROR, + "invalid number format \"%s\" of \"option " + "page-count\"", + page_count_string); goto out; - } - gf_log (this->name, GF_LOG_DEBUG, "Using conf->page_count = %u", - conf->page_count); - } - - if (dict_get (options, "force-atime-update")) { - char *force_atime_update_str = data_to_str (dict_get (options, - "force-atime-update")); - if (gf_string2boolean (force_atime_update_str, + } + + gf_log (this->name, GF_LOG_DEBUG, "Using conf->page_count = %u", + conf->page_count); + } + + if (dict_get (options, "force-atime-update")) { + char *force_atime_update_str = NULL; + + force_atime_update_str + = data_to_str (dict_get (options, + "force-atime-update")); + + if (gf_string2boolean (force_atime_update_str, &conf->force_atime_update) == -1) { - gf_log (this->name, GF_LOG_ERROR, - "'force-atime-update' takes only boolean " + gf_log (this->name, GF_LOG_ERROR, + "'force-atime-update' takes only boolean " "options"); goto out; - } - if (conf->force_atime_update) - gf_log (this->name, GF_LOG_DEBUG, "Forcing atime " + } + + if (conf->force_atime_update) { + gf_log (this->name, GF_LOG_DEBUG, "Forcing atime " "updates on cache hit"); - } + } + } - conf->files.next = &conf->files; - conf->files.prev = &conf->files; + conf->files.next = &conf->files; + conf->files.prev = &conf->files; - pthread_mutex_init (&conf->conf_lock, NULL); - this->private = conf; + pthread_mutex_init (&conf->conf_lock, NULL); + this->private = conf; ret = 0; out: @@ -925,35 +937,36 @@ out: return ret; } + void fini (xlator_t *this) { - ra_conf_t *conf = this->private; + ra_conf_t *conf = this->private; if (conf == NULL) return; - pthread_mutex_destroy (&conf->conf_lock); - GF_FREE (conf); + pthread_mutex_destroy (&conf->conf_lock); + GF_FREE (conf); - this->private = NULL; - return; + this->private = NULL; + return; } struct xlator_fops fops = { - .open = ra_open, - .create = ra_create, - .readv = ra_readv, - .writev = ra_writev, - .flush = ra_flush, - .fsync = ra_fsync, - .truncate = ra_truncate, - .ftruncate = ra_ftruncate, - .fstat = ra_fstat, + .open = ra_open, + .create = ra_create, + .readv = ra_readv, + .writev = ra_writev, + .flush = ra_flush, + .fsync = ra_fsync, + .truncate = ra_truncate, + .ftruncate = ra_ftruncate, + .fstat = ra_fstat, }; struct xlator_cbks cbks = { - .release = ra_release, + .release = ra_release, }; struct xlator_dumpops dumpops = { @@ -961,13 +974,13 @@ struct xlator_dumpops dumpops = { }; struct volume_options options[] = { - { .key = {"force-atime-update"}, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {"page-count"}, - .type = GF_OPTION_TYPE_INT, - .min = 1, - .max = 16 - }, - { .key = {NULL} }, + { .key = {"force-atime-update"}, + .type = GF_OPTION_TYPE_BOOL + }, + { .key = {"page-count"}, + .type = GF_OPTION_TYPE_INT, + .min = 1, + .max = 16 + }, + { .key = {NULL} }, }; diff --git a/xlators/performance/read-ahead/src/read-ahead.h b/xlators/performance/read-ahead/src/read-ahead.h index 6eb6ffdc8fc..ed918094fbc 100644 --- a/xlators/performance/read-ahead/src/read-ahead.h +++ b/xlators/performance/read-ahead/src/read-ahead.h @@ -41,77 +41,77 @@ struct ra_waitq; struct ra_waitq { - struct ra_waitq *next; - void *data; + struct ra_waitq *next; + void *data; }; struct ra_fill { - struct ra_fill *next; - struct ra_fill *prev; - off_t offset; - size_t size; - struct iovec *vector; - int32_t count; + struct ra_fill *next; + struct ra_fill *prev; + off_t offset; + size_t size; + struct iovec *vector; + int32_t count; struct iobref *iobref; }; struct ra_local { - mode_t mode; - struct ra_fill fill; - off_t offset; - size_t size; - int32_t op_ret; - int32_t op_errno; - off_t pending_offset; - size_t pending_size; - fd_t *fd; - int32_t wait_count; - pthread_mutex_t local_lock; + mode_t mode; + struct ra_fill fill; + off_t offset; + size_t size; + int32_t op_ret; + int32_t op_errno; + off_t pending_offset; + size_t pending_size; + fd_t *fd; + int32_t wait_count; + pthread_mutex_t local_lock; }; struct ra_page { - struct ra_page *next; - struct ra_page *prev; - struct ra_file *file; - char dirty; - char ready; - struct iovec *vector; - int32_t count; - off_t offset; - size_t size; - struct ra_waitq *waitq; + struct ra_page *next; + struct ra_page *prev; + struct ra_file *file; + char dirty; + char ready; + struct iovec *vector; + int32_t count; + off_t offset; + size_t size; + struct ra_waitq *waitq; struct iobref *iobref; }; struct ra_file { - struct ra_file *next; - struct ra_file *prev; - struct ra_conf *conf; - fd_t *fd; - int disabled; - size_t expected; - struct ra_page pages; - off_t offset; - size_t size; - int32_t refcount; - pthread_mutex_t file_lock; - struct iatt stbuf; - uint64_t page_size; - uint32_t page_count; + struct ra_file *next; + struct ra_file *prev; + struct ra_conf *conf; + fd_t *fd; + int disabled; + size_t expected; + struct ra_page pages; + off_t offset; + size_t size; + int32_t refcount; + pthread_mutex_t file_lock; + struct iatt stbuf; + uint64_t page_size; + uint32_t page_count; }; struct ra_conf { - uint64_t page_size; - uint32_t page_count; - void *cache_block; - struct ra_file files; - gf_boolean_t force_atime_update; - pthread_mutex_t conf_lock; + uint64_t page_size; + uint32_t page_count; + void *cache_block; + struct ra_file files; + gf_boolean_t force_atime_update; + pthread_mutex_t conf_lock; }; @@ -124,19 +124,19 @@ typedef struct ra_fill ra_fill_t; ra_page_t * ra_page_get (ra_file_t *file, - off_t offset); + off_t offset); ra_page_t * ra_page_create (ra_file_t *file, - off_t offset); + off_t offset); void ra_page_fault (ra_file_t *file, - call_frame_t *frame, - off_t offset); + call_frame_t *frame, + off_t offset); void ra_wait_on_page (ra_page_t *page, - call_frame_t *frame); + call_frame_t *frame); ra_waitq_t * ra_page_wakeup (ra_page_t *page); @@ -146,8 +146,8 @@ ra_page_flush (ra_page_t *page); ra_waitq_t * ra_page_error (ra_page_t *page, - int32_t op_ret, - int32_t op_errno); + int32_t op_ret, + int32_t op_errno); void ra_page_purge (ra_page_t *page); @@ -156,7 +156,7 @@ ra_frame_return (call_frame_t *frame); void ra_frame_fill (ra_page_t *page, - call_frame_t *frame); + call_frame_t *frame); void ra_file_destroy (ra_file_t *file); @@ -164,36 +164,36 @@ ra_file_destroy (ra_file_t *file); static inline void ra_file_lock (ra_file_t *file) { - pthread_mutex_lock (&file->file_lock); + pthread_mutex_lock (&file->file_lock); } static inline void ra_file_unlock (ra_file_t *file) { - pthread_mutex_unlock (&file->file_lock); + pthread_mutex_unlock (&file->file_lock); } static inline void ra_conf_lock (ra_conf_t *conf) { - pthread_mutex_lock (&conf->conf_lock); + pthread_mutex_lock (&conf->conf_lock); } static inline void ra_conf_unlock (ra_conf_t *conf) { - pthread_mutex_unlock (&conf->conf_lock); + pthread_mutex_unlock (&conf->conf_lock); } static inline void ra_local_lock (ra_local_t *local) { - pthread_mutex_lock (&local->local_lock); + pthread_mutex_lock (&local->local_lock); } static inline void ra_local_unlock (ra_local_t *local) { - pthread_mutex_unlock (&local->local_lock); + pthread_mutex_unlock (&local->local_lock); } #endif /* __READ_AHEAD_H */ -- cgit