X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Fwinnt%2Fwinnt-sync.c;h=a2b3e1d67cca501e30fb11e12db9f94a6592de1c;hb=34c1700d3acc0daefe056fe7472c51687df68c1b;hp=0153a9870c79a9bcdcd3dcfbc49610bd8b424718;hpb=0f8dca08a4f68cba82c2c822998ecc309d3b7aaf;p=fs%2Flustre-release.git diff --git a/libcfs/libcfs/winnt/winnt-sync.c b/libcfs/libcfs/winnt/winnt-sync.c index 0153a98..a2b3e1d 100644 --- a/libcfs/libcfs/winnt/winnt-sync.c +++ b/libcfs/libcfs/winnt/winnt-sync.c @@ -1,6 +1,4 @@ -/* -*- 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. @@ -28,6 +26,8 @@ /* * 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/ @@ -44,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 @@ -57,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; CFS_INIT_LIST_HEAD(&(waitq->waiters)); - cfs_spin_lock_init(&(waitq->guard)); + 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 @@ -79,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) { @@ -93,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; @@ -101,7 +101,7 @@ void cfs_waitlink_init(cfs_waitlink_t *link) link->event = &(slot->Event); link->hits = &(slot->hits); - cfs_atomic_inc(&slot->count); + atomic_inc(&slot->count); CFS_INIT_LIST_HEAD(&(link->waitq[0].link)); CFS_INIT_LIST_HEAD(&(link->waitq[1].link)); @@ -115,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 @@ -124,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) { @@ -141,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); - cfs_atomic_dec(&slot->count); + atomic_dec(&slot->count); } @@ -150,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: @@ -161,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); @@ -171,7 +171,7 @@ void cfs_waitq_add_internal(cfs_waitq_t *waitq, LASSERT(link->magic == CFS_WAITLINK_MAGIC); LASSERT(waitqid < CFS_WAITQ_CHANNELS); - cfs_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) { @@ -179,15 +179,15 @@ void cfs_waitq_add_internal(cfs_waitq_t *waitq, } else { cfs_list_add(&link->waitq[waitqid].link, &waitq->waiters); } - cfs_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 @@ -196,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: @@ -218,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); @@ -227,16 +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_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 @@ -245,8 +245,8 @@ void cfs_waitq_add_exclusive( cfs_waitq_t *waitq, * 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; @@ -256,7 +256,7 @@ void cfs_waitq_del( cfs_waitq_t *waitq, LASSERT(waitq->magic == CFS_WAITQ_MAGIC); LASSERT(link->magic == CFS_WAITLINK_MAGIC); - cfs_spin_lock(&(waitq->guard)); + spin_lock(&(waitq->guard)); for (i=0; i < CFS_WAITQ_CHANNELS; i++) { if (link->waitq[i].waitq == waitq) @@ -270,11 +270,11 @@ void cfs_waitq_del( cfs_waitq_t *waitq, cfs_enter_debugger(); } - cfs_spin_unlock(&(waitq->guard)); + spin_unlock(&(waitq->guard)); } /* - * cfs_waitq_active + * waitqueue_active * Is the waitq active (not empty) ? * * Arguments: @@ -288,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); @@ -297,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: @@ -313,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; @@ -321,34 +321,34 @@ void cfs_waitq_signal_nr(cfs_waitq_t *waitq, int nr) LASSERT(waitq != NULL); LASSERT(waitq->magic == CFS_WAITQ_MAGIC); - cfs_spin_lock(&waitq->guard); + 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) { - cfs_atomic_inc(waitl->hits); + atomic_inc(waitl->hits); } if ((waitl->flags & CFS_WAITQ_EXCLUSIVE) && --nr == 0) break; } - cfs_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 @@ -357,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 @@ -377,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 @@ -399,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 (cfs_atomic_read(link->hits) > 0) { - cfs_atomic_dec(link->hits); - LASSERT((__u32)cfs_atomic_read(link->hits) < (__u32)0xFFFFFF00); + if (atomic_read(link->hits) > 0) { + atomic_dec(link->hits); + LASSERT((__u32)atomic_read(link->hits) < (__u32)0xFFFFFF00); } else { 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: @@ -429,14 +429,14 @@ 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 !? */ -int64_t cfs_waitq_timedwait( cfs_waitlink_t *link, - cfs_task_state_t state, +int64_t waitq_timedwait( wait_queue_t *link, + long state, int64_t timeout) { - if (cfs_atomic_read(link->hits) > 0) { - cfs_atomic_dec(link->hits); - LASSERT((__u32)cfs_atomic_read(link->hits) < (__u32)0xFFFFFF00); + if (atomic_read(link->hits) > 0) { + atomic_dec(link->hits); + LASSERT((__u32)atomic_read(link->hits) < (__u32)0xFFFFFF00); return (int64_t)TRUE; }