diff options
Diffstat (limited to 'xlators/features/locks/src/posix.c')
| -rw-r--r-- | xlators/features/locks/src/posix.c | 996 |
1 files changed, 498 insertions, 498 deletions
diff --git a/xlators/features/locks/src/posix.c b/xlators/features/locks/src/posix.c index 50958a2ed93..c7ae1baedbd 100644 --- a/xlators/features/locks/src/posix.c +++ b/xlators/features/locks/src/posix.c @@ -49,262 +49,262 @@ void do_blocked_rw (pl_inode_t *); static int __rw_allowable (pl_inode_t *, posix_lock_t *, glusterfs_fop_t); struct _truncate_ops { - loc_t loc; - fd_t *fd; - off_t offset; - enum {TRUNCATE, FTRUNCATE} op; + loc_t loc; + fd_t *fd; + off_t offset; + enum {TRUNCATE, FTRUNCATE} op; }; int pl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct stat *prebuf, + int32_t op_ret, int32_t op_errno, struct stat *prebuf, struct stat *postbuf) { - struct _truncate_ops *local = NULL; + struct _truncate_ops *local = NULL; - local = frame->local; + local = frame->local; - if (local->op == TRUNCATE) - loc_wipe (&local->loc); + if (local->op == TRUNCATE) + loc_wipe (&local->loc); - STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, + STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + return 0; } static int truncate_allowed (pl_inode_t *pl_inode, - transport_t *transport, pid_t client_pid, - off_t offset) + transport_t *transport, pid_t client_pid, + off_t offset) { - posix_lock_t *l = NULL; - posix_lock_t region = {.list = {0, }, }; - int ret = 1; - - region.fl_start = offset; - region.fl_end = LLONG_MAX; - region.transport = transport; - region.client_pid = client_pid; - - pthread_mutex_lock (&pl_inode->mutex); - { - list_for_each_entry (l, &pl_inode->ext_list, list) { - if (!l->blocked - && locks_overlap (®ion, l) - && !same_owner (®ion, l)) { - ret = 0; - break; - } - } - } - pthread_mutex_unlock (&pl_inode->mutex); - - return ret; + posix_lock_t *l = NULL; + posix_lock_t region = {.list = {0, }, }; + int ret = 1; + + region.fl_start = offset; + region.fl_end = LLONG_MAX; + region.transport = transport; + region.client_pid = client_pid; + + pthread_mutex_lock (&pl_inode->mutex); + { + list_for_each_entry (l, &pl_inode->ext_list, list) { + if (!l->blocked + && locks_overlap (®ion, l) + && !same_owner (®ion, l)) { + ret = 0; + break; + } + } + } + pthread_mutex_unlock (&pl_inode->mutex); + + return ret; } static int truncate_stat_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 stat *buf) { - posix_locks_private_t *priv = NULL; - struct _truncate_ops *local = NULL; - inode_t *inode = NULL; - pl_inode_t *pl_inode = NULL; - - - priv = this->private; - local = frame->local; - - if (op_ret != 0) { - gf_log (this->name, GF_LOG_ERROR, - "got error (errno=%d, stderror=%s) from child", - op_errno, strerror (op_errno)); - goto unwind; - } - - if (local->op == TRUNCATE) - inode = local->loc.inode; - else - inode = local->fd->inode; - - pl_inode = pl_inode_get (this, inode); - if (!pl_inode) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); + posix_locks_private_t *priv = NULL; + struct _truncate_ops *local = NULL; + inode_t *inode = NULL; + pl_inode_t *pl_inode = NULL; + + + priv = this->private; + local = frame->local; + + if (op_ret != 0) { + gf_log (this->name, GF_LOG_ERROR, + "got error (errno=%d, stderror=%s) from child", + op_errno, strerror (op_errno)); + goto unwind; + } + + if (local->op == TRUNCATE) + inode = local->loc.inode; + else + inode = local->fd->inode; + + pl_inode = pl_inode_get (this, inode); + if (!pl_inode) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); op_ret = -1; - op_errno = ENOMEM; - goto unwind; - } - - if (priv->mandatory - && pl_inode->mandatory - && !truncate_allowed (pl_inode, frame->root->trans, - frame->root->pid, local->offset)) { + op_errno = ENOMEM; + goto unwind; + } + + if (priv->mandatory + && pl_inode->mandatory + && !truncate_allowed (pl_inode, frame->root->trans, + frame->root->pid, local->offset)) { op_ret = -1; - op_errno = EAGAIN; - goto unwind; - } - - switch (local->op) { - case TRUNCATE: - STACK_WIND (frame, pl_truncate_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->truncate, - &local->loc, local->offset); - break; - case FTRUNCATE: - STACK_WIND (frame, pl_truncate_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->ftruncate, - local->fd, local->offset); - break; - } - - return 0; + op_errno = EAGAIN; + goto unwind; + } + + switch (local->op) { + case TRUNCATE: + STACK_WIND (frame, pl_truncate_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->truncate, + &local->loc, local->offset); + break; + case FTRUNCATE: + STACK_WIND (frame, pl_truncate_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->ftruncate, + local->fd, local->offset); + break; + } + + return 0; unwind: - if (local->op == TRUNCATE) - loc_wipe (&local->loc); + if (local->op == TRUNCATE) + loc_wipe (&local->loc); - STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, buf, NULL); - return 0; + STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, buf, NULL); + return 0; } int pl_truncate (call_frame_t *frame, xlator_t *this, - loc_t *loc, off_t offset) + loc_t *loc, off_t offset) { - struct _truncate_ops *local = NULL; + struct _truncate_ops *local = NULL; - local = CALLOC (1, sizeof (struct _truncate_ops)); - if (!local) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - goto unwind; - } + local = CALLOC (1, sizeof (struct _truncate_ops)); + if (!local) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + goto unwind; + } - local->op = TRUNCATE; - local->offset = offset; - loc_copy (&local->loc, loc); + local->op = TRUNCATE; + local->offset = offset; + loc_copy (&local->loc, loc); - frame->local = local; + frame->local = local; - STACK_WIND (frame, truncate_stat_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->stat, loc); + STACK_WIND (frame, truncate_stat_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->stat, loc); - return 0; + return 0; unwind: - STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL); + STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL); - return 0; + return 0; } int pl_ftruncate (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset) + fd_t *fd, off_t offset) { - struct _truncate_ops *local = NULL; + struct _truncate_ops *local = NULL; - local = CALLOC (1, sizeof (struct _truncate_ops)); - if (!local) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - goto unwind; - } + local = CALLOC (1, sizeof (struct _truncate_ops)); + if (!local) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + goto unwind; + } - local->op = FTRUNCATE; - local->offset = offset; - local->fd = fd; + local->op = FTRUNCATE; + local->offset = offset; + local->fd = fd; - frame->local = local; + frame->local = local; - STACK_WIND (frame, truncate_stat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, fd); - return 0; + STACK_WIND (frame, truncate_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd); + return 0; unwind: - STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL); + STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL); - return 0; + return 0; } static void __delete_locks_of_owner (pl_inode_t *pl_inode, - transport_t *transport, pid_t pid) + transport_t *transport, pid_t pid) { - posix_lock_t *tmp = NULL; - posix_lock_t *l = NULL; + posix_lock_t *tmp = NULL; + posix_lock_t *l = NULL; - /* TODO: what if it is a blocked lock with pending l->frame */ + /* TODO: what if it is a blocked lock with pending l->frame */ - list_for_each_entry_safe (l, tmp, &pl_inode->ext_list, list) { - if ((l->transport == transport) - && (l->client_pid == pid)) { - __delete_lock (pl_inode, l); - __destroy_lock (l); - } - } + list_for_each_entry_safe (l, tmp, &pl_inode->ext_list, list) { + if ((l->transport == transport) + && (l->client_pid == pid)) { + __delete_lock (pl_inode, l); + __destroy_lock (l); + } + } - return; + return; } int pl_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno) { - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); - return 0; + return 0; } int pl_flush (call_frame_t *frame, xlator_t *this, - fd_t *fd) + fd_t *fd) { - posix_locks_private_t *priv = NULL; - pl_inode_t *pl_inode = NULL; + posix_locks_private_t *priv = NULL; + pl_inode_t *pl_inode = NULL; - priv = this->private; + priv = this->private; - pl_inode = pl_inode_get (this, fd->inode); + pl_inode = pl_inode_get (this, fd->inode); - if (!pl_inode) { - gf_log (this->name, GF_LOG_DEBUG, "Could not get inode."); - STACK_UNWIND_STRICT (flush, frame, -1, EBADFD); - return 0; - } + if (!pl_inode) { + gf_log (this->name, GF_LOG_DEBUG, "Could not get inode."); + STACK_UNWIND_STRICT (flush, frame, -1, EBADFD); + return 0; + } - pthread_mutex_lock (&pl_inode->mutex); - { - __delete_locks_of_owner (pl_inode, frame->root->trans, - frame->root->pid); - } - pthread_mutex_unlock (&pl_inode->mutex); + pthread_mutex_lock (&pl_inode->mutex); + { + __delete_locks_of_owner (pl_inode, frame->root->trans, + frame->root->pid); + } + pthread_mutex_unlock (&pl_inode->mutex); - grant_blocked_locks (this, pl_inode); + grant_blocked_locks (this, pl_inode); - do_blocked_rw (pl_inode); + do_blocked_rw (pl_inode); - STACK_WIND (frame, pl_flush_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->flush, fd); - return 0; + STACK_WIND (frame, pl_flush_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->flush, fd); + return 0; } int pl_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) { - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); + STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); - return 0; + return 0; } @@ -312,190 +312,190 @@ int pl_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, fd_t *fd, int32_t wbflags) { - /* why isn't O_TRUNC being handled ? */ - STACK_WIND (frame, pl_open_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, - loc, flags & ~O_TRUNC, fd, wbflags); + /* why isn't O_TRUNC being handled ? */ + STACK_WIND (frame, pl_open_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, + loc, flags & ~O_TRUNC, fd, wbflags); - return 0; + return 0; } int pl_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, + xlator_t *this, int32_t op_ret, int32_t op_errno, + fd_t *fd, inode_t *inode, struct stat *buf, struct stat *preparent, struct stat *postparent) { - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, + STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, preparent, postparent); - return 0; + return 0; } int pl_create (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t flags, mode_t mode, fd_t *fd) + loc_t *loc, int32_t flags, mode_t mode, fd_t *fd) { - STACK_WIND (frame, pl_create_cbk, - FIRST_CHILD (this), FIRST_CHILD (this)->fops->create, - loc, flags, mode, fd); - return 0; + STACK_WIND (frame, pl_create_cbk, + FIRST_CHILD (this), FIRST_CHILD (this)->fops->create, + loc, flags, mode, fd); + return 0; } int pl_readv_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, + int32_t op_ret, int32_t op_errno, + struct iovec *vector, int32_t count, struct stat *stbuf, struct iobref *iobref) { - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, + STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count, stbuf, iobref); - return 0; + return 0; } int pl_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct stat *prebuf, + int32_t op_ret, int32_t op_errno, struct stat *prebuf, struct stat *postbuf) { - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); + STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + return 0; } void do_blocked_rw (pl_inode_t *pl_inode) { - struct list_head wind_list; - pl_rw_req_t *rw = NULL; - pl_rw_req_t *tmp = NULL; - - INIT_LIST_HEAD (&wind_list); - - pthread_mutex_lock (&pl_inode->mutex); - { - list_for_each_entry_safe (rw, tmp, &pl_inode->rw_list, list) { - if (__rw_allowable (pl_inode, &rw->region, - rw->stub->fop)) { - list_del_init (&rw->list); - list_add_tail (&rw->list, &wind_list); - } - } - } - pthread_mutex_unlock (&pl_inode->mutex); - - list_for_each_entry_safe (rw, tmp, &wind_list, list) { - list_del_init (&rw->list); - call_resume (rw->stub); - free (rw); - } - - return; + struct list_head wind_list; + pl_rw_req_t *rw = NULL; + pl_rw_req_t *tmp = NULL; + + INIT_LIST_HEAD (&wind_list); + + pthread_mutex_lock (&pl_inode->mutex); + { + list_for_each_entry_safe (rw, tmp, &pl_inode->rw_list, list) { + if (__rw_allowable (pl_inode, &rw->region, + rw->stub->fop)) { + list_del_init (&rw->list); + list_add_tail (&rw->list, &wind_list); + } + } + } + pthread_mutex_unlock (&pl_inode->mutex); + + list_for_each_entry_safe (rw, tmp, &wind_list, list) { + list_del_init (&rw->list); + call_resume (rw->stub); + free (rw); + } + + return; } static int __rw_allowable (pl_inode_t *pl_inode, posix_lock_t *region, - glusterfs_fop_t op) + glusterfs_fop_t op) { - posix_lock_t *l = NULL; - int ret = 1; - - list_for_each_entry (l, &pl_inode->ext_list, list) { - if (locks_overlap (l, region) && !same_owner (l, region)) { - if ((op == GF_FOP_READ) && (l->fl_type != F_WRLCK)) - continue; - ret = 0; - break; - } - } - - return ret; + posix_lock_t *l = NULL; + int ret = 1; + + list_for_each_entry (l, &pl_inode->ext_list, list) { + if (locks_overlap (l, region) && !same_owner (l, region)) { + if ((op == GF_FOP_READ) && (l->fl_type != F_WRLCK)) + continue; + ret = 0; + break; + } + } + + return ret; } int pl_readv_cont (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset) + fd_t *fd, size_t size, off_t offset) { - STACK_WIND (frame, pl_readv_cbk, - FIRST_CHILD (this), FIRST_CHILD (this)->fops->readv, - fd, size, offset); + STACK_WIND (frame, pl_readv_cbk, + FIRST_CHILD (this), FIRST_CHILD (this)->fops->readv, + fd, size, offset); - return 0; + return 0; } int pl_readv (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset) + fd_t *fd, size_t size, off_t offset) { - posix_locks_private_t *priv = NULL; - pl_inode_t *pl_inode = NULL; - pl_rw_req_t *rw = NULL; - posix_lock_t region = {.list = {0, }, }; - int op_ret = 0; - int op_errno = 0; - char wind_needed = 1; - - - priv = this->private; - pl_inode = pl_inode_get (this, fd->inode); - - if (priv->mandatory && pl_inode->mandatory) { - region.fl_start = offset; - region.fl_end = offset + size - 1; - region.transport = frame->root->trans; - region.client_pid = frame->root->pid; + posix_locks_private_t *priv = NULL; + pl_inode_t *pl_inode = NULL; + pl_rw_req_t *rw = NULL; + posix_lock_t region = {.list = {0, }, }; + int op_ret = 0; + int op_errno = 0; + char wind_needed = 1; + + + priv = this->private; + pl_inode = pl_inode_get (this, fd->inode); + + if (priv->mandatory && pl_inode->mandatory) { + region.fl_start = offset; + region.fl_end = offset + size - 1; + region.transport = frame->root->trans; + region.client_pid = frame->root->pid; - pthread_mutex_lock (&pl_inode->mutex); - { - wind_needed = __rw_allowable (pl_inode, ®ion, + pthread_mutex_lock (&pl_inode->mutex); + { + wind_needed = __rw_allowable (pl_inode, ®ion, GF_FOP_READ); - if (wind_needed) { - goto unlock; + if (wind_needed) { + goto unlock; + } + + if (fd->flags & O_NONBLOCK) { + gf_log (this->name, GF_LOG_TRACE, + "returning EAGAIN as fd is O_NONBLOCK"); + op_errno = EAGAIN; + op_ret = -1; + goto unlock; + } + + rw = CALLOC (1, sizeof (*rw)); + if (!rw) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + op_errno = ENOMEM; + op_ret = -1; + goto unlock; } - if (fd->flags & O_NONBLOCK) { - gf_log (this->name, GF_LOG_TRACE, - "returning EAGAIN as fd is O_NONBLOCK"); - op_errno = EAGAIN; - op_ret = -1; - goto unlock; - } - - rw = CALLOC (1, sizeof (*rw)); - if (!rw) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - op_errno = ENOMEM; - op_ret = -1; - goto unlock; - } - - rw->stub = fop_readv_stub (frame, pl_readv_cont, - fd, size, offset); - if (!rw->stub) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - op_errno = ENOMEM; - op_ret = -1; - free (rw); - goto unlock; - } - - rw->region = region; - - list_add_tail (&rw->list, &pl_inode->rw_list); - } - unlock: - pthread_mutex_unlock (&pl_inode->mutex); - } + rw->stub = fop_readv_stub (frame, pl_readv_cont, + fd, size, offset); + if (!rw->stub) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + op_errno = ENOMEM; + op_ret = -1; + free (rw); + goto unlock; + } + + rw->region = region; + + list_add_tail (&rw->list, &pl_inode->rw_list); + } + unlock: + pthread_mutex_unlock (&pl_inode->mutex); + } if (wind_needed) { @@ -504,94 +504,94 @@ pl_readv (call_frame_t *frame, xlator_t *this, fd, size, offset); } - if (op_ret == -1) - STACK_UNWIND_STRICT (readv, frame, -1, op_errno, + if (op_ret == -1) + STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0, NULL, NULL); - return 0; + return 0; } int pl_writev_cont (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int count, off_t offset, + struct iovec *vector, int count, off_t offset, struct iobref *iobref) { - STACK_WIND (frame, pl_writev_cbk, - FIRST_CHILD (this), FIRST_CHILD (this)->fops->writev, - fd, vector, count, offset, iobref); + STACK_WIND (frame, pl_writev_cbk, + FIRST_CHILD (this), FIRST_CHILD (this)->fops->writev, + fd, vector, count, offset, iobref); - return 0; + return 0; } int pl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int32_t count, off_t offset, + struct iovec *vector, int32_t count, off_t offset, struct iobref *iobref) { - posix_locks_private_t *priv = NULL; - pl_inode_t *pl_inode = NULL; - pl_rw_req_t *rw = NULL; - posix_lock_t region = {.list = {0, }, }; - int op_ret = 0; - int op_errno = 0; - char wind_needed = 1; - - - priv = this->private; - pl_inode = pl_inode_get (this, fd->inode); - - if (priv->mandatory && pl_inode->mandatory) { - region.fl_start = offset; - region.fl_end = offset + iov_length (vector, count) - 1; - region.transport = frame->root->trans; - region.client_pid = frame->root->pid; + posix_locks_private_t *priv = NULL; + pl_inode_t *pl_inode = NULL; + pl_rw_req_t *rw = NULL; + posix_lock_t region = {.list = {0, }, }; + int op_ret = 0; + int op_errno = 0; + char wind_needed = 1; + + + priv = this->private; + pl_inode = pl_inode_get (this, fd->inode); + + if (priv->mandatory && pl_inode->mandatory) { + region.fl_start = offset; + region.fl_end = offset + iov_length (vector, count) - 1; + region.transport = frame->root->trans; + region.client_pid = frame->root->pid; - pthread_mutex_lock (&pl_inode->mutex); - { - wind_needed = __rw_allowable (pl_inode, ®ion, + pthread_mutex_lock (&pl_inode->mutex); + { + wind_needed = __rw_allowable (pl_inode, ®ion, GF_FOP_WRITE); - if (wind_needed) - goto unlock; + if (wind_needed) + goto unlock; - if (fd->flags & O_NONBLOCK) { - gf_log (this->name, GF_LOG_TRACE, - "returning EAGAIN because fd is " + if (fd->flags & O_NONBLOCK) { + gf_log (this->name, GF_LOG_TRACE, + "returning EAGAIN because fd is " "O_NONBLOCK"); - op_errno = EAGAIN; - op_ret = -1; - goto unlock; - } - - rw = CALLOC (1, sizeof (*rw)); - if (!rw) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - op_errno = ENOMEM; - op_ret = -1; - goto unlock; - } - - rw->stub = fop_writev_stub (frame, pl_writev_cont, - fd, vector, count, offset, + op_errno = EAGAIN; + op_ret = -1; + goto unlock; + } + + rw = CALLOC (1, sizeof (*rw)); + if (!rw) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + op_errno = ENOMEM; + op_ret = -1; + goto unlock; + } + + rw->stub = fop_writev_stub (frame, pl_writev_cont, + fd, vector, count, offset, iobref); - if (!rw->stub) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - op_errno = ENOMEM; - op_ret = -1; - free (rw); - goto unlock; - } + if (!rw->stub) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + op_errno = ENOMEM; + op_ret = -1; + free (rw); + goto unlock; + } - rw->region = region; + rw->region = region; - list_add_tail (&rw->list, &pl_inode->rw_list); - } - unlock: - pthread_mutex_unlock (&pl_inode->mutex); - } + list_add_tail (&rw->list, &pl_inode->rw_list); + } + unlock: + pthread_mutex_unlock (&pl_inode->mutex); + } if (wind_needed) @@ -599,10 +599,10 @@ pl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, FIRST_CHILD (this), FIRST_CHILD (this)->fops->writev, fd, vector, count, offset, iobref); - if (op_ret == -1) - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL); + if (op_ret == -1) + STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL); - return 0; + return 0; } @@ -610,95 +610,95 @@ int pl_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, struct flock *flock) { - transport_t *transport = NULL; - pid_t client_pid = 0; - posix_locks_private_t *priv = NULL; - pl_inode_t *pl_inode = NULL; - int op_ret = 0; - int op_errno = 0; - int can_block = 0; - posix_lock_t *reqlock = NULL; - posix_lock_t *conf = NULL; - int ret = 0; - - transport = frame->root->trans; - client_pid = frame->root->pid; - priv = this->private; - - pl_inode = pl_inode_get (this, fd->inode); - if (!pl_inode) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - op_ret = -1; - op_errno = ENOMEM; - goto unwind; - } - - reqlock = new_posix_lock (flock, transport, client_pid); - if (!reqlock) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - op_ret = -1; - op_errno = ENOMEM; - goto unwind; - } - - switch (cmd) { + transport_t *transport = NULL; + pid_t client_pid = 0; + posix_locks_private_t *priv = NULL; + pl_inode_t *pl_inode = NULL; + int op_ret = 0; + int op_errno = 0; + int can_block = 0; + posix_lock_t *reqlock = NULL; + posix_lock_t *conf = NULL; + int ret = 0; + + transport = frame->root->trans; + client_pid = frame->root->pid; + priv = this->private; + + pl_inode = pl_inode_get (this, fd->inode); + if (!pl_inode) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + op_ret = -1; + op_errno = ENOMEM; + goto unwind; + } + + reqlock = new_posix_lock (flock, transport, client_pid); + if (!reqlock) { + gf_log (this->name, GF_LOG_ERROR, + "Out of memory."); + op_ret = -1; + op_errno = ENOMEM; + goto unwind; + } + + switch (cmd) { #if F_GETLK != F_GETLK64 - case F_GETLK64: + case F_GETLK64: #endif - case F_GETLK: - conf = pl_getlk (pl_inode, reqlock); - posix_lock_to_flock (conf, flock); - __destroy_lock (reqlock); + case F_GETLK: + conf = pl_getlk (pl_inode, reqlock); + posix_lock_to_flock (conf, flock); + __destroy_lock (reqlock); - break; + break; #if F_SETLKW != F_SETLKW64 - case F_SETLKW64: + case F_SETLKW64: #endif - case F_SETLKW: - can_block = 1; - reqlock->frame = frame; - reqlock->this = this; - reqlock->fd = fd; + case F_SETLKW: + can_block = 1; + reqlock->frame = frame; + reqlock->this = this; + reqlock->fd = fd; - /* fall through */ + /* fall through */ #if F_SETLK != F_SETLK64 - case F_SETLK64: + case F_SETLK64: #endif - case F_SETLK: - memcpy (&reqlock->user_flock, flock, sizeof (struct flock)); - ret = pl_setlk (this, pl_inode, reqlock, - can_block); - - if (ret == -1) { - if (can_block) - goto out; - - gf_log (this->name, GF_LOG_DEBUG, "returning EAGAIN"); - op_ret = -1; - op_errno = EAGAIN; - __destroy_lock (reqlock); - } - } + case F_SETLK: + memcpy (&reqlock->user_flock, flock, sizeof (struct flock)); + ret = pl_setlk (this, pl_inode, reqlock, + can_block); + + if (ret == -1) { + if (can_block) + goto out; + + gf_log (this->name, GF_LOG_DEBUG, "returning EAGAIN"); + op_ret = -1; + op_errno = EAGAIN; + __destroy_lock (reqlock); + } + } unwind: pl_update_refkeeper (this, fd->inode); - STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, flock); + STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, flock); out: - return 0; + return 0; } /* TODO: this function just logs, no action required?? */ int pl_forget (xlator_t *this, - inode_t *inode) + inode_t *inode) { - pl_inode_t *pl_inode = NULL; + pl_inode_t *pl_inode = NULL; posix_lock_t *ext_tmp = NULL; posix_lock_t *ext_l = NULL; @@ -715,11 +715,11 @@ pl_forget (xlator_t *this, pl_dom_list_t *dom = NULL; pl_dom_list_t *dom_tmp = NULL; - pl_inode = pl_inode_get (this, inode); + pl_inode = pl_inode_get (this, inode); - if (!list_empty (&pl_inode->rw_list)) { - gf_log (this->name, GF_LOG_DEBUG, - "Pending R/W requests found, releasing."); + if (!list_empty (&pl_inode->rw_list)) { + gf_log (this->name, GF_LOG_DEBUG, + "Pending R/W requests found, releasing."); list_for_each_entry_safe (rw_req, rw_tmp, &pl_inode->rw_list, list) { @@ -727,11 +727,11 @@ pl_forget (xlator_t *this, list_del (&rw_req->list); FREE (rw_req); } - } + } - if (!list_empty (&pl_inode->ext_list)) { - gf_log (this->name, GF_LOG_DEBUG, - "Pending fcntl locks found, releasing."); + if (!list_empty (&pl_inode->ext_list)) { + gf_log (this->name, GF_LOG_DEBUG, + "Pending fcntl locks found, releasing."); list_for_each_entry_safe (ext_l, ext_tmp, &pl_inode->ext_list, list) { @@ -739,7 +739,7 @@ pl_forget (xlator_t *this, __delete_lock (pl_inode, ext_l); __destroy_lock (ext_l); } - } + } list_for_each_entry_safe (dom, dom_tmp, &pl_inode->dom_list, inode_list) { @@ -778,7 +778,7 @@ pl_forget (xlator_t *this, FREE (pl_inode); - return 0; + return 0; } @@ -794,9 +794,9 @@ pl_dump_inode_priv (xlator_t *this, inode_t *inode) if (!inode) return -1; - ret = inode_ctx_get (inode, this, &tmp_pl_inode); + ret = inode_ctx_get (inode, this, &tmp_pl_inode); - if (ret != 0) + if (ret != 0) return ret; pl_inode = (pl_inode_t *)(long)tmp_pl_inode; @@ -829,7 +829,7 @@ pl_dump_inode (xlator_t *this) "xlator.features.locks.inode_table"); } - return 0; + return 0; } @@ -837,93 +837,93 @@ pl_dump_inode (xlator_t *this) int init (xlator_t *this) { - posix_locks_private_t *priv = NULL; - xlator_list_t *trav = NULL; - data_t *mandatory = NULL; - - if (!this->children || this->children->next) { - gf_log (this->name, GF_LOG_CRITICAL, - "FATAL: posix-locks should have exactly one child"); - return -1; - } - - if (!this->parents) { - gf_log (this->name, GF_LOG_WARNING, - "Volume is dangling. Please check the volume file."); - } - - trav = this->children; - while (trav->xlator->children) - trav = trav->xlator->children; - - if (strncmp ("storage/", trav->xlator->type, 8)) { - gf_log (this->name, GF_LOG_CRITICAL, - "'locks' translator is not loaded over a storage " + posix_locks_private_t *priv = NULL; + xlator_list_t *trav = NULL; + data_t *mandatory = NULL; + + if (!this->children || this->children->next) { + gf_log (this->name, GF_LOG_CRITICAL, + "FATAL: posix-locks should have exactly one child"); + return -1; + } + + if (!this->parents) { + gf_log (this->name, GF_LOG_WARNING, + "Volume is dangling. Please check the volume file."); + } + + trav = this->children; + while (trav->xlator->children) + trav = trav->xlator->children; + + if (strncmp ("storage/", trav->xlator->type, 8)) { + gf_log (this->name, GF_LOG_CRITICAL, + "'locks' translator is not loaded over a storage " "translator"); - return -1; - } + return -1; + } - priv = CALLOC (1, sizeof (*priv)); + priv = CALLOC (1, sizeof (*priv)); - mandatory = dict_get (this->options, "mandatory-locks"); - if (mandatory) { - if (gf_string2boolean (mandatory->data, - &priv->mandatory) == -1) { - gf_log (this->name, GF_LOG_ERROR, - "'mandatory-locks' takes on only boolean " + mandatory = dict_get (this->options, "mandatory-locks"); + if (mandatory) { + if (gf_string2boolean (mandatory->data, + &priv->mandatory) == -1) { + gf_log (this->name, GF_LOG_ERROR, + "'mandatory-locks' takes on only boolean " "values."); - return -1; - } - } + return -1; + } + } - this->private = priv; - return 0; + this->private = priv; + return 0; } int fini (xlator_t *this) { - posix_locks_private_t *priv = NULL; + posix_locks_private_t *priv = NULL; - priv = this->private; - free (priv); + priv = this->private; + free (priv); - return 0; + return 0; } int pl_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, struct flock *flock); + const char *volume, loc_t *loc, int32_t cmd, struct flock *flock); int pl_finodelk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, int32_t cmd, struct flock *flock); + const char *volume, fd_t *fd, int32_t cmd, struct flock *flock); int pl_entrylk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type); + const char *volume, loc_t *loc, const char *basename, + entrylk_cmd cmd, entrylk_type type); int pl_fentrylk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type); + const char *volume, fd_t *fd, const char *basename, + entrylk_cmd cmd, entrylk_type type); struct xlator_fops fops = { - .create = pl_create, - .truncate = pl_truncate, - .ftruncate = pl_ftruncate, - .open = pl_open, - .readv = pl_readv, - .writev = pl_writev, - .lk = pl_lk, - .inodelk = pl_inodelk, - .finodelk = pl_finodelk, - .entrylk = pl_entrylk, - .fentrylk = pl_fentrylk, - .flush = pl_flush, + .create = pl_create, + .truncate = pl_truncate, + .ftruncate = pl_ftruncate, + .open = pl_open, + .readv = pl_readv, + .writev = pl_writev, + .lk = pl_lk, + .inodelk = pl_inodelk, + .finodelk = pl_finodelk, + .entrylk = pl_entrylk, + .fentrylk = pl_fentrylk, + .flush = pl_flush, }; @@ -935,13 +935,13 @@ struct xlator_dumpops dumpops = { }; struct xlator_cbks cbks = { - .forget = pl_forget, + .forget = pl_forget, }; struct volume_options options[] = { - { .key = { "mandatory-locks", "mandatory" }, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {NULL} }, + { .key = { "mandatory-locks", "mandatory" }, + .type = GF_OPTION_TYPE_BOOL + }, + { .key = {NULL} }, }; |