自学教程：C++ GetFirstNode函数代码示例

/***  List all available Usb devices and all their partitions.    @param[in|out]  DeviceList  The linked list contains all Usb devices.    @retval  EFI_SUCCESS	The function exited normally.  @retval  Other     	  An error occurred.***/EFI_STATUSUsbListAllUsbDevices (  IN OUT LIST_ENTRY        *DeviceList  ){  LIST_ENTRY              *DiskNode = NULL;  LIST_ENTRY              *PartitionNode = NULL;  DISK_ENTRY              *DiskEntry = NULL;  PARTITION_ENTRY         *PartitionEntry = NULL;  EFI_BLOCK_IO_PROTOCOL   *BlockIo = NULL;  DISK_INFO               *DiskInfo = NULL;  PARTITION_INFO          *PartitionInfo = NULL;    if (DeviceList == NULL) {    return EFI_INVALID_PARAMETER;  }    DiskNode = GetFirstNode (DeviceList);  while (!IsNull (DeviceList, DiskNode)) {    DiskEntry = (DISK_ENTRY*)DiskNode;    if (DiskEntry != NULL) {      DiskInfo = &(DiskEntry->DiskInfo);      BlockIo = DiskInfo->BlockIo;            Print (L"/n[%d] /n", DiskInfo->DiskIndex);      if (DiskInfo->MaxPartitions > 0) {        PartitionNode = GetFirstNode(&(DiskInfo->PartitionsList));        while (!IsNull (&(DiskInfo->PartitionsList), PartitionNode)) {          PartitionEntry = (PARTITION_ENTRY*)PartitionNode;          if (PartitionEntry != NULL) {            PartitionInfo = &(PartitionEntry->PartitionInfo);            Print (L"|____[Partition] %d, ", PartitionInfo->PartitionNumber);            Print (L"[Size] %ld, ", (PartitionInfo->EndLBA - PartitionInfo->StartLBA + 1));            Print (L"[StartLBA] %ld, [EndLBA] %ld/n", PartitionInfo->StartLBA, PartitionInfo->EndLBA);          }          PartitionNode = GetNextNode (&(DiskInfo->PartitionsList), PartitionNode);        } //end while()       }    }    DiskNode = GetNextNode (DeviceList, DiskNode);  } //end while()  Print (L"Press ESC to return./n");    return EFI_SUCCESS;}

/**  Register a notification function for a particular keystroke for the input device.  @param  This                     Protocol instance pointer.  @param  KeyData                  A pointer to a buffer that is filled in with the                                   keystroke information data for the key that was                                   pressed.  @param  KeyNotificationFunction  Points to the function to be called when the key                                   sequence is typed specified by KeyData.  @param  NotifyHandle             Points to the unique handle assigned to the                                   registered notification.  @retval EFI_SUCCESS              The notification function was registered                                   successfully.  @retval EFI_OUT_OF_RESOURCES     Unable to allocate resources for necessary data                                   structures.  @retval EFI_INVALID_PARAMETER    KeyData or NotifyHandle is NULL.**/EFI_STATUSEFIAPITerminalConInRegisterKeyNotify (  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,  IN EFI_KEY_DATA                       *KeyData,  IN EFI_KEY_NOTIFY_FUNCTION            KeyNotificationFunction,  OUT VOID                              **NotifyHandle  ){  TERMINAL_DEV                    *TerminalDevice;  TERMINAL_CONSOLE_IN_EX_NOTIFY   *NewNotify;  LIST_ENTRY                      *Link;  LIST_ENTRY                      *NotifyList;  TERMINAL_CONSOLE_IN_EX_NOTIFY   *CurrentNotify;  if (KeyData == NULL || NotifyHandle == NULL || KeyNotificationFunction == NULL) {    return EFI_INVALID_PARAMETER;  }  TerminalDevice = TERMINAL_CON_IN_EX_DEV_FROM_THIS (This);  //  // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.  //  NotifyList = &TerminalDevice->NotifyList;  for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList,Link); Link = GetNextNode (NotifyList,Link)) {    CurrentNotify = CR (                      Link,                      TERMINAL_CONSOLE_IN_EX_NOTIFY,                      NotifyEntry,                      TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE                      );    if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {      if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) {        *NotifyHandle = CurrentNotify;        return EFI_SUCCESS;      }    }  }  //  // Allocate resource to save the notification function  //  NewNotify = (TERMINAL_CONSOLE_IN_EX_NOTIFY *) AllocateZeroPool (sizeof (TERMINAL_CONSOLE_IN_EX_NOTIFY));  if (NewNotify == NULL) {    return EFI_OUT_OF_RESOURCES;  }  NewNotify->Signature         = TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE;  NewNotify->KeyNotificationFn = KeyNotificationFunction;  CopyMem (&NewNotify->KeyData, KeyData, sizeof (EFI_KEY_DATA));  InsertTailList (&TerminalDevice->NotifyList, &NewNotify->NotifyEntry);  *NotifyHandle                = NewNotify;  return EFI_SUCCESS;}

/**  This call back function is registered with Boot Manager formset.  When user selects a boot option, this call back function will  be triggered. The boot option is saved for later processing.  @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.  @param Action          Specifies the type of action taken by the browser.  @param QuestionId      A unique value which is sent to the original exporting driver                         so that it can identify the type of data to expect.  @param Type            The type of value for the question.  @param Value           A pointer to the data being sent to the original exporting driver.  @param ActionRequest   On return, points to the action requested by the callback function.  @retval  EFI_SUCCESS           The callback successfully handled the action.  @retval  EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters.**/EFI_STATUSEFIAPIBootManagerCallback (    IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,    IN  EFI_BROWSER_ACTION                     Action,    IN  EFI_QUESTION_ID                        QuestionId,    IN  UINT8                                  Type,    IN  EFI_IFR_TYPE_VALUE                     *Value,    OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest){    BDS_COMMON_OPTION       *Option;    LIST_ENTRY              *Link;    UINT16                  KeyCount;    if (Action == EFI_BROWSER_ACTION_CHANGED) {        if ((Value == NULL) || (ActionRequest == NULL)) {            return EFI_INVALID_PARAMETER;        }        //        // Initialize the key count        //        KeyCount = 0;        for (Link = GetFirstNode (&mBootOptionsList); !IsNull (&mBootOptionsList, Link); Link = GetNextNode (&mBootOptionsList, Link)) {            Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);            KeyCount++;            gOption = Option;            //            // Is this device the one chosen?            //            if (KeyCount == QuestionId) {                //                // Assigning the returned Key to a global allows the original routine to know what was chosen                //                mKeyInput = QuestionId;                //                // Request to exit SendForm(), so that we could boot the selected option                //                *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;                break;            }        }        return EFI_SUCCESS;    }    //    // All other action return unsupported.    //    return EFI_UNSUPPORTED;}

/**  Adjust option order base on the question value.  @param  Question           Pointer to current question.  @param  PopUpMenuLines     The line number of the pop up menu.  @retval EFI_SUCCESS       If Option input is processed successfully  @retval EFI_DEVICE_ERROR  If operation fails**/EFI_STATUSAdjustOptionOrder (  IN  FORM_DISPLAY_ENGINE_STATEMENT  *Question,  OUT UINTN                          *PopUpMenuLines  ){  UINTN                   Index;  EFI_IFR_ORDERED_LIST    *OrderList;  UINT8                   *ValueArray;  UINT8                   ValueType;  LIST_ENTRY              *Link;  DISPLAY_QUESTION_OPTION *OneOfOption;  EFI_HII_VALUE           *HiiValueArray;  Link        = GetFirstNode (&Question->OptionListHead);  OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);  ValueArray  = Question->CurrentValue.Buffer;  ValueType   =  OneOfOption->OptionOpCode->Type;  OrderList   = (EFI_IFR_ORDERED_LIST *) Question->OpCode;  for (Index = 0; Index < OrderList->MaxContainers; Index++) {    if (GetArrayData (ValueArray, ValueType, Index) == 0) {      break;    }  }    *PopUpMenuLines = Index;    //  // Prepare HiiValue array  //    HiiValueArray = AllocateZeroPool (*PopUpMenuLines * sizeof (EFI_HII_VALUE));  ASSERT (HiiValueArray != NULL);  for (Index = 0; Index < *PopUpMenuLines; Index++) {    HiiValueArray[Index].Type = ValueType;    HiiValueArray[Index].Value.u64 = GetArrayData (ValueArray, ValueType, Index);  }    for (Index = 0; Index < *PopUpMenuLines; Index++) {    OneOfOption = ValueToOption (Question, &HiiValueArray[*PopUpMenuLines - Index - 1]);    if (OneOfOption == NULL) {      return EFI_NOT_FOUND;    }      RemoveEntryList (&OneOfOption->Link);      //    // Insert to head.    //    InsertHeadList (&Question->OptionListHead, &OneOfOption->Link);  }    FreePool (HiiValueArray);  return EFI_SUCCESS;}

/**  Get the ONE_OF_OPTION_MAP_ENTRY for a QuestionId that invokes the   EFI_FORM_CALLBACK_PROTOCOL.Callback. The information is needed as  the callback mechanism for EFI_IFR_ONE_OF_OPTION is changed from   EFI_IFR_ONE_OF_OPTION in Framework IFR. Check EFI_IFR_GUID_OPTIONKEY  for detailed information.  @param ThunkContext   The Thunk Context.  @param QuestionId     The Question Id.  @param Type           The Question Type.  @param Value          The One Of Option's value.  @return The ONE_OF_OPTION_MAP_ENTRY found.  @retval NULL If no entry is found.**/ONE_OF_OPTION_MAP_ENTRY *GetOneOfOptionMapEntry (  IN  HII_THUNK_CONTEXT              *ThunkContext,  IN  EFI_QUESTION_ID                QuestionId,  IN  UINT8                          Type,  IN  EFI_IFR_TYPE_VALUE             *Value  ){  LIST_ENTRY              *Link;  LIST_ENTRY              *Link2;  ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry;  ONE_OF_OPTION_MAP       *OneOfOptionMap;  FORM_BROWSER_FORMSET    *FormSet;  FormSet = ThunkContext->FormSet;  Link = GetFirstNode (&FormSet->OneOfOptionMapListHead);  while (!IsNull (&FormSet->OneOfOptionMapListHead, Link)) {    OneOfOptionMap = ONE_OF_OPTION_MAP_FROM_LINK(Link);    if (OneOfOptionMap->QuestionId == QuestionId) {      ASSERT (OneOfOptionMap->ValueType == Type);      Link2 = GetFirstNode (&OneOfOptionMap->OneOfOptionMapEntryListHead);      while (!IsNull (&OneOfOptionMap->OneOfOptionMapEntryListHead, Link2)) {        OneOfOptionMapEntry = ONE_OF_OPTION_MAP_ENTRY_FROM_LINK (Link2);        if (CompareMem (Value, &OneOfOptionMapEntry->Value, sizeof (EFI_IFR_TYPE_VALUE)) == 0) {          return OneOfOptionMapEntry;        }        Link2 = GetNextNode (&OneOfOptionMap->OneOfOptionMapEntryListHead, Link2);      }    }    Link = GetNextNode (&FormSet->OneOfOptionMapListHead, Link);  }  return NULL;}

// Free the resources in the file's Region list.STATICVOIDFreeFileRegions (  IN  BOOTMON_FS_FILE *File  ){  LIST_ENTRY              *RegionToFlushLink;  BOOTMON_FS_FILE_REGION  *Region;  RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);  while (!IsNull (&File->RegionToFlushLink, RegionToFlushLink)) {    // Repeatedly remove the first node from the list and free its resources.    Region = (BOOTMON_FS_FILE_REGION *) RegionToFlushLink;    RemoveEntryList (RegionToFlushLink);    FreePool (Region->Buffer);    FreePool (Region);    RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);  }}

//// stoplights and stopsigns//void vtRoadMap3d::GenerateSigns(vtLodGrid *pLodGrid){	if (!pLodGrid)		return;	vtContentManager3d &con = vtGetContent();	osg::Node *stopsign = con.CreateNodeFromItemname("American Stopsign");	osg::Node *stoplight = con.CreateNodeFromItemname("Stoplight (right)");	if (!stopsign || !stoplight)	{		VTLOG("Couldn't find stopsign and stoplight./n");		return;	}	for (NodeGeom *pN = GetFirstNode(); pN; pN = pN->GetNext())	{		for (int r = 0; r < pN->NumLinks(); r++)		{			osg::Node *shape = NULL;			if (pN->GetIntersectType(r) == IT_STOPSIGN && stopsign)			{				shape = (osg::Node *) stopsign->clone(osg::CopyOp::SHALLOW_COPY);			}			if (pN->GetIntersectType(r) == IT_LIGHT && stoplight)			{				shape = (osg::Node *) stoplight->clone(osg::CopyOp::SHALLOW_COPY);			}			if (!shape) continue;			vtTransform *trans = new vtTransform;			trans->addChild(shape);			LinkGeom *link = pN->GetLink(r);			FPoint3 unit = pN->GetUnitLinkVector(r);			FPoint3 perp(unit.z, unit.y, -unit.x);			FPoint3 offset;			// Turn the sign (yaw) to face the oncoming traffic			trans->RotateLocal(FPoint3(0,1,0), pN->GetLinkAngle(r) + PID2f);			if (pN->GetIntersectType(r) == IT_STOPSIGN)			{				offset = pN->m_p3 + (unit * 6.0f) + (perp * (link->m_fRightWidth));			}			if (pN->GetIntersectType(r) == IT_LIGHT)			{				offset = pN->m_p3 - (unit * 6.0f) + (perp * (link->m_fRightWidth));			}			trans->Translate(offset);			pLodGrid->AddToGrid(trans);		}	}}

/**  Return the boot description for the controller.  @param Handle                Controller handle.  @return  The description string.**/CHAR16 *BmGetBootDescription (  IN EFI_HANDLE                  Handle  ){  LIST_ENTRY                     *Link;  BM_BOOT_DESCRIPTION_ENTRY      *Entry;  CHAR16                         *Description;  CHAR16                         *DefaultDescription;  CHAR16                         *Temp;  UINTN                          Index;  //  // Firstly get the default boot description  //  DefaultDescription = NULL;  for (Index = 0; Index < sizeof (mBmBootDescriptionHandlers) / sizeof (mBmBootDescriptionHandlers[0]); Index++) {    DefaultDescription = mBmBootDescriptionHandlers[Index] (Handle);    if (DefaultDescription != NULL) {      //      // Avoid description confusion between UEFI & Legacy boot option by adding "UEFI " prefix      // ONLY for core provided boot description handler.      //      Temp = AllocatePool (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix));      ASSERT (Temp != NULL);      StrCpyS (Temp, (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix)) / sizeof (CHAR16), mBmUefiPrefix);      StrCatS (Temp, (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix)) / sizeof (CHAR16), DefaultDescription);      FreePool (DefaultDescription);      DefaultDescription = Temp;      break;    }  }  ASSERT (DefaultDescription != NULL);  //  // Secondly query platform for the better boot description  //  for ( Link = GetFirstNode (&mPlatformBootDescriptionHandlers)      ; !IsNull (&mPlatformBootDescriptionHandlers, Link)      ; Link = GetNextNode (&mPlatformBootDescriptionHandlers, Link)      ) {    Entry = CR (Link, BM_BOOT_DESCRIPTION_ENTRY, Link, BM_BOOT_DESCRIPTION_ENTRY_SIGNATURE);    Description = Entry->Handler (Handle, DefaultDescription);    if (Description != NULL) {      FreePool (DefaultDescription);      return Description;    }  }  return DefaultDescription;}

/**  Remove a registered notification function from a particular keystroke.  @param  This                      Protocol instance pointer.  @param  NotificationHandle        The handle of the notification function being unregistered.  @retval EFI_SUCCESS              The notification function was unregistered successfully.  @retval EFI_INVALID_PARAMETER    The NotificationHandle is invalid**/EFI_STATUSEFIAPIUSBKeyboardUnregisterKeyNotify (  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,  IN EFI_HANDLE                         NotificationHandle  ){  USB_KB_DEV                        *UsbKeyboardDevice;  KEYBOARD_CONSOLE_IN_EX_NOTIFY     *CurrentNotify;  LIST_ENTRY                        *Link;  LIST_ENTRY                        *NotifyList;  if (NotificationHandle == NULL) {    return EFI_INVALID_PARAMETER;  }  if (((KEYBOARD_CONSOLE_IN_EX_NOTIFY *) NotificationHandle)->Signature != USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE) {    return EFI_INVALID_PARAMETER;  }  UsbKeyboardDevice = TEXT_INPUT_EX_USB_KB_DEV_FROM_THIS (This);  //  // Traverse notify list of USB keyboard and remove the entry of NotificationHandle.  //  NotifyList = &UsbKeyboardDevice->NotifyList;  for (Link = GetFirstNode (NotifyList);       !IsNull (NotifyList, Link);       Link = GetNextNode (NotifyList, Link)) {    CurrentNotify = CR (                      Link,                      KEYBOARD_CONSOLE_IN_EX_NOTIFY,                      NotifyEntry,                      USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE                      );    if (CurrentNotify->NotifyHandle == NotificationHandle) {      //      // Remove the notification function from NotifyList and free resources      //      RemoveEntryList (&CurrentNotify->NotifyEntry);      FreePool (CurrentNotify);      return EFI_SUCCESS;    }  }  //  // Cannot find the matching entry in database.  //  return EFI_INVALID_PARAMETER;}

/**  Resets an SD card that is connected to the SD controller.  The ResetDevice() function resets the SD card specified by Slot.  If this SD controller does not support a device reset operation, EFI_UNSUPPORTED is  returned.  If Slot is not in a valid slot number for this SD controller, EFI_INVALID_PARAMETER  is returned.  If the device reset operation is completed, EFI_SUCCESS is returned.  @param[in]  This              A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.  @param[in]  Slot              Specifies the slot number of the SD card to be reset.  @retval EFI_SUCCESS           The SD card specified by Slot was reset.  @retval EFI_UNSUPPORTED       The SD controller does not support a device reset operation.  @retval EFI_INVALID_PARAMETER Slot number is invalid.  @retval EFI_NO_MEDIA          SD Device not present in the Slot.  @retval EFI_DEVICE_ERROR      The reset command failed due to a device error**/EFI_STATUSEFIAPISdMmcPassThruResetDevice (  IN EFI_SD_MMC_PASS_THRU_PROTOCOL           *This,  IN UINT8                                   Slot  ){  SD_MMC_HC_PRIVATE_DATA          *Private;  LIST_ENTRY                      *Link;  LIST_ENTRY                      *NextLink;  SD_MMC_HC_TRB                   *Trb;  EFI_TPL                         OldTpl;  if (This == NULL) {    return EFI_INVALID_PARAMETER;  }  Private = SD_MMC_HC_PRIVATE_FROM_THIS (This);  if (!Private->Slot[Slot].Enable) {    return EFI_INVALID_PARAMETER;  }  if (!Private->Slot[Slot].MediaPresent) {    return EFI_NO_MEDIA;  }  if (!Private->Slot[Slot].Initialized) {    return EFI_DEVICE_ERROR;  }  //  // Free all async I/O requests in the queue  //  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);  for (Link = GetFirstNode (&Private->Queue);       !IsNull (&Private->Queue, Link);       Link = NextLink) {    NextLink = GetNextNode (&Private->Queue, Link);    RemoveEntryList (Link);    Trb = SD_MMC_HC_TRB_FROM_THIS (Link);    Trb->Packet->TransactionStatus = EFI_ABORTED;    gBS->SignalEvent (Trb->Event);    SdMmcFreeTrb (Trb);  }  gBS->RestoreTPL (OldTpl);  return EFI_SUCCESS;}

/** *  Gets the number of a nodes on a given node. * *  @param  refNode     Node to check level. *  @return             The previous node or NULL if there's no previous. */size_t VDFTree::CountBranchNodes(VDFNode *refNode){    VDFNode *firstNode;    size_t counter;    firstNode = GetFirstNode(refNode);    counter = 0;    while(firstNode) {        counter++;        firstNode = firstNode->nextNode;    }    return counter;}

/**  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.  It convers pointer to new virtual address.  @param  Event        Event whose notification function is being invoked.  @param  Context      Pointer to the notification function's context.**/VOIDEFIAPIVariableClassAddressChangeEvent (  IN EFI_EVENT                            Event,  IN VOID                                 *Context  ){  LIST_ENTRY     *Link;  VARIABLE_ENTRY *Entry;  EFI_STATUS     Status;  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetBlockSize);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetPhysicalAddress);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetAttributes);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->SetAttributes);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Read);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Write);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->EraseBlocks);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLangCodes);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->LangCodes);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLang);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);  EfiConvertPointer (0x0, (VOID **) &mHashCtx);  EfiConvertPointer (0x0, (VOID **) &mSerializationRuntimeBuffer);  EfiConvertPointer (0x0, (VOID **) &mNvVariableCache);  EfiConvertPointer (0x0, (VOID **) &mPubKeyStore);  EfiConvertPointer (0x0, (VOID **) &mCertDbStore);  //  // in the list of locked variables, convert the name pointers first  //  for ( Link = GetFirstNode (&mLockedVariableList)      ; !IsNull (&mLockedVariableList, Link)      ; Link = GetNextNode (&mLockedVariableList, Link)      ) {    Entry = BASE_CR (Link, VARIABLE_ENTRY, Link);    Status = EfiConvertPointer (0x0, (VOID **) &Entry->Name);    ASSERT_EFI_ERROR (Status);  }  //  // second, convert the list itself using UefiRuntimeLib  //  Status = EfiConvertList (0x0, &mLockedVariableList);  ASSERT_EFI_ERROR (Status);}

