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/features/locks/src/reservelk.c | 555 +++++++++++++++------------------ 1 file changed, 260 insertions(+), 295 deletions(-) (limited to 'xlators/features/locks/src/reservelk.c') diff --git a/xlators/features/locks/src/reservelk.c b/xlators/features/locks/src/reservelk.c index 5c7a5b47f3e..8b080dba030 100644 --- a/xlators/features/locks/src/reservelk.c +++ b/xlators/features/locks/src/reservelk.c @@ -19,407 +19,372 @@ /* Return true if the two reservelks have exactly same lock boundaries */ int -reservelks_equal (posix_lock_t *l1, posix_lock_t *l2) +reservelks_equal(posix_lock_t *l1, posix_lock_t *l2) { - if ((l1->fl_start == l2->fl_start) && - (l1->fl_end == l2->fl_end)) - return 1; + if ((l1->fl_start == l2->fl_start) && (l1->fl_end == l2->fl_end)) + return 1; - return 0; + return 0; } /* Determine if lock is grantable or not */ static posix_lock_t * -__reservelk_grantable (pl_inode_t *pl_inode, posix_lock_t *lock) +__reservelk_grantable(pl_inode_t *pl_inode, posix_lock_t *lock) { - xlator_t *this = NULL; - posix_lock_t *l = NULL; - posix_lock_t *ret_lock = NULL; - - this = THIS; - - if (list_empty (&pl_inode->reservelk_list)) { - gf_log (this->name, GF_LOG_TRACE, - "No reservelks in list"); - goto out; - } - list_for_each_entry (l, &pl_inode->reservelk_list, list){ - if (reservelks_equal (lock, l)) { - ret_lock = l; - break; - } + xlator_t *this = NULL; + posix_lock_t *l = NULL; + posix_lock_t *ret_lock = NULL; + + this = THIS; + + if (list_empty(&pl_inode->reservelk_list)) { + gf_log(this->name, GF_LOG_TRACE, "No reservelks in list"); + goto out; + } + list_for_each_entry(l, &pl_inode->reservelk_list, list) + { + if (reservelks_equal(lock, l)) { + ret_lock = l; + break; } + } out: - return ret_lock; + return ret_lock; } static int -__same_owner_reservelk (posix_lock_t *l1, posix_lock_t *l2) +__same_owner_reservelk(posix_lock_t *l1, posix_lock_t *l2) { - return (is_same_lkowner (&l1->owner, &l2->owner)); - + return (is_same_lkowner(&l1->owner, &l2->owner)); } static posix_lock_t * -__matching_reservelk (pl_inode_t *pl_inode, posix_lock_t *lock) +__matching_reservelk(pl_inode_t *pl_inode, posix_lock_t *lock) { - posix_lock_t *l = NULL; + posix_lock_t *l = NULL; - if (list_empty (&pl_inode->reservelk_list)) { - gf_log ("posix-locks", GF_LOG_TRACE, - "reservelk list empty"); - return NULL; - } + if (list_empty(&pl_inode->reservelk_list)) { + gf_log("posix-locks", GF_LOG_TRACE, "reservelk list empty"); + return NULL; + } - list_for_each_entry (l, &pl_inode->reservelk_list, list) { - if (reservelks_equal (l, lock)) { - gf_log ("posix-locks", GF_LOG_TRACE, - "equal reservelk found"); - break; - } + list_for_each_entry(l, &pl_inode->reservelk_list, list) + { + if (reservelks_equal(l, lock)) { + gf_log("posix-locks", GF_LOG_TRACE, "equal reservelk found"); + break; } + } - return l; + return l; } static int -__reservelk_conflict (xlator_t *this, pl_inode_t *pl_inode, - posix_lock_t *lock) +__reservelk_conflict(xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock) { - posix_lock_t *conf = NULL; - int ret = 0; - - conf = __matching_reservelk (pl_inode, lock); - if (conf) { - gf_log (this->name, GF_LOG_TRACE, - "Matching reservelk found"); - if (__same_owner_reservelk (lock, conf)) { - list_del_init (&conf->list); - gf_log (this->name, GF_LOG_TRACE, - "Removing the matching reservelk for setlk to progress"); - __destroy_lock(conf); - ret = 0; - } else { - gf_log (this->name, GF_LOG_TRACE, - "Conflicting reservelk found"); - ret = 1; - } - + posix_lock_t *conf = NULL; + int ret = 0; + + conf = __matching_reservelk(pl_inode, lock); + if (conf) { + gf_log(this->name, GF_LOG_TRACE, "Matching reservelk found"); + if (__same_owner_reservelk(lock, conf)) { + list_del_init(&conf->list); + gf_log(this->name, GF_LOG_TRACE, + "Removing the matching reservelk for setlk to progress"); + __destroy_lock(conf); + ret = 0; + } else { + gf_log(this->name, GF_LOG_TRACE, "Conflicting reservelk found"); + ret = 1; } - return ret; - + } + return ret; } int -pl_verify_reservelk (xlator_t *this, pl_inode_t *pl_inode, - posix_lock_t *lock, int can_block) +pl_verify_reservelk(xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, + int can_block) { - int ret = 0; - - pthread_mutex_lock (&pl_inode->mutex); - { - if (__reservelk_conflict (this, pl_inode, lock)) { - gf_log (this->name, GF_LOG_TRACE, - "Found conflicting reservelk. Blocking until reservelk is unlocked."); - lock->blocked = can_block; - list_add_tail (&lock->list, &pl_inode->blocked_calls); - ret = -1; - goto unlock; - } - - gf_log (this->name, GF_LOG_TRACE, - "no conflicting reservelk found. Call continuing"); - ret = 0; - + int ret = 0; + + pthread_mutex_lock(&pl_inode->mutex); + { + if (__reservelk_conflict(this, pl_inode, lock)) { + gf_log(this->name, GF_LOG_TRACE, + "Found conflicting reservelk. Blocking until reservelk is " + "unlocked."); + lock->blocked = can_block; + list_add_tail(&lock->list, &pl_inode->blocked_calls); + ret = -1; + goto unlock; } -unlock: - pthread_mutex_unlock (&pl_inode->mutex); - return ret; + gf_log(this->name, GF_LOG_TRACE, + "no conflicting reservelk found. Call continuing"); + ret = 0; + } +unlock: + pthread_mutex_unlock(&pl_inode->mutex); + return ret; } - /* Determines if lock can be granted and adds the lock. If the lock * is blocking, adds it to the blocked_reservelks. */ static int -__lock_reservelk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, - int can_block) +__lock_reservelk(xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, + int can_block) { - posix_lock_t *conf = NULL; - int ret = -EINVAL; + posix_lock_t *conf = NULL; + int ret = -EINVAL; - conf = __reservelk_grantable (pl_inode, lock); - if (conf){ - ret = -EAGAIN; - if (can_block == 0) - goto out; + conf = __reservelk_grantable(pl_inode, lock); + if (conf) { + ret = -EAGAIN; + if (can_block == 0) + goto out; - list_add_tail (&lock->list, &pl_inode->blocked_reservelks); + list_add_tail(&lock->list, &pl_inode->blocked_reservelks); - gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Blocked", - lock->fl_type == F_UNLCK ? "Unlock" : "Lock", - lock->client_pid, - lkowner_utoa (&lock->owner), - lock->user_flock.l_start, - lock->user_flock.l_len); + gf_log(this->name, GF_LOG_TRACE, + "%s (pid=%d) lk-owner:%s %" PRId64 " - %" PRId64 " => Blocked", + lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, + lkowner_utoa(&lock->owner), lock->user_flock.l_start, + lock->user_flock.l_len); + goto out; + } - goto out; - } + list_add(&lock->list, &pl_inode->reservelk_list); - list_add (&lock->list, &pl_inode->reservelk_list); - - ret = 0; + ret = 0; out: - return ret; + return ret; } static posix_lock_t * -find_matching_reservelk (posix_lock_t *lock, pl_inode_t *pl_inode) +find_matching_reservelk(posix_lock_t *lock, pl_inode_t *pl_inode) { - posix_lock_t *l = NULL; - list_for_each_entry (l, &pl_inode->reservelk_list, list) { - if (reservelks_equal (l, lock)) - return l; - } - return NULL; + posix_lock_t *l = NULL; + list_for_each_entry(l, &pl_inode->reservelk_list, list) + { + if (reservelks_equal(l, lock)) + return l; + } + return NULL; } /* Set F_UNLCK removes a lock which has the exact same lock boundaries * as the UNLCK lock specifies. If such a lock is not found, returns invalid */ static posix_lock_t * -__reserve_unlock_lock (xlator_t *this, posix_lock_t *lock, pl_inode_t *pl_inode) +__reserve_unlock_lock(xlator_t *this, posix_lock_t *lock, pl_inode_t *pl_inode) { + posix_lock_t *conf = NULL; - posix_lock_t *conf = NULL; - - conf = find_matching_reservelk (lock, pl_inode); - if (!conf) { - gf_log (this->name, GF_LOG_DEBUG, - " Matching lock not found for unlock"); - goto out; - } - __delete_lock(conf); - gf_log (this->name, GF_LOG_DEBUG, - " Matching lock found for unlock"); + conf = find_matching_reservelk(lock, pl_inode); + if (!conf) { + gf_log(this->name, GF_LOG_DEBUG, " Matching lock not found for unlock"); + goto out; + } + __delete_lock(conf); + gf_log(this->name, GF_LOG_DEBUG, " Matching lock found for unlock"); out: - return conf; - - + return conf; } static void -__grant_blocked_reserve_locks (xlator_t *this, pl_inode_t *pl_inode, - struct list_head *granted) +__grant_blocked_reserve_locks(xlator_t *this, pl_inode_t *pl_inode, + struct list_head *granted) { - int bl_ret = 0; - posix_lock_t *bl = NULL; - posix_lock_t *tmp = NULL; - - struct list_head blocked_list; + int bl_ret = 0; + posix_lock_t *bl = NULL; + posix_lock_t *tmp = NULL; - INIT_LIST_HEAD (&blocked_list); - list_splice_init (&pl_inode->blocked_reservelks, &blocked_list); + struct list_head blocked_list; - list_for_each_entry_safe (bl, tmp, &blocked_list, list) { + INIT_LIST_HEAD(&blocked_list); + list_splice_init(&pl_inode->blocked_reservelks, &blocked_list); - list_del_init (&bl->list); + list_for_each_entry_safe(bl, tmp, &blocked_list, list) + { + list_del_init(&bl->list); - bl_ret = __lock_reservelk (this, pl_inode, bl, 1); + bl_ret = __lock_reservelk(this, pl_inode, bl, 1); - if (bl_ret == 0) { - list_add (&bl->list, granted); - } + if (bl_ret == 0) { + list_add(&bl->list, granted); } - return; + } + return; } /* Grant all reservelks blocked on lock(s) */ void -grant_blocked_reserve_locks (xlator_t *this, pl_inode_t *pl_inode) +grant_blocked_reserve_locks(xlator_t *this, pl_inode_t *pl_inode) { - struct list_head granted; - posix_lock_t *lock = NULL; - posix_lock_t *tmp = NULL; + struct list_head granted; + posix_lock_t *lock = NULL; + posix_lock_t *tmp = NULL; - INIT_LIST_HEAD (&granted); - - if (list_empty (&pl_inode->blocked_reservelks)) { - gf_log (this->name, GF_LOG_TRACE, - "No blocked locks to be granted"); - return; - } - - pthread_mutex_lock (&pl_inode->mutex); - { - __grant_blocked_reserve_locks (this, pl_inode, &granted); - } - pthread_mutex_unlock (&pl_inode->mutex); - - list_for_each_entry_safe (lock, tmp, &granted, list) { - gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => Granted", - lock->fl_type == F_UNLCK ? "Unlock" : "Lock", - lock->client_pid, - lkowner_utoa (&lock->owner), - lock->user_flock.l_start, - lock->user_flock.l_len); - - STACK_UNWIND_STRICT (lk, lock->frame, 0, 0, &lock->user_flock, - NULL); - } + INIT_LIST_HEAD(&granted); + if (list_empty(&pl_inode->blocked_reservelks)) { + gf_log(this->name, GF_LOG_TRACE, "No blocked locks to be granted"); + return; + } + + pthread_mutex_lock(&pl_inode->mutex); + { + __grant_blocked_reserve_locks(this, pl_inode, &granted); + } + pthread_mutex_unlock(&pl_inode->mutex); + + list_for_each_entry_safe(lock, tmp, &granted, list) + { + gf_log(this->name, GF_LOG_TRACE, + "%s (pid=%d) (lk-owner=%s) %" PRId64 " - %" PRId64 " => Granted", + lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, + lkowner_utoa(&lock->owner), lock->user_flock.l_start, + lock->user_flock.l_len); + + STACK_UNWIND_STRICT(lk, lock->frame, 0, 0, &lock->user_flock, NULL); + } } static void -__grant_blocked_lock_calls (xlator_t *this, pl_inode_t *pl_inode, - struct list_head *granted) +__grant_blocked_lock_calls(xlator_t *this, pl_inode_t *pl_inode, + struct list_head *granted) { - int bl_ret = 0; - posix_lock_t *bl = NULL; - posix_lock_t *tmp = NULL; + int bl_ret = 0; + posix_lock_t *bl = NULL; + posix_lock_t *tmp = NULL; - struct list_head blocked_list; + struct list_head blocked_list; - INIT_LIST_HEAD (&blocked_list); - list_splice_init (&pl_inode->blocked_reservelks, &blocked_list); + INIT_LIST_HEAD(&blocked_list); + list_splice_init(&pl_inode->blocked_reservelks, &blocked_list); - list_for_each_entry_safe (bl, tmp, &blocked_list, list) { + list_for_each_entry_safe(bl, tmp, &blocked_list, list) + { + list_del_init(&bl->list); - list_del_init (&bl->list); + bl_ret = pl_verify_reservelk(this, pl_inode, bl, bl->blocked); - bl_ret = pl_verify_reservelk (this, pl_inode, bl, bl->blocked); - - if (bl_ret == 0) { - list_add_tail (&bl->list, granted); - } + if (bl_ret == 0) { + list_add_tail(&bl->list, granted); } - return; + } + return; } void -grant_blocked_lock_calls (xlator_t *this, pl_inode_t *pl_inode) +grant_blocked_lock_calls(xlator_t *this, pl_inode_t *pl_inode) { - struct list_head granted; - posix_lock_t *lock = NULL; - posix_lock_t *tmp = NULL; - fd_t *fd = NULL; - - int can_block = 0; - int32_t cmd = 0; - int ret = 0; - - if (list_empty (&pl_inode->blocked_calls)) { - gf_log (this->name, GF_LOG_TRACE, - "No blocked lock calls to be granted"); - return; - } + struct list_head granted; + posix_lock_t *lock = NULL; + posix_lock_t *tmp = NULL; + fd_t *fd = NULL; - pthread_mutex_lock (&pl_inode->mutex); - { - __grant_blocked_lock_calls (this, pl_inode, &granted); - } - pthread_mutex_unlock (&pl_inode->mutex); - - list_for_each_entry_safe (lock, tmp, &granted, list) { - fd = fd_from_fdnum (lock); - - if (lock->blocked) { - can_block = 1; - cmd = F_SETLKW; - } - else - cmd = F_SETLK; - - lock->blocked = 0; - ret = pl_setlk (this, pl_inode, lock, can_block); - if (ret == -1) { - if (can_block) { - pl_trace_block (this, lock->frame, fd, NULL, - cmd, &lock->user_flock, NULL); - continue; - } else { - gf_log (this->name, GF_LOG_DEBUG, "returning EAGAIN"); - pl_trace_out (this, lock->frame, fd, NULL, cmd, - &lock->user_flock, -1, EAGAIN, NULL); - pl_update_refkeeper (this, fd->inode); - STACK_UNWIND_STRICT (lk, lock->frame, -1, - EAGAIN, &lock->user_flock, - NULL); - __destroy_lock (lock); - } - } + int can_block = 0; + int32_t cmd = 0; + int ret = 0; + if (list_empty(&pl_inode->blocked_calls)) { + gf_log(this->name, GF_LOG_TRACE, "No blocked lock calls to be granted"); + return; + } + + pthread_mutex_lock(&pl_inode->mutex); + { + __grant_blocked_lock_calls(this, pl_inode, &granted); + } + pthread_mutex_unlock(&pl_inode->mutex); + + list_for_each_entry_safe(lock, tmp, &granted, list) + { + fd = fd_from_fdnum(lock); + + if (lock->blocked) { + can_block = 1; + cmd = F_SETLKW; + } else + cmd = F_SETLK; + + lock->blocked = 0; + ret = pl_setlk(this, pl_inode, lock, can_block); + if (ret == -1) { + if (can_block) { + pl_trace_block(this, lock->frame, fd, NULL, cmd, + &lock->user_flock, NULL); + continue; + } else { + gf_log(this->name, GF_LOG_DEBUG, "returning EAGAIN"); + pl_trace_out(this, lock->frame, fd, NULL, cmd, + &lock->user_flock, -1, EAGAIN, NULL); + pl_update_refkeeper(this, fd->inode); + STACK_UNWIND_STRICT(lk, lock->frame, -1, EAGAIN, + &lock->user_flock, NULL); + __destroy_lock(lock); + } } - + } } - int -pl_reserve_unlock (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock) +pl_reserve_unlock(xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock) { - posix_lock_t *retlock = NULL; - int ret = -1; - - pthread_mutex_lock (&pl_inode->mutex); - { - retlock = __reserve_unlock_lock (this, lock, pl_inode); - if (!retlock) { - gf_log (this->name, GF_LOG_DEBUG, - "Bad Unlock issued on Inode lock"); - ret = -EINVAL; - goto out; - } - - gf_log (this->name, GF_LOG_TRACE, - "Reservelk Unlock successful"); - __destroy_lock(retlock); - ret = 0; + posix_lock_t *retlock = NULL; + int ret = -1; + + pthread_mutex_lock(&pl_inode->mutex); + { + retlock = __reserve_unlock_lock(this, lock, pl_inode); + if (!retlock) { + gf_log(this->name, GF_LOG_DEBUG, "Bad Unlock issued on Inode lock"); + ret = -EINVAL; + goto out; } -out: - pthread_mutex_unlock (&pl_inode->mutex); - grant_blocked_reserve_locks (this, pl_inode); - grant_blocked_lock_calls (this, pl_inode); + gf_log(this->name, GF_LOG_TRACE, "Reservelk Unlock successful"); + __destroy_lock(retlock); + ret = 0; + } +out: + pthread_mutex_unlock(&pl_inode->mutex); - return ret; + grant_blocked_reserve_locks(this, pl_inode); + grant_blocked_lock_calls(this, pl_inode); + return ret; } int -pl_reserve_setlk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, - int can_block) +pl_reserve_setlk(xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, + int can_block) { - int ret = -EINVAL; - - pthread_mutex_lock (&pl_inode->mutex); - { - - ret = __lock_reservelk (this, pl_inode, lock, can_block); - if (ret < 0) - gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => NOK", - lock->fl_type == F_UNLCK ? "Unlock" : "Lock", - lock->client_pid, - lkowner_utoa (&lock->owner), - lock->user_flock.l_start, - lock->user_flock.l_len); - else - gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => OK", - lock->fl_type == F_UNLCK ? "Unlock" : "Lock", - lock->client_pid, - lkowner_utoa (&lock->owner), - lock->fl_start, - lock->fl_end); - - } - pthread_mutex_unlock (&pl_inode->mutex); - return ret; + int ret = -EINVAL; + + pthread_mutex_lock(&pl_inode->mutex); + { + ret = __lock_reservelk(this, pl_inode, lock, can_block); + if (ret < 0) + gf_log(this->name, GF_LOG_TRACE, + "%s (pid=%d) (lk-owner=%s) %" PRId64 " - %" PRId64 " => NOK", + lock->fl_type == F_UNLCK ? "Unlock" : "Lock", + lock->client_pid, lkowner_utoa(&lock->owner), + lock->user_flock.l_start, lock->user_flock.l_len); + else + gf_log(this->name, GF_LOG_TRACE, + "%s (pid=%d) (lk-owner=%s) %" PRId64 " - %" PRId64 " => OK", + lock->fl_type == F_UNLCK ? "Unlock" : "Lock", + lock->client_pid, lkowner_utoa(&lock->owner), lock->fl_start, + lock->fl_end); + } + pthread_mutex_unlock(&pl_inode->mutex); + return ret; } -- cgit