6ed00870ab
Abstracts threading from itself a bit, changes the way its queues are handled and does type hiding for that as well. Do alot here due to already required major brain surgery. Threads may now be on a run queue and a wait queue simultaneously so that the expired timer only has to wake the thread but not remove it from the wait queue which simplifies the implicit wake handling. List formats change for wait queues-- doubly-linked, not circular. Timeout queue is now singly-linked. The run queue is still circular as before. Adds a better thread slot allocator that may keep the slot marked as used regardless of the thread state. Assists in dumping special tasks that switch_thread was tasked to perform (blocking tasks). Deletes alot of code yet surprisingly, gets larger than expected. Well, I'm not not minding that for the time being-- omlettes and break a few eggs and all that. Change-Id: I0834d7bb16b2aecb2f63b58886eeda6ae4f29d59
116 lines
3.5 KiB
C
116 lines
3.5 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2002 by Björn Stenberg
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
|
|
/****************************************************************************
|
|
* Simple mutex functions ;)
|
|
****************************************************************************/
|
|
#include "kernel-internal.h"
|
|
#include "mutex.h"
|
|
|
|
/* Initialize a mutex object - call before any use and do not call again once
|
|
* the object is available to other threads */
|
|
void mutex_init(struct mutex *m)
|
|
{
|
|
wait_queue_init(&m->queue);
|
|
m->recursion = 0;
|
|
blocker_init(&m->blocker);
|
|
#ifdef HAVE_PRIORITY_SCHEDULING
|
|
m->no_preempt = false;
|
|
#endif
|
|
corelock_init(&m->cl);
|
|
}
|
|
|
|
/* Gain ownership of a mutex object or block until it becomes free */
|
|
void mutex_lock(struct mutex *m)
|
|
{
|
|
struct thread_entry *current = __running_self_entry();
|
|
|
|
if(current == m->blocker.thread)
|
|
{
|
|
/* current thread already owns this mutex */
|
|
m->recursion++;
|
|
return;
|
|
}
|
|
|
|
/* lock out other cores */
|
|
corelock_lock(&m->cl);
|
|
|
|
/* must read thread again inside cs (a multiprocessor concern really) */
|
|
if(LIKELY(m->blocker.thread == NULL))
|
|
{
|
|
/* lock is open */
|
|
m->blocker.thread = current;
|
|
corelock_unlock(&m->cl);
|
|
return;
|
|
}
|
|
|
|
/* block until the lock is open... */
|
|
disable_irq();
|
|
block_thread(current, TIMEOUT_BLOCK, &m->queue, &m->blocker);
|
|
|
|
corelock_unlock(&m->cl);
|
|
|
|
/* ...and turn control over to next thread */
|
|
switch_thread();
|
|
}
|
|
|
|
/* Release ownership of a mutex object - only owning thread must call this */
|
|
void mutex_unlock(struct mutex *m)
|
|
{
|
|
/* unlocker not being the owner is an unlocking violation */
|
|
KERNEL_ASSERT(m->blocker.thread == __running_self_entry(),
|
|
"mutex_unlock->wrong thread (%s != %s)\n",
|
|
m->blocker.thread->name,
|
|
__running_self_entry()->name);
|
|
|
|
if(m->recursion > 0)
|
|
{
|
|
/* this thread still owns lock */
|
|
m->recursion--;
|
|
return;
|
|
}
|
|
|
|
/* lock out other cores */
|
|
corelock_lock(&m->cl);
|
|
|
|
/* transfer to next queued thread if any */
|
|
struct thread_entry *thread = WQ_THREAD_FIRST(&m->queue);
|
|
if(LIKELY(thread == NULL))
|
|
{
|
|
/* no threads waiting - open the lock */
|
|
m->blocker.thread = NULL;
|
|
corelock_unlock(&m->cl);
|
|
return;
|
|
}
|
|
|
|
const int oldlevel = disable_irq_save();
|
|
unsigned int result = wakeup_thread(thread, WAKEUP_TRANSFER);
|
|
restore_irq(oldlevel);
|
|
|
|
corelock_unlock(&m->cl);
|
|
|
|
#ifdef HAVE_PRIORITY_SCHEDULING
|
|
if((result & THREAD_SWITCH) && !m->no_preempt)
|
|
switch_thread();
|
|
#endif
|
|
(void)result;
|
|
}
|