ACPI_STATUS
AcpiExSystemWaitSemaphore (
ACPI_SEMAPHORE Semaphore,
UINT16 Timeout)
{
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (ExSystemWaitSemaphore);
Status = AcpiOsWaitSemaphore (Semaphore, 1, ACPI_DO_NOT_WAIT);
if (ACPI_SUCCESS (Status))
{
return_ACPI_STATUS (Status);
}
if (Status == AE_TIME)
{
/* We must wait, so unlock the interpreter */
AcpiExExitInterpreter ();
Status = AcpiOsWaitSemaphore (Semaphore, 1, Timeout);
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"*** Thread awake after blocking, %s\n",
AcpiFormatException (Status)));
/* Reacquire the interpreter */
AcpiExEnterInterpreter ();
}
return_ACPI_STATUS (Status);
}
ACPI_CPU_FLAGS
AcpiOsAcquireLock (
ACPI_HANDLE Handle)
{
AcpiOsWaitSemaphore (Handle, 1, 0xFFFF);
return (0);
}
ACPI_STATUS
AcpiOsAcquireMutex (
ACPI_MUTEX Handle,
UINT16 Timeout)
{
AcpiOsWaitSemaphore (Handle, 1, Timeout);
return (0);
}
void
AcpiDbCreateExecutionThreads (
char *NumThreadsArg,
char *NumLoopsArg,
char *MethodNameArg)
{
ACPI_STATUS Status;
UINT32 NumThreads;
UINT32 NumLoops;
UINT32 i;
UINT32 Size;
ACPI_MUTEX MainThreadGate;
ACPI_MUTEX ThreadCompleteGate;
ACPI_MUTEX InfoGate;
/* Get the arguments */
NumThreads = ACPI_STRTOUL (NumThreadsArg, NULL, 0);
NumLoops = ACPI_STRTOUL (NumLoopsArg, NULL, 0);
if (!NumThreads || !NumLoops)
{
AcpiOsPrintf ("Bad argument: Threads %X, Loops %X\n",
NumThreads, NumLoops);
return;
}
/*
* Create the semaphore for synchronization of
* the created threads with the main thread.
*/
Status = AcpiOsCreateSemaphore (1, 0, &MainThreadGate);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not create semaphore for synchronization with the main thread, %s\n",
AcpiFormatException (Status));
return;
}
/*
* Create the semaphore for synchronization
* between the created threads.
*/
Status = AcpiOsCreateSemaphore (1, 1, &ThreadCompleteGate);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not create semaphore for synchronization between the created threads, %s\n",
AcpiFormatException (Status));
(void) AcpiOsDeleteSemaphore (MainThreadGate);
return;
}
Status = AcpiOsCreateSemaphore (1, 1, &InfoGate);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not create semaphore for synchronization of AcpiGbl_DbMethodInfo, %s\n",
AcpiFormatException (Status));
(void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
(void) AcpiOsDeleteSemaphore (MainThreadGate);
return;
}
ACPI_MEMSET (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
/* Array to store IDs of threads */
AcpiGbl_DbMethodInfo.NumThreads = NumThreads;
Size = sizeof (ACPI_THREAD_ID) * AcpiGbl_DbMethodInfo.NumThreads;
AcpiGbl_DbMethodInfo.Threads = AcpiOsAllocate (Size);
if (AcpiGbl_DbMethodInfo.Threads == NULL)
{
AcpiOsPrintf ("No memory for thread IDs array\n");
(void) AcpiOsDeleteSemaphore (MainThreadGate);
(void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
(void) AcpiOsDeleteSemaphore (InfoGate);
return;
}
ACPI_MEMSET (AcpiGbl_DbMethodInfo.Threads, 0, Size);
/* Setup the context to be passed to each thread */
AcpiGbl_DbMethodInfo.Name = MethodNameArg;
AcpiGbl_DbMethodInfo.Flags = 0;
AcpiGbl_DbMethodInfo.NumLoops = NumLoops;
AcpiGbl_DbMethodInfo.MainThreadGate = MainThreadGate;
AcpiGbl_DbMethodInfo.ThreadCompleteGate = ThreadCompleteGate;
AcpiGbl_DbMethodInfo.InfoGate = InfoGate;
/* Init arguments to be passed to method */
AcpiGbl_DbMethodInfo.InitArgs = 1;
AcpiGbl_DbMethodInfo.Args = AcpiGbl_DbMethodInfo.Arguments;
AcpiGbl_DbMethodInfo.Arguments[0] = AcpiGbl_DbMethodInfo.NumThreadsStr;
AcpiGbl_DbMethodInfo.Arguments[1] = AcpiGbl_DbMethodInfo.IdOfThreadStr;
AcpiGbl_DbMethodInfo.Arguments[2] = AcpiGbl_DbMethodInfo.IndexOfThreadStr;
AcpiGbl_DbMethodInfo.Arguments[3] = NULL;
AcpiGbl_DbMethodInfo.Types = AcpiGbl_DbMethodInfo.ArgTypes;
AcpiGbl_DbMethodInfo.ArgTypes[0] = ACPI_TYPE_INTEGER;
AcpiGbl_DbMethodInfo.ArgTypes[1] = ACPI_TYPE_INTEGER;
AcpiGbl_DbMethodInfo.ArgTypes[2] = ACPI_TYPE_INTEGER;
AcpiDbUint32ToHexString (NumThreads, AcpiGbl_DbMethodInfo.NumThreadsStr);
Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
goto CleanupAndExit;
}
/* Get the NS node, determines existence also */
Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
&AcpiGbl_DbMethodInfo.Method);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s Could not get handle for %s\n",
AcpiFormatException (Status), AcpiGbl_DbMethodInfo.Pathname);
goto CleanupAndExit;
}
/* Create the threads */
AcpiOsPrintf ("Creating %X threads to execute %X times each\n",
NumThreads, NumLoops);
for (i = 0; i < (NumThreads); i++)
{
Status = AcpiOsExecute (OSL_DEBUGGER_THREAD, AcpiDbMethodThread,
&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
break;
}
}
/* Wait for all threads to complete */
(void) AcpiOsWaitSemaphore (MainThreadGate, 1, ACPI_WAIT_FOREVER);
AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
AcpiOsPrintf ("All threads (%X) have completed\n", NumThreads);
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
CleanupAndExit:
/* Cleanup and exit */
(void) AcpiOsDeleteSemaphore (MainThreadGate);
(void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
(void) AcpiOsDeleteSemaphore (InfoGate);
AcpiOsFree (AcpiGbl_DbMethodInfo.Threads);
AcpiGbl_DbMethodInfo.Threads = NULL;
}
static void ACPI_SYSTEM_XFACE
AcpiDbMethodThread (
void *Context)
{
ACPI_STATUS Status;
ACPI_DB_METHOD_INFO *Info = Context;
ACPI_DB_METHOD_INFO LocalInfo;
UINT32 i;
UINT8 Allow;
ACPI_BUFFER ReturnObj;
/*
* AcpiGbl_DbMethodInfo.Arguments will be passed as method arguments.
* Prevent AcpiGbl_DbMethodInfo from being modified by multiple threads
* concurrently.
*
* Note: The arguments we are passing are used by the ASL test suite
* (aslts). Do not change them without updating the tests.
*/
(void) AcpiOsWaitSemaphore (Info->InfoGate, 1, ACPI_WAIT_FOREVER);
if (Info->InitArgs)
{
AcpiDbUint32ToHexString (Info->NumCreated, Info->IndexOfThreadStr);
AcpiDbUint32ToHexString ((UINT32) AcpiOsGetThreadId (), Info->IdOfThreadStr);
}
if (Info->Threads && (Info->NumCreated < Info->NumThreads))
{
Info->Threads[Info->NumCreated++] = AcpiOsGetThreadId();
}
LocalInfo = *Info;
LocalInfo.Args = LocalInfo.Arguments;
LocalInfo.Arguments[0] = LocalInfo.NumThreadsStr;
LocalInfo.Arguments[1] = LocalInfo.IdOfThreadStr;
LocalInfo.Arguments[2] = LocalInfo.IndexOfThreadStr;
LocalInfo.Arguments[3] = NULL;
LocalInfo.Types = LocalInfo.ArgTypes;
(void) AcpiOsSignalSemaphore (Info->InfoGate, 1);
for (i = 0; i < Info->NumLoops; i++)
{
Status = AcpiDbExecuteMethod (&LocalInfo, &ReturnObj);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s During evaluation of %s at iteration %X\n",
AcpiFormatException (Status), Info->Pathname, i);
if (Status == AE_ABORT_METHOD)
{
break;
}
}
#if 0
if ((i % 100) == 0)
{
AcpiOsPrintf ("%u loops, Thread 0x%x\n", i, AcpiOsGetThreadId ());
}
if (ReturnObj.Length)
{
AcpiOsPrintf ("Evaluation of %s returned object %p Buflen %X\n",
Info->Pathname, ReturnObj.Pointer, (UINT32) ReturnObj.Length);
AcpiDbDumpExternalObject (ReturnObj.Pointer, 1);
}
#endif
}
/* Signal our completion */
Allow = 0;
(void) AcpiOsWaitSemaphore (Info->ThreadCompleteGate, 1, ACPI_WAIT_FOREVER);
Info->NumCompleted++;
if (Info->NumCompleted == Info->NumThreads)
{
/* Do signal for main thread once only */
Allow = 1;
}
(void) AcpiOsSignalSemaphore (Info->ThreadCompleteGate, 1);
if (Allow)
{
Status = AcpiOsSignalSemaphore (Info->MainThreadGate, 1);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not signal debugger thread sync semaphore, %s\n",
AcpiFormatException (Status));
}
}
}
void
AcpiDbCreateExecutionThreads (
NATIVE_CHAR *NumThreadsArg,
NATIVE_CHAR *NumLoopsArg,
NATIVE_CHAR *MethodNameArg)
{
ACPI_STATUS Status;
UINT32 NumThreads;
UINT32 NumLoops;
UINT32 i;
ACPI_HANDLE ThreadGate;
/* Get the arguments */
NumThreads = STRTOUL (NumThreadsArg, NULL, 0);
NumLoops = STRTOUL (NumLoopsArg, NULL, 0);
if (!NumThreads || !NumLoops)
{
AcpiOsPrintf ("Bad argument: Threads %X, Loops %X\n", NumThreads, NumLoops);
return;
}
/* Create the synchronization semaphore */
Status = AcpiOsCreateSemaphore (1, 0, &ThreadGate);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not create semaphore, %s\n", AcpiFormatException (Status));
return;
}
/* Setup the context to be passed to each thread */
AcpiGbl_DbMethodInfo.Name = MethodNameArg;
AcpiGbl_DbMethodInfo.Args = NULL;
AcpiGbl_DbMethodInfo.Flags = 0;
AcpiGbl_DbMethodInfo.NumLoops = NumLoops;
AcpiGbl_DbMethodInfo.ThreadGate = ThreadGate;
AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
/* Create the threads */
AcpiOsPrintf ("Creating %X threads to execute %X times each\n", NumThreads, NumLoops);
for (i = 0; i < (NumThreads); i++)
{
AcpiOsQueueForExecution (OSD_PRIORITY_MED, AcpiDbMethodThread, &AcpiGbl_DbMethodInfo);
}
/* Wait for all threads to complete */
i = NumThreads;
while (i) /* Brain damage for OSD implementations that only support wait of 1 unit */
{
Status = AcpiOsWaitSemaphore (ThreadGate, 1, WAIT_FOREVER);
i--;
}
/* Cleanup and exit */
AcpiOsDeleteSemaphore (ThreadGate);
AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);
AcpiOsPrintf ("All threads (%X) have completed\n", NumThreads);
AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
}
ACPI_STATUS
AcpiUtAcquireMutex (
ACPI_MUTEX_HANDLE MutexId)
{
ACPI_STATUS Status;
UINT32 i;
UINT32 ThisThreadId;
ACPI_FUNCTION_NAME ("UtAcquireMutex");
if (MutexId > MAX_MTX)
{
return (AE_BAD_PARAMETER);
}
ThisThreadId = AcpiOsGetThreadId ();
/*
* Deadlock prevention. Check if this thread owns any mutexes of value
* greater than or equal to this one. If so, the thread has violated
* the mutex ordering rule. This indicates a coding error somewhere in
* the ACPI subsystem code.
*/
for (i = MutexId; i < MAX_MTX; i++)
{
if (AcpiGbl_AcpiMutexInfo[i].OwnerId == ThisThreadId)
{
if (i == MutexId)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Mutex [%s] already acquired by this thread [%X]\n",
AcpiUtGetMutexName (MutexId), ThisThreadId));
return (AE_ALREADY_ACQUIRED);
}
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Invalid acquire order: Thread %X owns [%s], wants [%s]\n",
ThisThreadId, AcpiUtGetMutexName (i),
AcpiUtGetMutexName (MutexId)));
return (AE_ACQUIRE_DEADLOCK);
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
"Thread %X attempting to acquire Mutex [%s]\n",
ThisThreadId, AcpiUtGetMutexName (MutexId)));
Status = AcpiOsWaitSemaphore (AcpiGbl_AcpiMutexInfo[MutexId].Mutex,
1, ACPI_WAIT_FOREVER);
if (ACPI_SUCCESS (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X acquired Mutex [%s]\n",
ThisThreadId, AcpiUtGetMutexName (MutexId)));
AcpiGbl_AcpiMutexInfo[MutexId].UseCount++;
AcpiGbl_AcpiMutexInfo[MutexId].OwnerId = ThisThreadId;
}
else
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not acquire Mutex [%s] %s\n",
ThisThreadId, AcpiUtGetMutexName (MutexId),
AcpiFormatException (Status)));
}
return (Status);
}
