/** Create a socket with initial data SockInitData. @param SockInitData Pointer to the initial data of the socket. @return Pointer to the newly created socket, return NULL when exception occured. **/ SOCKET * SockCreate ( IN SOCK_INIT_DATA *SockInitData ) { SOCKET *Sock; SOCKET *Parent; EFI_STATUS Status; ASSERT ((SockInitData != NULL) && (SockInitData->ProtoHandler != NULL)); ASSERT (SockInitData->Type == SockStream); ASSERT ((SockInitData->ProtoData != NULL) && (SockInitData->DataSize <= PROTO_RESERVED_LEN)); Parent = SockInitData->Parent; if ((Parent != NULL) && (Parent->ConnCnt == Parent->BackLog)) { DEBUG ( (EFI_D_ERROR, "SockCreate: Socket parent has " "reached its connection limit with %d ConnCnt and %d BackLog\n", Parent->ConnCnt, Parent->BackLog) ); return NULL; } Sock = AllocateZeroPool (sizeof (SOCKET)); if (NULL == Sock) { DEBUG ((EFI_D_ERROR, "SockCreate: No resource to create a new socket\n")); return NULL; } InitializeListHead (&Sock->Link); InitializeListHead (&Sock->ConnectionList); InitializeListHead (&Sock->ListenTokenList); InitializeListHead (&Sock->RcvTokenList); InitializeListHead (&Sock->SndTokenList); InitializeListHead (&Sock->ProcessingSndTokenList); EfiInitializeLock (&(Sock->Lock), TPL_CALLBACK); Sock->SndBuffer.DataQueue = NetbufQueAlloc (); if (NULL == Sock->SndBuffer.DataQueue) { DEBUG ((EFI_D_ERROR, "SockCreate: No resource to allocate" " SndBuffer for new socket\n")); goto OnError; } Sock->RcvBuffer.DataQueue = NetbufQueAlloc (); if (NULL == Sock->RcvBuffer.DataQueue) { DEBUG ((EFI_D_ERROR, "SockCreate: No resource to allocate " "RcvBuffer for new socket\n")); goto OnError; } Sock->Signature = SOCK_SIGNATURE; Sock->Parent = Parent; Sock->BackLog = SockInitData->BackLog; Sock->ProtoHandler = SockInitData->ProtoHandler; Sock->SndBuffer.HighWater = SockInitData->SndBufferSize; Sock->RcvBuffer.HighWater = SockInitData->RcvBufferSize; Sock->Type = SockInitData->Type; Sock->DriverBinding = SockInitData->DriverBinding; Sock->State = SockInitData->State; Sock->CreateCallback = SockInitData->CreateCallback; Sock->DestroyCallback = SockInitData->DestroyCallback; Sock->Context = SockInitData->Context; Sock->SockError = EFI_ABORTED; Sock->SndBuffer.LowWater = SOCK_BUFF_LOW_WATER; Sock->RcvBuffer.LowWater = SOCK_BUFF_LOW_WATER; // // Install protocol on Sock->SockHandle // CopyMem ( &(Sock->NetProtocol.TcpProtocol), SockInitData->Protocol, sizeof (EFI_TCP4_PROTOCOL) ); // // copy the protodata into socket // CopyMem (Sock->ProtoReserved, SockInitData->ProtoData, SockInitData->DataSize); Status = gBS->InstallMultipleProtocolInterfaces ( &Sock->SockHandle, &gEfiTcp4ProtocolGuid, &(Sock->NetProtocol.TcpProtocol), NULL ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "SockCreate: Install TCP protocol in " "socket failed with %r\n", Status)); goto OnError; } if (Parent != NULL) { ASSERT (Parent->BackLog > 0); ASSERT (SOCK_IS_LISTENING (Parent)); // // need to add it into Parent->ConnectionList // if the Parent->ConnCnt < Parent->BackLog // Parent->ConnCnt++; DEBUG ( (EFI_D_NET, "SockCreate: Create a new socket and add to parent, now conncnt is %d\n", Parent->ConnCnt) ); InsertTailList (&Parent->ConnectionList, &Sock->ConnectionList); } if (Sock->CreateCallback != NULL) { Status = Sock->CreateCallback (Sock, Sock->Context); if (EFI_ERROR (Status)) { goto OnError; } } return Sock; OnError: if (Sock->SockHandle != NULL) { gBS->UninstallMultipleProtocolInterfaces ( Sock->SockHandle, &gEfiTcp4ProtocolGuid, &(Sock->NetProtocol.TcpProtocol), NULL ); } if (NULL != Sock->SndBuffer.DataQueue) { NetbufQueFree (Sock->SndBuffer.DataQueue); } if (NULL != Sock->RcvBuffer.DataQueue) { NetbufQueFree (Sock->RcvBuffer.DataQueue); } FreePool (Sock); return NULL; }
VOID NTAPI FatCreateRootDcb(IN PFAT_IRP_CONTEXT IrpContext, IN PVCB Vcb) { PFCB Dcb; /* Make sure it's not already created */ ASSERT(!Vcb->RootDcb); /* Allocate the DCB */ Dcb = FsRtlAllocatePoolWithTag(NonPagedPool, sizeof(FCB), TAG_FCB); /* Zero it */ RtlZeroMemory(Dcb, sizeof(FCB)); /* Assign it to the VCB */ Vcb->RootDcb = Dcb; /* Set its header */ Dcb->Header.NodeTypeCode = FAT_NTC_ROOT_DCB; Dcb->Header.NodeByteSize = sizeof(FCB); /* FCB is in a good condition */ Dcb->Condition = FcbGood; /* Initialize FCB's resource */ Dcb->Header.Resource = &Dcb->Resource; ExInitializeResourceLite(&Dcb->Resource); /* Initialize Paging Io resource*/ Dcb->Header.PagingIoResource = &Dcb->PagingIoResource; ExInitializeResourceLite(&Dcb->PagingIoResource); /* Initialize a list of parent DCBs*/ InitializeListHead(&Dcb->ParentDcbLinks); /* Set VCB */ Dcb->Vcb = Vcb; /* Initialize parent's DCB list */ InitializeListHead(&Dcb->Dcb.ParentDcbList); /* Initialize the full file name */ Dcb->FullFileName.Buffer = L"\\"; Dcb->FullFileName.Length = 1 * sizeof(WCHAR); Dcb->FullFileName.MaximumLength = 2 * sizeof(WCHAR); Dcb->ShortName.Name.Ansi.Buffer = "\\"; Dcb->ShortName.Name.Ansi.Length = 1; Dcb->ShortName.Name.Ansi.MaximumLength = 2 * sizeof(CHAR); /* Fill dirent attribute byte copy */ Dcb->DirentFatFlags = FILE_ATTRIBUTE_DIRECTORY; /* Initialize advanced FCB header fields */ ExInitializeFastMutex(&Dcb->HeaderMutex); FsRtlSetupAdvancedHeader(&Dcb->Header, &Dcb->HeaderMutex); /* Set up first cluster field depending on FAT type */ if (TRUE/*FatIsFat32(Vcb)*/) { /* First cluster is really the first cluster of this volume */ Dcb->FirstClusterOfFile = Vcb->Bpb.RootDirFirstCluster; /* Calculate size of FAT32 root dir */ Dcb->Header.AllocationSize.LowPart = 0xFFFFFFFF; //FatLookupFileAllocationSize(IrpContext, Dcb); DPRINT1("Calculation of a size of a root dir is missing!\n"); Dcb->Header.FileSize.QuadPart = Dcb->Header.AllocationSize.QuadPart; } else { #if 0 /* Add MCB entry */ FatAddMcbEntry(Vcb, &Dcb->Mcb, 0, FatRootDirectoryLbo(&Vcb->Bpb), FatRootDirectorySize(&Vcb->Bpb)); /* Set a real size of the root directory */ Dcb->Header.FileSize.QuadPart = FatRootDirectorySize(&Vcb->Bpb); Dcb->Header.AllocationSize.QuadPart = Dcb->Header.FileSize.QuadPart; #endif UNIMPLEMENTED; } }
//@@@@@@@@@@@@@@@@@@@@@@@@ // IRQL = passive level //@@@@@@@@@@@@@@@@@@@@@@@@@ extern "C" NTSTATUS DriverEntry( IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING RegistryPath ) { NTSTATUS Status = {0}; DbgPrint("Keyboard Filter Driver - DriverEntry\nCompiled at " __TIME__ " on " __DATE__ "\n"); ///////////////////////////////////////////////////////////////////////////////////////// // Fill in IRP dispatch table in the DriverObject to handle I/O Request Packets (IRPs) ///////////////////////////////////////////////////////////////////////////////////////// // For a filter driver, we want pass down ALL IRP_MJ_XX requests to the driver which // we are hooking except for those we are interested in modifying. for(int i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++) pDriverObject->MajorFunction[i] = DispatchPassDown; DbgPrint("Filled dispatch table with generic pass down routine...\n"); //Explicitly fill in the IRP's we want to hook pDriverObject->MajorFunction[IRP_MJ_READ] = DispatchRead; //Go ahead and hook the keyboard now HookKeyboard(pDriverObject); DbgPrint("Hooked IRP_MJ_READ routine...\n"); //Set up our worker thread to handle file writes of the scan codes extracted from the //read IRPs InitThreadKeyLogger(pDriverObject); //Initialize the linked list that will serve as a queue to hold the captured keyboard scan codes PDEVICE_EXTENSION pKeyboardDeviceExtension = (PDEVICE_EXTENSION)pDriverObject->DeviceObject->DeviceExtension; InitializeListHead(&pKeyboardDeviceExtension->QueueListHead); //Initialize the lock for the linked list queue KeInitializeSpinLock(&pKeyboardDeviceExtension->lockQueue); //Initialize the work queue semaphore KeInitializeSemaphore(&pKeyboardDeviceExtension->semQueue, 0 , MAXLONG); //Create the log file IO_STATUS_BLOCK file_status; OBJECT_ATTRIBUTES obj_attrib; CCHAR ntNameFile[64] = "\\DosDevices\\c:\\klog.txt"; STRING ntNameString; UNICODE_STRING uFileName; RtlInitAnsiString( &ntNameString, ntNameFile); RtlAnsiStringToUnicodeString(&uFileName, &ntNameString, TRUE ); InitializeObjectAttributes(&obj_attrib, &uFileName, OBJ_CASE_INSENSITIVE, NULL, NULL); Status = ZwCreateFile(&pKeyboardDeviceExtension->hLogFile,GENERIC_WRITE,&obj_attrib,&file_status, NULL,FILE_ATTRIBUTE_NORMAL,0,FILE_OPEN_IF,FILE_SYNCHRONOUS_IO_NONALERT,NULL,0); RtlFreeUnicodeString(&uFileName); if (Status != STATUS_SUCCESS) { DbgPrint("Failed to create log file...\n"); DbgPrint("File Status = %x\n",file_status); } else { DbgPrint("Successfully created log file...\n"); DbgPrint("File Handle = %x\n",pKeyboardDeviceExtension->hLogFile); } // Set the DriverUnload procedure pDriverObject->DriverUnload = Unload; DbgPrint("Set DriverUnload function pointer...\n"); DbgPrint("Exiting Driver Entry......\n"); return STATUS_SUCCESS; }
LOGICAL DllMain( __in HINSTANCE Instance, __in ULONG Reason, __reserved PVOID Reserved ) { switch (Reason) { case DLL_PROCESS_ATTACH: { PPH_PLUGIN_INFORMATION info; PluginInstance = PhRegisterPlugin(L"ProcessHacker.ExtendedTools", Instance, &info); if (!PluginInstance) return FALSE; info->DisplayName = L"Extended Tools"; info->Author = L"wj32"; info->Description = L"Extended functionality for Windows Vista and above, including ETW monitoring and a Disk tab."; info->HasOptions = TRUE; PhRegisterCallback( PhGetPluginCallback(PluginInstance, PluginCallbackLoad), LoadCallback, NULL, &PluginLoadCallbackRegistration ); PhRegisterCallback( PhGetPluginCallback(PluginInstance, PluginCallbackUnload), UnloadCallback, NULL, &PluginUnloadCallbackRegistration ); PhRegisterCallback( PhGetPluginCallback(PluginInstance, PluginCallbackShowOptions), ShowOptionsCallback, NULL, &PluginShowOptionsCallbackRegistration ); PhRegisterCallback( PhGetPluginCallback(PluginInstance, PluginCallbackMenuItem), MenuItemCallback, NULL, &PluginMenuItemCallbackRegistration ); PhRegisterCallback( PhGetPluginCallback(PluginInstance, PluginCallbackTreeNewMessage), TreeNewMessageCallback, NULL, &PluginTreeNewMessageCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackMainWindowShowing), MainWindowShowingCallback, NULL, &MainWindowShowingCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackProcessPropertiesInitializing), ProcessPropertiesInitializingCallback, NULL, &ProcessPropertiesInitializingCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackHandlePropertiesInitializing), HandlePropertiesInitializingCallback, NULL, &HandlePropertiesInitializingCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackProcessMenuInitializing), ProcessMenuInitializingCallback, NULL, &ProcessMenuInitializingCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackThreadMenuInitializing), ThreadMenuInitializingCallback, NULL, &ThreadMenuInitializingCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackModuleMenuInitializing), ModuleMenuInitializingCallback, NULL, &ModuleMenuInitializingCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackProcessTreeNewInitializing), ProcessTreeNewInitializingCallback, NULL, &ProcessTreeNewInitializingCallbackRegistration ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackNetworkTreeNewInitializing), NetworkTreeNewInitializingCallback, NULL, &NetworkTreeNewInitializingCallbackRegistration ); PhRegisterCallback( &PhProcessesUpdatedEvent, ProcessesUpdatedCallback, NULL, &ProcessesUpdatedCallbackRegistration ); PhRegisterCallback( &PhNetworkItemsUpdatedEvent, NetworkItemsUpdatedCallback, NULL, &NetworkItemsUpdatedCallbackRegistration ); InitializeListHead(&EtProcessBlockListHead); InitializeListHead(&EtNetworkBlockListHead); PhPluginSetObjectExtension( PluginInstance, EmProcessItemType, sizeof(ET_PROCESS_BLOCK), ProcessItemCreateCallback, ProcessItemDeleteCallback ); PhPluginSetObjectExtension( PluginInstance, EmNetworkItemType, sizeof(ET_NETWORK_BLOCK), NetworkItemCreateCallback, NetworkItemDeleteCallback ); { static PH_SETTING_CREATE settings[] = { { StringSettingType, SETTING_NAME_DISK_TREE_LIST_COLUMNS, L"" }, { IntegerPairSettingType, SETTING_NAME_DISK_TREE_LIST_SORT, L"4,2" }, // 4, DescendingSortOrder { IntegerSettingType, SETTING_NAME_ENABLE_ETW_MONITOR, L"1" }, { IntegerSettingType, SETTING_NAME_ETWSYS_ALWAYS_ON_TOP, L"0" }, { IntegerPairSettingType, SETTING_NAME_ETWSYS_WINDOW_POSITION, L"400,400" }, { IntegerPairSettingType, SETTING_NAME_ETWSYS_WINDOW_SIZE, L"500,400" }, { IntegerPairSettingType, SETTING_NAME_MEMORY_LISTS_WINDOW_POSITION, L"400,400" } }; PhAddSettings(settings, sizeof(settings) / sizeof(PH_SETTING_CREATE)); } } break; } return TRUE; }
/* Our merge algorithm is pretty straightforward. 1. If the active context is not null and not the helper context, init the list of known contexts with the active context 2. For all contexts in the inactive context list a. get the signature of the context b. For each context constructed so far if the signature of the two context are compatible merge the two the context else create a new context and add it to the list of constructed contexts */ VOID HvlPerformCtxMerge( PHVL pHvl, BOOLEAN *pfMerged ) { LIST_ENTRY *pEntryCtx = NULL; PHVL_CONTEXT pCtx = NULL; VNIC_SIGNATURE Ctx1Sig = {0}, Ctx2Sig = {0}; BOOLEAN fMerge = FALSE; PHVL_CONTEXT HvlCtxArray[HVL_NUM_CONTEXTS] = {0}; ULONG ulNumCtxs = 0, ulCtxIndex = 0, ulNumCtxsBeforeMerge = 0; ASSERT(HvlIsLocked(pHvl)); *pfMerged = FALSE; if (pHvl->ulNumPortCtxs <= 2) { return; } ulNumCtxsBeforeMerge = pHvl->ulNumPortCtxs; /* 1. If the active context is not null and not the helper context, init the list of known contexts with the active context */ if (pHvl->pActiveContext && pHvl->pHelperPortCtx != pHvl->pActiveContext) { HvlCtxArray[ulNumCtxs++] = pHvl->pActiveContext; } /* 2. For all contexts in the inactive context list */ pEntryCtx = pHvl->InactiveContextList.Flink; while (pEntryCtx != &pHvl->InactiveContextList) { pCtx = CONTAINING_RECORD(pEntryCtx, HVL_CONTEXT, Link); // remove this context from the linked list RemoveEntryList (&pCtx->Link); InitializeListHead(&pCtx->Link); /* a. get the signature of the context */ Ctx1Sig = HvlCtxGetSignature(pCtx); /* b. For each context constructed so far */ fMerge = FALSE; for (ulCtxIndex = 0; ulCtxIndex < ulNumCtxs; ulCtxIndex++) { Ctx2Sig = HvlCtxGetSignature(HvlCtxArray[ulCtxIndex]); if (VNic11AreCompatibleSignatures(&Ctx1Sig, &Ctx2Sig)) { fMerge = TRUE; break; } } /* if the signature of the two context are compatible merge the two the context else create a new context and add it to the list of constructed contexts */ if (fMerge) { HvlMergeCtxs(pHvl, pCtx, HvlCtxArray[ulCtxIndex]); } else { HvlCtxArray[ulNumCtxs++] = pCtx; } // move to the next context in the inactive context list pEntryCtx = pHvl->InactiveContextList.Flink; } /* We have walked the complete linked list of contexts */ ASSERT(IsListEmpty(&pHvl->InactiveContextList)); /* Now build up the Inactive context list again from the context array we have constructed */ ulCtxIndex = 0; if (pHvl->pActiveContext == HvlCtxArray[0]) { /* The first context is already referred by the active context. Skip it */ ulCtxIndex++; } for ( ; ulCtxIndex < ulNumCtxs; ulCtxIndex++) { InsertTailList(&pHvl->InactiveContextList, &HvlCtxArray[ulCtxIndex]->Link); } ulNumCtxs = ulNumCtxs + 1; // +1 for the helper port context if (ulNumCtxsBeforeMerge != ulNumCtxs) { ASSERT(ulNumCtxs < ulNumCtxsBeforeMerge); ASSERT(pHvl->ulNumPortCtxs == ulNumCtxs); *pfMerged = TRUE; MpTrace(COMP_HVL, DBG_NORMAL, ("Merged contexts. Previous # contexts = %d, new # contexts = %d", ulNumCtxsBeforeMerge, ulNumCtxs)); } else { ASSERT(!fMerge); } }
/** Attach a Pcb to the socket. @param[in] Sk Pointer to the socket of this TCP instance. @retval EFI_SUCCESS The operation completed successfully. @retval EFI_OUT_OF_RESOURCES Failed due to resource limits. **/ EFI_STATUS TcpAttachPcb ( IN SOCKET *Sk ) { TCP_CB *Tcb; TCP_PROTO_DATA *ProtoData; IP_IO *IpIo; EFI_STATUS Status; VOID *Ip; EFI_GUID *IpProtocolGuid; if (Sk->IpVersion == IP_VERSION_4) { IpProtocolGuid = &gEfiIp4ProtocolGuid; } else { IpProtocolGuid = &gEfiIp6ProtocolGuid; } Tcb = AllocateZeroPool (sizeof (TCP_CB)); if (Tcb == NULL) { DEBUG ((EFI_D_ERROR, "TcpConfigurePcb: failed to allocate a TCB\n")); return EFI_OUT_OF_RESOURCES; } ProtoData = (TCP_PROTO_DATA *) Sk->ProtoReserved; IpIo = ProtoData->TcpService->IpIo; // // Create an IpInfo for this Tcb. // Tcb->IpInfo = IpIoAddIp (IpIo); if (Tcb->IpInfo == NULL) { FreePool (Tcb); return EFI_OUT_OF_RESOURCES; } // // Open the new created IP instance BY_CHILD. // Status = gBS->OpenProtocol ( Tcb->IpInfo->ChildHandle, IpProtocolGuid, &Ip, IpIo->Image, Sk->SockHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); if (EFI_ERROR (Status)) { IpIoRemoveIp (IpIo, Tcb->IpInfo); return Status; } InitializeListHead (&Tcb->List); InitializeListHead (&Tcb->SndQue); InitializeListHead (&Tcb->RcvQue); Tcb->State = TCP_CLOSED; Tcb->Sk = Sk; ProtoData->TcpPcb = Tcb; return EFI_SUCCESS; }
PCI_IO_DEVICE * CreatePciIoDevice ( IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo, IN PCI_TYPE00 *Pci, UINT8 Bus, UINT8 Device, UINT8 Func ) /*++ Routine Description: Arguments: Returns: None --*/ { EFI_STATUS Status; PCI_IO_DEVICE *PciIoDevice; PciIoDevice = NULL; Status = gBS->AllocatePool ( EfiBootServicesData, sizeof (PCI_IO_DEVICE), (VOID **) &PciIoDevice ); if (EFI_ERROR (Status)) { return NULL; } ZeroMem (PciIoDevice, sizeof (PCI_IO_DEVICE)); PciIoDevice->Signature = PCI_IO_DEVICE_SIGNATURE; PciIoDevice->Handle = NULL; PciIoDevice->PciRootBridgeIo = PciRootBridgeIo; PciIoDevice->DevicePath = NULL; PciIoDevice->BusNumber = Bus; PciIoDevice->DeviceNumber = Device; PciIoDevice->FunctionNumber = Func; PciIoDevice->Decodes = 0; if (gFullEnumeration) { PciIoDevice->Allocated = FALSE; } else { PciIoDevice->Allocated = TRUE; } PciIoDevice->Attributes = 0; PciIoDevice->Supports = 0; PciIoDevice->BusOverride = FALSE; PciIoDevice->IsPciExp = FALSE; CopyMem (&(PciIoDevice->Pci), Pci, sizeof (PCI_TYPE01)); // // Initialize the PCI I/O instance structure // Status = InitializePciIoInstance (PciIoDevice); Status = InitializePciDriverOverrideInstance (PciIoDevice); if (EFI_ERROR (Status)) { gBS->FreePool (PciIoDevice); return NULL; } // // Initialize the reserved resource list // InitializeListHead (&PciIoDevice->ReservedResourceList); // // Initialize the driver list // InitializeListHead (&PciIoDevice->OptionRomDriverList); // // Initialize the child list // InitializeListHead (&PciIoDevice->ChildList); return PciIoDevice; }
PPRIMARY_SESSION PrimarySession_Create ( IN PIRP_CONTEXT IrpContext, IN PVOLUME_DEVICE_OBJECT VolDo, IN PSESSION_INFORMATION SessionInformation, IN PIRP Irp ) { PPRIMARY_SESSION primarySession; OBJECT_ATTRIBUTES objectAttributes; NTSTATUS status; LARGE_INTEGER timeOut; ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL ); VolDo_Reference( VolDo ); primarySession = FsRtlAllocatePoolWithTag( NonPagedPool, sizeof(PRIMARY_SESSION), NDFAT_ALLOC_TAG ); if (primarySession == NULL) { ASSERT( NDASFAT_INSUFFICIENT_RESOURCES ); VolDo_Dereference( VolDo ); return NULL; } try { RtlZeroMemory( primarySession, sizeof(PRIMARY_SESSION) ); primarySession->Flags = PRIMARY_SESSION_FLAG_INITIALIZING; primarySession->ReferenceCount = 1; primarySession->VolDo = VolDo; ExInitializeFastMutex( &primarySession->FastMutex ); InitializeListHead( &primarySession->ListEntry ); primarySession->NetdiskPartitionInformation = SessionInformation->NetdiskPartitionInformation; RtlInitEmptyUnicodeString( &primarySession->NetdiskPartitionInformation.VolumeName, primarySession->NetdiskPartitionInformation.VolumeNameBuffer, sizeof(primarySession->NetdiskPartitionInformation.VolumeNameBuffer) ); if (RtlAppendUnicodeStringToString( &primarySession->NetdiskPartitionInformation.VolumeName, &SessionInformation->NetdiskPartitionInformation.VolumeName) != STATUS_SUCCESS) { ASSERT( NDASFAT_UNEXPECTED ); } ASSERT( primarySession->NetdiskPartitionInformation.VolumeName.Buffer == primarySession->NetdiskPartitionInformation.VolumeNameBuffer ); primarySession->ConnectionFileHandle = SessionInformation->ConnectionFileHandle; primarySession->ConnectionFileObject = SessionInformation->ConnectionFileObject; primarySession->RemoteAddress = SessionInformation->RemoteAddress; primarySession->IsLocalAddress = SessionInformation->IsLocalAddress; primarySession->Irp = Irp; primarySession->SessionContext = SessionInformation->SessionContext; primarySession->SessionContext.PrimaryMaxDataSize = DEFAULT_NDAS_MAX_DATA_SIZE; //SessionInformation->PrimaryMaxDataSize; primarySession->SessionContext.SecondaryMaxDataSize = DEFAULT_NDAS_MAX_DATA_SIZE; // SessionInformation->SecondaryMaxDataSize; DebugTrace2( 0, Dbg2, ("primarySession->ConnectionFileHandle = %x " "primarySession->SessionContext.PrimaryMaxDataSize = %x primarySession->SessionContext.SecondaryMaxDataSize = %x\n", primarySession->ConnectionFileHandle, primarySession->SessionContext.PrimaryMaxDataSize, primarySession->SessionContext.SecondaryMaxDataSize) ); KeInitializeEvent( &primarySession->ReadyEvent, NotificationEvent, FALSE ); InitializeListHead( &primarySession->RequestQueue ); KeInitializeSpinLock( &primarySession->RequestQSpinLock ); KeInitializeEvent( &primarySession->RequestEvent, NotificationEvent, FALSE ); primarySession->ThreadHandle = 0; primarySession->ThreadObject = NULL; primarySession->Thread.TdiReceiveContext.Irp = NULL; KeInitializeEvent( &primarySession->Thread.TdiReceiveContext.CompletionEvent, NotificationEvent, FALSE ); InitializeObjectAttributes( &objectAttributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL ); primarySession->Thread.SessionState = SESSION_TREE_CONNECT; ExInterlockedInsertTailList( &VolDo->PrimarySessionQueue, &primarySession->ListEntry, &VolDo->PrimarySessionQSpinLock ); status = PsCreateSystemThread( &primarySession->ThreadHandle, THREAD_ALL_ACCESS, &objectAttributes, NULL, NULL, PrimarySessionThreadProc, primarySession ); if (!NT_SUCCESS(status)) { leave; } status = ObReferenceObjectByHandle( primarySession->ThreadHandle, FILE_READ_DATA, NULL, KernelMode, &primarySession->ThreadObject, NULL ); if (!NT_SUCCESS(status)) { leave; } timeOut.QuadPart = -NDASFAT_TIME_OUT; status = KeWaitForSingleObject( &primarySession->ReadyEvent, Executive, KernelMode, FALSE, &timeOut ); if (!NT_SUCCESS(status)) { leave; } KeClearEvent( &primarySession->ReadyEvent ); DebugTrace2( 0, Dbg, ("PrimarySession_Create: The primary thread are ready\n") ); DebugTrace2( 0, Dbg2, ("Fat PrimarySession_Create: primarySession = %p\n", primarySession) ); } finally { if (AbnormalTermination()) { status = IrpContext->ExceptionStatus; } if (!NT_SUCCESS(status)) { ASSERT( NDASFAT_UNEXPECTED ); PrimarySession_Close( primarySession ); primarySession = NULL; } } return primarySession; }
BOOLEAN CLog::Init() { BOOLEAN bRet = FALSE; NTSTATUS ntStatus = STATUS_UNSUCCESSFUL; HANDLE hThead = NULL; KdPrintKrnl(LOG_PRINTF_LEVEL_INFO, LOG_RECORED_LEVEL_NEEDNOT, L"begin"); __try { InitializeListHead(&ms_ListHead); KeInitializeSpinLock(&ms_SpLock); ExInitializeResourceLite(&ms_Lock); KeInitializeEvent(&ms_UnloadEvent, NotificationEvent, FALSE); ms_pLogFile = new(MEMORY_TAG_LOG) CKrnlStr; ms_pLogDir = new(MEMORY_TAG_LOG) CKrnlStr; ntStatus = PsCreateSystemThread( &hThead, GENERIC_ALL, NULL, NULL, NULL, ThreadStart, NULL ); if (!NT_SUCCESS(ntStatus)) { KdPrintKrnl(LOG_PRINTF_LEVEL_ERROR, LOG_RECORED_LEVEL_NEEDNOT, L"PsCreateSystemThread failed. (%x)", ntStatus); __leave; } ntStatus = ObReferenceObjectByHandle( hThead, GENERIC_ALL, *PsThreadType, KernelMode, (PVOID *)&ms_pEThread, NULL ); if (!NT_SUCCESS(ntStatus)) { KdPrintKrnl(LOG_PRINTF_LEVEL_ERROR, LOG_RECORED_LEVEL_NEEDNOT, L"ObReferenceObjectByHandle failed. (%x)", ntStatus); __leave; } KeSetBasePriorityThread(ms_pEThread, -4); ms_bCanInsertLog = TRUE; bRet = TRUE; } __finally { // 不要置为NULL if (ms_pEThread) ObDereferenceObject(ms_pEThread); if (hThead) { ZwClose(hThead); hThead = NULL; } if (!bRet) { delete ms_pLogFile; ms_pLogFile = NULL; delete ms_pLogDir; ms_pLogDir = NULL; ExDeleteResourceLite(&ms_Lock); RtlZeroMemory(&ms_Lock, sizeof(ms_Lock)); } } KdPrintKrnl(LOG_PRINTF_LEVEL_INFO, LOG_RECORED_LEVEL_NEEDNOT, L"end"); return bRet; }
/* * @implemented */ BOOLEAN NTAPI FsRtlPrivateLock(IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, IN BOOLEAN FailImmediately, IN BOOLEAN ExclusiveLock, OUT PIO_STATUS_BLOCK IoStatus, IN PIRP Irp OPTIONAL, IN PVOID Context OPTIONAL, IN BOOLEAN AlreadySynchronized) { NTSTATUS Status; COMBINED_LOCK_ELEMENT ToInsert; PCOMBINED_LOCK_ELEMENT Conflict; PLOCK_INFORMATION LockInfo; PLOCK_SHARED_RANGE NewSharedRange; BOOLEAN InsertedNew; ULARGE_INTEGER UnsignedStart; ULARGE_INTEGER UnsignedEnd; DPRINT("FsRtlPrivateLock(%wZ, Offset %08x%08x (%d), Length %08x%08x (%d), Key %x, FailImmediately %u, Exclusive %u)\n", &FileObject->FileName, FileOffset->HighPart, FileOffset->LowPart, (int)FileOffset->QuadPart, Length->HighPart, Length->LowPart, (int)Length->QuadPart, Key, FailImmediately, ExclusiveLock); UnsignedStart.QuadPart = FileOffset->QuadPart; UnsignedEnd.QuadPart = FileOffset->QuadPart + Length->QuadPart; if (UnsignedEnd.QuadPart < UnsignedStart.QuadPart) { DPRINT("File offset out of range\n"); IoStatus->Status = STATUS_INVALID_PARAMETER; if (Irp) { DPRINT("Complete lock %p Status %x\n", Irp, IoStatus->Status); FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } return FALSE; } /* Initialize the lock, if necessary */ if (!FileLock->LockInformation) { LockInfo = ExAllocatePoolWithTag(NonPagedPool, sizeof(LOCK_INFORMATION), TAG_FLOCK); if (!LockInfo) { IoStatus->Status = STATUS_NO_MEMORY; return FALSE; } FileLock->LockInformation = LockInfo; LockInfo->BelongsTo = FileLock; InitializeListHead(&LockInfo->SharedLocks); RtlInitializeGenericTable (&LockInfo->RangeTable, LockCompare, LockAllocate, LockFree, NULL); KeInitializeSpinLock(&LockInfo->CsqLock); InitializeListHead(&LockInfo->CsqList); IoCsqInitializeEx (&LockInfo->Csq, LockInsertIrpEx, LockRemoveIrp, LockPeekNextIrp, LockAcquireQueueLock, LockReleaseQueueLock, LockCompleteCanceledIrp); } LockInfo = FileLock->LockInformation; ToInsert.Exclusive.FileLock.FileObject = FileObject; ToInsert.Exclusive.FileLock.StartingByte = *FileOffset; ToInsert.Exclusive.FileLock.EndingByte.QuadPart = FileOffset->QuadPart + Length->QuadPart; ToInsert.Exclusive.FileLock.ProcessId = Process->UniqueProcessId; ToInsert.Exclusive.FileLock.Key = Key; ToInsert.Exclusive.FileLock.ExclusiveLock = ExclusiveLock; Conflict = RtlInsertElementGenericTable (FileLock->LockInformation, &ToInsert, sizeof(ToInsert), &InsertedNew); if (Conflict && !InsertedNew) { if (Conflict->Exclusive.FileLock.ExclusiveLock || ExclusiveLock) { DPRINT("Conflict %08x%08x:%08x%08x Exc %u (Want Exc %u)\n", Conflict->Exclusive.FileLock.StartingByte.HighPart, Conflict->Exclusive.FileLock.StartingByte.LowPart, Conflict->Exclusive.FileLock.EndingByte.HighPart, Conflict->Exclusive.FileLock.EndingByte.LowPart, Conflict->Exclusive.FileLock.ExclusiveLock, ExclusiveLock); if (FailImmediately) { DPRINT("STATUS_FILE_LOCK_CONFLICT\n"); IoStatus->Status = STATUS_FILE_LOCK_CONFLICT; if (Irp) { DPRINT("STATUS_FILE_LOCK_CONFLICT: Complete\n"); FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } return FALSE; } else { IoStatus->Status = STATUS_PENDING; if (Irp) { Irp->IoStatus.Information = LockInfo->Generation; IoMarkIrpPending(Irp); IoCsqInsertIrpEx (&LockInfo->Csq, Irp, NULL, NULL); } } return FALSE; } else { ULONG i; /* We know of at least one lock in range that's shared. We need to * find out if any more exist and any are exclusive. */ for (i = 0; i < RtlNumberGenericTableElements(&LockInfo->RangeTable); i++) { Conflict = RtlGetElementGenericTable(&LockInfo->RangeTable, i); /* The first argument will be inserted as a shared range */ if (Conflict && (LockCompare(&LockInfo->RangeTable, Conflict, &ToInsert) == GenericEqual)) { if (Conflict->Exclusive.FileLock.ExclusiveLock) { /* Found an exclusive match */ if (FailImmediately) { IoStatus->Status = STATUS_FILE_LOCK_CONFLICT; DPRINT("STATUS_FILE_LOCK_CONFLICT\n"); if (Irp) { DPRINT("STATUS_FILE_LOCK_CONFLICT: Complete\n"); FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } } else { IoStatus->Status = STATUS_PENDING; if (Irp) { IoMarkIrpPending(Irp); IoCsqInsertIrpEx (&LockInfo->Csq, Irp, NULL, NULL); } } return FALSE; } } } DPRINT("Overlapping shared lock %wZ %08x%08x %08x%08x\n", &FileObject->FileName, Conflict->Exclusive.FileLock.StartingByte.HighPart, Conflict->Exclusive.FileLock.StartingByte.LowPart, Conflict->Exclusive.FileLock.EndingByte.HighPart, Conflict->Exclusive.FileLock.EndingByte.LowPart); Conflict = FsRtlpRebuildSharedLockRange(FileLock, LockInfo, &ToInsert); if (!Conflict) { IoStatus->Status = STATUS_NO_MEMORY; if (Irp) { FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } } /* We got here because there were only overlapping shared locks */ /* A shared lock is both a range *and* a list entry. Insert the entry here. */ DPRINT("Adding shared lock %wZ\n", &FileObject->FileName); NewSharedRange = ExAllocatePoolWithTag(NonPagedPool, sizeof(*NewSharedRange), TAG_RANGE); if (!NewSharedRange) { IoStatus->Status = STATUS_NO_MEMORY; if (Irp) { FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } return FALSE; } DPRINT("Adding shared lock %wZ\n", &FileObject->FileName); NewSharedRange->Start = *FileOffset; NewSharedRange->End.QuadPart = FileOffset->QuadPart + Length->QuadPart; NewSharedRange->Key = Key; NewSharedRange->ProcessId = ToInsert.Exclusive.FileLock.ProcessId; InsertTailList(&LockInfo->SharedLocks, &NewSharedRange->Entry); DPRINT("Acquired shared lock %wZ %08x%08x %08x%08x\n", &FileObject->FileName, Conflict->Exclusive.FileLock.StartingByte.HighPart, Conflict->Exclusive.FileLock.StartingByte.LowPart, Conflict->Exclusive.FileLock.EndingByte.HighPart, Conflict->Exclusive.FileLock.EndingByte.LowPart); IoStatus->Status = STATUS_SUCCESS; if (Irp) { FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } return TRUE; } } else if (!Conflict) { /* Conflict here is (or would be) the newly inserted element, but we ran * out of space probably. */ IoStatus->Status = STATUS_NO_MEMORY; if (Irp) { FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } return FALSE; } else { DPRINT("Inserted new lock %wZ %08x%08x %08x%08x exclusive %u\n", &FileObject->FileName, Conflict->Exclusive.FileLock.StartingByte.HighPart, Conflict->Exclusive.FileLock.StartingByte.LowPart, Conflict->Exclusive.FileLock.EndingByte.HighPart, Conflict->Exclusive.FileLock.EndingByte.LowPart, Conflict->Exclusive.FileLock.ExclusiveLock); if (!ExclusiveLock) { NewSharedRange = ExAllocatePoolWithTag(NonPagedPool, sizeof(*NewSharedRange), TAG_RANGE); if (!NewSharedRange) { IoStatus->Status = STATUS_NO_MEMORY; if (Irp) { FsRtlCompleteLockIrpReal (FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); } return FALSE; } DPRINT("Adding shared lock %wZ\n", &FileObject->FileName); NewSharedRange->Start = *FileOffset; NewSharedRange->End.QuadPart = FileOffset->QuadPart + Length->QuadPart; NewSharedRange->Key = Key; NewSharedRange->ProcessId = Process->UniqueProcessId; InsertTailList(&LockInfo->SharedLocks, &NewSharedRange->Entry); } /* Assume all is cool, and lock is set */ IoStatus->Status = STATUS_SUCCESS; if (Irp) { /* Complete the request */ FsRtlCompleteLockIrpReal(FileLock->CompleteLockIrpRoutine, Context, Irp, IoStatus->Status, &Status, FileObject); /* Update the status */ IoStatus->Status = Status; } } return TRUE; }
/** This is the declaration of an EFI image entry point. This entry point is the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers, including both device drivers and bus drivers. The entry point for the IfConfig6 application which parses the command line input and calls the IfConfig6 process. @param[in] ImageHandle The image handle of this application. @param[in] SystemTable The pointer to the EFI System Table. @retval EFI_SUCCESS The operation completed successfully. @retval Others Some errors occur. **/ EFI_STATUS EFIAPI IfConfig6Initialize ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; IFCONFIG6_PRIVATE_DATA *Private; LIST_ENTRY *ParamPackage; CONST CHAR16 *ValueStr; ARG_LIST *ArgList; CHAR16 *ProblemParam; CHAR16 *Str; Private = NULL; // // Register our string package with HII and return the handle to it. // mHiiHandle = HiiAddPackages (&gEfiCallerIdGuid, ImageHandle, IfConfig6Strings, NULL); ASSERT (mHiiHandle != NULL); Status = ShellCommandLineParseEx (mIfConfig6CheckList, &ParamPackage, &ProblemParam, TRUE, FALSE); if (EFI_ERROR (Status)) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_IFCONFIG6_ERR_INVALID_COMMAND), mHiiHandle, ProblemParam); goto ON_EXIT; } // // To handle no option. // if (!ShellCommandLineGetFlag (ParamPackage, L"-r") && !ShellCommandLineGetFlag (ParamPackage, L"-s") && !ShellCommandLineGetFlag (ParamPackage, L"-?") && !ShellCommandLineGetFlag (ParamPackage, L"-l")) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_IFCONFIG6_LACK_OPTION), mHiiHandle); goto ON_EXIT; } // // To handle conflict options. // if (((ShellCommandLineGetFlag (ParamPackage, L"-r")) && (ShellCommandLineGetFlag (ParamPackage, L"-s"))) || ((ShellCommandLineGetFlag (ParamPackage, L"-r")) && (ShellCommandLineGetFlag (ParamPackage, L"-l"))) || ((ShellCommandLineGetFlag (ParamPackage, L"-r")) && (ShellCommandLineGetFlag (ParamPackage, L"-?"))) || ((ShellCommandLineGetFlag (ParamPackage, L"-s")) && (ShellCommandLineGetFlag (ParamPackage, L"-l"))) || ((ShellCommandLineGetFlag (ParamPackage, L"-s")) && (ShellCommandLineGetFlag (ParamPackage, L"-?"))) || ((ShellCommandLineGetFlag (ParamPackage, L"-l")) && (ShellCommandLineGetFlag (ParamPackage, L"-?")))) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_IFCONFIG6_CONFLICT_OPTIONS), mHiiHandle); goto ON_EXIT; } // // To show the help information of ifconfig6 command. // if (ShellCommandLineGetFlag (ParamPackage, L"-?")) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_IFCONFIG6_HELP), mHiiHandle); goto ON_EXIT; } Status = EFI_INVALID_PARAMETER; Private = AllocateZeroPool (sizeof (IFCONFIG6_PRIVATE_DATA)); if (Private == NULL) { Status = EFI_OUT_OF_RESOURCES; goto ON_EXIT; } InitializeListHead (&Private->IfList); // // To get interface name for the list option. // if (ShellCommandLineGetFlag (ParamPackage, L"-l")) { Private->OpCode = IfConfig6OpList; ValueStr = ShellCommandLineGetValue (ParamPackage, L"-l"); if (ValueStr != NULL) { Str = (CHAR16 *) AllocateZeroPool (StrSize (ValueStr)); ASSERT (Str != NULL); Str = StrCpy (Str, ValueStr); Private->IfName = Str; } } // // To get interface name for the clear option. // if (ShellCommandLineGetFlag (ParamPackage, L"-r")) { Private->OpCode = IfConfig6OpClear; ValueStr = ShellCommandLineGetValue (ParamPackage, L"-r"); if (ValueStr != NULL) { Str = (CHAR16 *) AllocateZeroPool (StrSize (ValueStr)); ASSERT (Str != NULL); Str = StrCpy (Str, ValueStr); Private->IfName = Str; } } // // To get interface name and corresponding Args for the set option. // if (ShellCommandLineGetFlag (ParamPackage, L"-s")) { ValueStr = ShellCommandLineGetValue (ParamPackage, L"-s"); if (ValueStr == NULL) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_IFCONFIG6_ERR_LACK_INTERFACE), mHiiHandle); goto ON_EXIT; } // // To split the configuration into multi-section. // ArgList = SplitStrToList (ValueStr, L' '); ASSERT (ArgList != NULL); Private->OpCode = IfConfig6OpSet; Private->IfName = ArgList->Arg; Private->VarArg = ArgList->Next; if (Private->IfName == NULL || Private->VarArg == NULL) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_IFCONFIG6_ERR_LACK_COMMAND), mHiiHandle); goto ON_EXIT; } } // // Main process of ifconfig6. // Status = IfConfig6 (Private); ON_EXIT: ShellCommandLineFreeVarList (ParamPackage); HiiRemovePackages (mHiiHandle); if (Private != NULL) IfConfig6Cleanup (Private); return Status; }
int TestInterlockedDList(int argc, char* argv[]) { ULONG Count; PLIST_ITEM pListItem; PLIST_ENTRY pListHead; PLIST_ENTRY pListEntry; pListHead = (PLIST_ENTRY) _aligned_malloc(sizeof(LIST_ENTRY), MEMORY_ALLOCATION_ALIGNMENT); if (!pListHead) { printf("Memory allocation failed.\n"); return -1; } InitializeListHead(pListHead); if (!IsListEmpty(pListHead)) { printf("Expected empty list\n"); return -1; } /* InsertHeadList / RemoveHeadList */ printf("InsertHeadList / RemoveHeadList\n"); for (Count = 1; Count <= 10; Count += 1) { pListItem = (PLIST_ITEM) _aligned_malloc(sizeof(LIST_ITEM), MEMORY_ALLOCATION_ALIGNMENT); pListItem->Signature = Count; InsertHeadList(pListHead, &(pListItem->ItemEntry)); } for (Count = 10; Count >= 1; Count -= 1) { pListEntry = RemoveHeadList(pListHead); pListItem = (PLIST_ITEM) pListEntry; _aligned_free(pListEntry); } /* InsertTailList / RemoveTailList */ printf("InsertTailList / RemoveTailList\n"); for (Count = 1; Count <= 10; Count += 1) { pListItem = (PLIST_ITEM) _aligned_malloc(sizeof(LIST_ITEM), MEMORY_ALLOCATION_ALIGNMENT); pListItem->Signature = Count; InsertTailList(pListHead, &(pListItem->ItemEntry)); } for (Count = 10; Count >= 1; Count -= 1) { pListEntry = RemoveTailList(pListHead); pListItem = (PLIST_ITEM) pListEntry; _aligned_free(pListEntry); } _aligned_free(pListHead); return 0; }
/** Opens a new file relative to the source file's location. @param This A pointer to the EFI_FILE_PROTOCOL instance that is the file handle to the source location. This would typically be an open handle to a directory. @param NewHandle A pointer to the location to return the opened handle for the new file. @param FileName The Null-terminated string of the name of the file to be opened. The file name may contain the following path modifiers: "\", ".", and "..". @param OpenMode The mode to open the file. The only valid combinations that the file may be opened with are: Read, Read/Write, or Create/Read/Write. @param Attributes Only valid for EFI_FILE_MODE_CREATE, in which case these are the attribute bits for the newly created file. @retval EFI_SUCCESS The file was opened. @retval EFI_NOT_FOUND The specified file could not be found on the device. @retval EFI_NO_MEDIA The device has no medium. @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no longer supported. @retval EFI_DEVICE_ERROR The device reported an error. @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write when the media is write-protected. @retval EFI_ACCESS_DENIED The service denied access to the file. @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. @retval EFI_VOLUME_FULL The volume is full. **/ EFI_STATUS EFIAPI FvSimpleFileSystemOpen ( IN EFI_FILE_PROTOCOL *This, OUT EFI_FILE_PROTOCOL **NewHandle, IN CHAR16 *FileName, IN UINT64 OpenMode, IN UINT64 Attributes ) { FV_FILESYSTEM_INSTANCE *Instance; FV_FILESYSTEM_FILE *File; FV_FILESYSTEM_FILE *NewFile; FV_FILESYSTEM_FILE_INFO *FvFileInfo; LIST_ENTRY *FvFileInfoLink; EFI_STATUS Status; UINTN FileNameLength; UINTN NewFileNameLength; CHAR16 *FileNameWithExtension; // // Check for a valid mode // switch (OpenMode) { case EFI_FILE_MODE_READ: break; default: return EFI_WRITE_PROTECTED; } File = FVFS_FILE_FROM_FILE_THIS (This); Instance = File->Instance; FileName = TrimFilePathToAbsolutePath (FileName); if (FileName == NULL) { return EFI_INVALID_PARAMETER; } if (FileName[0] == L'\\') { FileName++; } // // Check for opening root // if (StrCmp (FileName, L".") == 0 || StrCmp (FileName, L"") == 0) { NewFile = AllocateZeroPool (sizeof (FV_FILESYSTEM_FILE)); if (NewFile == NULL) { return EFI_OUT_OF_RESOURCES; } NewFile->Signature = FVFS_FILE_SIGNATURE; NewFile->Instance = Instance; NewFile->FvFileInfo = File->FvFileInfo; CopyMem (&NewFile->FileProtocol, &mFileSystemTemplate, sizeof (mFileSystemTemplate)); InitializeListHead (&NewFile->Link); InsertHeadList (&Instance->FileHead, &NewFile->Link); NewFile->DirReadNext = NULL; if (!IsListEmpty (&Instance->FileInfoHead)) { NewFile->DirReadNext = FVFS_GET_FIRST_FILE_INFO (Instance); } *NewHandle = &NewFile->FileProtocol; return EFI_SUCCESS; } // // Do a linear search for a file in the FV with a matching filename // Status = EFI_NOT_FOUND; FvFileInfo = NULL; for (FvFileInfoLink = GetFirstNode (&Instance->FileInfoHead); !IsNull (&Instance->FileInfoHead, FvFileInfoLink); FvFileInfoLink = GetNextNode (&Instance->FileInfoHead, FvFileInfoLink)) { FvFileInfo = FVFS_FILE_INFO_FROM_LINK (FvFileInfoLink); if (mUnicodeCollation->StriColl (mUnicodeCollation, &FvFileInfo->FileInfo.FileName[0], FileName) == 0) { Status = EFI_SUCCESS; break; } } // If the file has not been found check if the filename exists with an extension // in case there was no extension present. // FvFileSystem adds a 'virtual' extension '.EFI' to EFI applications and drivers // present in the Firmware Volume if (Status == EFI_NOT_FOUND) { FileNameLength = StrLen (FileName); // Does the filename already contain the '.EFI' extension? if (mUnicodeCollation->StriColl (mUnicodeCollation, FileName + FileNameLength - 4, L".efi") != 0) { // No, there was no extension. So add one and search again for the file // NewFileNameLength = FileNameLength + 1 + 4 = (Number of non-null character) + (file extension) + (a null character) NewFileNameLength = FileNameLength + 1 + 4; FileNameWithExtension = AllocatePool (NewFileNameLength * 2); StrCpyS (FileNameWithExtension, NewFileNameLength, FileName); StrCatS (FileNameWithExtension, NewFileNameLength, L".EFI"); for (FvFileInfoLink = GetFirstNode (&Instance->FileInfoHead); !IsNull (&Instance->FileInfoHead, FvFileInfoLink); FvFileInfoLink = GetNextNode (&Instance->FileInfoHead, FvFileInfoLink)) { FvFileInfo = FVFS_FILE_INFO_FROM_LINK (FvFileInfoLink); if (mUnicodeCollation->StriColl (mUnicodeCollation, &FvFileInfo->FileInfo.FileName[0], FileNameWithExtension) == 0) { Status = EFI_SUCCESS; break; } } } } if (!EFI_ERROR (Status)) { NewFile = AllocateZeroPool (sizeof (FV_FILESYSTEM_FILE)); if (NewFile == NULL) { return EFI_OUT_OF_RESOURCES; } NewFile->Signature = FVFS_FILE_SIGNATURE; NewFile->Instance = Instance; NewFile->FvFileInfo = FvFileInfo; CopyMem (&NewFile->FileProtocol, &mFileSystemTemplate, sizeof (mFileSystemTemplate)); InitializeListHead (&NewFile->Link); InsertHeadList (&Instance->FileHead, &NewFile->Link); *NewHandle = &NewFile->FileProtocol; return EFI_SUCCESS; } return EFI_NOT_FOUND; }
LONG RegCreateKey(FRLDRHKEY ParentKey, PCWSTR KeyName, PFRLDRHKEY Key) { PLIST_ENTRY Ptr; FRLDRHKEY SearchKey = NULL; FRLDRHKEY CurrentKey; FRLDRHKEY NewKey; PWCHAR p; PCWSTR name; int subkeyLength; int stringLength; ULONG NameSize; int CmpResult; TRACE("KeyName '%S'\n", KeyName); if (*KeyName == L'\\') { KeyName++; CurrentKey = RootKey; } else if (ParentKey == NULL) { CurrentKey = RootKey; } else { CurrentKey = ParentKey; } /* Check whether current key is a link */ if (CurrentKey->DataType == REG_LINK) { CurrentKey = (FRLDRHKEY)CurrentKey->Data; } while (*KeyName != 0) { TRACE("KeyName '%S'\n", KeyName); if (*KeyName == L'\\') KeyName++; p = wcschr(KeyName, L'\\'); if ((p != NULL) && (p != KeyName)) { subkeyLength = p - KeyName; stringLength = subkeyLength + 1; name = KeyName; } else { subkeyLength = wcslen(KeyName); stringLength = subkeyLength; name = KeyName; } NameSize = (subkeyLength + 1) * sizeof(WCHAR); Ptr = CurrentKey->SubKeyList.Flink; CmpResult = 1; while (Ptr != &CurrentKey->SubKeyList) { TRACE("Ptr 0x%x\n", Ptr); SearchKey = CONTAINING_RECORD(Ptr, KEY, KeyList); TRACE("SearchKey 0x%x\n", SearchKey); TRACE("Searching '%S'\n", SearchKey->Name); CmpResult = _wcsnicmp(SearchKey->Name, name, subkeyLength); if (CmpResult == 0 && SearchKey->NameSize == NameSize) break; else if (CmpResult == -1) break; Ptr = Ptr->Flink; } if (CmpResult != 0) { /* no key found -> create new subkey */ NewKey = MmHeapAlloc(sizeof(KEY)); if (NewKey == NULL) return ERROR_OUTOFMEMORY; InitializeListHead(&NewKey->SubKeyList); InitializeListHead(&NewKey->ValueList); NewKey->SubKeyCount = 0; NewKey->ValueCount = 0; NewKey->DataType = 0; NewKey->DataSize = 0; NewKey->Data = NULL; InsertTailList(Ptr, &NewKey->KeyList); CurrentKey->SubKeyCount++; NewKey->NameSize = NameSize; NewKey->Name = (PWCHAR)MmHeapAlloc(NewKey->NameSize); if (NewKey->Name == NULL) return ERROR_OUTOFMEMORY; memcpy(NewKey->Name, name, NewKey->NameSize - sizeof(WCHAR)); NewKey->Name[subkeyLength] = 0; TRACE("NewKey 0x%x\n", NewKey); TRACE("NewKey '%S' Length %d\n", NewKey->Name, NewKey->NameSize); CurrentKey = NewKey; } else { CurrentKey = SearchKey; /* Check whether current key is a link */ if (CurrentKey->DataType == REG_LINK) { CurrentKey = (FRLDRHKEY)CurrentKey->Data; } } KeyName = KeyName + stringLength; } if (Key != NULL) *Key = CurrentKey; return ERROR_SUCCESS; }
EFI_STATUS FatAllocateVolume ( IN EFI_HANDLE Handle, IN EFI_DISK_IO_PROTOCOL *DiskIo, IN EFI_BLOCK_IO_PROTOCOL *BlockIo ) /*++ Routine Description: Allocates volume structure, detects FAT file system, installs protocol, and initialize cache. Arguments: Handle - The handle of parent device. DiskIo - The DiskIo of parent device. BlockIo - The BlockIo of parent devicel Returns: EFI_SUCCESS - Allocate a new volume successfully. EFI_OUT_OF_RESOURCES - Can not allocate the memory. Others - Allocating a new volume failed. --*/ { EFI_STATUS Status; FAT_VOLUME *Volume; // // Allocate a volume structure // Volume = AllocateZeroPool (sizeof (FAT_VOLUME)); if (Volume == NULL) { return EFI_OUT_OF_RESOURCES; } // // Initialize the structure // Volume->Signature = FAT_VOLUME_SIGNATURE; Volume->Handle = Handle; Volume->DiskIo = DiskIo; Volume->BlockIo = BlockIo; Volume->MediaId = BlockIo->Media->MediaId; Volume->ReadOnly = BlockIo->Media->ReadOnly; Volume->VolumeInterface.Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION; Volume->VolumeInterface.OpenVolume = FatOpenVolume; InitializeListHead (&Volume->CheckRef); InitializeListHead (&Volume->DirCacheList); // // Initialize Root Directory entry // Volume->RootDirEnt.FileString = Volume->RootFileString; Volume->RootDirEnt.Entry.Attributes = FAT_ATTRIBUTE_DIRECTORY; // // Check to see if there's a file system on the volume // Status = FatOpenDevice (Volume); if (EFI_ERROR (Status)) { goto Done; } // // Initialize cache // Status = FatInitializeDiskCache (Volume); if (EFI_ERROR (Status)) { goto Done; } // // Install our protocol interfaces on the device's handle // Status = gBS->InstallMultipleProtocolInterfaces ( &Volume->Handle, &gEfiSimpleFileSystemProtocolGuid, &Volume->VolumeInterface, NULL ); if (EFI_ERROR (Status)) { goto Done; } // // Volume installed // DEBUG ((EFI_D_INIT, "Installed Fat filesystem on %p\n", Handle)); Volume->Valid = TRUE; Done: if (EFI_ERROR (Status)) { FatFreeVolume (Volume); } return Status; }
NTSTATUS CreateThread( IN PDEVICE_OBJECT DeviceObject ) { PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension; HANDLE thread_handle; NTSTATUS status; // //create thread and set spin lock // ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL); InitializeListHead(&deviceExtension->list_head); KeInitializeSpinLock(&deviceExtension->list_lock); KeInitializeEvent(&deviceExtension->PagingPathCountEvent, NotificationEvent, TRUE); KeInitializeEvent(&deviceExtension->request_event, SynchronizationEvent,FALSE); deviceExtension->terminate_thread = FALSE; status = PsCreateSystemThread( &thread_handle, (ACCESS_MASK) 0L, NULL, NULL, NULL, Thread, DeviceObject ); if (!NT_SUCCESS(status)) { //DeleteDevice(DeviceObject); return status; } status = ObReferenceObjectByHandle( thread_handle, THREAD_ALL_ACCESS, NULL, KernelMode, &deviceExtension->thread_pointer, NULL ); if (!NT_SUCCESS(status)) { ZwClose(thread_handle); deviceExtension->terminate_thread = TRUE; KeSetEvent( &deviceExtension->request_event, (KPRIORITY) 0, FALSE ); return status; } ZwClose(thread_handle); return status; }
static NTSTATUS UcaAllocateContext(_In_ FLT_CONTEXT_TYPE ContextType, _Outptr_ PFLT_CONTEXT *Context) { PUCA_TRANSACTION_CONTEXT TransactionContext; NTSTATUS Status; PAGED_CODE(); switch (ContextType) { case FLT_STREAM_CONTEXT: /* Allocate stream context */ Status = FltAllocateContext(DriverData.FilterHandle, FLT_STREAM_CONTEXT, sizeof(UCA_STREAM_CONTEXT), UCA_CONTEXT_POOL_TYPE, Context); if (NT_SUCCESS(Status)) { RtlZeroMemory(*Context, sizeof(UCA_STREAM_CONTEXT)); FltInitializePushLock(&((PUCA_STREAM_CONTEXT)*Context)->Lock); } break; case FLT_FILE_CONTEXT: /* Allocate file context */ Status = FltAllocateContext(DriverData.FilterHandle, FLT_FILE_CONTEXT, sizeof(UCA_STREAM_CONTEXT), UCA_CONTEXT_POOL_TYPE, Context); if (NT_SUCCESS(Status)) { RtlZeroMemory(*Context, sizeof(UCA_STREAM_CONTEXT)); FltInitializePushLock(&((PUCA_STREAM_CONTEXT)*Context)->Lock); } break; case FLT_TRANSACTION_CONTEXT: /* Allocate transaction context */ Status = FltAllocateContext(DriverData.FilterHandle, FLT_TRANSACTION_CONTEXT, sizeof(UCA_TRANSACTION_CONTEXT), UCA_CONTEXT_POOL_TYPE, Context); if (NT_SUCCESS(Status)) { TransactionContext = (PUCA_TRANSACTION_CONTEXT)*Context; /* Zero the memory */ RtlZeroMemory(TransactionContext, sizeof(UCA_TRANSACTION_CONTEXT)); /* Initialize the notify list */ InitializeListHead(&TransactionContext->DeleteNotifyList); /* The resource needs to be in NPP */ TransactionContext->Resource = (PERESOURCE)ExAllocatePoolWithTag(NonPagedPool, sizeof(ERESOURCE), UCA_ERESOURCE_POOL_TAG); if (TransactionContext->Resource == NULL) { FltReleaseContext(TransactionContext); return STATUS_INSUFFICIENT_RESOURCES; } /* Initialize the lock */ ExInitializeResourceLite(TransactionContext->Resource); } break; case FLT_INSTANCE_CONTEXT: /* Allocate instance context */ Status = FltAllocateContext(DriverData.FilterHandle, FLT_INSTANCE_CONTEXT, sizeof(UCA_INSTANCE_CONTEXT), UCA_CONTEXT_POOL_TYPE, Context); if (NT_SUCCESS(Status)) { RtlZeroMemory(*Context, sizeof(UCA_INSTANCE_CONTEXT)); } break; default: Status = STATUS_INVALID_PARAMETER; break; } return Status; }
ULONG VirtIoFindAdapter( IN PVOID DeviceExtension, IN PVOID HwContext, IN PVOID BusInformation, IN PCHAR ArgumentString, IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo, OUT PBOOLEAN Again ) { PACCESS_RANGE accessRange; PADAPTER_EXTENSION adaptExt; ULONG_PTR deviceBase; ULONG allocationSize; ULONG pageNum; #ifdef MSI_SUPPORTED PPCI_COMMON_CONFIG pPciConf = NULL; UCHAR pci_cfg_buf[256]; ULONG pci_cfg_len; #endif UNREFERENCED_PARAMETER( HwContext ); UNREFERENCED_PARAMETER( BusInformation ); UNREFERENCED_PARAMETER( ArgumentString ); UNREFERENCED_PARAMETER( Again ); adaptExt = (PADAPTER_EXTENSION)DeviceExtension; adaptExt->dump_mode = IsCrashDumpMode; ConfigInfo->Master = TRUE; ConfigInfo->ScatterGather = TRUE; ConfigInfo->DmaWidth = Width32Bits; ConfigInfo->Dma32BitAddresses = TRUE; ConfigInfo->Dma64BitAddresses = TRUE; ConfigInfo->WmiDataProvider = FALSE; ConfigInfo->AlignmentMask = 0x3; #ifdef USE_STORPORT ConfigInfo->MapBuffers = STOR_MAP_NON_READ_WRITE_BUFFERS; ConfigInfo->SynchronizationModel = StorSynchronizeFullDuplex; #ifdef MSI_SUPPORTED ConfigInfo->HwMSInterruptRoutine = VirtIoMSInterruptRoutine; ConfigInfo->InterruptSynchronizationMode=InterruptSynchronizePerMessage; #endif #else ConfigInfo->MapBuffers = TRUE; #endif accessRange = &(*ConfigInfo->AccessRanges)[0]; ASSERT (FALSE == accessRange->RangeInMemory) ; RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("Port Resource [%08I64X-%08I64X]\n", accessRange->RangeStart.QuadPart, accessRange->RangeStart.QuadPart + accessRange->RangeLength)); if ( accessRange->RangeLength < IO_PORT_LENGTH) { LogError(DeviceExtension, SP_INTERNAL_ADAPTER_ERROR, __LINE__); RhelDbgPrint(TRACE_LEVEL_FATAL, ("Wrong access range %x bytes\n", accessRange->RangeLength)); return SP_RETURN_NOT_FOUND; } #ifndef USE_STORPORT if (!ScsiPortValidateRange(DeviceExtension, ConfigInfo->AdapterInterfaceType, ConfigInfo->SystemIoBusNumber, accessRange->RangeStart, accessRange->RangeLength, (BOOLEAN)!accessRange->RangeInMemory)) { LogError(DeviceExtension, SP_INTERNAL_ADAPTER_ERROR, __LINE__); RhelDbgPrint(TRACE_LEVEL_FATAL, ("Range validation failed %x for %x bytes\n", (*ConfigInfo->AccessRanges)[0].RangeStart.LowPart, (*ConfigInfo->AccessRanges)[0].RangeLength)); return SP_RETURN_ERROR; } #endif ConfigInfo->NumberOfBuses = 1; ConfigInfo->MaximumNumberOfTargets = 1; ConfigInfo->MaximumNumberOfLogicalUnits = 1; deviceBase = (ULONG_PTR)ScsiPortGetDeviceBase(DeviceExtension, ConfigInfo->AdapterInterfaceType, ConfigInfo->SystemIoBusNumber, accessRange->RangeStart, accessRange->RangeLength, (BOOLEAN)!accessRange->RangeInMemory); if (deviceBase == (ULONG_PTR)NULL) { LogError(DeviceExtension, SP_INTERNAL_ADAPTER_ERROR, __LINE__); RhelDbgPrint(TRACE_LEVEL_FATAL, ("Couldn't map %x for %x bytes\n", (*ConfigInfo->AccessRanges)[0].RangeStart.LowPart, (*ConfigInfo->AccessRanges)[0].RangeLength)); return SP_RETURN_ERROR; } VirtIODeviceInitialize(&adaptExt->vdev, deviceBase, sizeof(adaptExt->vdev)); VirtIODeviceAddStatus(&adaptExt->vdev, VIRTIO_CONFIG_S_DRIVER); adaptExt->msix_enabled = FALSE; #ifdef MSI_SUPPORTED pci_cfg_len = StorPortGetBusData (DeviceExtension, PCIConfiguration, ConfigInfo->SystemIoBusNumber, (ULONG)ConfigInfo->SlotNumber, (PVOID)pci_cfg_buf, (ULONG)256); if (pci_cfg_len == 256) { UCHAR CapOffset; PPCI_MSIX_CAPABILITY pMsixCapOffset; pPciConf = (PPCI_COMMON_CONFIG)pci_cfg_buf; if ( (pPciConf->Status & PCI_STATUS_CAPABILITIES_LIST) == 0) { RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("NO CAPABILITIES_LIST\n")); } else { if ( (pPciConf->HeaderType & (~PCI_MULTIFUNCTION)) == PCI_DEVICE_TYPE ) { CapOffset = pPciConf->u.type0.CapabilitiesPtr; while (CapOffset != 0) { pMsixCapOffset = (PPCI_MSIX_CAPABILITY)(pci_cfg_buf + CapOffset); if ( pMsixCapOffset->Header.CapabilityID == PCI_CAPABILITY_ID_MSIX ) { RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageControl.TableSize = %d\n", pMsixCapOffset->MessageControl.TableSize)); RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageControl.FunctionMask = %d\n", pMsixCapOffset->MessageControl.FunctionMask)); RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageControl.MSIXEnable = %d\n", pMsixCapOffset->MessageControl.MSIXEnable)); RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("MessageTable = %p\n", pMsixCapOffset->MessageTable)); RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("PBATable = %d\n", pMsixCapOffset->PBATable)); adaptExt->msix_enabled = (pMsixCapOffset->MessageControl.MSIXEnable == 1); break; } else { CapOffset = pMsixCapOffset->Header.Next; RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("CapabilityID = %x, Next CapOffset = %x\n", pMsixCapOffset->Header.CapabilityID, CapOffset)); } } VirtIODeviceSetMSIXUsed(&adaptExt->vdev, adaptExt->msix_enabled); } else { RhelDbgPrint(TRACE_LEVEL_FATAL, ("NOT A PCI_DEVICE_TYPE\n")); } } } else { RhelDbgPrint(TRACE_LEVEL_FATAL, ("CANNOT READ PCI CONFIGURATION SPACE %d\n", pci_cfg_len)); } #endif VirtIODeviceReset(&adaptExt->vdev); VirtIODeviceAddStatus(&adaptExt->vdev, VIRTIO_CONFIG_S_ACKNOWLEDGE); WriteVirtIODeviceWord(adaptExt->vdev.addr + VIRTIO_PCI_QUEUE_SEL, (USHORT)0); if (adaptExt->dump_mode) { WriteVirtIODeviceWord(adaptExt->vdev.addr + VIRTIO_PCI_QUEUE_PFN, (USHORT)0); } adaptExt->features = ReadVirtIODeviceRegister(adaptExt->vdev.addr + VIRTIO_PCI_HOST_FEATURES); ConfigInfo->CachesData = CHECKBIT(adaptExt->features, VIRTIO_BLK_F_WCACHE) ? TRUE : FALSE; if (ConfigInfo->CachesData) { u32 GuestFeatures = 0; VirtIOFeatureEnable(GuestFeatures, VIRTIO_BLK_F_WCACHE); VirtIODeviceWriteGuestFeatures(&adaptExt->vdev, GuestFeatures); } RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("VIRTIO_BLK_F_WCACHE = %d\n", ConfigInfo->CachesData)); VirtIODeviceQueryQueueAllocation(&adaptExt->vdev, 0, &pageNum, &allocationSize); if(adaptExt->dump_mode) { ConfigInfo->NumberOfPhysicalBreaks = 8; } else { ConfigInfo->NumberOfPhysicalBreaks = MAX_PHYS_SEGMENTS + 1; } ConfigInfo->MaximumTransferLength = 0x00FFFFFF; adaptExt->queue_depth = pageNum / ConfigInfo->NumberOfPhysicalBreaks - 1; #if (INDIRECT_SUPPORTED) if(!adaptExt->dump_mode) { adaptExt->indirect = CHECKBIT(adaptExt->features, VIRTIO_RING_F_INDIRECT_DESC); } if(adaptExt->indirect) { adaptExt->queue_depth = pageNum; } #else adaptExt->indirect = 0; #endif RhelDbgPrint(TRACE_LEVEL_INFORMATION, ("breaks_number = %x queue_depth = %x\n", ConfigInfo->NumberOfPhysicalBreaks, adaptExt->queue_depth)); adaptExt->uncachedExtensionVa = ScsiPortGetUncachedExtension(DeviceExtension, ConfigInfo, allocationSize); if (!adaptExt->uncachedExtensionVa) { LogError(DeviceExtension, SP_INTERNAL_ADAPTER_ERROR, __LINE__); RhelDbgPrint(TRACE_LEVEL_FATAL, ("Couldn't get uncached extension\n")); return SP_RETURN_ERROR; } InitializeListHead(&adaptExt->list_head); #ifdef USE_STORPORT InitializeListHead(&adaptExt->complete_list); #endif return SP_RETURN_FOUND; }
/*! \brief Initializes the KDB symbols implementation. * * \param DispatchTable Pointer to the KD dispatch table * \param BootPhase Phase of initialization */ VOID NTAPI KdbInitialize( PKD_DISPATCH_TABLE DispatchTable, ULONG BootPhase) { PCHAR p1, p2; SHORT Found = FALSE; CHAR YesNo; PLDR_DATA_TABLE_ENTRY LdrEntry; DPRINT("KdbSymInit() BootPhase=%d\n", BootPhase); LoadSymbols = FALSE; #if DBG /* Load symbols only if we have 96Mb of RAM or more */ if (MmNumberOfPhysicalPages >= 0x6000) LoadSymbols = TRUE; #endif if (BootPhase == 0) { /* Write out the functions that we support for now */ DispatchTable->KdpInitRoutine = KdpKdbgInit; DispatchTable->KdpPrintRoutine = KdbDebugPrint; /* Register as a Provider */ InsertTailList(&KdProviders, &DispatchTable->KdProvidersList); /* Perform actual initialization of symbol module */ //NtoskrnlModuleObject->PatchInformation = NULL; //LdrHalModuleObject->PatchInformation = NULL; InitializeListHead(&SymbolFileListHead); KeInitializeSpinLock(&SymbolFileListLock); /* Check the command line for /LOADSYMBOLS, /NOLOADSYMBOLS, * /LOADSYMBOLS={YES|NO}, /NOLOADSYMBOLS={YES|NO} */ ASSERT(KeLoaderBlock); p1 = KeLoaderBlock->LoadOptions; while('\0' != *p1 && NULL != (p2 = strchr(p1, '/'))) { p2++; Found = 0; if (0 == _strnicmp(p2, "LOADSYMBOLS", 11)) { Found = +1; p2 += 11; } else if (0 == _strnicmp(p2, "NOLOADSYMBOLS", 13)) { Found = -1; p2 += 13; } if (0 != Found) { while (isspace(*p2)) { p2++; } if ('=' == *p2) { p2++; while (isspace(*p2)) { p2++; } YesNo = toupper(*p2); if ('N' == YesNo || 'F' == YesNo || '0' == YesNo) { Found = -1 * Found; } } LoadSymbols = (0 < Found); } p1 = p2; } RosSymInitKernelMode(); } else if (BootPhase == 1) { /* Load symbols for NTOSKRNL.EXE. It is always the first module in PsLoadedModuleList. KeLoaderBlock can't be used here as its content is just temporary. */ LdrEntry = CONTAINING_RECORD(PsLoadedModuleList.Flink, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks); KdbSymProcessSymbols(LdrEntry); /* Also load them for HAL.DLL. */ LdrEntry = CONTAINING_RECORD(PsLoadedModuleList.Flink->Flink, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks); KdbSymProcessSymbols(LdrEntry); KdbpSymbolsInitialized = TRUE; } }
BOOLEAN NTAPI INIT_FUNCTION PoInitSystem(IN ULONG BootPhase) { PVOID NotificationEntry; PCHAR CommandLine; BOOLEAN ForceAcpiDisable = FALSE; /* Check if this is phase 1 init */ if (BootPhase == 1) { /* Register power button notification */ IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange, PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES, (PVOID)&GUID_DEVICE_SYS_BUTTON, IopRootDeviceNode-> PhysicalDeviceObject->DriverObject, PopAddRemoveSysCapsCallback, NULL, &NotificationEntry); /* Register lid notification */ IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange, PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES, (PVOID)&GUID_DEVICE_LID, IopRootDeviceNode-> PhysicalDeviceObject->DriverObject, PopAddRemoveSysCapsCallback, NULL, &NotificationEntry); return TRUE; } /* Get the Command Line */ CommandLine = KeLoaderBlock->LoadOptions; /* Upcase it */ _strupr(CommandLine); /* Check for ACPI disable */ if (strstr(CommandLine, "NOACPI")) ForceAcpiDisable = TRUE; if (ForceAcpiDisable) { /* Set the ACPI State to False if it's been forced that way */ PopAcpiPresent = FALSE; } else { /* Otherwise check if the LoaderBlock has a ACPI Table */ PopAcpiPresent = KeLoaderBlock->Extension->AcpiTable != NULL ? TRUE : FALSE; } /* Initialize volume support */ InitializeListHead(&PopVolumeDevices); KeInitializeGuardedMutex(&PopVolumeLock); /* Initialize support for dope */ KeInitializeSpinLock(&PopDopeGlobalLock); /* Initialize support for shutdown waits and work-items */ PopInitShutdownList(); return TRUE; }
VOID NotificationLoop( __in PIRP_LIST PendingIrp, __in PIRP_LIST NotifyEvent ) { PDRIVER_EVENT_CONTEXT driverEventContext; PLIST_ENTRY listHead; PIRP_ENTRY irpEntry; LIST_ENTRY completeList; KIRQL irpIrql; KIRQL notifyIrql; PIRP irp; ULONG eventLen; ULONG bufferLen; PVOID buffer; //DDbgPrint("=> NotificationLoop\n"); InitializeListHead(&completeList); ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL); KeAcquireSpinLock(&PendingIrp->ListLock, &irpIrql); KeAcquireSpinLock(&NotifyEvent->ListLock, ¬ifyIrql); while (!IsListEmpty(&PendingIrp->ListHead) && !IsListEmpty(&NotifyEvent->ListHead)) { listHead = RemoveHeadList(&NotifyEvent->ListHead); driverEventContext = CONTAINING_RECORD( listHead, DRIVER_EVENT_CONTEXT, ListEntry); listHead = RemoveHeadList(&PendingIrp->ListHead); irpEntry = CONTAINING_RECORD(listHead, IRP_ENTRY, ListEntry); eventLen = driverEventContext->EventContext.Length; // ensure this eventIrp is not cancelled irp = irpEntry->Irp; if (irp == NULL) { // this IRP has already been canceled ASSERT(irpEntry->CancelRoutineFreeMemory == FALSE); DokanFreeIrpEntry(irpEntry); // push back InsertTailList(&NotifyEvent->ListHead, &driverEventContext->ListEntry); continue; } if (IoSetCancelRoutine(irp, NULL) == NULL) { // Cancel routine will run as soon as we release the lock InitializeListHead(&irpEntry->ListEntry); irpEntry->CancelRoutineFreeMemory = TRUE; // push back InsertTailList(&NotifyEvent->ListHead, &driverEventContext->ListEntry); continue; } // available size that is used for event notification bufferLen = irpEntry->IrpSp->Parameters.DeviceIoControl.OutputBufferLength; // buffer that is used to inform Event buffer = irp->AssociatedIrp.SystemBuffer; // buffer is not specified or short of length if (bufferLen == 0 || buffer == NULL || bufferLen < eventLen) { DDbgPrint("EventNotice : STATUS_INSUFFICIENT_RESOURCES\n"); DDbgPrint(" bufferLen: %d, eventLen: %d\n", bufferLen, eventLen); // push back InsertTailList(&NotifyEvent->ListHead, &driverEventContext->ListEntry); // marks as STATUS_INSUFFICIENT_RESOURCES irpEntry->SerialNumber = 0; } else { // let's copy EVENT_CONTEXT RtlCopyMemory(buffer, &driverEventContext->EventContext, eventLen); // save event length irpEntry->SerialNumber = eventLen; if (driverEventContext->Completed) { KeSetEvent(driverEventContext->Completed, IO_NO_INCREMENT, FALSE); } ExFreePool(driverEventContext); } InsertTailList(&completeList, &irpEntry->ListEntry); } KeClearEvent(&NotifyEvent->NotEmpty); KeClearEvent(&PendingIrp->NotEmpty); KeReleaseSpinLock(&NotifyEvent->ListLock, notifyIrql); KeReleaseSpinLock(&PendingIrp->ListLock, irpIrql); while (!IsListEmpty(&completeList)) { listHead = RemoveHeadList(&completeList); irpEntry = CONTAINING_RECORD(listHead, IRP_ENTRY, ListEntry); irp = irpEntry->Irp; if (irpEntry->SerialNumber == 0) { irp->IoStatus.Information = 0; irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; } else { irp->IoStatus.Information = irpEntry->SerialNumber; irp->IoStatus.Status = STATUS_SUCCESS; } DokanFreeIrpEntry(irpEntry); IoCompleteRequest(irp, IO_NO_INCREMENT); } //DDbgPrint("<= NotificationLoop\n"); }
NTSTATUS LfsSvrDatagramRecvHandler ( IN PVOID TdiEventContext, IN LONG SourceAddressLength, IN PVOID SourceAddress, IN LONG OptionsLength, IN PVOID Options, IN ULONG ReceiveDatagramFlags, IN ULONG BytesIndicated, IN ULONG BytesAvailable, OUT ULONG *BytesTaken, IN PVOID Tsdu, OUT PIRP *IoRequestPacket ) { PLFSDGRAMSVR_CTX SvrCtx = (PLFSDGRAMSVR_CTX)TdiEventContext; PTRANSPORT_ADDRESS ClientAddr = (PTRANSPORT_ADDRESS)SourceAddress; PLPX_ADDRESS ClientLpxAddr = (PLPX_ADDRESS)ClientAddr->Address[0].Address; PLFSDG_PKT Pkt; BOOLEAN bRet; static UCHAR Protocol[4] = NDFT_PROTOCOL; UNREFERENCED_PARAMETER( SourceAddressLength ); UNREFERENCED_PARAMETER( OptionsLength ); UNREFERENCED_PARAMETER( Options ); UNREFERENCED_PARAMETER( ReceiveDatagramFlags ); UNREFERENCED_PARAMETER( BytesTaken ); UNREFERENCED_PARAMETER( IoRequestPacket ); #if !DBG UNREFERENCED_PARAMETER(BytesIndicated); #endif // BytesIndicated, BytesAvailable, BytesTaken SPY_LOG_PRINT( LFS_DEBUG_LIB_NOISE, ("[LFS] LfsSvrDatagramRecvHandler: BytesIndicated : %d BytesAvailable : %d\n", BytesIndicated, BytesAvailable) ); if (BytesAvailable < sizeof(NDFT_HEADER) ) { SPY_LOG_PRINT( LFS_DEBUG_LIB_INFO, ( "[LFS] LfsSvrDatagramRecvHandler: too small bytes.\n" ) ); goto not_accepted; } bRet = LfsAllocDGPkt( &Pkt, MAX_DATAGRAM_DATA_SIZE ); if (FALSE == bRet) { SPY_LOG_PRINT( LFS_DEBUG_LIB_INFO, ( "[LFS] LfsSvrDatagramRecvHandler: LfsAllocDGPkt() failed.\n") ); goto not_accepted; } // read the head RtlCopyMemory( &Pkt->RawHeadDG, Tsdu, sizeof(Pkt->RawHeadDG) ); // validation check SPY_LOG_PRINT( LFS_DEBUG_LIB_NOISE, ("[LFS] LfsSvrDatagramRecvHandler: Protocol:%lx Ver:%x.%x TotalSize:%ld" " Type:%x\n", *((ULONG *)Pkt->RawHeadDG.Protocol), NTOHS(Pkt->RawHeadDG.NdfsMajorVersion2), NTOHS(Pkt->RawHeadDG.NdfsMinorVersion2), NTOHL(Pkt->RawHeadDG.MessageSize4), NTOHS(Pkt->RawHeadDG.Type2)) ); if (RtlCompareMemory(Pkt->RawHeadDG.Protocol, Protocol, 4) != 4 || NTOHS(Pkt->RawHeadDG.NdfsMajorVersion2) != NDFT_MAJVER || NTOHS(Pkt->RawHeadDG.NdfsMinorVersion2) != NDFT_MINVER || (NTOHS(Pkt->RawHeadDG.Type2) & LFSPKTTYPE_PREFIX) != (LFSPKTTYPE_DATAGRAM | LFSPKTTYPE_REQUEST) ) { LfsDereferenceDGPkt(Pkt); SPY_LOG_PRINT( LFS_DEBUG_LIB_NOISE, ("[LFS] LfsSvrDatagramRecvHandler: Invalid reply header.\n") ); goto not_accepted; } Pkt->PacketSize = NTOHL(Pkt->RawHeadDG.MessageSize4); Pkt->DataSize = NTOHL(Pkt->RawHeadDG.MessageSize4) - sizeof(NDFT_HEADER); if (Pkt->PacketSize != sizeof(NDFT_HEADER) + Pkt->DataSize ) { LfsDereferenceDGPkt(Pkt); SPY_LOG_PRINT( LFS_DEBUG_LIB_INFO, ("[LFS] LfsSvrDatagramRecvHandler: Invalid reply packet size.\n") ); goto not_accepted; } if (BytesAvailable < Pkt->PacketSize) { LfsDereferenceDGPkt(Pkt); SPY_LOG_PRINT( LFS_DEBUG_LIB_INFO, ("[LFS] LfsSvrDatagramRecvHandler: wrong message size contained.\n") ); goto not_accepted; } // retrieve the source address. // Do not trust Owner's address in the packet. RtlCopyMemory(&Pkt->SourceAddr, ClientLpxAddr, sizeof(LPX_ADDRESS)); SPY_LOG_PRINT( LFS_DEBUG_LIB_NOISE, ("[LFS] LfsSvrDatagramRecvHandler:" " received a datagram packet from %02X:%02X:%02X:%02X:%02X:%02X/%d\n", ClientLpxAddr->Node[0],ClientLpxAddr->Node[1],ClientLpxAddr->Node[2], ClientLpxAddr->Node[3],ClientLpxAddr->Node[4],ClientLpxAddr->Node[5], (int)ClientLpxAddr->Port) ); // read the data RtlCopyMemory( &Pkt->RawDataDG, (PUCHAR)Tsdu + sizeof(Pkt->RawHeadDG), Pkt->DataSize ); // insert to the packet queue InitializeListHead( &Pkt->PktListEntry ); ExInterlockedInsertTailList( &SvrCtx->RecvDGPktQueue, &Pkt->PktListEntry, &SvrCtx->RecvDGPktQSpinLock ); KeSetEvent( &SvrCtx->DatagramRecvEvent, IO_NO_INCREMENT, FALSE ); return STATUS_SUCCESS; not_accepted: SPY_LOG_PRINT( LFS_DEBUG_LIB_NOISE, ("[LFS] LfsSvrDatagramRecvHandler: a datagram packet rejected.\n") ); return STATUS_DATA_NOT_ACCEPTED; }
/** This is the common notification function for HotKeys, it will be registered with SimpleTextInEx protocol interface - RegisterKeyNotify() of ConIn handle. @param KeyData A pointer to a buffer that is filled in with the keystroke information for the key that was pressed. @retval EFI_SUCCESS KeyData is successfully processed. @return EFI_NOT_FOUND Fail to find boot option variable. **/ EFI_STATUS EFIAPI HotkeyCallback ( IN EFI_KEY_DATA *KeyData ) { BOOLEAN HotkeyCatched; LIST_ENTRY BootLists; LIST_ENTRY *Link; BDS_HOTKEY_OPTION *Hotkey; UINT16 Buffer[10]; BDS_COMMON_OPTION *BootOption; UINTN ExitDataSize; CHAR16 *ExitData; EFI_STATUS Status; EFI_KEY_DATA *HotkeyData; if (mHotkeyCallbackPending) { // // When responsing to a Hotkey, ignore sequential hotkey stroke until // the current Boot#### load option returned // return EFI_SUCCESS; } Status = EFI_SUCCESS; Link = GetFirstNode (&mHotkeyList); while (!IsNull (&mHotkeyList, Link)) { HotkeyCatched = FALSE; Hotkey = BDS_HOTKEY_OPTION_FROM_LINK (Link); // // Is this Key Stroke we are waiting for? // ASSERT (Hotkey->WaitingKey < (sizeof (Hotkey->KeyData) / sizeof (Hotkey->KeyData[0]))); HotkeyData = &Hotkey->KeyData[Hotkey->WaitingKey]; if ((KeyData->Key.ScanCode == HotkeyData->Key.ScanCode) && (KeyData->Key.UnicodeChar == HotkeyData->Key.UnicodeChar) && (((HotkeyData->KeyState.KeyShiftState & EFI_SHIFT_STATE_VALID) != 0) ? (KeyData->KeyState.KeyShiftState == HotkeyData->KeyState.KeyShiftState) : TRUE)) { // // Receive an expecting key stroke // if (Hotkey->CodeCount > 1) { // // For hotkey of key combination, transit to next waiting state // Hotkey->WaitingKey++; if (Hotkey->WaitingKey == Hotkey->CodeCount) { // // Received the whole key stroke sequence // HotkeyCatched = TRUE; } } else { // // For hotkey of single key stroke // HotkeyCatched = TRUE; } } else { // // Receive an unexpected key stroke, reset to initial waiting state // Hotkey->WaitingKey = 0; } if (HotkeyCatched) { // // Reset to initial waiting state // Hotkey->WaitingKey = 0; // // Launch its BootOption // InitializeListHead (&BootLists); UnicodeSPrint (Buffer, sizeof (Buffer), L"Boot%04x", Hotkey->BootOptionNumber); BootOption = BdsLibVariableToOption (&BootLists, Buffer); if (BootOption == NULL) { return EFI_NOT_FOUND; } BootOption->BootCurrent = Hotkey->BootOptionNumber; BdsLibConnectDevicePath (BootOption->DevicePath); // // Clear the screen before launch this BootOption // gST->ConOut->Reset (gST->ConOut, FALSE); mHotkeyCallbackPending = TRUE; Status = BdsLibBootViaBootOption (BootOption, BootOption->DevicePath, &ExitDataSize, &ExitData); mHotkeyCallbackPending = FALSE; if (EFI_ERROR (Status)) { // // Call platform action to indicate the boot fail // BootOption->StatusString = GetStringById (STRING_TOKEN (STR_BOOT_FAILED)); PlatformBdsBootFail (BootOption, Status, ExitData, ExitDataSize); } else { // // Call platform action to indicate the boot success // BootOption->StatusString = GetStringById (STRING_TOKEN (STR_BOOT_SUCCEEDED)); PlatformBdsBootSuccess (BootOption); } } Link = GetNextNode (&mHotkeyList, Link); } return Status; }
BOOLEAN RdsvrDatagramInit ( PLFS_TABLE LfsTable, PVOID *DGSvrCtx, PVOID *NtcCtx ) { NTSTATUS status; OBJECT_ATTRIBUTES objectAttributes; // create the datagram server thread LFSDGSvrCtx.LfsTable = LfsTable; *DGSvrCtx = &LFSDGSvrCtx; KeInitializeEvent( &LFSDGSvrCtx.ShutdownEvent, NotificationEvent, FALSE ); KeInitializeEvent( &LFSDGSvrCtx.NetworkEvent, NotificationEvent, FALSE ); KeInitializeEvent( &LFSDGSvrCtx.DatagramRecvEvent, NotificationEvent, FALSE ); KeInitializeSpinLock( &LFSDGSvrCtx.RecvDGPktQSpinLock ); InitializeListHead( &LFSDGSvrCtx.RecvDGPktQueue ); InitializeObjectAttributes( &objectAttributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL ); status = PsCreateSystemThread( &LFSDGSvrCtx.hSvrThread, THREAD_ALL_ACCESS, &objectAttributes, NULL, NULL, RedirDataGramSvrThreadProc, &LFSDGSvrCtx ); if (!NT_SUCCESS(status)) { NDAS_ASSERT( FALSE ); return FALSE; } // create the datagram notification broadcaster InitializeObjectAttributes( &objectAttributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL ); KeInitializeEvent( &LFSNtcCtx.ShutdownEvent, NotificationEvent, FALSE ); LFSNtcCtx.LfsTable = LfsTable; *NtcCtx = &LFSNtcCtx; InitializeListHead( &LFSNtcCtx.SendPkts ); status = PsCreateSystemThread( &LFSNtcCtx.hThread, THREAD_ALL_ACCESS, &objectAttributes, NULL, NULL, RedirDataGramNotifierThreadProc, &LFSNtcCtx ); if (!NT_SUCCESS(status)) { NDAS_ASSERT( FALSE ); return FALSE; } return TRUE; }
// // Функция инициализации драйвера. // NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING RegistryPath) { PDEVICE_OBJECT pDeviceObject; // указатель на объект устройство NTSTATUS status = STATUS_SUCCESS; // статус завершения функции ULONG reg; UNICODE_STRING f1; char* str; char* ptr; int len; //InitProtectedFiles(); //DbgPrint("ProtectedFiles: %wZ, %wZ", &glProtectedFiles[0], &glProtectedFiles[1]); //DbgPrint("Load driver %wZ", &DriverObject->DriverName); //DbgPrint("Registry path %wZ", RegistryPath); pDriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreate; //pDriverObject->MajorFunction [IRP_MJ_CREATE_NAMED_PIPE ] = 0; pDriverObject->MajorFunction[IRP_MJ_CLOSE] = DispatchClose; pDriverObject->MajorFunction[IRP_MJ_READ] = DispatchRead; pDriverObject->MajorFunction[IRP_MJ_WRITE] = DispatchWrite; pDriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = DispatchQueryInformation; //pDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = DispatchSetInformation; pDriverObject->DriverUnload = DriverUnload; KdPrint(("Load driver %wZ\n", &pDriverObject->DriverName)); KdPrint(("Registry path %wZ\n", RegistryPath)); RtlInitUnicodeString(&glDeviceName, DEVICE_NAME); RtlInitUnicodeString(&glSymLinkName, SYM_LINK_NAME); // создание устройства status = IoCreateDevice(pDriverObject, // указатель на объект драйвера 0, // размер области дополнительной памяти устройства &glDeviceName, // имя устройства FILE_DEVICE_UNKNOWN, // идентификатор типа устройства 0, // дополнительная информация об устройстве FALSE, // используется системой(для драйверов должно быть FALSE) &pDeviceObject); // адрес для сохранения указателя на объект устройства if (!NT_SUCCESS(status)) { return status; } // буферизованный ввод/вывод для операций чтения/записи pDeviceObject->Flags |= DO_BUFFERED_IO; KdPrint(("Create device %wZ\n", &glDeviceName)); // создание символьной ссылки status = IoCreateSymbolicLink(&glSymLinkName, &glDeviceName); if (!NT_SUCCESS(status)) { IoDeleteDevice(pDeviceObject); return status; } KdPrint(("Create symbolic link %wZ\n", &glSymLinkName)); // создаем резервный список ExInitializePagedLookasideList(&glPagedList, NULL, NULL, 0, sizeof(OpenFileEntry), ' LFO', 0); InitializeListHead(&glOpenFiles); // запоминаем адрес реального обработчика вызова NtCreateFile glRealNtCreateFile = (NT_CREATE_FILE)KeServiceDescriptorTable->Base[NUMBER_NT_CREATE_FILE]; glRealNtOpenFile = (NT_OPEN_FILE)KeServiceDescriptorTable->Base[NUMBER_NT_OPEN_FILE]; //glRealNtOpenFile = KeServiceDescriptorTable->Base[NUMBER_NT_CREATE_FILE]; // подставляем адрес нового обработчика //reg = ClearWP(); KeServiceDescriptorTable->Base[NUMBER_NT_CREATE_FILE] = (ULONG)HookNtCreateFile; KeServiceDescriptorTable->Base[NUMBER_NT_OPEN_FILE] = (ULONG)HookNtOpenFile; //WriteCR0(reg); return status; }
// but this still gives a PFD warning?! NTSTATUS CreateDevice ( IN PDRIVER_OBJECT DriverObject, OUT PDEVICE_OBJECT *DeviceObject ) { NTSTATUS status; UNICODE_STRING devName; PDEVICE_EXTENSION devExtension; HANDLE threadHandle; PDEVICE_OBJECT devObj; ANSI_STRING tmpANSIName; GUID driverGUID; HASH_DRIVER_INFO tmpDevExt; DEBUGOUTHASHDRV(DEBUGLEV_ENTER, ("CreateDevice\n")); ASSERT(DriverObject != NULL); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("Building device name...\n")); // We subtrace a sizeof(WCHAR) to discount the #NULL - required // since although the UNICODE_STRING string doesn't require it, swprintf // adds one on anyway // This is a bit of a hack to get the driver's GUID ImpHashDriverExtDetailsInit(&tmpDevExt); driverGUID = tmpDevExt.DriverGUID; ImpHashDriverExtDetailsCleardown(&tmpDevExt); devName.MaximumLength = sizeof(DEVICE_HASH_DIR_NAME) // ^^ dir name + sizeof(WCHAR) // ^^ slash + GUID_STRING_REP_UNICODE_BYTE_LENGTH // ^^ GUID length + sizeof(WCHAR); // ^^ terminating NULL devName.Buffer = FREEOTFE_MEMALLOC(devName.MaximumLength); RtlZeroMemory(devName.Buffer, devName.MaximumLength); // Note the "/" in the format string devName.Length = (USHORT)FREEOTFE_SWPRINTF( devName.Buffer, (devName.MaximumLength / sizeof(*(devName.Buffer))), L"%s\\", DEVICE_HASH_DIR_NAME ); // swprintf returns the number of WCHARs, not the length in bytes devName.Length = devName.Length * sizeof(WCHAR); status = AppendGUIDToUnicodeString(driverGUID, &devName); if (!NT_SUCCESS(status)) { DEBUGOUTHASHDRV(DEBUGLEV_ERROR, ("AppendGUIDToUnicodeString NOT OK\n")); SecZeroAndFreeMemory( devName.Buffer, devName.MaximumLength ); return status; } DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("xdevNameLength: %d\n", devName.Length)); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("xdevNameMaximumLength: %d\n", devName.MaximumLength)); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("About to create device: %ls\n", devName.Buffer)); // Hmmm... I'd prefer to use FILE_DEVICE_UNKNOWN, but since // IOCTL control codes pass through the device type, and we just // pass then through... // (See other call to IoCreateDevice in this file for details why we don't // use FILE_DEVICE_VIRTUAL_DISK) status = IoCreateDevice( DriverObject, sizeof(DEVICE_EXTENSION), &devName, FILE_DEVICE_UNKNOWN, 0, FALSE, &devObj ); if (!NT_SUCCESS(status)) { DEBUGOUTHASHDRV(DEBUGLEV_ERROR, ("Status NOT OK\n")); SecZeroAndFreeMemory( devName.Buffer, devName.MaximumLength ); return status; } devExtension = (PDEVICE_EXTENSION)devObj->DeviceExtension; devExtension->zzDeviceName = devName; devExtension->ThreadObject = NULL; devExtension->zzSymbolicLinkName.Buffer = NULL; status = ImpHashDriverExtDetailsInit(&(devExtension->DriverInfo)); if (!NT_SUCCESS(status)) { DEBUGOUTHASHDRV(DEBUGLEV_ERROR, ("Failed to ImpHashDriverExtDetailsInit.\n")); DestroyDevice(devObj); return status; } // Create symlink; his allows user applications to CreateFile with // "SymbolicName" DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("Building symlink name...\n")); // We add on sizeof(WCHAR) to include the terminating #NULL - required // since although the UNICODE_STRING string doesn't require it, swprintf // adds one on anyway devExtension->zzSymbolicLinkName.MaximumLength = sizeof(DEVICE_HASH_SYMLINK_PREFIX) // ^^ dir name + sizeof(WCHAR) // ^^ slash + GUID_STRING_REP_UNICODE_BYTE_LENGTH // ^^ GUID length + sizeof(WCHAR); // ^^ terminating NULL devExtension->zzSymbolicLinkName.Buffer = FREEOTFE_MEMALLOC(devExtension->zzSymbolicLinkName.MaximumLength); RtlZeroMemory(devExtension->zzSymbolicLinkName.Buffer, devExtension->zzSymbolicLinkName.MaximumLength); devExtension->zzSymbolicLinkName.Length = (USHORT)FREEOTFE_SWPRINTF( devExtension->zzSymbolicLinkName.Buffer, (devExtension->zzSymbolicLinkName.MaximumLength / sizeof(*(devExtension->zzSymbolicLinkName.Buffer))), L"%s", DEVICE_HASH_SYMLINK_PREFIX ); // swprintf returns the number of WCHARs, not the length in bytes devExtension->zzSymbolicLinkName.Length = devExtension->zzSymbolicLinkName.Length * sizeof(WCHAR); status = AppendGUIDToUnicodeString(driverGUID, &devExtension->zzSymbolicLinkName); if (!NT_SUCCESS(status)) { DEBUGOUTHASHDRV(DEBUGLEV_ERROR, ("AppendGUIDToUnicodeString NOT OK\n")); DestroyDevice(devObj); return status; } DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("Unicoded symlink name: %ls\n", devExtension->zzSymbolicLinkName.Buffer)); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("Length: %d\n", devExtension->zzSymbolicLinkName.Length)); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("MaximumLength: %d\n", devExtension->zzSymbolicLinkName.MaximumLength)); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("About to create dosdevice symlink: %ls -> %ls\n", devExtension->zzSymbolicLinkName.Buffer, devExtension->zzDeviceName.Buffer)); status = IoCreateSymbolicLink(&devExtension->zzSymbolicLinkName, &devExtension->zzDeviceName); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("Done, checking status...\n")); if (!NT_SUCCESS(status)) { DEBUGOUTHASHDRV(DEBUGLEV_ERROR, ("Status NOT OK\n")); DestroyDevice(devObj); return status; } DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("OK\n")); devObj->Flags |= DO_DIRECT_IO; devObj->Characteristics |= FILE_READ_ONLY_DEVICE; // (Some of the bits following are taken from the DDK src/general/cancel example) // This is used to serialize access to the queue. KeInitializeSpinLock(&devExtension->IRPQueueLock); KeInitializeSemaphore(&devExtension->IRPQueueSemaphore, 0, MAXLONG ); // Initialize the pending Irp devicequeue InitializeListHead(&devExtension->PendingIRPQueue); // Initialize the cancel safe queue IoCsqInitialize(&devExtension->CancelSafeQueue, CSQInsertIrp, CSQRemoveIrp, CSQPeekNextIrp, CSQAcquireLock, CSQReleaseLock, CSQCompleteCanceledIrp); // Create a thread for the device object devExtension->TerminateThread = FALSE; status = PsCreateSystemThread( &threadHandle, (ACCESS_MASK)0, NULL, (HANDLE)0L, // )0L because it's a // driver-created thread NULL, FreeOTFEThread, devObj ); if (!(NT_SUCCESS(status))) { DEBUGOUTHASHDRV(DEBUGLEV_ERROR, ("Create thread FAILED.\n")); DestroyDevice(devObj); return status; } DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("OK\n")); // Convert the Thread object handle into a pointer to the Thread object // itself. Then close the handle. status = ObReferenceObjectByHandle( threadHandle, THREAD_ALL_ACCESS, NULL, KernelMode, &devExtension->ThreadObject, NULL ); DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("Done processing thread; checking status.\n")); if (!NT_SUCCESS(status)) { DEBUGOUTHASHDRV(DEBUGLEV_ERROR, ("Status FAILED.\n")); ZwClose(threadHandle); DestroyDevice(devObj); return status; } DEBUGOUTHASHDRV(DEBUGLEV_INFO, ("OK\n")); // Close the thread handle ZwClose(threadHandle); // This is an easy thing to overlook - we do *not* have to unset the // device's DO_DEVICE_INITIALIZING "Flags" as this function is carried out // undef DriverEntry, and not something like AddDevice *DeviceObject = devObj; DEBUGOUTHASHDRV(DEBUGLEV_EXIT, ("CreateDevice\n")); return STATUS_SUCCESS; }
VOID NDIS_API PacketBindAdapter(OUT PNDIS_STATUS pStatus, IN NDIS_HANDLE BindAdapterContext, IN PNDIS_STRING pAdapterName, IN PVOID SystemSpecific1, IN PVOID SystemSpecific2) { // bind this driver to a NIC POPEN_INSTANCE oiNew; NDIS_STATUS ErrorStatus, AllocStatus; UINT Medium; NDIS_MEDIUM MediumArray = NdisMedium802_3; UINT i; // allocate some memory for the open structure NdisAllocateMemory((PVOID *)&oiNew, sizeof(OPEN_INSTANCE), 0, -1); if (oiNew == NULL) { // not enough memory *pStatus = NDIS_STATUS_RESOURCES; return; } NdisZeroMemory((PVOID)oiNew, sizeof(OPEN_INSTANCE)); // Save Binding Context oiNew->BindAdapterContext = BindAdapterContext; // Save the device handle oiNew->hDevice = (DWORD)SystemSpecific1; // Allocate a packet pool for our xmit and receive packets NdisAllocatePacketPool(&AllocStatus, &(oiNew->PacketPool), TRANSMIT_PACKETS, sizeof(PACKET_RESERVED)); if (AllocStatus != NDIS_STATUS_SUCCESS) { // not enough memory NdisFreeMemory(oiNew, sizeof(OPEN_INSTANCE), 0); *pStatus = NDIS_STATUS_RESOURCES; return; } // Allocate a buffer pool for our xmit and receive buffers NdisAllocateBufferPool(&AllocStatus, &(oiNew->BufferPool), TRANSMIT_PACKETS); if (AllocStatus != NDIS_STATUS_SUCCESS) { // not enough memory NdisFreeMemory(oiNew, sizeof(OPEN_INSTANCE), 0); *pStatus = NDIS_STATUS_RESOURCES; return; } // list to hold irp's that want to reset the adapter NdisAllocateSpinLock(&oiNew->ResetSpinLock); InitializeListHead(&oiNew->ResetIrpList); // Initialize list for holding pending read requests NdisAllocateSpinLock(&oiNew->RcvQSpinLock); InitializeListHead(&oiNew->RcvList); // Initialize the request list NdisAllocateSpinLock(&oiNew->RequestSpinLock); InitializeListHead(&oiNew->RequestList); // link up the request stored in our open block for (i = 0; i < MAX_REQUESTS; i++) { // Braces are required as InsertTailList macro has multiple statements in it InsertTailList(&oiNew->RequestList, &oiNew->Requests[i].Reserved.ListElement); } // Try to open the MAC NdisOpenAdapter(pStatus, &ErrorStatus, &oiNew->AdapterHandle, &Medium, &MediumArray, 1, GlobalDeviceExtension->NdisProtocolHandle, oiNew, pAdapterName, 0, NULL); // Save the status returned by NdisOpenAdapter for completion routine oiNew->Status = *pStatus; switch (*pStatus) { case NDIS_STATUS_PENDING: break; case NDIS_STATUS_SUCCESS: ErrorStatus = NDIS_STATUS_SUCCESS; // fall through to completion routine with oiNew->Status // set to !NDIS_STATUS_PENDING default: PacketBindAdapterComplete(oiNew, *pStatus, ErrorStatus); break; } }
/* * InitializeTransferPackets * * Allocate/initialize TRANSFER_PACKETs and related resources. */ NTSTATUS NTAPI InitializeTransferPackets(PDEVICE_OBJECT Fdo) { PCOMMON_DEVICE_EXTENSION commonExt = Fdo->DeviceExtension; PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension; PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData; PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExt->PartitionZeroExtension->AdapterDescriptor; ULONG hwMaxPages; NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); /* * Precompute the maximum transfer length */ ASSERT(adapterDesc->MaximumTransferLength); ASSERT(adapterDesc->MaximumPhysicalPages); hwMaxPages = adapterDesc->MaximumPhysicalPages ? adapterDesc->MaximumPhysicalPages-1 : 0; #if defined(_AMD64_SIMULATOR_) // // The simulator appears to have a problem with large transfers. // if (hwMaxPages > 4) { hwMaxPages = 4; } #endif fdoData->HwMaxXferLen = MIN(adapterDesc->MaximumTransferLength, hwMaxPages << PAGE_SHIFT); fdoData->HwMaxXferLen = MAX(fdoData->HwMaxXferLen, PAGE_SIZE); fdoData->NumTotalTransferPackets = 0; fdoData->NumFreeTransferPackets = 0; InitializeSListHead(&fdoData->FreeTransferPacketsList); InitializeListHead(&fdoData->AllTransferPacketsList); InitializeListHead(&fdoData->DeferredClientIrpList); /* * Set the packet threshold numbers based on the Windows SKU. */ if (ExVerifySuite(Personal)){ // this is Windows Personal MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Consumer; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Consumer; } else if (ExVerifySuite(Enterprise) || ExVerifySuite(DataCenter)){ // this is Advanced Server or Datacenter MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Enterprise; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Enterprise; } else if (ExVerifySuite(TerminalServer)){ // this is standard Server or Pro with terminal server MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Server; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Server; } else { // this is Professional without terminal server MinWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Consumer; MaxWorkingSetTransferPackets = MAX_WORKINGSET_TRANSFER_PACKETS_Consumer; } while (fdoData->NumFreeTransferPackets < MIN_INITIAL_TRANSFER_PACKETS){ PTRANSFER_PACKET pkt = NewTransferPacket(Fdo); if (pkt){ InterlockedIncrement((PLONG)&fdoData->NumTotalTransferPackets); EnqueueFreeTransferPacket(Fdo, pkt); } else { status = STATUS_INSUFFICIENT_RESOURCES; break; } } fdoData->DbgPeakNumTransferPackets = fdoData->NumTotalTransferPackets; /* * Pre-initialize our SCSI_REQUEST_BLOCK template with all * the constant fields. This will save a little time for each xfer. * NOTE: a CdbLength field of 10 may not always be appropriate */ RtlZeroMemory(&fdoData->SrbTemplate, sizeof(SCSI_REQUEST_BLOCK)); fdoData->SrbTemplate.Length = sizeof(SCSI_REQUEST_BLOCK); fdoData->SrbTemplate.Function = SRB_FUNCTION_EXECUTE_SCSI; fdoData->SrbTemplate.QueueAction = SRB_SIMPLE_TAG_REQUEST; fdoData->SrbTemplate.SenseInfoBufferLength = sizeof(SENSE_DATA); fdoData->SrbTemplate.CdbLength = 10; return status; }
NTSTATUS DraidStart( PDRAID_GLOBALS DraidGlobals ) { NTSTATUS status; OBJECT_ATTRIBUTES objectAttributes; #if 0 TDI_CLIENT_INTERFACE_INFO info; UNICODE_STRING clientName; #endif KDPrintM(DBG_LURN_INFO, ("Starting\n")); InitializeListHead(&DraidGlobals->ArbiterList); KeInitializeSpinLock(&DraidGlobals->ArbiterListSpinlock); InitializeListHead(&DraidGlobals->ClientList); KeInitializeSpinLock(&DraidGlobals->ClientListSpinlock); KeInitializeEvent(&DraidGlobals->DraidExitEvent, NotificationEvent, FALSE); KeInitializeEvent(&DraidGlobals->NetChangedEvent, NotificationEvent, FALSE); InitializeListHead(&DraidGlobals->ListenContextList); KeInitializeSpinLock(&DraidGlobals->ListenContextSpinlock); InitializeObjectAttributes( &objectAttributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL); g_DraidGlobals = DraidGlobals; status = PsCreateSystemThread( &DraidGlobals->DraidThreadHandle, THREAD_ALL_ACCESS, &objectAttributes, NULL, NULL, DraidListenerThreadProc, DraidGlobals ); if(!NT_SUCCESS(status)) { ASSERT(FALSE); DraidGlobals->DraidThreadHandle = NULL; DraidGlobals->DraidThreadObject = NULL; return STATUS_UNSUCCESSFUL; } status = ObReferenceObjectByHandle( DraidGlobals->DraidThreadHandle, FILE_READ_DATA, NULL, KernelMode, &DraidGlobals->DraidThreadObject, NULL ); if(!NT_SUCCESS(status)) { ASSERT(FALSE); DraidGlobals->DraidThreadObject = NULL; DraidGlobals->DraidThreadHandle = NULL; return STATUS_UNSUCCESSFUL; } return STATUS_SUCCESS; }
/** Create KEYBOARD_CONSOLE_IN_DEV instance on controller. @param This Pointer of EFI_DRIVER_BINDING_PROTOCOL @param Controller driver controller handle @param RemainingDevicePath Children's device path @retval whether success to create floppy control instance. **/ EFI_STATUS EFIAPI KbdControllerDriverStart ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE Controller, IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath ) { EFI_STATUS Status; EFI_STATUS Status1; EFI_SIO_PROTOCOL *Sio; KEYBOARD_CONSOLE_IN_DEV *ConsoleIn; UINT8 Data; EFI_STATUS_CODE_VALUE StatusCode; EFI_DEVICE_PATH_PROTOCOL *DevicePath; StatusCode = 0; Status = gBS->OpenProtocol ( Controller, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePath, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_GET_PROTOCOL ); if (EFI_ERROR (Status)) { return Status; } // // Report that the keyboard is being enabled // REPORT_STATUS_CODE_WITH_DEVICE_PATH ( EFI_PROGRESS_CODE, EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_ENABLE, DevicePath ); // // Get the ISA I/O Protocol on Controller's handle // Status = gBS->OpenProtocol ( Controller, &gEfiSioProtocolGuid, (VOID **) &Sio, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { return Status; } // // Allocate private data // ConsoleIn = AllocateZeroPool (sizeof (KEYBOARD_CONSOLE_IN_DEV)); if (ConsoleIn == NULL) { Status = EFI_OUT_OF_RESOURCES; StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; goto ErrorExit; } // // Setup the device instance // ConsoleIn->Signature = KEYBOARD_CONSOLE_IN_DEV_SIGNATURE; ConsoleIn->Handle = Controller; (ConsoleIn->ConIn).Reset = KeyboardEfiReset; (ConsoleIn->ConIn).ReadKeyStroke = KeyboardReadKeyStroke; ConsoleIn->DataRegisterAddress = KEYBOARD_8042_DATA_REGISTER; ConsoleIn->StatusRegisterAddress = KEYBOARD_8042_STATUS_REGISTER; ConsoleIn->CommandRegisterAddress = KEYBOARD_8042_COMMAND_REGISTER; ConsoleIn->DevicePath = DevicePath; ConsoleIn->ConInEx.Reset = KeyboardEfiResetEx; ConsoleIn->ConInEx.ReadKeyStrokeEx = KeyboardReadKeyStrokeEx; ConsoleIn->ConInEx.SetState = KeyboardSetState; ConsoleIn->ConInEx.RegisterKeyNotify = KeyboardRegisterKeyNotify; ConsoleIn->ConInEx.UnregisterKeyNotify = KeyboardUnregisterKeyNotify; InitializeListHead (&ConsoleIn->NotifyList); // // Fix for random hangs in System waiting for the Key if no KBC is present in BIOS. // When KBC decode (IO port 0x60/0x64 decode) is not enabled, // KeyboardRead will read back as 0xFF and return status is EFI_SUCCESS. // So instead we read status register to detect after read if KBC decode is enabled. // // // Return code is ignored on purpose. // if (!PcdGetBool (PcdFastPS2Detection)) { KeyboardRead (ConsoleIn, &Data); if ((KeyReadStatusRegister (ConsoleIn) & (KBC_PARE | KBC_TIM)) == (KBC_PARE | KBC_TIM)) { // // If nobody decodes KBC I/O port, it will read back as 0xFF. // Check the Time-Out and Parity bit to see if it has an active KBC in system // Status = EFI_DEVICE_ERROR; StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_NOT_DETECTED; goto ErrorExit; } } // // Setup the WaitForKey event // Status = gBS->CreateEvent ( EVT_NOTIFY_WAIT, TPL_NOTIFY, KeyboardWaitForKey, ConsoleIn, &((ConsoleIn->ConIn).WaitForKey) ); if (EFI_ERROR (Status)) { Status = EFI_OUT_OF_RESOURCES; StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; goto ErrorExit; } // // Setup the WaitForKeyEx event // Status = gBS->CreateEvent ( EVT_NOTIFY_WAIT, TPL_NOTIFY, KeyboardWaitForKeyEx, ConsoleIn, &(ConsoleIn->ConInEx.WaitForKeyEx) ); if (EFI_ERROR (Status)) { Status = EFI_OUT_OF_RESOURCES; StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; goto ErrorExit; } // Setup a periodic timer, used for reading keystrokes at a fixed interval // Status = gBS->CreateEvent ( EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_NOTIFY, KeyboardTimerHandler, ConsoleIn, &ConsoleIn->TimerEvent ); if (EFI_ERROR (Status)) { Status = EFI_OUT_OF_RESOURCES; StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; goto ErrorExit; } Status = gBS->SetTimer ( ConsoleIn->TimerEvent, TimerPeriodic, KEYBOARD_TIMER_INTERVAL ); if (EFI_ERROR (Status)) { Status = EFI_OUT_OF_RESOURCES; StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; goto ErrorExit; } REPORT_STATUS_CODE_WITH_DEVICE_PATH ( EFI_PROGRESS_CODE, EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_PRESENCE_DETECT, DevicePath ); // // Reset the keyboard device // Status = ConsoleIn->ConInEx.Reset (&ConsoleIn->ConInEx, FeaturePcdGet (PcdPs2KbdExtendedVerification)); if (EFI_ERROR (Status)) { Status = EFI_DEVICE_ERROR; StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_NOT_DETECTED; goto ErrorExit; } REPORT_STATUS_CODE_WITH_DEVICE_PATH ( EFI_PROGRESS_CODE, EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_DETECTED, DevicePath ); ConsoleIn->ControllerNameTable = NULL; AddUnicodeString2 ( "eng", gPs2KeyboardComponentName.SupportedLanguages, &ConsoleIn->ControllerNameTable, L"PS/2 Keyboard Device", TRUE ); AddUnicodeString2 ( "en", gPs2KeyboardComponentName2.SupportedLanguages, &ConsoleIn->ControllerNameTable, L"PS/2 Keyboard Device", FALSE ); // // Install protocol interfaces for the keyboard device. // Status = gBS->InstallMultipleProtocolInterfaces ( &Controller, &gEfiSimpleTextInProtocolGuid, &ConsoleIn->ConIn, &gEfiSimpleTextInputExProtocolGuid, &ConsoleIn->ConInEx, NULL ); if (EFI_ERROR (Status)) { StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; goto ErrorExit; } return Status; ErrorExit: // // Report error code // if (StatusCode != 0) { REPORT_STATUS_CODE_WITH_DEVICE_PATH ( EFI_ERROR_CODE | EFI_ERROR_MINOR, StatusCode, DevicePath ); } if ((ConsoleIn != NULL) && (ConsoleIn->ConIn.WaitForKey != NULL)) { gBS->CloseEvent (ConsoleIn->ConIn.WaitForKey); } if ((ConsoleIn != NULL) && (ConsoleIn->TimerEvent != NULL)) { gBS->CloseEvent (ConsoleIn->TimerEvent); } if ((ConsoleIn != NULL) && (ConsoleIn->ConInEx.WaitForKeyEx != NULL)) { gBS->CloseEvent (ConsoleIn->ConInEx.WaitForKeyEx); } KbdFreeNotifyList (&ConsoleIn->NotifyList); if ((ConsoleIn != NULL) && (ConsoleIn->ControllerNameTable != NULL)) { FreeUnicodeStringTable (ConsoleIn->ControllerNameTable); } // // Since there will be no timer handler for keyboard input any more, // exhaust input data just in case there is still keyboard data left // if (ConsoleIn != NULL) { Status1 = EFI_SUCCESS; while (!EFI_ERROR (Status1) && (Status != EFI_DEVICE_ERROR)) { Status1 = KeyboardRead (ConsoleIn, &Data);; } } if (ConsoleIn != NULL) { gBS->FreePool (ConsoleIn); } gBS->CloseProtocol ( Controller, &gEfiSioProtocolGuid, This->DriverBindingHandle, Controller ); return Status; }