diff options
Diffstat (limited to 'xlators/performance/read-ahead/src/read-ahead.c')
| -rw-r--r-- | xlators/performance/read-ahead/src/read-ahead.c | 1614 |
1 files changed, 979 insertions, 635 deletions
diff --git a/xlators/performance/read-ahead/src/read-ahead.c b/xlators/performance/read-ahead/src/read-ahead.c index 49cf0b9bf..069ab1f1a 100644 --- a/xlators/performance/read-ahead/src/read-ahead.c +++ b/xlators/performance/read-ahead/src/read-ahead.c @@ -1,27 +1,18 @@ /* - Copyright (c) 2006-2009 Z RESEARCH, Inc. <http://www.zresearch.com> + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com> This file is part of GlusterFS. - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU 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 - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. */ -/* - 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 management in case of random seek */ #ifndef _CONFIG_H @@ -34,6 +25,7 @@ #include "dict.h" #include "xlator.h" #include "read-ahead.h" +#include "statedump.h" #include <assert.h> #include <sys/time.h> @@ -43,160 +35,177 @@ 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) + 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; + ra_conf_t *conf = NULL; + ra_file_t *file = NULL; + int ret = 0; - conf = this->private; + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - if (op_ret == -1) { - goto unwind; - } + conf = this->private; + + if (op_ret == -1) { + goto unwind; + } - file = CALLOC (1, sizeof (*file)); - 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; - } - - ret = fd_ctx_set (fd, this, (uint64_t)(long)file); - - /* If mandatory locking has been enabled on this file, - we disable caching on it */ + goto unwind; + } - if ((fd->inode->st_mode & S_ISGID) && !(fd->inode->st_mode & S_IXGRP)) - file->disabled = 1; + /* 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; + 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; - 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); - 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); - 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; + } - if (!file->disabled) { - file->page_count = 1; - } + ret = fd_ctx_set (fd, this, (uint64_t)(long)file); + if (ret == -1) { + gf_log (frame->this->name, GF_LOG_WARNING, + "cannot set read-ahead context information in fd (%p)", + fd); + ra_file_destroy (file); + op_ret = -1; + op_errno = ENOMEM; + } unwind: - STACK_UNWIND (frame, op_ret, op_errno, fd); + frame->local = NULL; - return 0; + STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); + + 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 stat *buf) + 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; + ra_conf_t *conf = NULL; + ra_file_t *file = NULL; + int ret = 0; - conf = this->private; + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); - if (op_ret == -1) { - goto unwind; - } + conf = this->private; + + if (op_ret == -1) { + goto unwind; + } - file = CALLOC (1, sizeof (*file)); - 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; - } - - ret = fd_ctx_set (fd, this, (uint64_t)(long)file); - - /* If mandatory locking has been enabled on this file, - we disable caching on it */ - - if ((fd->inode->st_mode & S_ISGID) && !(fd->inode->st_mode & S_IXGRP)) - file->disabled = 1; - - /* If O_DIRECT open, we disable caching on it */ - - if ((fd->flags & O_DIRECT) || ((fd->flags & O_ACCMODE) == O_WRONLY)) - file->disabled = 1; + goto unwind; + } - file->offset = (unsigned long long) 0; - //file->size = fd->inode->buf.st_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; + /* 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); - 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); - 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_log (this->name, GF_LOG_WARNING, + "cannot set read ahead context information in fd (%p)", + fd); + ra_file_destroy (file); + op_ret = -1; + op_errno = ENOMEM; + } unwind: - STACK_UNWIND (frame, op_ret, op_errno, fd, inode, buf); + 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) + fd_t *fd, dict_t *xdata) { - STACK_WIND (frame, ra_open_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->open, - loc, flags, fd); + GF_ASSERT (frame); + GF_ASSERT (this); + + 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, fd_t *fd) + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - STACK_WIND (frame, ra_create_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->create, - loc, flags, mode, fd); + 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); - return 0; + return 0; } /* free cache pages between offset and offset+size, @@ -204,712 +213,1047 @@ 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); +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_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); - } + GF_VALIDATE_OR_GOTO ("read-ahead", this, out); + GF_VALIDATE_OR_GOTO (this->name, fd, out); + + ret = fd_ctx_del (fd, this, &tmp_file); + + if (!ret) { + ra_file_destroy ((ra_file_t *)(long)tmp_file); + } - return 0; +out: + 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; + 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; + } - 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; - 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)) { - 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_file_lock (file); - { - trav = ra_page_get (file, ra_offset); - } - ra_file_unlock (file); + if (!trav) + break; - if (!trav) - break; + ra_offset += file->page_size; + } - ra_offset += file->page_size; - } + if (trav) { + /* comfortable enough */ + goto out; + } - if (trav) - /* comfortable enough */ - return; - - trav_offset = ra_offset; - - trav = file->pages.next; - 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; - } + 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; +out: + 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 stat *stbuf, struct iobref *iobref) + int32_t count, struct iatt *stbuf, struct iobref *iobref, + dict_t *xdata) { - 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) { - 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; - trav = file->pages.next; - - 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; + 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_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 (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 (local->op_ret == -1) { + goto out; + } + + if (fault) { + gf_log (frame->this->name, GF_LOG_TRACE, + "MISS at offset=%"PRId64".", + trav_offset); + ra_page_fault (file, frame, trav_offset); + } - 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); + 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); - } + 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 stat *stbuf, struct iobref *iobref) + int32_t count, struct iatt *stbuf, struct iobref *iobref, + dict_t *xdata) { - STACK_UNWIND (frame, op_ret, op_errno, vector, count, stbuf, iobref); + GF_ASSERT (frame); + + 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) + 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 = 0; - int ret = 0; - char expected_offset = 1; - uint64_t tmp_file = 0; - - conf = this->private; + 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_log (this->name, GF_LOG_TRACE, - "NEW REQ at offset=%"PRId64" for size=%"GF_PRI_SIZET"", - offset, size); + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); - ret = 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, "readv received on fd with no" - " file set in its context"); - goto unwind; - } + conf = this->private; - if (file->offset != offset) { - gf_log (this->name, GF_LOG_DEBUG, - "unexpected offset (%"PRId64" != %"PRId64") resetting", - file->offset, offset); + gf_log (this->name, GF_LOG_TRACE, + "NEW REQ at offset=%"PRId64" for size=%"GF_PRI_SIZET"", + offset, size); - 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); + fd_ctx_get (fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; - 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 (!file || file->disabled) { + goto disabled; + } - if (!expected_offset) { - flush_region (frame, file, 0, file->pages.prev->offset + 1); - } + if (file->offset != offset) { + gf_log (this->name, GF_LOG_TRACE, + "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 < (file->page_size * conf->page_count)) { + file->expected += size; + file->page_count = min ((file->expected + / file->page_size), + conf->page_count); + } + } - 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; - } + if (!expected_offset) { + flush_region (frame, file, 0, file->pages.prev->offset + 1, 0); + } - local = (void *) CALLOC (1, sizeof (*local)); - if (!local) { - gf_log (this->name, GF_LOG_ERROR, - "out of memory"); - 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)); + flush_region (frame, file, 0, floor (offset, file->page_size), 0); read_ahead (frame, file); - - ra_frame_return (frame); - file->offset = offset + size; + ra_frame_return (frame); - return 0; + file->offset = offset + size; + + return 0; unwind: - STACK_UNWIND (frame, -1, op_errno, NULL, 0, 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; } int ra_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, - int32_t op_errno) + int32_t op_errno, dict_t *xdata) { - STACK_UNWIND (frame, op_ret, op_errno); - return 0; + GF_ASSERT (frame); + STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata); + return 0; } + int -ra_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) +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_file_t *file = NULL; - int ret = 0; - uint64_t tmp_file = 0; - int32_t op_errno = 0; + GF_ASSERT (frame); + STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; +} - ret = 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, "flush received on fd with no" - " file set in its context"); - goto unwind; - } - flush_region (frame, file, 0, file->pages.prev->offset+1); +int +ra_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +{ + ra_file_t *file = 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); + + fd_ctx_get (fd, this, &tmp_file); - STACK_WIND (frame, ra_flush_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->flush, - fd); - return 0; + file = (ra_file_t *)(long)tmp_file; + if (file) { + flush_region (frame, file, 0, file->pages.prev->offset+1, 0); + } + + STACK_WIND (frame, ra_flush_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->flush, fd, xdata); + return 0; unwind: - STACK_UNWIND (frame, -1, op_errno); + 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) +ra_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, + dict_t *xdata) { - ra_file_t *file = NULL; - int ret = 0; - uint64_t tmp_file = 0; - int32_t op_errno = 0; + ra_file_t *file = NULL; + uint64_t tmp_file = 0; + int32_t op_errno = EINVAL; - ret = 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" - " file set in its context"); - goto unwind; - } + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); - if (file) { - flush_region (frame, file, 0, file->pages.prev->offset+1); - } + fd_ctx_get (fd, this, &tmp_file); + + file = (ra_file_t *)(long)tmp_file; + if (file) { + flush_region (frame, file, 0, file->pages.prev->offset+1, 0); + } - STACK_WIND (frame, ra_flush_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, xdata); + return 0; unwind: - STACK_UNWIND (frame, -1, op_errno); + 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 stat *stbuf) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - fd_t *fd = NULL; - ra_file_t *file = NULL; - int ret = 0; - uint64_t tmp_file = 0; + ra_file_t *file = NULL; - fd = frame->local; + GF_ASSERT (frame); - ret = fd_ctx_get (fd, this, &tmp_file); - file = (ra_file_t *)(long)tmp_file; + file = frame->local; - flush_region (frame, file, 0, file->pages.prev->offset+1); + if (file) { + flush_region (frame, file, 0, file->pages.prev->offset+1, 1); + } - frame->local = NULL; - STACK_UNWIND (frame, op_ret, op_errno, stbuf); - 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, struct iobref *iobref) + int32_t count, off_t offset, uint32_t flags, struct iobref *iobref, + dict_t *xdata) { - ra_file_t *file = NULL; - int ret = 0; - uint64_t tmp_file = 0; - int32_t op_errno = 0; - - ret = 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" - "no file set in its context"); - goto unwind; + ra_file_t *file = 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); + + fd_ctx_get (fd, this, &tmp_file); + file = (ra_file_t *)(long)tmp_file; + if (file) { + flush_region (frame, file, 0, file->pages.prev->offset+1, 1); + frame->local = file; + /* reset the read-ahead counters too */ + file->expected = file->page_count = 0; } - flush_region (frame, file, 0, file->pages.prev->offset+1); + STACK_WIND (frame, ra_writev_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, + fd, vector, count, offset, flags, iobref, xdata); - /* reset the read-ahead counters too */ - file->expected = file->page_count = 0; + return 0; - frame->local = fd; +unwind: + STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL, NULL); + return 0; +} - STACK_WIND (frame, ra_writev_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, iobref); - 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) +{ + GF_ASSERT (frame); -unwind: - STACK_UNWIND (frame, -1, op_errno, NULL); + 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 stat *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - STACK_UNWIND (frame, op_ret, op_errno, buf); - return 0; + GF_ASSERT (frame); + + 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) -{ - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - int ret = 0; - uint64_t tmp_file = 0; - - inode = loc->inode; - - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - ret = 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); - } +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; + + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO (frame->this->name, loc, unwind); + + 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; + /* + * 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); + + 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; +} + + +void +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; + + if (page == NULL) { + goto out; + } + + gf_proc_dump_write ("offset", "%"PRId64, page->offset); + + gf_proc_dump_write ("size", "%"PRId64, page->size); + + gf_proc_dump_write ("dirty", "%s", page->dirty ? "yes" : "no"); + + gf_proc_dump_write ("poisoned", "%s", page->poisoned ? "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); } - UNLOCK (&inode->lock); - STACK_WIND (frame, ra_attr_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->truncate, - loc, offset); - return 0; +out: + return; } +int32_t +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; + } + + gf_proc_dump_build_key (key_prefix, + "xlator.performance.read-ahead", + "file"); + + 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); + } + + gf_proc_dump_write ("fd", "%p", fd); + + gf_proc_dump_write ("disabled", "%s", file->disabled ? "yes" : "no"); + + if (file->disabled) { + ret = 0; + goto out; + } + + gf_proc_dump_write ("page-size", "%"PRId64, file->page_size); + + gf_proc_dump_write ("page-count", "%u", file->page_count); + + 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); + } + + ret = 0; +out: + return ret; +} 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; - int ret = 0; - uint64_t tmp_file = 0; - - inode = fd->inode; - - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - ret = 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); +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; + + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + + 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, 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); - return 0; +unwind: + STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL, NULL); + return 0; } int -ra_fchown (call_frame_t *frame, xlator_t *this, fd_t *fd, uid_t uid, gid_t gid) -{ - ra_file_t *file = NULL; - fd_t *iter_fd = NULL; - inode_t *inode = NULL; - int ret = 0; - uint64_t tmp_file = 0; - - inode = fd->inode; - - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - ret = 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); +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; + + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + + 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; + /* + * 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); + + 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; +} + +int +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); - STACK_WIND (frame, ra_attr_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fchown, - fd, uid, gid); - 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) +{ + 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); + + 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, offset, len, 1); + } + } + UNLOCK (&inode->lock); + + 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; +} 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; - int ret = 0; - uint64_t tmp_file = 0; - - inode = fd->inode; - - LOCK (&inode->lock); - { - list_for_each_entry (iter_fd, &inode->fd_list, inode_list) { - ret = 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); +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) +{ + GF_ASSERT (frame); + + 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, + 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; + + GF_ASSERT (frame); + GF_VALIDATE_OR_GOTO (frame->this->name, this, unwind); + GF_VALIDATE_OR_GOTO (frame->this->name, fd, unwind); + + 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, offset, len, 1); + } + } + UNLOCK (&inode->lock); - STACK_WIND (frame, ra_attr_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->ftruncate, - fd, offset); - 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; +} + +int +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_log (this->name, GF_LOG_WARNING, "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; +} + + +int32_t +mem_acct_init (xlator_t *this) +{ + int ret = -1; + + if (!this) { + goto out; + } + + 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"); + } + +out: + return ret; } +int +reconfigure (xlator_t *this, dict_t *options) +{ + 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); + + conf = this->private; + + GF_OPTION_RECONF ("page-count", conf->page_count, options, uint32, out); + + GF_OPTION_RECONF ("page-size", conf->page_size, options, size, out); + + ret = 0; + out: + return ret; +} int init (xlator_t *this) { - ra_conf_t *conf = NULL; - dict_t *options = this->options; - char *page_count_string = NULL; - int32_t ret = -1; + ra_conf_t *conf = 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" + GF_VALIDATE_OR_GOTO ("read-ahead", this, out); + + 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 *) 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, - "FATAL: Out of memory"); 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); - 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, - &conf->force_atime_update) == -1) { - 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 " - "updates on cache hit"); - } + conf->page_size = this->ctx->page_size; + + GF_OPTION_INIT ("page-size", conf->page_size, size, out); - conf->files.next = &conf->files; - conf->files.prev = &conf->files; + GF_OPTION_INIT ("page-count", conf->page_count, uint32, out); - pthread_mutex_init (&conf->conf_lock, NULL); - this->private = conf; + GF_OPTION_INIT ("force-atime-update", conf->force_atime_update, bool, out); + + conf->files.next = &conf->files; + conf->files.prev = &conf->files; + + pthread_mutex_init (&conf->conf_lock, NULL); + + this->local_pool = mem_pool_new (ra_local_t, 64); + if (!this->local_pool) { + ret = -1; + gf_log (this->name, GF_LOG_ERROR, + "failed to create local_t's memory pool"); + goto out; + } + + this->private = conf; ret = 0; out: if (ret == -1) { - if (conf != NULL) { - FREE (conf); - } + GF_FREE (conf); } return ret; } + void fini (xlator_t *this) { - ra_conf_t *conf = this->private; + ra_conf_t *conf = NULL; + + GF_VALIDATE_OR_GOTO ("read-ahead", this, out); - pthread_mutex_destroy (&conf->conf_lock); - FREE (conf); + conf = this->private; + if (conf == NULL) { + goto out; + } + + this->private = NULL; + + GF_ASSERT ((conf->files.next == &conf->files) + && (conf->files.prev == &conf->files)); - this->private = NULL; - return; + pthread_mutex_destroy (&conf->conf_lock); + GF_FREE (conf); + +out: + 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, - .fchown = ra_fchown, + .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_mops mops = { +struct xlator_cbks cbks = { + .release = ra_release, }; -struct xlator_cbks cbks = { - .release = ra_release, +struct xlator_dumpops dumpops = { + .priv = ra_priv_dump, + .fdctx = ra_fdctx_dump, }; 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 = {"force-atime-update"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false" + }, + { .key = {"page-count"}, + .type = GF_OPTION_TYPE_INT, + .min = 1, + .max = 16, + .default_value = "4", + .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", + .description = "Page size with which read-ahead performs server I/O" }, - { .key = {NULL} }, + { .key = {NULL} }, }; |