X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Fwinnt%2Fwinnt-sync.c;h=696e8ae7e02d231b82456529bc7cd767acdd890d;hb=refs%2Fchanges%2F56%2F6956%2F8;hp=921c02ed976570fc0896c5c1b22de40c587c1bc8;hpb=e903932500fc08b143467ce5a1c2702df35d8f0f;p=fs%2Flustre-release.git diff --git a/libcfs/libcfs/winnt/winnt-sync.c b/libcfs/libcfs/winnt/winnt-sync.c index 921c02e..696e8ae 100644 --- a/libcfs/libcfs/winnt/winnt-sync.c +++ b/libcfs/libcfs/winnt/winnt-sync.c @@ -1,22 +1,40 @@ -/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=4:tabstop=4: - * - * Copyright (c) 2004 Cluster File Systems, Inc. - * - * This file is part of Lustre, http://www.lustre.org. - * - * Lustre is free software; you can redistribute it and/or modify it under - * the terms of version 2 of the GNU General Public License as published by - * the Free Software Foundation. Lustre 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 Lustre; if not, write - * to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, - * USA. +/* + * GPL HEADER START + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. + * + * This program 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 version 2 for more details (a copy is included + * 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 + * 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 + * have any questions. + * + * GPL HEADER END + */ +/* + * 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 @@ -26,11 +44,11 @@ */ /* - * 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 @@ -39,20 +57,20 @@ * 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 @@ -61,9 +79,9 @@ void cfs_waitq_init(cfs_waitq_t *waitq) * 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) { @@ -75,7 +93,7 @@ void cfs_waitlink_init(cfs_waitlink_t *link) 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; @@ -83,10 +101,10 @@ void cfs_waitlink_init(cfs_waitlink_t *link) link->event = &(slot->Event); link->hits = &(slot->hits); - atomic_inc(&slot->count); + cfs_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; } @@ -97,7 +115,7 @@ void cfs_waitlink_init(cfs_waitlink_t *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 @@ -106,9 +124,9 @@ void cfs_waitlink_init(cfs_waitlink_t *link) * 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) { @@ -123,7 +141,7 @@ void cfs_waitlink_fini(cfs_waitlink_t *link) cfs_assert(link->waitq[0].waitq == NULL); cfs_assert(link->waitq[1].waitq == NULL); - atomic_dec(&slot->count); + cfs_atomic_dec(&slot->count); } @@ -132,8 +150,8 @@ void cfs_waitlink_fini(cfs_waitlink_t *link) * 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: @@ -143,8 +161,8 @@ void cfs_waitlink_fini(cfs_waitlink_t *link) * 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); @@ -153,23 +171,23 @@ void cfs_waitq_add_internal(cfs_waitq_t *waitq, 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 @@ -178,19 +196,19 @@ void cfs_waitq_add_internal(cfs_waitq_t *waitq, * 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: @@ -200,8 +218,8 @@ void cfs_waitq_add(cfs_waitq_t *waitq, * 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); @@ -209,37 +227,16 @@ void cfs_waitq_add_exclusive( cfs_waitq_t *waitq, LASSERT(link->magic == CFS_WAITLINK_MAGIC); link->flags |= CFS_WAITQ_EXCLUSIVE; - cfs_waitq_add(waitq, link); + add_wait_queue(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); -} - -/* - * 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 @@ -248,8 +245,8 @@ void cfs_waitq_forward( cfs_waitlink_t *link, * 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; @@ -259,7 +256,7 @@ void cfs_waitq_del( cfs_waitq_t *waitq, 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) @@ -268,16 +265,16 @@ void cfs_waitq_del( cfs_waitq_t *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: @@ -291,7 +288,7 @@ void cfs_waitq_del( cfs_waitq_t *waitq, * 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); @@ -300,12 +297,12 @@ int cfs_waitq_active(cfs_waitq_t *waitq) } /* - * 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: @@ -316,7 +313,7 @@ int cfs_waitq_active(cfs_waitq_t *waitq) */ -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; @@ -324,33 +321,34 @@ void cfs_waitq_signal_nr(cfs_waitq_t *waitq, int nr) LASSERT(waitq != NULL); LASSERT(waitq->magic == CFS_WAITQ_MAGIC); - spin_lock(&waitq->guard); + spin_lock(&waitq->guard); + cfs_list_for_each_entry_typed(scan, &waitq->waiters, + cfs_waitlink_channel_t, + link) { - list_for_each_entry(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); + cfs_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 @@ -359,18 +357,18 @@ void cfs_waitq_signal_nr(cfs_waitq_t *waitq, int nr) * 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 @@ -379,20 +377,20 @@ void cfs_waitq_signal(cfs_waitq_t *waitq) * 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 @@ -401,25 +399,25 @@ void cfs_waitq_broadcast(cfs_waitq_t *waitq) * 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); + if (cfs_atomic_read(link->hits) > 0) { + cfs_atomic_dec(link->hits); + LASSERT((__u32)cfs_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: @@ -431,18 +429,16 @@ void cfs_waitq_wait(cfs_waitlink_t *link, cfs_task_state_t state) * 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; + if (cfs_atomic_read(link->hits) > 0) { + cfs_atomic_dec(link->hits); + LASSERT((__u32)cfs_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); } - -