/**  Process key notify.  @param  Event                 Indicates the event that invoke this function.  @param  Context               Indicates the calling context.**/VOIDEFIAPIKeyNotifyProcessHandler (  IN  EFI_EVENT                 Event,  IN  VOID                      *Context  ){  EFI_STATUS                            Status;  VIRTUAL_KEYBOARD_DEV                  *VirtualKeyboardPrivate;  EFI_KEY_DATA                          KeyData;  LIST_ENTRY                            *Link;  LIST_ENTRY                            *NotifyList;  VIRTUAL_KEYBOARD_CONSOLE_IN_EX_NOTIFY *CurrentNotify;  EFI_TPL                               OldTpl;  VirtualKeyboardPrivate = (VIRTUAL_KEYBOARD_DEV *) Context;  //  // Invoke notification functions.  //  NotifyList = &VirtualKeyboardPrivate->NotifyList;  while (TRUE) {    //    // Enter critical section    //    OldTpl = gBS->RaiseTPL (TPL_NOTIFY);    Status = Dequeue (&VirtualKeyboardPrivate->QueueForNotify, &KeyData);    //    // Leave critical section    //    gBS->RestoreTPL (OldTpl);    if (EFI_ERROR (Status)) {      break;    }    for (Link = GetFirstNode (NotifyList);         !IsNull (NotifyList, Link);         Link = GetNextNode (NotifyList, Link)) {      CurrentNotify = CR (Link,                        VIRTUAL_KEYBOARD_CONSOLE_IN_EX_NOTIFY,                        NotifyEntry,                        VIRTUAL_KEYBOARD_CONSOLE_IN_EX_NOTIFY_SIGNATURE                        );      if (IsKeyRegistered (&CurrentNotify->KeyData, &KeyData)) {        CurrentNotify->KeyNotificationFn (&KeyData);      }    }  }}

/**  Search for Framework SMI handler information according to specific PI SMM dispatch handle.  @param[in] DispatchHandle  The unique handle assigned by SmiHandlerRegister().    @return  Pointer to CALLBACK_INFO. If NULL, no callback info record is found.**/CALLBACK_INFO *GetCallbackInfo (  IN EFI_HANDLE  DispatchHandle  ){  LIST_ENTRY  *Node;  Node = GetFirstNode (&mCallbackInfoListHead);  while (!IsNull (&mCallbackInfoListHead, Node)) {    if (((CALLBACK_INFO *)Node)->DispatchHandle == DispatchHandle) {      return (CALLBACK_INFO *)Node;    }    Node = GetNextNode (&mCallbackInfoListHead, Node);  }  return NULL;}

/***  Get all partitions of all USB devices in linked list.  @param[in|out]  DeviceList  - Linked list of USB devices.  @param[in]      MaxDevices  - Number of USB devices in linked list.    @retval  EFI_SUCCESS	The function exited normally.  @retval  Other     	  An error occurred.***/EFI_STATUSUsbGetAllPartitions (     IN OUT LIST_ENTRY   *DeviceList,  IN UINTN            MaxDevices  ){  EFI_STATUS      Status;    LIST_ENTRY      ChildHandleList[MaxDevices];  LIST_ENTRY      *Node = NULL;  DISK_ENTRY      *DiskEntry = NULL;  UINTN           MaxPartitions, Index;    if (IsListEmpty (DeviceList)) {    return EFI_INVALID_PARAMETER;  }    Index = 0;  Node = GetFirstNode (DeviceList);  while (!IsNull (DeviceList, Node)) {     DiskEntry = (DISK_ENTRY*)Node;    MaxPartitions = 0;    Status = GetChildHandles (                    DiskEntry->DiskInfo.DiskHandle,                     &gEfiBlockIoProtocolGuid,                     &gEfiDiskIoProtocolGuid,                     &ChildHandleList[Index]                    );    if (Status == EFI_SUCCESS) {        Status = CheckGptMbrPartitions (                    &ChildHandleList[Index],                     DiskEntry->DiskInfo.BlockIo->Media->MediaId,                     &(DiskEntry->DiskInfo.PartitionsList),                    &MaxPartitions                    );      if (Status == EFI_SUCCESS) {        DiskEntry->DiskInfo.MaxPartitions = MaxPartitions;        DBG ("MaxPartitions: %d/n", MaxPartitions);      }    }    Index++;    Node = GetNextNode (DeviceList, Node);  }  DBG ("OK/n");    return EFI_SUCCESS;}

/**  Complete the current request  This routine is called at TPL_I2C_SYNC.  @param[in] I2cHostContext  Address of an I2C_HOST_CONTEXT structure.  @param[in] Status          Status of the I2C operation.  @return This routine returns the input status value.**/EFI_STATUSI2cHostRequestComplete (  I2C_HOST_CONTEXT *I2cHostContext,  EFI_STATUS       Status  ){  I2C_REQUEST *I2cRequest;  LIST_ENTRY  *EntryHeader;  LIST_ENTRY  *Entry;  //  // Remove the current I2C request from the list  //  EntryHeader = &I2cHostContext->RequestList;  Entry = GetFirstNode (EntryHeader);  I2cRequest = I2C_REQUEST_FROM_ENTRY (Entry);  //  // Save the status for QueueRequest  //  if ( NULL != I2cRequest->Status ) {    *I2cRequest->Status = Status;  }  //  //  Notify the user of the I2C request completion  //  if ( NULL != I2cRequest->Event ) {    gBS->SignalEvent (I2cRequest->Event);  }  //  // Done with this request, remove the current request from list  //  RemoveEntryList (&I2cRequest->Link);  FreePool (I2cRequest->RequestPacket);  FreePool (I2cRequest);  //  // If there is more I2C request, start next one  //  if(!IsListEmpty (EntryHeader)) {    I2cHostRequestEnable (I2cHostContext);  }    return Status;}

/**  Update the value of a given alias on the list.  If the alias is not there then add it.  @param[in] Alias               The alias to test for.  @param[in] CommandString       The updated command string.  @param[in, out] List           The list to search.  @retval EFI_SUCCESS           The operation was completed successfully.  @retval EFI_OUT_OF_RESOURCES  There was not enough free memory.**/EFI_STATUSEFIAPIInternalUpdateAliasOnList(  IN CONST CHAR16       *Alias,  IN CONST CHAR16       *CommandString,  IN OUT LIST_ENTRY     *List  ){  ALIAS_LIST *Node;  BOOLEAN    Found;  //  // assert for NULL parameter  //  ASSERT(Alias != NULL);  //  // check for the Alias  //  for ( Node = (ALIAS_LIST *)GetFirstNode(List), Found = FALSE      ; !IsNull(List, &Node->Link)      ; Node = (ALIAS_LIST *)GetNextNode(List, &Node->Link)     ){    ASSERT(Node->CommandString != NULL);    ASSERT(Node->Alias != NULL);    if (StrCmp(Node->Alias, Alias)==0) {      FreePool(Node->CommandString);      Node->CommandString = NULL;      Node->CommandString = StrnCatGrow(&Node->CommandString, NULL, CommandString, 0);      Found = TRUE;      break;    }  }  if (!Found) {    Node = AllocateZeroPool(sizeof(ALIAS_LIST));    if (Node == NULL) {      return (EFI_OUT_OF_RESOURCES);    }    ASSERT(Node->Alias == NULL);    Node->Alias         = StrnCatGrow(&Node->Alias, NULL, Alias, 0);    ASSERT(Node->CommandString == NULL);    Node->CommandString = StrnCatGrow(&Node->CommandString, NULL, CommandString, 0);    InsertTailList(List, &Node->Link);  }  return (EFI_SUCCESS);}

/**   function to add each command name from the linked list to the string list.   the resultant list is a double NULL terminated list of NULL terminated strings.   @param[in,out] DestList    double pointer to the list. may be NULL.   @param[in,out] DestSize    pointer to the size of list. may be 0, if DestList is NULL.   @param[in]     SourceList  the double linked list of commands.   @retval EFI_SUCCESS        the operation was successful.**/EFI_STATUSCopyListOfCommandNames(  IN OUT   CHAR16       **DestList,  IN OUT   UINTN        *DestSize,  IN CONST COMMAND_LIST *SourceList  ){  CONST COMMAND_LIST  *Node;  for ( Node = (COMMAND_LIST*)GetFirstNode(&SourceList->Link)      ; SourceList != NULL && !IsListEmpty(&SourceList->Link) && !IsNull(&SourceList->Link, &Node->Link)      ; Node = (COMMAND_LIST*)GetNextNode(&SourceList->Link, &Node->Link)    ) {    LexicalInsertIntoList(DestList, DestSize, Node->CommandString);  }  return (EFI_SUCCESS);}

/**  Insert one pre-fetched key into the FIFO buffer.  @param  TerminalDevice       Terminal driver private structure.  @param  Key                  The key will be input.  @retval TRUE                 If insert successfully.  @retval FLASE                If FIFO buffer is full before key insertion,                               and the key is lost.**/BOOLEANEfiKeyFiFoInsertOneKey (  TERMINAL_DEV                    *TerminalDevice,  EFI_INPUT_KEY                   *Key  ){  UINT8                           Tail;  LIST_ENTRY                      *Link;  LIST_ENTRY                      *NotifyList;  TERMINAL_CONSOLE_IN_EX_NOTIFY   *CurrentNotify;  EFI_KEY_DATA                    KeyData;  Tail = TerminalDevice->EfiKeyFiFo->Tail;  CopyMem (&KeyData.Key, Key, sizeof (EFI_INPUT_KEY));  KeyData.KeyState.KeyShiftState  = 0;  KeyData.KeyState.KeyToggleState = 0;  //  // Invoke notification functions if exist  //  NotifyList = &TerminalDevice->NotifyList;  for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList,Link); Link = GetNextNode (NotifyList,Link)) {    CurrentNotify = CR (                      Link,                      TERMINAL_CONSOLE_IN_EX_NOTIFY,                      NotifyEntry,                      TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE                      );    if (IsKeyRegistered (&CurrentNotify->KeyData, &KeyData)) {      CurrentNotify->KeyNotificationFn (&KeyData);    }  }  if (IsEfiKeyFiFoFull (TerminalDevice)) {    //    // Efi Key FIFO is full    //    return FALSE;  }  CopyMem (&TerminalDevice->EfiKeyFiFo->Data[Tail], Key, sizeof (EFI_INPUT_KEY));  TerminalDevice->EfiKeyFiFo->Tail = (UINT8) ((Tail + 1) % (FIFO_MAX_NUMBER + 1));  return TRUE;}

/**  Callback function for SimpleTextInEx protocol install events  @param Event           the event that is signaled.  @param Context         not used here.**/VOIDEFIAPITxtInExCallback (  IN EFI_EVENT    Event,  IN VOID         *Context  ){  EFI_STATUS                         Status;  UINTN                              BufferSize;  EFI_HANDLE                         Handle;  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *TxtInEx;  LIST_ENTRY                         *Link;  while (TRUE) {    BufferSize = sizeof (EFI_HANDLE);    Status = gBS->LocateHandle (                    ByRegisterNotify,                    NULL,                    mTxtInExRegistration,                    &BufferSize,                    &Handle                    );    if (EFI_ERROR (Status)) {      //      // If no more notification events exist      //      return ;    }    Status = gBS->HandleProtocol (                    Handle,                    &gEfiSimpleTextInputExProtocolGuid,                    (VOID **) &TxtInEx                    );    ASSERT_EFI_ERROR (Status);    //    // Register the hot key notification for the existing items in the list    //    EfiAcquireLock (&mHotkeyLock);    for (Link = GetFirstNode (&mHotkeyList); !IsNull (&mHotkeyList, Link); Link = GetNextNode (&mHotkeyList, Link)) {      RegisterHotkeyNotify (TxtInEx, HOTKEY_FROM_LINK (Link));    }    EfiReleaseLock (&mHotkeyLock);  }}

EFIAPIShellCommandFindMapItem (  IN CONST CHAR16 *MapKey  ){  SHELL_MAP_LIST *MapListItem;  for ( MapListItem = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)      ; !IsNull(&gShellMapList.Link, &MapListItem->Link)      ; MapListItem = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &MapListItem->Link)     ){    if (gUnicodeCollation->StriColl(gUnicodeCollation,MapListItem->MapName,(CHAR16*)MapKey) == 0) {      return (MapListItem);    }  }  return (NULL);}

/**  Get the first EFI_IFR_VARSTORE from the FormSet.       @param FormSet                  The Form Set.     @retval FORMSET_STORAGE *       Return the first EFI_IFR_VARSTORE.  @retval NULL                    If the Form Set does not have EFI_IFR_VARSTORE.**/FORMSET_STORAGE *GetFirstStorageOfFormSet (  IN CONST FORM_BROWSER_FORMSET * FormSet  ) {  LIST_ENTRY             *StorageList;  FORMSET_STORAGE        *Storage;  StorageList = GetFirstNode (&FormSet->StorageListHead);  if (!IsNull (&FormSet->StorageListHead, StorageList)) {    Storage = FORMSET_STORAGE_FROM_LINK (StorageList);    return Storage;  }    return NULL;}

/**  Search the Head list for a EFI_DATA_HUB_FILTER_DRIVER member that  represents Event and return it.  @param Head   Pointer to head of dual linked list of EFI_DATA_HUB_FILTER_DRIVER structures.  @param Event  Event to be search for in the Head list.  @retval EFI_DATA_HUB_FILTER_DRIVER  Returned if Event stored in the Head doubly linked list.  @retval NULL                        If Event is not in the list**/DATA_HUB_FILTER_DRIVER *FindFilterDriverByEvent (  IN  LIST_ENTRY      *Head,  IN  EFI_EVENT       Event  ){  DATA_HUB_FILTER_DRIVER  *FilterEntry;  LIST_ENTRY              *Link;  for (Link = GetFirstNode(Head); Link != Head; Link = GetNextNode(Head, Link)) {    FilterEntry = FILTER_ENTRY_FROM_LINK (Link);    if (FilterEntry->Event == Event) {      return FilterEntry;    }  }  return NULL;}

VOIDQNCSmmPeriodicTimerClearSource (  IN QNC_SMM_SOURCE_DESC     *SrcDesc  )/*++Routine Description:  This function is responsible for calculating and enabling any timers that are required  to dispatch messages to children. The SrcDesc argument isn't acutally used.Arguments:  SrcDesc - Pointer to the QNC_SMM_SOURCE_DESC instance.Returns:  None.--*/{  DATABASE_RECORD   *RecordInDb;  LIST_ENTRY        *LinkInDb;  QNCSmmPeriodicTimerProgramTimers ();  //  // Reset Elapsed time  //  LinkInDb = GetFirstNode (&mPrivateData.CallbackDataBase);  while (!IsNull (&mPrivateData.CallbackDataBase, LinkInDb)) {    RecordInDb = DATABASE_RECORD_FROM_LINK (LinkInDb);    if (RecordInDb->ProtocolType == PeriodicTimerType) {      //      // This child is registerd with the PeriodicTimer protocol and Callback      // has been invoked, so reset the ElapsedTime to 0      //      if (RecordInDb->CommBuffer.PeriodicTimer.ElapsedTime >= RecordInDb->ChildContext.PeriodicTimer.Period) {        RecordInDb->CommBuffer.PeriodicTimer.ElapsedTime = 0;      }    }    LinkInDb = GetNextNode (&mPrivateData.CallbackDataBase, &RecordInDb->Link);  }}

/**  Internal Function. Allocate a pool by specified PoolIndex.  @param  PoolType              Type of pool to allocate.  @param  PoolIndex             Index which indicate the Pool size.  @param  FreePoolHdr           The returned Free pool.  @retval EFI_OUT_OF_RESOURCES   Allocation failed.  @retval EFI_SUCCESS            Pool successfully allocated.**/EFI_STATUSInternalAllocPoolByIndex (  IN  EFI_MEMORY_TYPE   PoolType,  IN  UINTN             PoolIndex,  OUT FREE_POOL_HEADER  **FreePoolHdr  ){  EFI_STATUS            Status;  FREE_POOL_HEADER      *Hdr;  POOL_TAIL             *Tail;  EFI_PHYSICAL_ADDRESS  Address;  SMM_POOL_TYPE         SmmPoolType;  Address     = 0;  SmmPoolType = UefiMemoryTypeToSmmPoolType(PoolType);  ASSERT (PoolIndex <= MAX_POOL_INDEX);  Status = EFI_SUCCESS;  Hdr = NULL;  if (PoolIndex == MAX_POOL_INDEX) {    Status = SmmInternalAllocatePages (AllocateAnyPages, PoolType,                                       EFI_SIZE_TO_PAGES (MAX_POOL_SIZE << 1),                                       &Address, FALSE);    if (EFI_ERROR (Status)) {      return EFI_OUT_OF_RESOURCES;    }    Hdr = (FREE_POOL_HEADER *) (UINTN) Address;  } else if (!IsListEmpty (&mSmmPoolLists[SmmPoolType][PoolIndex])) {    Hdr = BASE_CR (GetFirstNode (&mSmmPoolLists[SmmPoolType][PoolIndex]), FREE_POOL_HEADER, Link);    RemoveEntryList (&Hdr->Link);  } else {    Status = InternalAllocPoolByIndex (PoolType, PoolIndex + 1, &Hdr);    if (!EFI_ERROR (Status)) {      Hdr->Header.Signature = 0;      Hdr->Header.Size >>= 1;      Hdr->Header.Available = TRUE;      Hdr->Header.Type = 0;      Tail = HEAD_TO_TAIL(&Hdr->Header);      Tail->Signature = 0;      Tail->Size = 0;      InsertHeadList (&mSmmPoolLists[SmmPoolType][PoolIndex], &Hdr->Link);      Hdr = (FREE_POOL_HEADER*)((UINT8*)Hdr + Hdr->Header.Size);    }  }

/**  Insert the String Package into the Package Lists which has the TAG GUID matching  the PackageListGuid of the String Package.   The Package List must have only IFR Package and no String Package.   Otherwise, ASSERT.  @param Private                      The HII THUNK driver context data.  @param StringPackageThunkContext    The HII THUNK context data.  @param StringPackageListHeader      The String Package List Header.  **/VOIDUpdatePackListWithOnlyIfrPack (  IN       HII_THUNK_PRIVATE_DATA      *Private,  IN       HII_THUNK_CONTEXT            *StringPackageThunkContext,  IN CONST EFI_HII_PACKAGE_LIST_HEADER *StringPackageListHeader  ){  EFI_STATUS                 Status;  LIST_ENTRY                 *Link;  HII_THUNK_CONTEXT          *ThunkContext;  Link = GetFirstNode (&Private->ThunkContextListHead);  while (!IsNull (&Private->ThunkContextListHead, Link)) {    ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);    if (StringPackageThunkContext != ThunkContext) {      //      // Skip the String Package Thunk Entry itself.      //          if (CompareGuid (&StringPackageListHeader->PackageListGuid, &ThunkContext->TagGuid)) {        ASSERT (ThunkContext->StringPackageCount == 0 && ThunkContext->IfrPackageCount == 1);        ThunkContext->StringPackageCount = GetPackageCountByType (StringPackageListHeader, EFI_HII_PACKAGE_STRINGS);                Status = mHiiDatabase->UpdatePackageList (                                              mHiiDatabase,                                              ThunkContext->UefiHiiHandle,                                              StringPackageListHeader                                              );        ASSERT_EFI_ERROR (Status);        ThunkContext->SharingStringPack = TRUE;        StringPackageThunkContext->SharingStringPack = TRUE;      }    }        Link = GetNextNode (&Private->ThunkContextListHead, Link);  }}