-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* 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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2012, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
* Lustre is a trademark of Sun Microsystems, Inc.
*/
-#define DEBUG_SUBSYSTEM S_LIBCFS
+#define DEBUG_SUBSYSTEM S_LNET
#include <libcfs/libcfs.h>
*/
/*
- * cfs_waitq_init
+ * init_waitqueue_head
* To initialize the wait queue
*
* Arguments:
- * waitq: pointer to the cfs_waitq_t structure
+ * waitq: pointer to the wait_queue_head_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitq_init(cfs_waitq_t *waitq)
+void init_waitqueue_head(wait_queue_head_t *waitq)
{
waitq->magic = CFS_WAITQ_MAGIC;
waitq->flags = 0;
- INIT_LIST_HEAD(&(waitq->waiters));
- spin_lock_init(&(waitq->guard));
+ CFS_INIT_LIST_HEAD(&(waitq->waiters));
+ spin_lock_init(&(waitq->guard));
}
/*
- * cfs_waitlink_init
+ * init_waitqueue_entry_current
* To initialize the wake link node
*
* Arguments:
- * link: pointer to the cfs_waitlink_t structure
+ * link: pointer to the wait_queue_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitlink_init(cfs_waitlink_t *link)
+void init_waitqueue_entry_current(wait_queue_t *link)
{
- cfs_task_t * task = cfs_current();
+ struct task_struct * task = current;
PTASK_SLOT slot = NULL;
if (!task) {
slot = CONTAINING_RECORD(task, TASK_SLOT, task);
cfs_assert(slot->Magic == TASKSLT_MAGIC);
- memset(link, 0, sizeof(cfs_waitlink_t));
+ memset(link, 0, sizeof(wait_queue_t));
link->magic = CFS_WAITLINK_MAGIC;
link->flags = 0;
atomic_inc(&slot->count);
- INIT_LIST_HEAD(&(link->waitq[0].link));
- INIT_LIST_HEAD(&(link->waitq[1].link));
+ CFS_INIT_LIST_HEAD(&(link->waitq[0].link));
+ CFS_INIT_LIST_HEAD(&(link->waitq[1].link));
link->waitq[0].waitl = link->waitq[1].waitl = link;
}
* To finilize the wake link node
*
* Arguments:
- * link: pointer to the cfs_waitlink_t structure
+ * link: pointer to the wait_queue_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitlink_fini(cfs_waitlink_t *link)
+void cfs_waitlink_fini(wait_queue_t *link)
{
- cfs_task_t * task = cfs_current();
+ struct task_struct * task = current;
PTASK_SLOT slot = NULL;
if (!task) {
* To queue the wait link node to the wait queue
*
* Arguments:
- * waitq: pointer to the cfs_waitq_t structure
- * link: pointer to the cfs_waitlink_t structure
+ * waitq: pointer to the wait_queue_head_t structure
+ * link: pointer to the wait_queue_t structure
* int: queue no (Normal or Forward waitq)
*
* Return Value:
* N/A
*/
-void cfs_waitq_add_internal(cfs_waitq_t *waitq,
- cfs_waitlink_t *link,
+void cfs_waitq_add_internal(wait_queue_head_t *waitq,
+ wait_queue_t *link,
__u32 waitqid )
{
LASSERT(waitq != NULL);
LASSERT(link->magic == CFS_WAITLINK_MAGIC);
LASSERT(waitqid < CFS_WAITQ_CHANNELS);
- spin_lock(&(waitq->guard));
+ spin_lock(&(waitq->guard));
LASSERT(link->waitq[waitqid].waitq == NULL);
link->waitq[waitqid].waitq = waitq;
if (link->flags & CFS_WAITQ_EXCLUSIVE) {
- list_add_tail(&link->waitq[waitqid].link, &waitq->waiters);
+ cfs_list_add_tail(&link->waitq[waitqid].link, &waitq->waiters);
} else {
- list_add(&link->waitq[waitqid].link, &waitq->waiters);
+ cfs_list_add(&link->waitq[waitqid].link, &waitq->waiters);
}
- spin_unlock(&(waitq->guard));
+ spin_unlock(&(waitq->guard));
}
/*
- * cfs_waitq_add
+ * add_wait_queue
* To queue the wait link node to the wait queue
*
* Arguments:
- * waitq: pointer to the cfs_waitq_t structure
- * link: pointer to the cfs_waitlink_t structure
+ * waitq: pointer to the wait_queue_head_t structure
+ * link: pointer to the wait_queue_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitq_add(cfs_waitq_t *waitq,
- cfs_waitlink_t *link)
+void add_wait_queue(wait_queue_head_t *waitq,
+ wait_queue_t *link)
{
cfs_waitq_add_internal(waitq, link, CFS_WAITQ_CHAN_NORMAL);
}
/*
- * cfs_waitq_add_exclusive
+ * add_wait_queue_exclusive
* To set the wait link node to exclusive mode
* and queue it to the wait queue
*
* Arguments:
- * waitq: pointer to the cfs_waitq_t structure
+ * waitq: pointer to the wait_queue_head_t structure
* link: pointer to the cfs_wait_link structure
*
* Return Value:
* N/A
*/
-void cfs_waitq_add_exclusive( cfs_waitq_t *waitq,
- cfs_waitlink_t *link)
+void add_wait_queue_exclusive( wait_queue_head_t *waitq,
+ wait_queue_t *link)
{
LASSERT(waitq != NULL);
LASSERT(link != NULL);
LASSERT(link->magic == CFS_WAITLINK_MAGIC);
link->flags |= CFS_WAITQ_EXCLUSIVE;
- cfs_waitq_add(waitq, link);
-}
-
-/*
- * cfs_waitq_forward
- * To be determinated.
- *
- * Arguments:
- * waitq: pointer to the cfs_waitq_t structure
- * link: pointer to the cfs_waitlink_t structure
- *
- * Return Value:
- * N/A
- *
- * Notes:
- * N/A
- */
-
-void cfs_waitq_forward( cfs_waitlink_t *link,
- cfs_waitq_t *waitq)
-{
- cfs_waitq_add_internal(waitq, link, CFS_WAITQ_CHAN_FORWARD);
+ add_wait_queue(waitq, link);
}
/*
- * cfs_waitq_del
+ * remove_wait_queue
* To remove the wait link node from the waitq
*
* Arguments:
* waitq: pointer to the cfs_ waitq_t structure
- * link: pointer to the cfs_waitlink_t structure
+ * link: pointer to the wait_queue_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitq_del( cfs_waitq_t *waitq,
- cfs_waitlink_t *link)
+void remove_wait_queue( wait_queue_head_t *waitq,
+ wait_queue_t *link)
{
int i = 0;
LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
LASSERT(link->magic == CFS_WAITLINK_MAGIC);
- spin_lock(&(waitq->guard));
+ spin_lock(&(waitq->guard));
for (i=0; i < CFS_WAITQ_CHANNELS; i++) {
if (link->waitq[i].waitq == waitq)
if (i < CFS_WAITQ_CHANNELS) {
link->waitq[i].waitq = NULL;
- list_del_init(&link->waitq[i].link);
+ cfs_list_del_init(&link->waitq[i].link);
} else {
cfs_enter_debugger();
}
- spin_unlock(&(waitq->guard));
+ spin_unlock(&(waitq->guard));
}
/*
- * cfs_waitq_active
+ * waitqueue_active
* Is the waitq active (not empty) ?
*
* Arguments:
* We always returns TRUE here, the same to Darwin.
*/
-int cfs_waitq_active(cfs_waitq_t *waitq)
+int waitqueue_active(wait_queue_head_t *waitq)
{
LASSERT(waitq != NULL);
LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
}
/*
- * cfs_waitq_signal_nr
+ * wake_up_nr
* To wake up all the non-exclusive tasks plus nr exclusive
* ones in the waitq
*
* Arguments:
- * waitq: pointer to the cfs_waitq_t structure
+ * waitq: pointer to the wait_queue_head_t structure
* nr: number of exclusive tasks to be woken up
*
* Return Value:
*/
-void cfs_waitq_signal_nr(cfs_waitq_t *waitq, int nr)
+void wake_up_nr(wait_queue_head_t *waitq, int nr)
{
int result;
cfs_waitlink_channel_t * scan;
LASSERT(waitq != NULL);
LASSERT(waitq->magic == CFS_WAITQ_MAGIC);
- spin_lock(&waitq->guard);
-
- list_for_each_entry(scan, &waitq->waiters, cfs_waitlink_channel_t, link) {
+ spin_lock(&waitq->guard);
+ cfs_list_for_each_entry_typed(scan, &waitq->waiters,
+ cfs_waitlink_channel_t,
+ link) {
- cfs_waitlink_t *waitl = scan->waitl;
+ wait_queue_t *waitl = scan->waitl;
result = cfs_wake_event(waitl->event);
LASSERT( result == FALSE || result == TRUE );
if (result) {
- atomic_inc(waitl->hits);
+ atomic_inc(waitl->hits);
}
if ((waitl->flags & CFS_WAITQ_EXCLUSIVE) && --nr == 0)
break;
}
- spin_unlock(&waitq->guard);
- return;
+ spin_unlock(&waitq->guard);
+ return;
}
/*
- * cfs_waitq_signal
+ * wake_up
* To wake up all the non-exclusive tasks and 1 exclusive
*
* Arguments:
- * waitq: pointer to the cfs_waitq_t structure
+ * waitq: pointer to the wait_queue_head_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitq_signal(cfs_waitq_t *waitq)
+void wake_up(wait_queue_head_t *waitq)
{
- cfs_waitq_signal_nr(waitq, 1);
+ wake_up_nr(waitq, 1);
}
/*
- * cfs_waitq_broadcast
+ * wake_up_all
* To wake up all the tasks in the waitq
*
* Arguments:
- * waitq: pointer to the cfs_waitq_t structure
+ * waitq: pointer to the wait_queue_head_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitq_broadcast(cfs_waitq_t *waitq)
+void wake_up_all(wait_queue_head_t *waitq)
{
LASSERT(waitq != NULL);
LASSERT(waitq->magic ==CFS_WAITQ_MAGIC);
- cfs_waitq_signal_nr(waitq, 0);
+ wake_up_nr(waitq, 0);
}
/*
- * cfs_waitq_wait
+ * waitq_wait
* To wait on the link node until it is signaled.
*
* Arguments:
- * link: pointer to the cfs_waitlink_t structure
+ * link: pointer to the wait_queue_t structure
*
* Return Value:
* N/A
* N/A
*/
-void cfs_waitq_wait(cfs_waitlink_t *link, cfs_task_state_t state)
+void waitq_wait(wait_queue_t *link, long state)
{
LASSERT(link != NULL);
LASSERT(link->magic == CFS_WAITLINK_MAGIC);
if (atomic_read(link->hits) > 0) {
- atomic_dec(link->hits);
- LASSERT((__u32)atomic_read(link->hits) < (__u32)0xFFFFFF00);
+ atomic_dec(link->hits);
+ LASSERT((__u32)atomic_read(link->hits) < (__u32)0xFFFFFF00);
} else {
- cfs_wait_event(link->event, 0);
+ cfs_wait_event_internal(link->event, 0);
}
}
/*
- * cfs_waitq_timedwait
+ * waitq_timedwait
* To wait the link node to be signaled with a timeout limit
*
* Arguments:
- * link: pointer to the cfs_waitlink_t structure
+ * link: pointer to the wait_queue_t structure
* timeout: the timeout limitation
*
* Return Value:
* What if it happens to be woken up at the just timeout time !?
*/
-cfs_duration_t cfs_waitq_timedwait( cfs_waitlink_t *link,
- cfs_task_state_t state,
- cfs_duration_t timeout)
+int64_t waitq_timedwait( wait_queue_t *link,
+ long state,
+ int64_t timeout)
{
if (atomic_read(link->hits) > 0) {
- atomic_dec(link->hits);
- LASSERT((__u32)atomic_read(link->hits) < (__u32)0xFFFFFF00);
- return TRUE;
+ atomic_dec(link->hits);
+ LASSERT((__u32)atomic_read(link->hits) < (__u32)0xFFFFFF00);
+ return (int64_t)TRUE;
}
- return (cfs_duration_t)cfs_wait_event(link->event, timeout);
+ return (int64_t)cfs_wait_event_internal(link->event, timeout);
}