From e16868dede6455cab644805af6fe1ac312775e13 Mon Sep 17 00:00:00 2001 From: Gluster Ant Date: Wed, 12 Sep 2018 17:52:45 +0530 Subject: Land part 2 of clang-format changes Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4 Signed-off-by: Nigel Babu --- xlators/performance/read-ahead/src/page.c | 857 ++++++----- xlators/performance/read-ahead/src/read-ahead.c | 1840 +++++++++++------------ 2 files changed, 1317 insertions(+), 1380 deletions(-) (limited to 'xlators/performance/read-ahead') diff --git a/xlators/performance/read-ahead/src/page.c b/xlators/performance/read-ahead/src/page.c index 17e346ec947..c4071393c95 100644 --- a/xlators/performance/read-ahead/src/page.c +++ b/xlators/performance/read-ahead/src/page.c @@ -17,458 +17,443 @@ #include "read-ahead-messages.h" ra_page_t * -ra_page_get (ra_file_t *file, off_t offset) +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; - GF_VALIDATE_OR_GOTO ("read-ahead", file, out); + GF_VALIDATE_OR_GOTO("read-ahead", file, out); - 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; out: - return page; + return page; } - ra_page_t * -ra_page_create (ra_file_t *file, off_t offset) +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; - GF_VALIDATE_OR_GOTO ("read-ahead", file, out); + GF_VALIDATE_OR_GOTO("read-ahead", file, out); - 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), gf_ra_mt_ra_page_t); - if (!newpage) { - goto out; - } + if (page == &file->pages || page->offset != rounded_offset) { + newpage = GF_CALLOC(1, sizeof(*newpage), gf_ra_mt_ra_page_t); + if (!newpage) { + goto out; + } - 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; + } out: - return page; + return page; } - void -ra_wait_on_page (ra_page_t *page, call_frame_t *frame) +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; - GF_VALIDATE_OR_GOTO ("read-ahead", frame, out); - GF_VALIDATE_OR_GOTO (frame->this->name, page, out); + GF_VALIDATE_OR_GOTO("read-ahead", frame, out); + GF_VALIDATE_OR_GOTO(frame->this->name, page, out); - local = frame->local; + local = frame->local; - waitq = GF_CALLOC (1, sizeof (*waitq), gf_ra_mt_ra_waitq_t); - if (!waitq) { - local->op_ret = -1; - local->op_errno = ENOMEM; - goto out; - } + waitq = GF_CALLOC(1, sizeof(*waitq), gf_ra_mt_ra_waitq_t); + if (!waitq) { + 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; + return; } - void -ra_waitq_return (ra_waitq_t *waitq) +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); + } - return; + return; } - 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, - dict_t *xdata) +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, dict_t *xdata) { - 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; - gf_boolean_t stale = _gf_false; - - GF_ASSERT (frame); + 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; + gf_boolean_t stale = _gf_false; + + GF_ASSERT(frame); + + 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; + + if (file == NULL) { + gf_msg(this->name, GF_LOG_WARNING, EBADF, + READ_AHEAD_MSG_FD_CONTEXT_NOT_SET, + "read-ahead context not set in fd (%p)", fd); + op_ret = -1; + op_errno = EBADF; + goto out; + } + + ra_file_lock(file); + { + if (op_ret >= 0) + file->stbuf = *stbuf; + + page = ra_page_get(file, pending_offset); + + if (!page) { + gf_msg_trace(this->name, 0, + "wasted copy: " + "%" PRId64 "[+%" PRId64 "] file=%p", + pending_offset, file->page_size, file); + goto unlock; + } - local = frame->local; - fd = local->fd; + if (page->stale) { + page->stale = 0; + page->ready = 0; + stale = 1; + goto unlock; + } - fd_ctx_get (fd, this, &tmp_file); + /* + * "Dirty" means that the request was a pure read-ahead; it's + * set for requests we issue ourselves, and cleared when user + * requests are issued or put on the waitq. "Poisoned" means + * that we got a write while a read was still in flight, and we + * couldn't stop it so we marked it instead. If it's both + * dirty and poisoned by the time we get here, we cancel its + * effect so that a subsequent user read doesn't get data that + * we know is stale (because we made it stale ourselves). We + * can't use ESTALE because that has special significance. + * ECANCELED has no such special meaning, and is close to what + * we're trying to indicate. + */ + if (page->dirty && page->poisoned) { + op_ret = -1; + op_errno = ECANCELED; + } - file = (ra_file_t *)(long)tmp_file; - pending_offset = local->pending_offset; + if (op_ret < 0) { + waitq = ra_page_error(page, op_ret, op_errno); + goto unlock; + } - if (file == NULL) { - gf_msg (this->name, GF_LOG_WARNING, EBADF, - READ_AHEAD_MSG_FD_CONTEXT_NOT_SET, - "read-ahead context not set in fd (%p)", fd); - op_ret = -1; - op_errno = EBADF; - goto out; + if (page->vector) { + iobref_unref(page->iobref); + GF_FREE(page->vector); } - ra_file_lock (file); - { - if (op_ret >= 0) - file->stbuf = *stbuf; - - page = ra_page_get (file, pending_offset); - - if (!page) { - gf_msg_trace (this->name, 0, - "wasted copy: " - "%"PRId64"[+%"PRId64"] file=%p", - pending_offset, file->page_size, file); - goto unlock; - } - - if (page->stale) { - page->stale = 0; - page->ready = 0; - stale = 1; - goto unlock; - } - - /* - * "Dirty" means that the request was a pure read-ahead; it's - * set for requests we issue ourselves, and cleared when user - * requests are issued or put on the waitq. "Poisoned" means - * that we got a write while a read was still in flight, and we - * couldn't stop it so we marked it instead. If it's both - * dirty and poisoned by the time we get here, we cancel its - * effect so that a subsequent user read doesn't get data that - * we know is stale (because we made it stale ourselves). We - * can't use ESTALE because that has special significance. - * ECANCELED has no such special meaning, and is close to what - * we're trying to indicate. - */ - if (page->dirty && page->poisoned) { - op_ret = -1; - op_errno = ECANCELED; - } - - if (op_ret < 0) { - waitq = ra_page_error (page, op_ret, op_errno); - 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->size = iov_length (vector, count); - - waitq = ra_page_wakeup (page); + 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->size = iov_length(vector, count); + + waitq = ra_page_wakeup(page); + } unlock: - ra_file_unlock (file); + ra_file_unlock(file); - if (stale) { - STACK_WIND (frame, ra_fault_cbk, - FIRST_CHILD (frame->this), - FIRST_CHILD (frame->this)->fops->readv, - local->fd, local->pending_size, - local->pending_offset, 0, NULL); + if (stale) { + STACK_WIND(frame, ra_fault_cbk, FIRST_CHILD(frame->this), + FIRST_CHILD(frame->this)->fops->readv, local->fd, + local->pending_size, local->pending_offset, 0, NULL); - return 0; - } + return 0; + } - ra_waitq_return (waitq); + ra_waitq_return(waitq); - fd_unref (local->fd); + fd_unref(local->fd); - mem_put (frame->local); - frame->local = NULL; + mem_put(frame->local); + frame->local = NULL; out: - 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) +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; - - GF_VALIDATE_OR_GOTO ("read-ahead", frame, out); - GF_VALIDATE_OR_GOTO (frame->this->name, file, out); - - fault_frame = copy_frame (frame); - if (fault_frame == NULL) { - op_ret = -1; - op_errno = ENOMEM; - goto err; - } - - fault_local = mem_get0 (THIS->local_pool); - if (fault_local == NULL) { - STACK_DESTROY (fault_frame->root); - op_ret = -1; - op_errno = ENOMEM; - goto err; - } - - fault_frame->local = fault_local; - fault_local->pending_offset = offset; - fault_local->pending_size = file->page_size; - - 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, 0, NULL); - - return; + 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; + + GF_VALIDATE_OR_GOTO("read-ahead", frame, out); + GF_VALIDATE_OR_GOTO(frame->this->name, file, out); + + fault_frame = copy_frame(frame); + if (fault_frame == NULL) { + op_ret = -1; + op_errno = ENOMEM; + goto err; + } + + fault_local = mem_get0(THIS->local_pool); + if (fault_local == NULL) { + STACK_DESTROY(fault_frame->root); + op_ret = -1; + op_errno = ENOMEM; + goto err; + } + + fault_frame->local = fault_local; + fault_local->pending_offset = offset; + fault_local->pending_size = file->page_size; + + 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, 0, NULL); + + return; err: - ra_file_lock (file); - { - page = ra_page_get (file, offset); - if (page) - waitq = ra_page_error (page, op_ret, - op_errno); - } - ra_file_unlock (file); - - if (waitq != NULL) { - ra_waitq_return (waitq); - } + ra_file_lock(file); + { + page = ra_page_get(file, offset); + if (page) + waitq = ra_page_error(page, op_ret, op_errno); + } + ra_file_unlock(file); + + if (waitq != NULL) { + ra_waitq_return(waitq); + } out: - return; + return; } - void -ra_frame_fill (ra_page_t *page, call_frame_t *frame) +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; - - GF_VALIDATE_OR_GOTO ("read-ahead", frame, out); - GF_VALIDATE_OR_GOTO (frame->this->name, page, out); - - 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), - gf_ra_mt_iovec); - if (new->vector == NULL) { - local->op_ret = -1; - local->op_errno = ENOMEM; - GF_FREE (new); - goto out; - } - - 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; - - local->op_ret += copy_size; + 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; + + GF_VALIDATE_OR_GOTO("read-ahead", frame, out); + GF_VALIDATE_OR_GOTO(frame->this->name, page, out); + + 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; } -out: - return; -} + 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; + } -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 = 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; - - GF_VALIDATE_OR_GOTO ("read-ahead", frame, 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), + gf_ra_mt_iovec); + if (new->vector == NULL) { + local->op_ret = -1; + local->op_errno = ENOMEM; + GF_FREE(new); + goto out; + } - local = frame->local; - fill = local->fill.next; + new->count = iov_subset(page->vector, page->count, src_offset, + src_offset + copy_size, new->vector); - iobref = iobref_new (); - if (iobref == NULL) { - local->op_ret = -1; - local->op_errno = ENOMEM; - } + new->next = fill; + new->prev = new->next->prev; + new->next->prev = new; + new->prev->next = new; - frame->local = NULL; + local->op_ret += copy_size; + } - while (fill != &local->fill) { - count += fill->count; - fill = fill->next; - } +out: + return; +} - vector = GF_CALLOC (count, sizeof (*vector), gf_ra_mt_iovec); - if (vector == NULL) { +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 = 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; + + GF_VALIDATE_OR_GOTO("read-ahead", frame, out); + + local = frame->local; + fill = local->fill.next; + + iobref = iobref_new(); + if (iobref == NULL) { + local->op_ret = -1; + local->op_errno = ENOMEM; + } + + frame->local = NULL; + + while (fill != &local->fill) { + count += fill->count; + fill = fill->next; + } + + vector = GF_CALLOC(count, sizeof(*vector), gf_ra_mt_iovec); + if (vector == NULL) { + local->op_ret = -1; + local->op_errno = ENOMEM; + iobref_unref(iobref); + iobref = NULL; + } + + fill = local->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)); + if (iobref_merge(iobref, fill->iobref)) { local->op_ret = -1; local->op_errno = ENOMEM; - iobref_unref (iobref); + iobref_unref(iobref); iobref = NULL; + } } - fill = local->fill.next; - - while (fill != &local->fill) { - next = fill->next; + fill->next->prev = fill->prev; + fill->prev->next = fill->prev; - if ((vector != NULL) && (iobref != NULL)) { - memcpy (((char *)vector) + copied, fill->vector, - fill->count * sizeof (*vector)); + iobref_unref(fill->iobref); + GF_FREE(fill->vector); + GF_FREE(fill); - copied += (fill->count * sizeof (*vector)); - if (iobref_merge (iobref, fill->iobref)) { - local->op_ret = -1; - local->op_errno = ENOMEM; - iobref_unref (iobref); - iobref = NULL; - } - } - - fill->next->prev = fill->prev; - fill->prev->next = fill->prev; - - 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, - vector, count, &file->stbuf, iobref, NULL); + STACK_UNWIND_STRICT(readv, frame, local->op_ret, local->op_errno, vector, + count, &file->stbuf, iobref, NULL); - iobref_unref (iobref); - pthread_mutex_destroy (&local->local_lock); - mem_put (local); - GF_FREE (vector); + iobref_unref(iobref); + pthread_mutex_destroy(&local->local_lock); + mem_put(local); + GF_FREE(vector); out: - return; + return; } /* @@ -477,27 +462,27 @@ out: * */ void -ra_frame_return (call_frame_t *frame) +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; - GF_VALIDATE_OR_GOTO ("read-ahead", frame, out); + GF_VALIDATE_OR_GOTO("read-ahead", frame, out); - 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); out: - return; + return; } /* @@ -506,26 +491,26 @@ out: * */ ra_waitq_t * -ra_page_wakeup (ra_page_t *page) +ra_page_wakeup(ra_page_t *page) { - ra_waitq_t *waitq = NULL, *trav = NULL; - call_frame_t *frame = NULL; + ra_waitq_t *waitq = NULL, *trav = NULL; + call_frame_t *frame = NULL; - GF_VALIDATE_OR_GOTO ("read-ahead", page, out); + GF_VALIDATE_OR_GOTO("read-ahead", page, out); - 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); + } - if (page->stale) { - ra_page_purge (page); - } + if (page->stale) { + ra_page_purge(page); + } out: - return waitq; + return waitq; } /* @@ -534,22 +519,22 @@ out: * */ void -ra_page_purge (ra_page_t *page) +ra_page_purge(ra_page_t *page) { - GF_VALIDATE_OR_GOTO ("read-ahead", page, out); + GF_VALIDATE_OR_GOTO("read-ahead", page, out); - page->prev->next = page->next; - page->next->prev = page->prev; + page->prev->next = page->next; + page->next->prev = page->prev; - if (page->iobref) { - iobref_unref (page->iobref); - } + if (page->iobref) { + iobref_unref(page->iobref); + } - GF_FREE (page->vector); - GF_FREE (page); + GF_FREE(page->vector); + GF_FREE(page); out: - return; + return; } /* @@ -560,32 +545,32 @@ out: * */ ra_waitq_t * -ra_page_error (ra_page_t *page, int32_t op_ret, int32_t op_errno) +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; - GF_VALIDATE_OR_GOTO ("read-ahead", page, out); + GF_VALIDATE_OR_GOTO("read-ahead", page, out); - 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); out: - return waitq; + return waitq; } /* @@ -594,31 +579,31 @@ out: * */ void -ra_file_destroy (ra_file_t *file) +ra_file_destroy(ra_file_t *file) { - ra_conf_t *conf = NULL; - ra_page_t *trav = NULL; + ra_conf_t *conf = NULL; + ra_page_t *trav = NULL; - GF_VALIDATE_OR_GOTO ("read-ahead", file, out); + GF_VALIDATE_OR_GOTO("read-ahead", file, out); - conf = file->conf; + conf = file->conf; - ra_conf_lock (conf); - { - file->prev->next = file->next; - file->next->prev = file->prev; - } - ra_conf_unlock (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; - while (trav != &file->pages) { - ra_page_error (trav, -1, EINVAL); - trav = file->pages.next; - } + } - pthread_mutex_destroy (&file->file_lock); - GF_FREE (file); + pthread_mutex_destroy(&file->file_lock); + GF_FREE(file); out: - return; + return; } diff --git a/xlators/performance/read-ahead/src/read-ahead.c b/xlators/performance/read-ahead/src/read-ahead.c index 652b001129b..2fdb56479ab 100644 --- a/xlators/performance/read-ahead/src/read-ahead.c +++ b/xlators/performance/read-ahead/src/read-ahead.c @@ -26,186 +26,176 @@ #include "read-ahead-messages.h" static void -read_ahead (call_frame_t *frame, ra_file_t *file); - +read_ahead(call_frame_t *frame, ra_file_t *file); int -ra_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +ra_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, fd_t *fd, dict_t *xdata) { - ra_conf_t *conf = NULL; - ra_file_t *file = NULL; - int ret = 0; - - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - - conf = this->private; - - if (op_ret == -1) { - goto unwind; - } - - file = GF_CALLOC (1, sizeof (*file), gf_ra_mt_ra_file_t); - if (!file) { - op_ret = -1; - op_errno = ENOMEM; - 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->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) { - gf_msg (frame->this->name, GF_LOG_WARNING, - 0, READ_AHEAD_MSG_NO_MEMORY, - "cannot set read-ahead context" - "information in fd (%p)", - fd); - ra_file_destroy (file); - op_ret = -1; - op_errno = ENOMEM; - } + ra_conf_t *conf = NULL; + ra_file_t *file = NULL; + int ret = 0; + + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + + conf = this->private; + + if (op_ret == -1) { + goto unwind; + } + + file = GF_CALLOC(1, sizeof(*file), gf_ra_mt_ra_file_t); + if (!file) { + op_ret = -1; + op_errno = ENOMEM; + 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->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) { + gf_msg(frame->this->name, GF_LOG_WARNING, 0, READ_AHEAD_MSG_NO_MEMORY, + "cannot set read-ahead context" + "information in fd (%p)", + fd); + ra_file_destroy(file); + op_ret = -1; + op_errno = ENOMEM; + } unwind: - frame->local = NULL; + frame->local = NULL; - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); + STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); - return 0; + return 0; } - int -ra_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +ra_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - ra_conf_t *conf = NULL; - ra_file_t *file = NULL; - int ret = 0; - - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - - conf = this->private; - - if (op_ret == -1) { - goto unwind; - } - - file = GF_CALLOC (1, sizeof (*file), gf_ra_mt_ra_file_t); - if (!file) { - op_ret = -1; - op_errno = ENOMEM; - 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) { - gf_msg (this->name, GF_LOG_WARNING, - 0, READ_AHEAD_MSG_NO_MEMORY, - "cannot set read ahead context" - "information in fd (%p)", - fd); - ra_file_destroy (file); - op_ret = -1; - op_errno = ENOMEM; - } + ra_conf_t *conf = NULL; + ra_file_t *file = NULL; + int ret = 0; + + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + + conf = this->private; + + if (op_ret == -1) { + goto unwind; + } + + file = GF_CALLOC(1, sizeof(*file), gf_ra_mt_ra_file_t); + if (!file) { + op_ret = -1; + op_errno = ENOMEM; + 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) { + gf_msg(this->name, GF_LOG_WARNING, 0, READ_AHEAD_MSG_NO_MEMORY, + "cannot set read ahead context" + "information in fd (%p)", + fd); + ra_file_destroy(file); + op_ret = -1; + op_errno = ENOMEM; + } unwind: - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); + STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, + preparent, postparent, xdata); - return 0; + return 0; } - int -ra_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - fd_t *fd, dict_t *xdata) +ra_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - GF_ASSERT (frame); - GF_ASSERT (this); + GF_ASSERT(frame); + GF_ASSERT(this); - STACK_WIND (frame, ra_open_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->open, - loc, flags, fd, xdata); + STACK_WIND(frame, ra_open_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); - return 0; + return 0; } - int -ra_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) +ra_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - GF_ASSERT (frame); - GF_ASSERT (this); + GF_ASSERT(frame); + GF_ASSERT(this); - STACK_WIND (frame, ra_create_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->create, - loc, flags, mode, umask, fd, xdata); + STACK_WIND(frame, ra_create_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, + xdata); - return 0; + return 0; } /* free cache pages between offset and offset+size, @@ -213,743 +203,714 @@ 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, - int for_write) +flush_region(call_frame_t *frame, ra_file_t *file, off_t offset, off_t size, + int for_write) { - 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) { - if (!trav->waitq) { - ra_page_purge (trav); - } - else { - trav->stale = 1; - - if (for_write) { - trav->poisoned = 1; - } - } - } - trav = next; + 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) { + if (!trav->waitq) { + ra_page_purge(trav); + } else { + trav->stale = 1; + + if (for_write) { + trav->poisoned = 1; + } } + } + trav = next; } - ra_file_unlock (file); + } + ra_file_unlock(file); } - int -ra_release (xlator_t *this, fd_t *fd) +ra_release(xlator_t *this, fd_t *fd) { - uint64_t tmp_file = 0; - int ret = 0; + uint64_t tmp_file = 0; + int ret = 0; - GF_VALIDATE_OR_GOTO ("read-ahead", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); + GF_VALIDATE_OR_GOTO("read-ahead", this, out); + GF_VALIDATE_OR_GOTO(this->name, fd, out); - ret = fd_ctx_del (fd, this, &tmp_file); + ret = fd_ctx_del(fd, this, &tmp_file); - if (!ret) { - ra_file_destroy ((ra_file_t *)(long)tmp_file); - } + if (!ret) { + ra_file_destroy((ra_file_t *)(long)tmp_file); + } out: - return 0; + return 0; } - void -read_ahead (call_frame_t *frame, ra_file_t *file) +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; - - GF_VALIDATE_OR_GOTO ("read-ahead", frame, out); - GF_VALIDATE_OR_GOTO (frame->this->name, file, out); - - if (!file->page_count) { - goto out; + 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; + + GF_VALIDATE_OR_GOTO("read-ahead", frame, out); + GF_VALIDATE_OR_GOTO(frame->this->name, file, out); + + if (!file->page_count) { + goto out; + } + + 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); - 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; + if (!trav) + break; - while (ra_offset < min (file->offset + ra_size, cap)) { + ra_offset += file->page_size; + } - ra_file_lock (file); - { - trav = ra_page_get (file, ra_offset); - } - ra_file_unlock (file); + if (trav) { + /* comfortable enough */ + goto out; + } - if (!trav) - break; + trav_offset = ra_offset; - ra_offset += file->page_size; - } + cap = file->size ? file->size : ra_offset + ra_size; - if (trav) { - /* comfortable enough */ - goto out; + 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); - 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 (!trav) { + /* OUT OF MEMORY */ + break; + } - if (fault) { - gf_msg_trace (frame->this->name, 0, - "RA at offset=%"PRId64, trav_offset); - ra_page_fault (file, frame, trav_offset); - } - trav_offset += file->page_size; + if (fault) { + gf_msg_trace(frame->this->name, 0, "RA at offset=%" PRId64, + trav_offset); + ra_page_fault(file, frame, trav_offset); } + trav_offset += file->page_size; + } out: - return; + return; } - int -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, - dict_t *xdata) +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, + dict_t *xdata) { - GF_ASSERT (frame); - STACK_DESTROY (frame->root); - return 0; + GF_ASSERT(frame); + STACK_DESTROY(frame->root); + return 0; } - static void -dispatch_requests (call_frame_t *frame, ra_file_t *file) +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; - - GF_VALIDATE_OR_GOTO ("read-ahead", frame, out); - GF_VALIDATE_OR_GOTO (frame->this->name, file, out); - - 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); - if (!trav) { - local->op_ret = -1; - local->op_errno = ENOMEM; - goto unlock; - } - fault = 1; - need_atime_update = 0; - } - trav->dirty = 0; - - if (trav->ready) { - gf_msg_trace (frame->this->name, 0, - "HIT at offset=%"PRId64".", - trav_offset); - ra_frame_fill (trav, frame); - } else { - gf_msg_trace (frame->this->name, 0, - "IN-TRANSIT at " - "offset=%"PRId64".", - trav_offset); - ra_wait_on_page (trav, frame); - need_atime_update = 0; - } - } - unlock: - ra_file_unlock (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; - if (local->op_ret == -1) { - goto out; - } + GF_VALIDATE_OR_GOTO("read-ahead", frame, out); + GF_VALIDATE_OR_GOTO(frame->this->name, file, out); + + 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; - if (fault) { - gf_msg_trace (frame->this->name, 0, - "MISS at offset=%"PRId64".", - trav_offset); - ra_page_fault (file, frame, trav_offset); + ra_file_lock(file); + { + trav = ra_page_get(file, trav_offset); + if (!trav) { + trav = ra_page_create(file, trav_offset); + if (!trav) { + local->op_ret = -1; + local->op_errno = ENOMEM; + goto unlock; } + fault = 1; + need_atime_update = 0; + } + trav->dirty = 0; + + if (trav->ready) { + gf_msg_trace(frame->this->name, 0, "HIT at offset=%" PRId64 ".", + trav_offset); + ra_frame_fill(trav, frame); + } else { + gf_msg_trace(frame->this->name, 0, + "IN-TRANSIT at " + "offset=%" PRId64 ".", + trav_offset); + ra_wait_on_page(trav, frame); + need_atime_update = 0; + } + } + unlock: + ra_file_unlock(file); - trav_offset += file->page_size; + if (local->op_ret == -1) { + goto out; } - 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; - } + if (fault) { + gf_msg_trace(frame->this->name, 0, "MISS at offset=%" PRId64 ".", + trav_offset); + ra_page_fault(file, frame, trav_offset); + } - STACK_WIND (ra_frame, ra_need_atime_cbk, - FIRST_CHILD (frame->this), - FIRST_CHILD (frame->this)->fops->readv, - file->fd, 1, 1, 0, NULL); + 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 (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, 0, + NULL); + } + out: - return ; + return; } - int -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, - dict_t *xdata) +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, + dict_t *xdata) { - GF_ASSERT (frame); + GF_ASSERT(frame); - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count, - stbuf, iobref, xdata); + STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf, + iobref, xdata); - return 0; + return 0; } - int -ra_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, uint32_t flags, dict_t *xdata) +ra_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - ra_file_t *file = NULL; - ra_local_t *local = NULL; - ra_conf_t *conf = NULL; - int op_errno = EINVAL; - char expected_offset = 1; - uint64_t tmp_file = 0; - - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); - - conf = this->private; - - gf_msg_trace (this->name, 0, - "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; - - if (!file || file->disabled) { - goto disabled; + ra_file_t *file = NULL; + ra_local_t *local = NULL; + ra_conf_t *conf = NULL; + int op_errno = EINVAL; + char expected_offset = 1; + uint64_t tmp_file = 0; + + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); + + conf = this->private; + + gf_msg_trace(this->name, 0, + "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; + + if (!file || file->disabled) { + goto disabled; + } + + if (file->offset != offset) { + gf_msg_trace(this->name, 0, + "unexpected offset (%" PRId64 " != %" PRId64 + ") " + "resetting", + file->offset, offset); + + expected_offset = file->expected = file->page_count = 0; + } else { + gf_msg_trace(this->name, 0, + "expected offset (%" PRId64 ") when page_count=%d", offset, + file->page_count); + + if (file->expected < (file->page_size * conf->page_count)) { + file->expected += size; + file->page_count = min((file->expected / file->page_size), + conf->page_count); } + } - if (file->offset != offset) { - gf_msg_trace (this->name, 0, - "unexpected offset (%"PRId64" != %"PRId64") " - "resetting", - file->offset, offset); - - expected_offset = file->expected = file->page_count = 0; - } else { - gf_msg_trace (this->name, 0, - "expected offset (%"PRId64") when page_count=%d", - offset, file->page_count); - - if (file->expected < (file->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, 0); - } + if (!expected_offset) { + flush_region(frame, file, 0, file->pages.prev->offset + 1, 0); + } - local = mem_get0 (this->local_pool); - if (!local) { - op_errno = ENOMEM; - goto unwind; - } + local = mem_get0(this->local_pool); + if (!local) { + 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), 0); + flush_region(frame, file, 0, floor(offset, file->page_size), 0); - read_ahead (frame, file); + 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, - NULL); + STACK_UNWIND_STRICT(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, NULL); - return 0; + return 0; disabled: - STACK_WIND (frame, ra_readv_disabled_cbk, - FIRST_CHILD (frame->this), - FIRST_CHILD (frame->this)->fops->readv, - fd, size, offset, flags, xdata); - return 0; + STACK_WIND(frame, ra_readv_disabled_cbk, FIRST_CHILD(frame->this), + FIRST_CHILD(frame->this)->fops->readv, fd, size, offset, flags, + xdata); + return 0; } - int -ra_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, - int32_t op_errno, dict_t *xdata) +ra_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, dict_t *xdata) { - GF_ASSERT (frame); - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata); - return 0; + GF_ASSERT(frame); + STACK_UNWIND_STRICT(flush, frame, op_ret, op_errno, xdata); + return 0; } - - 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, - dict_t *xdata) +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, + dict_t *xdata) { - GF_ASSERT (frame); - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, - xdata); - return 0; + GF_ASSERT(frame); + STACK_UNWIND_STRICT(fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } - int -ra_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +ra_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - int32_t op_errno = EINVAL; + int32_t op_errno = EINVAL; - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); - STACK_WIND (frame, ra_flush_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->flush, fd, xdata); - return 0; + STACK_WIND(frame, ra_flush_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->flush, fd, xdata); + return 0; unwind: - STACK_UNWIND_STRICT (flush, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT(flush, frame, -1, op_errno, NULL); + return 0; } - int -ra_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, - dict_t *xdata) +ra_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, + dict_t *xdata) { - int32_t op_errno = EINVAL; + int32_t op_errno = EINVAL; - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); - STACK_WIND (frame, ra_fsync_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fsync, fd, datasync, xdata); - return 0; + STACK_WIND(frame, ra_fsync_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata); + return 0; unwind: - STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(fsync, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } - int -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, dict_t *xdata) +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, + dict_t *xdata) { - ra_file_t *file = NULL; + ra_file_t *file = NULL; - GF_ASSERT (frame); + GF_ASSERT(frame); - file = frame->local; + file = frame->local; - if (file) { - flush_region (frame, file, 0, file->pages.prev->offset+1, 1); - } + if (file) { + flush_region(frame, file, 0, file->pages.prev->offset + 1, 1); + } - frame->local = NULL; - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf, - xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } - int -ra_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, - int32_t count, off_t offset, uint32_t flags, struct iobref *iobref, - dict_t *xdata) +ra_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, + int32_t count, off_t offset, uint32_t flags, struct iobref *iobref, + dict_t *xdata) { - ra_file_t *file = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = EINVAL; - inode_t *inode = NULL; - fd_t *iter_fd = NULL; + ra_file_t *file = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = EINVAL; + inode_t *inode = NULL; + fd_t *iter_fd = NULL; - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); - inode = fd->inode; + inode = fd->inode; - LOCK (&inode->lock); + LOCK(&inode->lock); + { + list_for_each_entry(iter_fd, &inode->fd_list, inode_list) { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - tmp_file = 0; - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + tmp_file = 0; + fd_ctx_get(iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; - if (!file) - continue; + if (!file) + continue; - if (iter_fd == fd) - frame->local = file; + if (iter_fd == fd) + frame->local = file; - flush_region (frame, file, 0, - file->pages.prev->offset + 1, 1); + flush_region(frame, file, 0, file->pages.prev->offset + 1, 1); - /* reset the read-ahead counters too */ - file->expected = file->page_count = 0; - } + /* reset the read-ahead counters too */ + file->expected = file->page_count = 0; } - UNLOCK (&inode->lock); + } + UNLOCK(&inode->lock); - STACK_WIND (frame, ra_writev_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, flags, iobref, xdata); + STACK_WIND(frame, ra_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, + flags, iobref, xdata); - return 0; + return 0; unwind: - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(writev, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } - int -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, dict_t *xdata) +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, dict_t *xdata) { - GF_ASSERT (frame); + GF_ASSERT(frame); - STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; + STACK_UNWIND_STRICT(truncate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + 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, dict_t *xdata) +ra_attr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *buf, dict_t *xdata) { - GF_ASSERT (frame); + GF_ASSERT(frame); - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata); - return 0; + STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); + return 0; } - int -ra_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, - dict_t *xdata) +ra_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = EINVAL; + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = EINVAL; - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, loc, unwind); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, loc, unwind); - inode = loc->inode; + inode = loc->inode; - LOCK (&inode->lock); + LOCK(&inode->lock); + { + list_for_each_entry(iter_fd, &inode->fd_list, inode_list) { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - tmp_file = 0; - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - - if (!file) - continue; - /* - * Truncation invalidates reads just like writing does. - * TBD: this seems to flush more than it should. The - * only time we should flush at all is when we're - * shortening (not lengthening) the file, and then only - * from new EOF to old EOF. The same problem exists in - * ra_ftruncate. - */ - flush_region (frame, file, 0, - file->pages.prev->offset + 1, 1); - } + tmp_file = 0; + fd_ctx_get(iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + + if (!file) + continue; + /* + * Truncation invalidates reads just like writing does. + * TBD: this seems to flush more than it should. The + * only time we should flush at all is when we're + * shortening (not lengthening) the file, and then only + * from new EOF to old EOF. The same problem exists in + * ra_ftruncate. + */ + flush_region(frame, file, 0, file->pages.prev->offset + 1, 1); } - UNLOCK (&inode->lock); + } + UNLOCK(&inode->lock); - STACK_WIND (frame, ra_truncate_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->truncate, - loc, offset, xdata); - return 0; + STACK_WIND(frame, ra_truncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); + return 0; unwind: - STACK_UNWIND_STRICT (truncate, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(truncate, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } - void -ra_page_dump (struct ra_page *page) +ra_page_dump(struct ra_page *page) { - int i = 0; - call_frame_t *frame = NULL; - char key[GF_DUMP_MAX_BUF_LEN] = {0, }; - ra_waitq_t *trav = NULL; + int i = 0; + call_frame_t *frame = NULL; + char key[GF_DUMP_MAX_BUF_LEN] = { + 0, + }; + ra_waitq_t *trav = NULL; - if (page == NULL) { - goto out; - } + if (page == NULL) { + goto out; + } - gf_proc_dump_write ("offset", "%"PRId64, page->offset); + gf_proc_dump_write("offset", "%" PRId64, page->offset); - gf_proc_dump_write ("size", "%"PRId64, page->size); + gf_proc_dump_write("size", "%" PRId64, page->size); - gf_proc_dump_write ("dirty", "%s", page->dirty ? "yes" : "no"); + gf_proc_dump_write("dirty", "%s", page->dirty ? "yes" : "no"); - gf_proc_dump_write ("poisoned", "%s", page->poisoned ? "yes" : "no"); + gf_proc_dump_write("poisoned", "%s", page->poisoned ? "yes" : "no"); - gf_proc_dump_write ("ready", "%s", page->ready ? "yes" : "no"); + gf_proc_dump_write("ready", "%s", page->ready ? "yes" : "no"); - for (trav = page->waitq; trav; trav = trav->next) { - frame = trav->data; - sprintf (key, "waiting-frame[%d]", i++); - gf_proc_dump_write (key, "%"PRId64, frame->root->unique); - } + for (trav = page->waitq; trav; trav = trav->next) { + frame = trav->data; + sprintf(key, "waiting-frame[%d]", i++); + gf_proc_dump_write(key, "%" PRId64, frame->root->unique); + } out: - return; + return; } int32_t -ra_fdctx_dump (xlator_t *this, fd_t *fd) +ra_fdctx_dump(xlator_t *this, fd_t *fd) { - ra_file_t *file = NULL; - ra_page_t *page = NULL; - int32_t ret = 0, i = 0; - uint64_t tmp_file = 0; - char *path = NULL; - char key[GF_DUMP_MAX_BUF_LEN] = {0, }; - char key_prefix[GF_DUMP_MAX_BUF_LEN] = {0, }; - - fd_ctx_get (fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - - if (file == NULL) { - ret = 0; - goto out; - } + ra_file_t *file = NULL; + ra_page_t *page = NULL; + int32_t ret = 0, i = 0; + uint64_t tmp_file = 0; + char *path = NULL; + char key[GF_DUMP_MAX_BUF_LEN] = { + 0, + }; + char key_prefix[GF_DUMP_MAX_BUF_LEN] = { + 0, + }; + + fd_ctx_get(fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + + if (file == NULL) { + ret = 0; + goto out; + } - gf_proc_dump_build_key (key_prefix, - "xlator.performance.read-ahead", - "file"); + gf_proc_dump_build_key(key_prefix, "xlator.performance.read-ahead", "file"); - gf_proc_dump_add_section (key_prefix); + gf_proc_dump_add_section(key_prefix); - ret = __inode_path (fd->inode, NULL, &path); - if (path != NULL) { - gf_proc_dump_write ("path", "%s", path); - GF_FREE (path); - } + ret = __inode_path(fd->inode, NULL, &path); + if (path != NULL) { + gf_proc_dump_write("path", "%s", path); + GF_FREE(path); + } - gf_proc_dump_write ("fd", "%p", fd); + gf_proc_dump_write("fd", "%p", fd); - gf_proc_dump_write ("disabled", "%s", file->disabled ? "yes" : "no"); + gf_proc_dump_write("disabled", "%s", file->disabled ? "yes" : "no"); - if (file->disabled) { - ret = 0; - goto out; - } + if (file->disabled) { + ret = 0; + goto out; + } - gf_proc_dump_write ("page-size", "%"PRId64, file->page_size); + gf_proc_dump_write("page-size", "%" PRId64, file->page_size); - gf_proc_dump_write ("page-count", "%u", file->page_count); + gf_proc_dump_write("page-count", "%u", file->page_count); - gf_proc_dump_write ("next-expected-offset-for-sequential-reads", - "%"PRId64, file->offset); + gf_proc_dump_write("next-expected-offset-for-sequential-reads", "%" PRId64, + file->offset); - for (page = file->pages.next; page != &file->pages; - page = page->next) { - sprintf (key, "page[%d]", i); - gf_proc_dump_write (key, "%p", page[i++]); - ra_page_dump (page); - } + for (page = file->pages.next; page != &file->pages; page = page->next) { + sprintf(key, "page[%d]", i); + gf_proc_dump_write(key, "%p", page[i++]); + ra_page_dump(page); + } - ret = 0; + ret = 0; out: - return ret; + return ret; } int -ra_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +ra_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = EINVAL; - ra_conf_t *conf = NULL; - - conf = this->private; - - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); - - inode = fd->inode; - - if (conf->force_atime_update) { - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, - inode_list) { - tmp_file = 0; - 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, 0); - } - } - UNLOCK (&inode->lock); + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = EINVAL; + ra_conf_t *conf = NULL; + + conf = this->private; + + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); + + inode = fd->inode; + + if (conf->force_atime_update) { + LOCK(&inode->lock); + { + list_for_each_entry(iter_fd, &inode->fd_list, inode_list) + { + tmp_file = 0; + 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, 0); + } } + UNLOCK(&inode->lock); + } - STACK_WIND (frame, ra_attr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fstat, fd, xdata); - return 0; + STACK_WIND(frame, ra_attr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); + return 0; unwind: - STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(stat, frame, -1, op_errno, NULL, NULL); + return 0; } - int -ra_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - dict_t *xdata) +ra_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = EINVAL; + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = EINVAL; - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); - inode = fd->inode; + inode = fd->inode; - LOCK (&inode->lock); + LOCK(&inode->lock); + { + list_for_each_entry(iter_fd, &inode->fd_list, inode_list) { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - tmp_file = 0; - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - if (!file) - continue; - /* - * Truncation invalidates reads just like writing does. - * TBD: this seems to flush more than it should. The - * only time we should flush at all is when we're - * shortening (not lengthening) the file, and then only - * from new EOF to old EOF. The same problem exists in - * ra_truncate. - */ - flush_region (frame, file, 0, - file->pages.prev->offset + 1, 1); - } + tmp_file = 0; + fd_ctx_get(iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + if (!file) + continue; + /* + * Truncation invalidates reads just like writing does. + * TBD: this seems to flush more than it should. The + * only time we should flush at all is when we're + * shortening (not lengthening) the file, and then only + * from new EOF to old EOF. The same problem exists in + * ra_truncate. + */ + flush_region(frame, file, 0, file->pages.prev->offset + 1, 1); } - UNLOCK (&inode->lock); + } + UNLOCK(&inode->lock); - STACK_WIND (frame, ra_truncate_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->ftruncate, fd, offset, xdata); - return 0; + STACK_WIND(frame, ra_truncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); + return 0; unwind: - STACK_UNWIND_STRICT (truncate, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(truncate, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } int @@ -957,351 +918,342 @@ ra_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - GF_ASSERT (frame); + GF_ASSERT(frame); - STACK_UNWIND_STRICT (discard, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; + STACK_UNWIND_STRICT(discard, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } static int ra_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - size_t len, dict_t *xdata) + size_t len, dict_t *xdata) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = EINVAL; + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = EINVAL; - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); - inode = fd->inode; + inode = fd->inode; - LOCK (&inode->lock); + LOCK(&inode->lock); + { + list_for_each_entry(iter_fd, &inode->fd_list, inode_list) { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - tmp_file = 0; - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - if (!file) - continue; - - flush_region(frame, file, offset, len, 1); - } + tmp_file = 0; + fd_ctx_get(iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + if (!file) + continue; + + flush_region(frame, file, offset, len, 1); } - UNLOCK (&inode->lock); + } + UNLOCK(&inode->lock); - STACK_WIND (frame, ra_discard_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->discard, fd, offset, len, xdata); - return 0; + STACK_WIND(frame, ra_discard_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata); + return 0; unwind: - STACK_UNWIND_STRICT (discard, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(discard, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } int ra_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - GF_ASSERT (frame); + GF_ASSERT(frame); - STACK_UNWIND_STRICT (zerofill, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; + STACK_UNWIND_STRICT(zerofill, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } static int ra_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - off_t len, dict_t *xdata) + off_t len, dict_t *xdata) { - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - uint64_t tmp_file = 0; - int32_t op_errno = EINVAL; + ra_file_t *file = NULL; + fd_t *iter_fd = NULL; + inode_t *inode = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = EINVAL; - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO(frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO(frame->this->name, fd, unwind); - inode = fd->inode; + inode = fd->inode; - LOCK (&inode->lock); + LOCK(&inode->lock); + { + list_for_each_entry(iter_fd, &inode->fd_list, inode_list) { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - tmp_file = 0; - fd_ctx_get (iter_fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; - if (!file) - continue; - - flush_region(frame, file, offset, len, 1); - } + tmp_file = 0; + fd_ctx_get(iter_fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + if (!file) + continue; + + flush_region(frame, file, offset, len, 1); } - UNLOCK (&inode->lock); + } + UNLOCK(&inode->lock); - STACK_WIND (frame, ra_zerofill_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->zerofill, fd, - offset, len, xdata); - return 0; + STACK_WIND(frame, ra_zerofill_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata); + return 0; unwind: - STACK_UNWIND_STRICT (zerofill, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(zerofill, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } int -ra_priv_dump (xlator_t *this) +ra_priv_dump(xlator_t *this) { - ra_conf_t *conf = NULL; - int ret = -1; - char key_prefix[GF_DUMP_MAX_BUF_LEN] = {0, }; - gf_boolean_t add_section = _gf_false; - - if (!this) { - goto out; - } - - conf = this->private; - if (!conf) { - gf_msg (this->name, GF_LOG_WARNING, 0, - READ_AHEAD_MSG_XLATOR_CONF_NULL, - "conf null in xlator"); - goto out; - } - - gf_proc_dump_build_key (key_prefix, "xlator.performance.read-ahead", - "priv"); - - gf_proc_dump_add_section (key_prefix); - add_section = _gf_true; - - ret = pthread_mutex_trylock (&conf->conf_lock); - if (ret) - goto out; - { - gf_proc_dump_write ("page_size", "%d", conf->page_size); - gf_proc_dump_write ("page_count", "%d", conf->page_count); - gf_proc_dump_write ("force_atime_update", "%d", - conf->force_atime_update); - } - pthread_mutex_unlock (&conf->conf_lock); - - ret = 0; + ra_conf_t *conf = NULL; + int ret = -1; + char key_prefix[GF_DUMP_MAX_BUF_LEN] = { + 0, + }; + gf_boolean_t add_section = _gf_false; + + if (!this) { + goto out; + } + + conf = this->private; + if (!conf) { + gf_msg(this->name, GF_LOG_WARNING, 0, READ_AHEAD_MSG_XLATOR_CONF_NULL, + "conf null in xlator"); + goto out; + } + + gf_proc_dump_build_key(key_prefix, "xlator.performance.read-ahead", "priv"); + + gf_proc_dump_add_section(key_prefix); + add_section = _gf_true; + + ret = pthread_mutex_trylock(&conf->conf_lock); + if (ret) + goto out; + { + gf_proc_dump_write("page_size", "%d", conf->page_size); + gf_proc_dump_write("page_count", "%d", conf->page_count); + gf_proc_dump_write("force_atime_update", "%d", + conf->force_atime_update); + } + pthread_mutex_unlock(&conf->conf_lock); + + ret = 0; out: - if (ret && conf) { - if (add_section == _gf_false) - gf_proc_dump_add_section (key_prefix); - - gf_proc_dump_write ("Unable to dump priv", - "(Lock acquisition failed) %s", this->name); - } - return ret; + if (ret && conf) { + if (add_section == _gf_false) + gf_proc_dump_add_section(key_prefix); + + gf_proc_dump_write("Unable to dump priv", + "(Lock acquisition failed) %s", this->name); + } + return ret; } - int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) { - goto out; - } + if (!this) { + goto out; + } - ret = xlator_mem_acct_init (this, gf_ra_mt_end + 1); + ret = xlator_mem_acct_init(this, gf_ra_mt_end + 1); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - READ_AHEAD_MSG_NO_MEMORY, "Memory accounting init" - "failed"); - } + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, READ_AHEAD_MSG_NO_MEMORY, + "Memory accounting init" + "failed"); + } out: - return ret; + return ret; } int -reconfigure (xlator_t *this, dict_t *options) +reconfigure(xlator_t *this, dict_t *options) { - ra_conf_t *conf = NULL; - int ret = -1; + ra_conf_t *conf = NULL; + int ret = -1; - GF_VALIDATE_OR_GOTO ("read-ahead", this, out); - GF_VALIDATE_OR_GOTO ("read-ahead", this->private, out); + GF_VALIDATE_OR_GOTO("read-ahead", this, out); + GF_VALIDATE_OR_GOTO("read-ahead", this->private, out); - conf = this->private; + conf = this->private; - GF_OPTION_RECONF ("page-count", conf->page_count, options, uint32, out); + GF_OPTION_RECONF("page-count", conf->page_count, options, uint32, out); - GF_OPTION_RECONF ("page-size", conf->page_size, options, size_uint64, - out); + GF_OPTION_RECONF("page-size", conf->page_size, options, size_uint64, out); - GF_OPTION_RECONF ("pass-through", this->pass_through, options, bool, - out); + GF_OPTION_RECONF("pass-through", this->pass_through, options, bool, out); - ret = 0; - out: - return ret; + ret = 0; +out: + return ret; } int -init (xlator_t *this) +init(xlator_t *this) { - ra_conf_t *conf = NULL; - int32_t ret = -1; + ra_conf_t *conf = NULL; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("read-ahead", this, out); + GF_VALIDATE_OR_GOTO("read-ahead", this, out); - if (!this->children || this->children->next) { - gf_msg (this->name, GF_LOG_ERROR, 0, - READ_AHEAD_MSG_XLATOR_CHILD_MISCONFIGURED, - "FATAL: read-ahead not configured with exactly one" - " child"); - goto out; - } + if (!this->children || this->children->next) { + gf_msg(this->name, GF_LOG_ERROR, 0, + READ_AHEAD_MSG_XLATOR_CHILD_MISCONFIGURED, + "FATAL: read-ahead not configured with exactly one" + " child"); + goto out; + } - if (!this->parents) { - gf_msg (this->name, GF_LOG_WARNING, 0, - READ_AHEAD_MSG_VOL_MISCONFIGURED, - "dangling volume. check volfile "); - } + if (!this->parents) { + gf_msg(this->name, GF_LOG_WARNING, 0, READ_AHEAD_MSG_VOL_MISCONFIGURED, + "dangling volume. check volfile "); + } - conf = (void *) GF_CALLOC (1, sizeof (*conf), gf_ra_mt_ra_conf_t); - if (conf == NULL) { - goto out; - } + conf = (void *)GF_CALLOC(1, sizeof(*conf), gf_ra_mt_ra_conf_t); + if (conf == NULL) { + goto out; + } - conf->page_size = this->ctx->page_size; + conf->page_size = this->ctx->page_size; - GF_OPTION_INIT ("page-size", conf->page_size, size_uint64, out); + GF_OPTION_INIT("page-size", conf->page_size, size_uint64, out); - GF_OPTION_INIT ("page-count", conf->page_count, uint32, out); + GF_OPTION_INIT("page-count", conf->page_count, uint32, out); - GF_OPTION_INIT ("force-atime-update", conf->force_atime_update, bool, out); + GF_OPTION_INIT("force-atime-update", conf->force_atime_update, bool, out); - GF_OPTION_INIT ("pass-through", this->pass_through, bool, out); + GF_OPTION_INIT("pass-through", this->pass_through, bool, out); - 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); + pthread_mutex_init(&conf->conf_lock, NULL); - this->local_pool = mem_pool_new (ra_local_t, 64); - if (!this->local_pool) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, - ENOMEM, READ_AHEAD_MSG_NO_MEMORY, - "failed to create local_t's memory pool"); - goto out; - } + this->local_pool = mem_pool_new(ra_local_t, 64); + if (!this->local_pool) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, READ_AHEAD_MSG_NO_MEMORY, + "failed to create local_t's memory pool"); + goto out; + } - this->private = conf; - ret = 0; + this->private = conf; + ret = 0; out: - if (ret == -1) { - GF_FREE (conf); - } + if (ret == -1) { + GF_FREE(conf); + } - return ret; + return ret; } - void -fini (xlator_t *this) +fini(xlator_t *this) { - ra_conf_t *conf = NULL; + ra_conf_t *conf = NULL; - GF_VALIDATE_OR_GOTO ("read-ahead", this, out); + GF_VALIDATE_OR_GOTO("read-ahead", this, out); - conf = this->private; - if (conf == NULL) { - goto out; - } + conf = this->private; + if (conf == NULL) { + goto out; + } - this->private = NULL; - - /* The files structures allocated in open and create are not deleted. - * until that is freed, marking the below assert as warning. - GF_ASSERT ((conf->files.next == &conf->files) - && (conf->files.prev == &conf->files)); - */ - if (!((conf->files.next == &conf->files) - && (conf->files.prev == &conf->files))) { - gf_msg (this->name, GF_LOG_INFO, 0, - READ_AHEAD_MSG_UNDESTROYED_FILE_FOUND, - "undestroyed read ahead file structures found"); - } + this->private = NULL; + + /* The files structures allocated in open and create are not deleted. + * until that is freed, marking the below assert as warning. + GF_ASSERT ((conf->files.next == &conf->files) + && (conf->files.prev == &conf->files)); + */ + if (!((conf->files.next == &conf->files) && + (conf->files.prev == &conf->files))) { + gf_msg(this->name, GF_LOG_INFO, 0, + READ_AHEAD_MSG_UNDESTROYED_FILE_FOUND, + "undestroyed read ahead file structures found"); + } - pthread_mutex_destroy (&conf->conf_lock); - GF_FREE (conf); + pthread_mutex_destroy(&conf->conf_lock); + GF_FREE(conf); out: - return; + 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, - .discard = ra_discard, - .zerofill = ra_zerofill, + .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, + .discard = ra_discard, + .zerofill = ra_zerofill, }; struct xlator_cbks cbks = { - .release = ra_release, + .release = ra_release, }; struct xlator_dumpops dumpops = { - .priv = ra_priv_dump, - .fdctx = ra_fdctx_dump, + .priv = ra_priv_dump, + .fdctx = ra_fdctx_dump, }; struct volume_options options[] = { - { .key = {"force-atime-update"}, - .type = GF_OPTION_TYPE_BOOL, - .op_version = {1}, - .tags = {"read-ahead"}, - .default_value = "false" - }, - { .key = {"page-count"}, - .type = GF_OPTION_TYPE_INT, - .min = 1, - .max = 16, - .default_value = "4", - .op_version = {1}, - .tags = {"read-ahead"}, - .description = "Number of pages that will be pre-fetched" - }, - { .key = {"page-size"}, - .type = GF_OPTION_TYPE_SIZET, - .min = 4096, - .max = 1048576 * 64, - .default_value = "131072", - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT, - .tags = {"read-ahead"}, - .description = "Page size with which read-ahead performs server I/O" - }, - { .key = {"pass-through"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "false", - .op_version = {GD_OP_VERSION_4_1_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT, - .tags = {"read-ahead"}, - .description = "Enable/Disable read ahead translator" - }, - { .key = {NULL} }, + {.key = {"force-atime-update"}, + .type = GF_OPTION_TYPE_BOOL, + .op_version = {1}, + .tags = {"read-ahead"}, + .default_value = "false"}, + {.key = {"page-count"}, + .type = GF_OPTION_TYPE_INT, + .min = 1, + .max = 16, + .default_value = "4", + .op_version = {1}, + .tags = {"read-ahead"}, + .description = "Number of pages that will be pre-fetched"}, + {.key = {"page-size"}, + .type = GF_OPTION_TYPE_SIZET, + .min = 4096, + .max = 1048576 * 64, + .default_value = "131072", + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT, + .tags = {"read-ahead"}, + .description = "Page size with which read-ahead performs server I/O"}, + {.key = {"pass-through"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false", + .op_version = {GD_OP_VERSION_4_1_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT, + .tags = {"read-ahead"}, + .description = "Enable/Disable read ahead translator"}, + {.key = {NULL}}, }; -- cgit