* in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see [sun.com URL with a
- * copy of GPLv2].
+ * version 2 along with this program; If not, see
+ * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*/
/*
return NULL;
UC_CACHE_SET_NEW(entry);
- INIT_LIST_HEAD(&entry->ue_hash);
+ CFS_INIT_LIST_HEAD(&entry->ue_hash);
entry->ue_key = key;
- atomic_set(&entry->ue_refcount, 0);
- init_waitqueue_head(&entry->ue_waitq);
+ cfs_atomic_set(&entry->ue_refcount, 0);
+ cfs_waitq_init(&entry->ue_waitq);
if (cache->uc_ops->init_entry)
cache->uc_ops->init_entry(entry, args);
return entry;
if (cache->uc_ops->free_entry)
cache->uc_ops->free_entry(cache, entry);
- list_del(&entry->ue_hash);
+ cfs_list_del(&entry->ue_hash);
CDEBUG(D_OTHER, "destroy cache entry %p for key "LPU64"\n",
entry, entry->ue_key);
OBD_FREE_PTR(entry);
static inline void get_entry(struct upcall_cache_entry *entry)
{
- atomic_inc(&entry->ue_refcount);
+ cfs_atomic_inc(&entry->ue_refcount);
}
static inline void put_entry(struct upcall_cache *cache,
struct upcall_cache_entry *entry)
{
- if (atomic_dec_and_test(&entry->ue_refcount) &&
+ if (cfs_atomic_dec_and_test(&entry->ue_refcount) &&
(UC_CACHE_IS_INVALID(entry) || UC_CACHE_IS_EXPIRED(entry))) {
free_entry(cache, entry);
}
struct upcall_cache_entry *entry)
{
if (UC_CACHE_IS_VALID(entry) &&
- time_before(jiffies, entry->ue_expire))
+ cfs_time_before(jiffies, entry->ue_expire))
return 0;
if (UC_CACHE_IS_ACQUIRING(entry)) {
- if (time_before(jiffies, entry->ue_acquire_expire))
+ if (entry->ue_acquire_expire == 0 ||
+ cfs_time_before(jiffies, entry->ue_acquire_expire))
return 0;
UC_CACHE_SET_EXPIRED(entry);
- wake_up_all(&entry->ue_waitq);
+ cfs_waitq_broadcast(&entry->ue_waitq);
} else if (!UC_CACHE_IS_INVALID(entry)) {
UC_CACHE_SET_EXPIRED(entry);
}
- list_del_init(&entry->ue_hash);
- if (!atomic_read(&entry->ue_refcount))
+ cfs_list_del_init(&entry->ue_hash);
+ if (!cfs_atomic_read(&entry->ue_refcount))
free_entry(cache, entry);
return 1;
}
__u64 key, void *args)
{
struct upcall_cache_entry *entry = NULL, *new = NULL, *next;
- struct list_head *head;
- wait_queue_t wait;
+ cfs_list_t *head;
+ cfs_waitlink_t wait;
int rc, found;
ENTRY;
head = &cache->uc_hashtable[UC_CACHE_HASH_INDEX(key)];
find_again:
found = 0;
- spin_lock(&cache->uc_lock);
- list_for_each_entry_safe(entry, next, head, ue_hash) {
+ cfs_spin_lock(&cache->uc_lock);
+ cfs_list_for_each_entry_safe(entry, next, head, ue_hash) {
/* check invalid & expired items */
if (check_unlink_entry(cache, entry))
continue;
}
}
- if (!found) { /* didn't find it */
+ if (!found) {
if (!new) {
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
new = alloc_entry(cache, key, args);
if (!new) {
CERROR("fail to alloc entry\n");
}
goto find_again;
} else {
- list_add(&new->ue_hash, head);
+ cfs_list_add(&new->ue_hash, head);
entry = new;
}
} else {
free_entry(cache, new);
new = NULL;
}
- list_move(&entry->ue_hash, head);
+ cfs_list_move(&entry->ue_hash, head);
}
get_entry(entry);
if (UC_CACHE_IS_NEW(entry)) {
UC_CACHE_SET_ACQUIRING(entry);
UC_CACHE_CLEAR_NEW(entry);
- entry->ue_acquire_expire = jiffies + cache->uc_acquire_expire;
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
rc = refresh_entry(cache, entry);
- spin_lock(&cache->uc_lock);
+ cfs_spin_lock(&cache->uc_lock);
+ entry->ue_acquire_expire = jiffies + cache->uc_acquire_expire;
if (rc < 0) {
UC_CACHE_CLEAR_ACQUIRING(entry);
UC_CACHE_SET_INVALID(entry);
+ cfs_waitq_broadcast(&entry->ue_waitq);
if (unlikely(rc == -EREMCHG)) {
put_entry(cache, entry);
GOTO(out, entry = ERR_PTR(rc));
}
}
- /* fall through */
}
- /* someone (and only one) is doing upcall upon
- * this item, just wait it complete
- */
+
+ /* someone (and only one) is doing upcall upon this item,
+ * wait it to complete */
if (UC_CACHE_IS_ACQUIRING(entry)) {
- unsigned long expiry = jiffies + cache->uc_acquire_expire;
+ long expiry = (entry == new) ? cache->uc_acquire_expire :
+ CFS_MAX_SCHEDULE_TIMEOUT;
+ long left;
- init_waitqueue_entry(&wait, current);
- add_wait_queue(&entry->ue_waitq, &wait);
- set_current_state(TASK_INTERRUPTIBLE);
- spin_unlock(&cache->uc_lock);
+ cfs_waitlink_init(&wait);
+ cfs_waitq_add(&entry->ue_waitq, &wait);
+ cfs_set_current_state(CFS_TASK_INTERRUPTIBLE);
+ cfs_spin_unlock(&cache->uc_lock);
- schedule_timeout(cache->uc_acquire_expire);
+ left = cfs_waitq_timedwait(&wait, CFS_TASK_INTERRUPTIBLE,
+ expiry);
- spin_lock(&cache->uc_lock);
- remove_wait_queue(&entry->ue_waitq, &wait);
+ cfs_spin_lock(&cache->uc_lock);
+ cfs_waitq_del(&entry->ue_waitq, &wait);
if (UC_CACHE_IS_ACQUIRING(entry)) {
/* we're interrupted or upcall failed in the middle */
- rc = time_before(jiffies, expiry) ? -EINTR : -ETIMEDOUT;
+ rc = left > 0 ? -EINTR : -ETIMEDOUT;
+ CERROR("acquire for key "LPU64": error %d\n",
+ entry->ue_key, rc);
put_entry(cache, entry);
- CERROR("acquire timeout exceeded for key "LPU64
- "\n", entry->ue_key);
GOTO(out, entry = ERR_PTR(rc));
}
- /* fall through */
}
/* invalid means error, don't need to try again */
*/
if (entry != new) {
put_entry(cache, entry);
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
new = NULL;
goto find_again;
}
/* Now we know it's good */
out:
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
RETURN(entry);
}
EXPORT_SYMBOL(upcall_cache_get_entry);
return;
}
- LASSERT(atomic_read(&entry->ue_refcount) > 0);
- spin_lock(&cache->uc_lock);
+ LASSERT(cfs_atomic_read(&entry->ue_refcount) > 0);
+ cfs_spin_lock(&cache->uc_lock);
put_entry(cache, entry);
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
EXIT;
}
EXPORT_SYMBOL(upcall_cache_put_entry);
void *args)
{
struct upcall_cache_entry *entry = NULL;
- struct list_head *head;
+ cfs_list_t *head;
int found = 0, rc = 0;
ENTRY;
head = &cache->uc_hashtable[UC_CACHE_HASH_INDEX(key)];
- spin_lock(&cache->uc_lock);
- list_for_each_entry(entry, head, ue_hash) {
+ cfs_spin_lock(&cache->uc_lock);
+ cfs_list_for_each_entry(entry, head, ue_hash) {
if (downcall_compare(cache, entry, key, args) == 0) {
found = 1;
get_entry(entry);
CDEBUG(D_OTHER, "%s: upcall for key "LPU64" not expected\n",
cache->uc_name, key);
/* haven't found, it's possible */
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
RETURN(-EINVAL);
}
GOTO(out, rc = -EINVAL);
}
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
if (cache->uc_ops->parse_downcall)
rc = cache->uc_ops->parse_downcall(cache, entry, args);
- spin_lock(&cache->uc_lock);
+ cfs_spin_lock(&cache->uc_lock);
if (rc)
GOTO(out, rc);
out:
if (rc) {
UC_CACHE_SET_INVALID(entry);
- list_del_init(&entry->ue_hash);
+ cfs_list_del_init(&entry->ue_hash);
}
UC_CACHE_CLEAR_ACQUIRING(entry);
- spin_unlock(&cache->uc_lock);
- wake_up_all(&entry->ue_waitq);
+ cfs_spin_unlock(&cache->uc_lock);
+ cfs_waitq_broadcast(&entry->ue_waitq);
put_entry(cache, entry);
RETURN(rc);
int i;
ENTRY;
- spin_lock(&cache->uc_lock);
+ cfs_spin_lock(&cache->uc_lock);
for (i = 0; i < UC_CACHE_HASH_SIZE; i++) {
- list_for_each_entry_safe(entry, next,
+ cfs_list_for_each_entry_safe(entry, next,
&cache->uc_hashtable[i], ue_hash) {
- if (!force && atomic_read(&entry->ue_refcount)) {
+ if (!force && cfs_atomic_read(&entry->ue_refcount)) {
UC_CACHE_SET_EXPIRED(entry);
continue;
}
- LASSERT(!atomic_read(&entry->ue_refcount));
+ LASSERT(!cfs_atomic_read(&entry->ue_refcount));
free_entry(cache, entry);
}
}
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
EXIT;
}
void upcall_cache_flush_one(struct upcall_cache *cache, __u64 key, void *args)
{
- struct list_head *head;
+ cfs_list_t *head;
struct upcall_cache_entry *entry;
int found = 0;
ENTRY;
head = &cache->uc_hashtable[UC_CACHE_HASH_INDEX(key)];
- spin_lock(&cache->uc_lock);
- list_for_each_entry(entry, head, ue_hash) {
+ cfs_spin_lock(&cache->uc_lock);
+ cfs_list_for_each_entry(entry, head, ue_hash) {
if (upcall_compare(cache, entry, key, args) == 0) {
found = 1;
break;
CWARN("%s: flush entry %p: key "LPU64", ref %d, fl %x, "
"cur %lu, ex %ld/%ld\n",
cache->uc_name, entry, entry->ue_key,
- atomic_read(&entry->ue_refcount), entry->ue_flags,
+ cfs_atomic_read(&entry->ue_refcount), entry->ue_flags,
get_seconds(), entry->ue_acquire_expire,
entry->ue_expire);
UC_CACHE_SET_EXPIRED(entry);
- if (!atomic_read(&entry->ue_refcount))
+ if (!cfs_atomic_read(&entry->ue_refcount))
free_entry(cache, entry);
}
- spin_unlock(&cache->uc_lock);
+ cfs_spin_unlock(&cache->uc_lock);
}
EXPORT_SYMBOL(upcall_cache_flush_one);
if (!cache)
RETURN(ERR_PTR(-ENOMEM));
- spin_lock_init(&cache->uc_lock);
- rwlock_init(&cache->uc_upcall_rwlock);
+ cfs_spin_lock_init(&cache->uc_lock);
+ cfs_rwlock_init(&cache->uc_upcall_rwlock);
for (i = 0; i < UC_CACHE_HASH_SIZE; i++)
- INIT_LIST_HEAD(&cache->uc_hashtable[i]);
+ CFS_INIT_LIST_HEAD(&cache->uc_hashtable[i]);
strncpy(cache->uc_name, name, sizeof(cache->uc_name) - 1);
/* upcall pathname proc tunable */
strncpy(cache->uc_upcall, upcall, sizeof(cache->uc_upcall) - 1);
- cache->uc_entry_expire = 10 * 60 * HZ;
- cache->uc_acquire_expire = 15 * HZ;
+ cache->uc_entry_expire = 20 * 60 * CFS_HZ;
+ cache->uc_acquire_expire = 30 * CFS_HZ;
cache->uc_ops = ops;
RETURN(cache);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff