CPU_DATA_BLOCK *CpuDatas;\r
UINTN NumberOfProcessors;\r
UINTN NumberOfEnabledProcessors;\r
+\r
+ EFI_AP_PROCEDURE Procedure;\r
+ VOID *ProcedureArgument;\r
+ UINTN StartCount;\r
+ UINTN FinishCount;\r
+ BOOLEAN SingleThread;\r
+ UINTN **FailedList;\r
+ UINTN FailedListIndex;\r
+ INTN Timeout;\r
+ EFI_EVENT WaitEvent;\r
+ BOOLEAN TimeoutActive;\r
+ EFI_EVENT CheckAllAPsEvent;\r
} MP_SYSTEM_DATA;\r
\r
/**\r
OUT EFI_PROCESSOR_INFORMATION *ProcessorInfoBuffer\r
);\r
\r
+/**\r
+ This service executes a caller provided function on all enabled APs. APs can\r
+ run either simultaneously or one at a time in sequence. This service supports\r
+ both blocking and non-blocking requests. The non-blocking requests use EFI\r
+ events so the BSP can detect when the APs have finished. This service may only\r
+ be called from the BSP.\r
+\r
+ This function is used to dispatch all the enabled APs to the function specified\r
+ by Procedure. If any enabled AP is busy, then EFI_NOT_READY is returned\r
+ immediately and Procedure is not started on any AP.\r
+\r
+ If SingleThread is TRUE, all the enabled APs execute the function specified by\r
+ Procedure one by one, in ascending order of processor handle number. Otherwise,\r
+ all the enabled APs execute the function specified by Procedure simultaneously.\r
+\r
+ If WaitEvent is NULL, execution is in blocking mode. The BSP waits until all\r
+ APs finish or TimeoutInMicroseconds expires. Otherwise, execution is in non-blocking\r
+ mode, and the BSP returns from this service without waiting for APs. If a\r
+ non-blocking mode is requested after the UEFI Event EFI_EVENT_GROUP_READY_TO_BOOT\r
+ is signaled, then EFI_UNSUPPORTED must be returned.\r
+\r
+ If the timeout specified by TimeoutInMicroseconds expires before all APs return\r
+ from Procedure, then Procedure on the failed APs is terminated. All enabled APs\r
+ are always available for further calls to EFI_MP_SERVICES_PROTOCOL.StartupAllAPs()\r
+ and EFI_MP_SERVICES_PROTOCOL.StartupThisAP(). If FailedCpuList is not NULL, its\r
+ content points to the list of processor handle numbers in which Procedure was\r
+ terminated.\r
+\r
+ Note: It is the responsibility of the consumer of the EFI_MP_SERVICES_PROTOCOL.StartupAllAPs()\r
+ to make sure that the nature of the code that is executed on the BSP and the\r
+ dispatched APs is well controlled. The MP Services Protocol does not guarantee\r
+ that the Procedure function is MP-safe. Hence, the tasks that can be run in\r
+ parallel are limited to certain independent tasks and well-controlled exclusive\r
+ code. EFI services and protocols may not be called by APs unless otherwise\r
+ specified.\r
+\r
+ In blocking execution mode, BSP waits until all APs finish or\r
+ TimeoutInMicroseconds expires.\r
+\r
+ In non-blocking execution mode, BSP is freed to return to the caller and then\r
+ proceed to the next task without having to wait for APs. The following\r
+ sequence needs to occur in a non-blocking execution mode:\r
+\r
+ -# The caller that intends to use this MP Services Protocol in non-blocking\r
+ mode creates WaitEvent by calling the EFI CreateEvent() service. The caller\r
+ invokes EFI_MP_SERVICES_PROTOCOL.StartupAllAPs(). If the parameter WaitEvent\r
+ is not NULL, then StartupAllAPs() executes in non-blocking mode. It requests\r
+ the function specified by Procedure to be started on all the enabled APs,\r
+ and releases the BSP to continue with other tasks.\r
+ -# The caller can use the CheckEvent() and WaitForEvent() services to check\r
+ the state of the WaitEvent created in step 1.\r
+ -# When the APs complete their task or TimeoutInMicroSecondss expires, the MP\r
+ Service signals WaitEvent by calling the EFI SignalEvent() function. If\r
+ FailedCpuList is not NULL, its content is available when WaitEvent is\r
+ signaled. If all APs returned from Procedure prior to the timeout, then\r
+ FailedCpuList is set to NULL. If not all APs return from Procedure before\r
+ the timeout, then FailedCpuList is filled in with the list of the failed\r
+ APs. The buffer is allocated by MP Service Protocol using AllocatePool().\r
+ It is the caller's responsibility to free the buffer with FreePool() service.\r
+ -# This invocation of SignalEvent() function informs the caller that invoked\r
+ EFI_MP_SERVICES_PROTOCOL.StartupAllAPs() that either all the APs completed\r
+ the specified task or a timeout occurred. The contents of FailedCpuList\r
+ can be examined to determine which APs did not complete the specified task\r
+ prior to the timeout.\r
+\r
+ @param[in] This A pointer to the EFI_MP_SERVICES_PROTOCOL\r
+ instance.\r
+ @param[in] Procedure A pointer to the function to be run on\r
+ enabled APs of the system. See type\r
+ EFI_AP_PROCEDURE.\r
+ @param[in] SingleThread If TRUE, then all the enabled APs execute\r
+ the function specified by Procedure one by\r
+ one, in ascending order of processor handle\r
+ number. If FALSE, then all the enabled APs\r
+ execute the function specified by Procedure\r
+ simultaneously.\r
+ @param[in] WaitEvent The event created by the caller with CreateEvent()\r
+ service. If it is NULL, then execute in\r
+ blocking mode. BSP waits until all APs finish\r
+ or TimeoutInMicroseconds expires. If it's\r
+ not NULL, then execute in non-blocking mode.\r
+ BSP requests the function specified by\r
+ Procedure to be started on all the enabled\r
+ APs, and go on executing immediately. If\r
+ all return from Procedure, or TimeoutInMicroseconds\r
+ expires, this event is signaled. The BSP\r
+ can use the CheckEvent() or WaitForEvent()\r
+ services to check the state of event. Type\r
+ EFI_EVENT is defined in CreateEvent() in\r
+ the Unified Extensible Firmware Interface\r
+ Specification.\r
+ @param[in] TimeoutInMicroseconds Indicates the time limit in microseconds for\r
+ APs to return from Procedure, either for\r
+ blocking or non-blocking mode. Zero means\r
+ infinity. If the timeout expires before\r
+ all APs return from Procedure, then Procedure\r
+ on the failed APs is terminated. All enabled\r
+ APs are available for next function assigned\r
+ by EFI_MP_SERVICES_PROTOCOL.StartupAllAPs()\r
+ or EFI_MP_SERVICES_PROTOCOL.StartupThisAP().\r
+ If the timeout expires in blocking mode,\r
+ BSP returns EFI_TIMEOUT. If the timeout\r
+ expires in non-blocking mode, WaitEvent\r
+ is signaled with SignalEvent().\r
+ @param[in] ProcedureArgument The parameter passed into Procedure for\r
+ all APs.\r
+ @param[out] FailedCpuList If NULL, this parameter is ignored. Otherwise,\r
+ if all APs finish successfully, then its\r
+ content is set to NULL. If not all APs\r
+ finish before timeout expires, then its\r
+ content is set to address of the buffer\r
+ holding handle numbers of the failed APs.\r
+ The buffer is allocated by MP Service Protocol,\r
+ and it's the caller's responsibility to\r
+ free the buffer with FreePool() service.\r
+ In blocking mode, it is ready for consumption\r
+ when the call returns. In non-blocking mode,\r
+ it is ready when WaitEvent is signaled. The\r
+ list of failed CPU is terminated by\r
+ END_OF_CPU_LIST.\r
+\r
+ @retval EFI_SUCCESS In blocking mode, all APs have finished before\r
+ the timeout expired.\r
+ @retval EFI_SUCCESS In non-blocking mode, function has been dispatched\r
+ to all enabled APs.\r
+ @retval EFI_UNSUPPORTED A non-blocking mode request was made after the\r
+ UEFI event EFI_EVENT_GROUP_READY_TO_BOOT was\r
+ signaled.\r
+ @retval EFI_DEVICE_ERROR Caller processor is AP.\r
+ @retval EFI_NOT_STARTED No enabled APs exist in the system.\r
+ @retval EFI_NOT_READY Any enabled APs are busy.\r
+ @retval EFI_TIMEOUT In blocking mode, the timeout expired before\r
+ all enabled APs have finished.\r
+ @retval EFI_INVALID_PARAMETER Procedure is NULL.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+StartupAllAPs (\r
+ IN EFI_MP_SERVICES_PROTOCOL *This,\r
+ IN EFI_AP_PROCEDURE Procedure,\r
+ IN BOOLEAN SingleThread,\r
+ IN EFI_EVENT WaitEvent OPTIONAL,\r
+ IN UINTN TimeoutInMicroseconds,\r
+ IN VOID *ProcedureArgument OPTIONAL,\r
+ OUT UINTN **FailedCpuList OPTIONAL\r
+ );\r
+\r
/**\r
This service lets the caller get one enabled AP to execute a caller-provided\r
function. The caller can request the BSP to either wait for the completion\r
projects / mirror_edk2.git / blobdiff