///
/// LockMailTransferListShared()
void LockMailTransferListShared(const struct MailTransferList *tlist)
{
ENTER();
if(AttemptSemaphoreShared(tlist->lockSemaphore) == FALSE)
{
if(transferLocks > 0)
E(DBF_ALWAYS, "nested (%ld) shared lock of MailTransferList %08lx", transferLocks + 1, tlist);
ObtainSemaphoreShared(tlist->lockSemaphore);
}
transferLocks++;
LEAVE();
}
/**************************************************************************
MUIM_Semaphore_AttemptShared
**************************************************************************/
IPTR Semaphore__MUIM_AttemptShared(struct IClass *cl, Object *obj, struct MUIP_Semaphore_AttemptShared *msg)
{
struct MUI_SemaphoreData *data = INST_DATA(cl, obj);
return (IPTR)AttemptSemaphoreShared(&data->sem);
}
long LIBFUNC L_GetSemaphore(
REG(a0, struct SignalSemaphore *sem),
REG(d0, long exclusive),
REG(a1, char *name))
{
#ifdef TRAP_SEMAPHORE
SemaphoreNode *node;
SemaphoreOwner *owner=0;
struct MyLibrary *libbase;
struct LibData *data;
#endif
// Attempt only?
if (exclusive&SEMF_ATTEMPT)
{
long res;
// Want exclusive lock?
if (exclusive&SEMF_EXCLUSIVE) res=AttemptSemaphore(sem);
// Shared lock
else
{
// Try for shared semaphore
if (!(res=AttemptSemaphoreShared(sem)))
{
// Fix <v39 bug
if (((struct Library *)SysBase)->lib_Version<39)
{
// Try for exclusive instead
res=AttemptSemaphore(sem);
}
}
}
return res;
}
#ifdef TRAP_SEMAPHORE
// Get our library data
libbase=GET_DOPUSLIB;
data=(struct LibData *)libbase->ml_UserData;
// Lock semaphore list
ObtainSemaphore(&data->semaphores.lock);
// Look for semaphore in list
for (node=(SemaphoreNode *)data->semaphores.list.lh_Head;
node->node.mln_Succ;
node=(SemaphoreNode *)node->node.mln_Succ)
{
// Try to match semaphore
if (node->sem==sem) break;
}
// Not matched?
if (!node->node.mln_Succ)
{
// Allocate node
if (node=AllocVec(sizeof(SemaphoreNode),MEMF_CLEAR))
{
// Add to semaphore list
AddTail(&data->semaphores.list,(struct Node *)node);
// Set semaphore pointer
node->sem=sem;
// Initialise lists
NewList((struct List *)&node->owners);
NewList((struct List *)&node->waiters);
}
}
// Got a valid node?
if (node)
{
// Allocate owner node
if (owner=AllocVec(sizeof(SemaphoreOwner),MEMF_CLEAR))
{
// Fill out owner
owner->task=FindTask(0);
owner->exclusive=exclusive;
owner->data=name;
// Add to waiter list
AddTail((struct List *)&node->waiters,(struct Node *)owner);
}
}
// Unlock semaphore list
ReleaseSemaphore(&data->semaphores.lock);
#endif
// Try to get the actual semaphore
if (exclusive&SEMF_EXCLUSIVE) ObtainSemaphore(sem);
else
{
// Fix <v39 bug
if (((struct Library *)SysBase)->lib_Version<39)
{
// Try to get shared semaphore
if (!AttemptSemaphoreShared(sem))
{
// Try for exclusive semaphore
if (!AttemptSemaphore(sem))
{
// Wait for shared lock
ObtainSemaphoreShared(sem);
}
}
}
// Under 39, just ask for shared lock
else ObtainSemaphoreShared(sem);
}
#ifdef TRAP_SEMAPHORE
// Valid owner?
if (owner)
{
// Lock semaphore list
ObtainSemaphore(&data->semaphores.lock);
// Remove us from the waiter queue
Remove((struct Node *)owner);
// Add us to the owner queue
AddTail((struct List *)&node->owners,(struct Node *)owner);
// Unlock semaphore list
ReleaseSemaphore(&data->semaphores.lock);
}
#endif
return TRUE;
}
