pnp.c File Reference

#include "precomp.h"

Go to the source code of this file.

Classes
struct	_CDROM_NOTIFY
Defines
#define	EVENT_CDROM_MEDIA_ARRIVAL   1
#define	EVENT_CDROM_MEDIA_REMOVAL   2
Typedefs
typedef _CDROM_NOTIFY	CDROM_NOTIFY
typedef _CDROM_NOTIFY *	PCDROM_NOTIFY
Functions
NTSTATUS	Win32kPnPDriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING pustrRegistryPath)
VOID	InitializeMediaChange (HANDLE hMediaRequestEvent)
__inline VOID	EnterMediaCrit ()
__inline VOID	LeaveMediaCrit ()
ULONG	GetDeviceChangeInfo ()
NTSTATUS	DeviceCDROMNotify (IN PTARGET_DEVICE_CUSTOM_NOTIFICATION Notification, IN PCDROM_NOTIFY pContext)
NTSTATUS	DeviceClassCDROMNotify (IN PDEVICE_INTERFACE_CHANGE_NOTIFICATION classChange, IN PVOID Unused)
PDEVICEINFO	CreateDeviceInfo (DWORD DeviceType, PUNICODE_STRING pustrName, BYTE bFlags)
NTSTATUS	DeviceClassNotify (IN PDEVICE_INTERFACE_CHANGE_NOTIFICATION classChange, IN PVOID DeviceType)
BOOL	OpenMultiplePortDevice (DWORD DeviceType)
NTSTATUS	xxxRegisterForDeviceClassNotifications ()
NTSTATUS	QueryDeviceInfo (PDEVICEINFO pDeviceInfo)
BOOL	OpenDevice (PDEVICEINFO pDeviceInfo)
VOID	CloseDevice (PDEVICEINFO pDeviceInfo)
BOOL	RegisterForDeviceChangeNotifications (PDEVICEINFO pDeviceInfo)
BOOL	UnregisterForDeviceChangeNotifications (PDEVICEINFO pDeviceInfo)
NTSTATUS	DeviceNotify (IN PPLUGPLAY_NOTIFY_HDR pNotification, IN PDEVICEINFO pDeviceInfo)
PDEVICEINFO	StartDeviceRead (PDEVICEINFO pDeviceInfo)
VOID	ProcessDeviceChanges (DWORD DeviceType)
VOID	RequestDeviceChange (PDEVICEINFO pDeviceInfo, USHORT usAction, BOOL fInDeviceInfoListCrit)
Variables
DEVICE_TEMPLATE	aDeviceTemplate [DEVICE_TYPE_MAX+1]
NTSTATUS	gKbdIoctlLEDSStatus = -1
LIST_ENTRY	gMediaChangeList
PFAST_MUTEX	gMediaChangeMutex
HANDLE	gpEventMediaChange = NULL
UCHAR	DriveLetterChange [26]

---

Define Documentation

#define EVENT_CDROM_MEDIA_ARRIVAL   1

Definition at line 70 of file w32/ntuser/kernel/pnp.c. Referenced by DeviceCDROMNotify(), and GetDeviceChangeInfo().

#define EVENT_CDROM_MEDIA_REMOVAL   2

Definition at line 71 of file w32/ntuser/kernel/pnp.c. Referenced by DeviceCDROMNotify().

---

Typedef Documentation

typedef struct _CDROM_NOTIFY CDROM_NOTIFY

typedef struct _CDROM_NOTIFY * PCDROM_NOTIFY

Referenced by DeviceCDROMNotify(), DeviceClassCDROMNotify(), and GetDeviceChangeInfo().

---

Function Documentation

VOID CloseDevice (  PDEVICEINFO  pDeviceInfo  )

Definition at line 885 of file w32/ntuser/kernel/pnp.c. References CheckCritIn, NT_SUCCESS, NTSTATUS(), PsGetCurrentThread, Status, and VOID(). Referenced by ProcessDeviceChanges(). { NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock; CheckCritIn(); TAGMSG3(DBGTAG_PNP, "CloseDevice(): closing type %d (%lx %ws)", pDeviceInfo->type, pDeviceInfo->handle, pDeviceInfo->ustrName.Buffer); if (pDeviceInfo->handle) { UserAssert(pDeviceInfo->OpenerProcess == PsGetCurrentThread()->Cid.UniqueProcess); ZwCancelIoFile(pDeviceInfo->handle, &IoStatusBlock); UserAssertMsg2(NT_SUCCESS(IoStatusBlock.Status), "NtCancelIoFile handle %x failed status %#x", pDeviceInfo->handle, IoStatusBlock.Status); Status = ZwClose(pDeviceInfo->handle); UserAssertMsg2(NT_SUCCESS(Status), "ZwClose handle %x failed status %#x", pDeviceInfo->handle, Status); pDeviceInfo->handle = 0; } else { /* * Assert the IO was cancelled or we tried to read the device * after the first close (which set the handle to 0 - an invalid handle) */ UserAssert((pDeviceInfo->iosb.Status == STATUS_CANCELLED) || (pDeviceInfo->ReadStatus == STATUS_INVALID_HANDLE)); } }

PDEVICEINFO CreateDeviceInfo (  DWORD  DeviceType, PUNICODE_STRING  pustrName, BYTE  bFlags )

Definition at line 406 of file w32/ntuser/kernel/pnp.c. References aDeviceTemplate, BEGINATOMICCHECK, BYTE, CheckCritIn, CreateKernelEvent(), DEVICE_TYPE_MAX, ENDATOMICCHECK, EnterDeviceInfoListCrit(), EXITATOMICCHECK, FALSE, GDIAF_ARRIVED, gpDeviceInfoList, LeaveDeviceInfoListCrit(), NULL, RequestDeviceChange(), RtlCopyUnicodeString(), and TRUE. Referenced by DeviceClassNotify(), OpenMultiplePortDevice(), and RawInputThread(). { PDEVICEINFO pDeviceInfo = NULL; CheckCritIn(); BEGINATOMICCHECK(); UserAssert(pustrName != NULL); TAGMSG3(DBGTAG_PNP, "CreateDeviceInfo(%d, %S, %x)", DeviceType, pustrName->Buffer, bFlags); if (DeviceType > DEVICE_TYPE_MAX) { RIPMSG1(RIP_ERROR, "Unknown DeviceType %lx", DeviceType); } pDeviceInfo = UserAllocPoolZInit(aDeviceTemplate[DeviceType].cbDeviceInfo, TAG_PNP); if (pDeviceInfo == NULL) { RIPMSG0(RIP_WARNING, "CreateDeviceInfo() out of memory allocating DEVICEINFO"); EXITATOMICCHECK(); return NULL; } if (pustrName->Buffer != NULL) { pDeviceInfo->ustrName.Buffer = UserAllocPool(pustrName->Length, TAG_PNP); if (pDeviceInfo->ustrName.Buffer == NULL) { RIPMSG1(RIP_WARNING, "CreateDeviceInfo: Can't duplicate string %ws", pustrName->Buffer); goto CreateFailed; } pDeviceInfo->ustrName.MaximumLength = pustrName->Length; RtlCopyUnicodeString(&pDeviceInfo->ustrName, pustrName); } pDeviceInfo->type = (BYTE)DeviceType; /* * Create this device's HidChangeCompletion event. When the RIT completes * a synchronous ProcessDeviceChanges() it signals the HidChangeCompletion * event to wake the requesting RequestDeviceChange() which is blocking on * the event. * Each device has it's own HidChangeCompletion event, * since multiple PnP notification may arrive for several different * devices simultaneously. (see #331320 IanJa) */ pDeviceInfo->pkeHidChangeCompleted = CreateKernelEvent(SynchronizationEvent, FALSE); if (pDeviceInfo->pkeHidChangeCompleted == NULL) { RIPMSG0(RIP_WARNING, "CreateDeviceInfo: failed to create pkeHidChangeCompleted"); goto CreateFailed; } /* * Link it in */ EnterDeviceInfoListCrit(); pDeviceInfo->pNext = gpDeviceInfoList; gpDeviceInfoList = pDeviceInfo; pDeviceInfo->bFlags |= bFlags; /* * Tell the RIT there is a new device so that it can open it and start * reading from it. This is non-blocking (no GDIAF_PNPWAITING bit set) */ RequestDeviceChange(pDeviceInfo, GDIAF_ARRIVED, TRUE); LeaveDeviceInfoListCrit(); EXITATOMICCHECK(); return pDeviceInfo; CreateFailed: if (pDeviceInfo) { if (pDeviceInfo->ustrName.Buffer) { UserFreePool(pDeviceInfo->ustrName.Buffer); } UserFreePool(pDeviceInfo); } ENDATOMICCHECK(); return NULL; }

NTSTATUS DeviceCDROMNotify (  IN PTARGET_DEVICE_CUSTOM_NOTIFICATION  Notification, IN PCDROM_NOTIFY  pContext )

Definition at line 248 of file w32/ntuser/kernel/pnp.c. References CheckCritOut, EnterMediaCrit(), _CDROM_NOTIFY::Entry, EVENT_CDROM_MEDIA_ARRIVAL, EVENT_CDROM_MEDIA_REMOVAL, EVENT_INCREMENT, FALSE, gbRemoteSession, gMediaChangeList, gpEventMediaChange, IoUnregisterPlugPlayNotification(), KeSetEvent(), LeaveMediaCrit(), NTSTATUS(), PCDROM_NOTIFY, PTARGET_DEVICE_CUSTOM_NOTIFICATION, and _CDROM_NOTIFY::Size. Referenced by DeviceClassCDROMNotify(). { PCDROM_NOTIFY pNew; CheckCritOut(); UserAssert(!gbRemoteSession); UserAssert(pContext); if (IsEqualGUID(&Notification->Event, &GUID_IO_MEDIA_ARRIVAL)) { pContext->Event = EVENT_CDROM_MEDIA_ARRIVAL; } else if (IsEqualGUID(&Notification->Event, &GUID_IO_MEDIA_REMOVAL)) { pContext->Event = EVENT_CDROM_MEDIA_REMOVAL; } else if (IsEqualGUID(&Notification->Event, &GUID_TARGET_DEVICE_REMOVE_COMPLETE)) { IoUnregisterPlugPlayNotification(pContext->RegistrationHandle); UserFreePool(pContext); return STATUS_SUCCESS; } else { return STATUS_SUCCESS; } // // Process the arrival or removal // // We must queue this otherwise we end up bugchecking on Terminal Server // This is due to opening a handle from within the system process which // requires us to do an attach process. // pNew = UserAllocPoolNonPaged(pContext->Size, TAG_PNP); if (pNew) { RtlCopyMemory(pNew, pContext, pContext->Size); EnterMediaCrit(); InsertHeadList(&gMediaChangeList, &pNew->Entry); LeaveMediaCrit(); KeSetEvent(gpEventMediaChange, EVENT_INCREMENT, FALSE); } return STATUS_SUCCESS; }

NTSTATUS DeviceClassCDROMNotify (  IN PDEVICE_INTERFACE_CHANGE_NOTIFICATION  classChange, IN PVOID  Unused )

Definition at line 310 of file w32/ntuser/kernel/pnp.c. References CheckCritOut, DeviceCDROMNotify(), _CDROM_NOTIFY::DeviceName, EventCategoryTargetDeviceChange, gpWin32kDriverObject, IoGetDeviceObjectPointer(), IoRegisterPlugPlayNotification(), NT_SUCCESS, NTSTATUS(), ObDereferenceObject, PCDROM_NOTIFY, PDEVICE_INTERFACE_CHANGE_NOTIFICATION, _CDROM_NOTIFY::RegistrationHandle, _CDROM_NOTIFY::Size, Size, and Status. Referenced by xxxRegisterForDeviceClassNotifications(). { NTSTATUS Status = STATUS_SUCCESS; PFILE_OBJECT FileObject; PDEVICE_OBJECT DeviceObject; PCDROM_NOTIFY pContext; ULONG Size; UNREFERENCED_PARAMETER(Unused); CheckCritOut(); /* * Sanity check the DeviceType, and that it matches the InterfaceClassGuid */ UserAssert(IsEqualGUID(&classChange->InterfaceClassGuid, &CdRomClassGuid)); if (IsEqualGUID(&classChange->Event, &GUID_DEVICE_INTERFACE_ARRIVAL)) { Status = IoGetDeviceObjectPointer(classChange->SymbolicLinkName, FILE_READ_ATTRIBUTES, &FileObject, &DeviceObject); if (NT_SUCCESS(Status)) { Size = sizeof(CDROM_NOTIFY) + classChange->SymbolicLinkName->Length; pContext = (PCDROM_NOTIFY) UserAllocPool(Size, TAG_PNP); // // Register For MediaChangeNotifications on all the CDROMs. // if (pContext) { pContext->Size = Size; pContext->DeviceName.DeviceNameLength = classChange->SymbolicLinkName->Length; RtlCopyMemory(pContext->DeviceName.DeviceName, classChange->SymbolicLinkName->Buffer, pContext->DeviceName.DeviceNameLength); IoRegisterPlugPlayNotification ( EventCategoryTargetDeviceChange, 0, FileObject, gpWin32kDriverObject, DeviceCDROMNotify, pContext, &(pContext->RegistrationHandle)); } ObDereferenceObject(FileObject); } } else if (IsEqualGUID(&classChange->Event, &GUID_DEVICE_INTERFACE_REMOVAL)) { // // Do nothing - we already remove the registration. // } else { RIPMSG0(RIP_ERROR, "unrecognized Event GUID"); } return STATUS_SUCCESS; }

NTSTATUS DeviceClassNotify (  IN PDEVICE_INTERFACE_CHANGE_NOTIFICATION  classChange, IN PVOID  DeviceType )

Definition at line 503 of file w32/ntuser/kernel/pnp.c. References aDeviceTemplate, CheckCritOut, CreateDeviceInfo(), DEVICE_TYPE_KEYBOARD, DEVICE_TYPE_MOUSE, DWORD, EnterCrit, LeaveCrit, and tagDEVICE_TEMPLATE::pClassGUID. Referenced by xxxRegisterForDeviceClassNotifications(). { DWORD dwDeviceType; CheckCritOut(); dwDeviceType = PtrToUlong( DeviceType ); TAGMSG2(DBGTAG_PNP, "enter DeviceClassNotify(%lx, %lx)", classChange, dwDeviceType); /* * Sanity check the DeviceType, and that it matches the InterfaceClassGuid */ UserAssert((dwDeviceType == DEVICE_TYPE_MOUSE) || (dwDeviceType == DEVICE_TYPE_KEYBOARD)); UserAssert(IsEqualGUID(&classChange->InterfaceClassGuid, aDeviceTemplate[dwDeviceType].pClassGUID)); TAGMSG3(DBGTAG_PNP | RIP_THERESMORE, " Event GUID %lx, %x, %x", classChange->Event.Data1, classChange->Event.Data2, classChange->Event.Data3); TAGMSG8(DBGTAG_PNP | RIP_THERESMORE, " %2x%2x%2x%2x%2x%2x%2x%2x", classChange->Event.Data4[0], classChange->Event.Data4[1], classChange->Event.Data4[2], classChange->Event.Data4[3], classChange->Event.Data4[4], classChange->Event.Data4[5], classChange->Event.Data4[6], classChange->Event.Data4[7]); TAGMSG4(DBGTAG_PNP | RIP_THERESMORE, " InterfaceClassGuid %lx, %lx, %lx, %lx", ((DWORD *)&(classChange->InterfaceClassGuid))[0], ((DWORD *)&(classChange->InterfaceClassGuid))[1], ((DWORD *)&(classChange->InterfaceClassGuid))[2], ((DWORD *)&(classChange->InterfaceClassGuid))[3]); TAGMSG1(DBGTAG_PNP | RIP_THERESMORE, " SymbolicLinkName %ws", classChange->SymbolicLinkName->Buffer); if (IsEqualGUID(&classChange->Event, &GUID_DEVICE_INTERFACE_ARRIVAL)) { // A new hid device class association has arrived EnterCrit(); CreateDeviceInfo(dwDeviceType, classChange->SymbolicLinkName, 0); LeaveCrit(); TAGMSG0(DBGTAG_PNP, "=== CREATED ==="); } return STATUS_SUCCESS; }

NTSTATUS DeviceNotify (  IN PPLUGPLAY_NOTIFY_HDR  pNotification, IN PDEVICEINFO  pDeviceInfo )

Definition at line 1025 of file w32/ntuser/kernel/pnp.c. References CheckCritOut, CheckDeviceInfoListCritOut, FALSE, gbRemoteSession, GDIAF_DEPARTED, GDIAF_PNPWAITING, GDIAF_QUERYREMOVE, GDIAF_REMOVECANCELLED, gpDeviceInfoList, NTSTATUS(), NULL, PsGetCurrentThread, RequestDeviceChange(), and USHORT. { USHORT usAction; #if DBG { PDEVICEINFO pDeviceInfoDbg; for (pDeviceInfoDbg = gpDeviceInfoList; pDeviceInfoDbg; pDeviceInfoDbg = pDeviceInfoDbg->pNext) { if (pDeviceInfoDbg == pDeviceInfo) { break; } } UserAssertMsg1(pDeviceInfoDbg != NULL, "Notification for unlisted DEVICEINFO %lx", pDeviceInfo); } #endif CheckCritOut(); UserAssert(!gbRemoteSession); TAGMSG1(DBGTAG_PNP | RIP_THERESMORE, "DeviceNotify >>> %lx", pDeviceInfo); UserAssert(pDeviceInfo->OpenerProcess != PsGetCurrentThread()->Cid.UniqueProcess); UserAssert(pDeviceInfo->usActions == 0); if (IsEqualGUID(&pNotification->Event, &GUID_TARGET_DEVICE_QUERY_REMOVE)) { TAGMSG0(DBGTAG_PNP | RIP_NONAME, "QueryRemove"); usAction = GDIAF_QUERYREMOVE; } else if (IsEqualGUID(&pNotification->Event, &GUID_TARGET_DEVICE_REMOVE_CANCELLED)) { TAGMSG0(DBGTAG_PNP | RIP_NONAME, "RemoveCancelled"); usAction = GDIAF_REMOVECANCELLED; } else if (IsEqualGUID(&pNotification->Event, &GUID_TARGET_DEVICE_REMOVE_COMPLETE)) { TAGMSG1(DBGTAG_PNP | RIP_NONAME, "RemoveComplete (process %#x)", PsGetCurrentThread()->Cid.UniqueProcess); usAction = GDIAF_DEPARTED; } else { TAGMSG4(DBGTAG_PNP | RIP_NONAME, "GUID Unknown: %lx:%lx:%lx:%x...", pNotification->Event.Data1, pNotification->Event.Data2, pNotification->Event.Data3, pNotification->Event.Data4[0]); return STATUS_UNSUCCESSFUL; } /* * Signal the RIT to ProcessDeviceChanges() * Wait for completion according to the GDIAF_PNPWAITING bit */ CheckCritOut(); CheckDeviceInfoListCritOut(); RequestDeviceChange(pDeviceInfo, (USHORT)(usAction | GDIAF_PNPWAITING), FALSE); return STATUS_SUCCESS; }

__inline VOID EnterMediaCrit (   )

Definition at line 142 of file w32/ntuser/kernel/pnp.c. References ExAcquireFastMutexUnsafe(), gMediaChangeMutex, KeEnterCriticalRegion, and VOID(). Referenced by DeviceCDROMNotify(), and GetDeviceChangeInfo(). { KeEnterCriticalRegion(); ExAcquireFastMutexUnsafe(gMediaChangeMutex); }

ULONG GetDeviceChangeInfo (   )

Definition at line 162 of file w32/ntuser/kernel/pnp.c. References _CDROM_NOTIFY::DeviceName, EnterMediaCrit(), _CDROM_NOTIFY::Event, EVENT_CDROM_MEDIA_ARRIVAL, Executive, FALSE, gMediaChangeList, IoBuildDeviceIoControlRequest(), IoCallDriver, IoGetDeviceObjectPointer(), ISCSRSS, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), LeaveMediaCrit(), NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, PCDROM_NOTIFY, and RtlInitUnicodeString(). { UNICODE_STRING name; PFILE_OBJECT FileObject; PDEVICE_OBJECT DeviceObject; KEVENT event; PIRP irp; MOUNTMGR_DRIVE_LETTER_INFORMATION output; IO_STATUS_BLOCK ioStatus; NTSTATUS status; PCDROM_NOTIFY pContext = 0; ULONG retval = 0; if (!(ISCSRSS())) { return 0; } EnterMediaCrit(); if (!IsListEmpty(&gMediaChangeList)) { pContext = (PCDROM_NOTIFY) RemoveTailList(&gMediaChangeList); } LeaveMediaCrit(); if (pContext == NULL) { return 0; } RtlInitUnicodeString(&name, MOUNTMGR_DEVICE_NAME); status = IoGetDeviceObjectPointer(&name, FILE_READ_ATTRIBUTES, &FileObject, &DeviceObject); if (NT_SUCCESS(status)) { KeInitializeEvent(&event, NotificationEvent, FALSE); irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER, DeviceObject, &pContext->DeviceName, sizeof(MOUNTMGR_DRIVE_LETTER_TARGET) + pContext->DeviceName.DeviceNameLength, &output, sizeof(output), FALSE, &event, &ioStatus); if (irp) { status = IoCallDriver(DeviceObject, irp); if (status == STATUS_PENDING) { KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL); status = ioStatus.Status; } if ((status == STATUS_SUCCESS) && (output.CurrentDriveLetter)) { UserAssert((output.CurrentDriveLetter - 'A') < 30); retval = 1 << (output.CurrentDriveLetter - 'A'); if (pContext->Event & EVENT_CDROM_MEDIA_ARRIVAL) { retval |= 0x80000000; } } } ObDereferenceObject(FileObject); } // // Allways free the request // UserFreePool(pContext); return retval; }

VOID InitializeMediaChange (  HANDLE  hMediaRequestEvent  )

Definition at line 119 of file w32/ntuser/kernel/pnp.c. References ExEventObjectType, ExInitializeFastMutex, gbRemoteSession, gMediaChangeList, gMediaChangeMutex, gpEventMediaChange, KernelMode, NULL, and ObReferenceObjectByHandle(). Referenced by NtUserInitialize(). { if (!gbRemoteSession) { InitializeListHead(&gMediaChangeList); ObReferenceObjectByHandle(hMediaRequestEvent, EVENT_ALL_ACCESS, *ExEventObjectType, KernelMode, &gpEventMediaChange, NULL); gMediaChangeMutex = UserAllocPoolNonPaged(sizeof(FAST_MUTEX), TAG_PNP); if (gMediaChangeMutex) { ExInitializeFastMutex(gMediaChangeMutex); } } return; }

__inline VOID LeaveMediaCrit (   )

Definition at line 147 of file w32/ntuser/kernel/pnp.c. References ExReleaseFastMutexUnsafe(), gMediaChangeMutex, KeLeaveCriticalRegion, and VOID(). Referenced by DeviceCDROMNotify(), and GetDeviceChangeInfo(). { ExReleaseFastMutexUnsafe(gMediaChangeMutex); KeLeaveCriticalRegion(); }

BOOL OpenDevice (  PDEVICEINFO  pDeviceInfo  )

Definition at line 807 of file w32/ntuser/kernel/pnp.c. References BOOL, CheckCritIn, DEVICE_TYPE_KEYBOARD, DEVICE_TYPE_MOUSE, FALSE, gbRemoteSession, GDIF_NOTPNP, ghRemoteKeyboardChannel, ghRemoteMouseChannel, gptiRit, gTermIO, NT_SUCCESS, NTSTATUS(), NULL, ObjectAttributes, PsGetCurrentThread, PtiCurrentShared, tagTERMINAL::ptiDesktop, QueryDeviceInfo(), Status, and ZwCreateFile(). Referenced by ProcessDeviceChanges(). { OBJECT_ATTRIBUTES ObjectAttributes; NTSTATUS Status; CheckCritIn(); UserAssert((PtiCurrentShared() == gptiRit) || (PtiCurrentShared() == gTermIO.ptiDesktop)); TAGMSG3(DBGTAG_PNP, "OpenDevice(): Opening type %d (%lx %ws)", pDeviceInfo->type, pDeviceInfo->handle, pDeviceInfo->ustrName.Buffer); #ifdef DIAGNOSE_IO pDeviceInfo->OpenerProcess = PsGetCurrentThread()->Cid.UniqueProcess; #endif if (gbRemoteSession) { /* * For other than the console, the mouse handle is * set before createwinstation. */ UserAssert(pDeviceInfo->ustrName.Buffer == NULL); pDeviceInfo->bFlags |= GDIF_NOTPNP; switch (pDeviceInfo->type) { case DEVICE_TYPE_MOUSE: pDeviceInfo->handle = ghRemoteMouseChannel; if (ghRemoteMouseChannel == NULL) { return FALSE; } break; case DEVICE_TYPE_KEYBOARD: pDeviceInfo->handle = ghRemoteKeyboardChannel; if (ghRemoteKeyboardChannel == NULL) { return FALSE; } break; default: RIPMSG2(RIP_ERROR, "Unknown device type %d DeviceInfo %#p", pDeviceInfo->type, pDeviceInfo); return FALSE; } } else { InitializeObjectAttributes(&ObjectAttributes, &(pDeviceInfo->ustrName), 0, NULL, NULL); #ifdef DIAGNOSE_IO pDeviceInfo->OpenStatus = #endif Status = ZwCreateFile(&pDeviceInfo->handle, FILE_READ_DATA | SYNCHRONIZE, &ObjectAttributes, &pDeviceInfo->iosb, NULL, 0, FILE_SHARE_WRITE, FILE_OPEN_IF, 0, NULL, 0); TAGMSG2(DBGTAG_PNP, "ZwCreateFile returns handle %lx, Status %lx", pDeviceInfo->handle, Status); if (!NT_SUCCESS(Status)) { if ((pDeviceInfo->bFlags & GDIF_NOTPNP) == 0) { /* * Don't warn about PS/2 mice: the PointerClassLegacy0 -9 and * KeyboardClassLegacy0 - 9 will usually fail to be created */ RIPMSG1(RIP_WARNING, "OpenDevice: ZwCreateFile failed with Status %lx", Status); } /* * Don't FreeDeviceInfo here because that alters gpDeviceInfoList * which our caller, ProcessDeviceChanges, is traversing. * Instead, let ProcessDeviceChanges do it. */ return FALSE; } } Status = QueryDeviceInfo(pDeviceInfo); return NT_SUCCESS(Status); }

BOOL OpenMultiplePortDevice (  DWORD  DeviceType  )

Definition at line 565 of file w32/ntuser/kernel/pnp.c. References aDeviceTemplate, CheckCritIn, CreateDeviceInfo(), DEVICE_TYPE_MAX, FALSE, FastGetProfileDwordW(), FastGetProfileStringW(), GDIF_NOTPNP, gpWin32kDriverObject, L, MAX_PATH, NULL, PMAP_INPUT, tagDEVICE_TEMPLATE::pwszClassName, tagDEVICE_TEMPLATE::pwszDefDevName, tagDEVICE_TEMPLATE::pwszLegacyDevName, RtlAppendUnicodeToString(), RtlInitUnicodeString(), TRUE, UINT, and tagDEVICE_TEMPLATE::uiRegistrySection. Referenced by xxxRegisterForDeviceClassNotifications(). { WCHAR awchDeviceName[MAX_PATH]; UNICODE_STRING DeviceName; PDEVICE_TEMPLATE pDevTpl; PDEVICEINFO pDeviceInfo; PWCHAR pwchNameIndex; UINT uiConnectMultiplePorts = 0; CheckCritIn(); if (DeviceType <= DEVICE_TYPE_MAX) { pDevTpl = &aDeviceTemplate[DeviceType]; } else { RIPMSG1(RIP_ERROR, "OpenMultiplePortDevice(%d) - unknown type", DeviceType); return FALSE; } /* * Note that we don't need to FastOpenUserProfileMapping() here since * uiRegistrySection (PMAP_MOUCLASS_PARAMS/PMAP_KBDCLASS_PARAMS) is a * machine setiing, not a user setting. */ uiConnectMultiplePorts = FastGetProfileDwordW(NULL, pDevTpl->uiRegistrySection, L"ConnectMultiplePorts", 0); /* * Open the device for read access. */ if (uiConnectMultiplePorts || (gpWin32kDriverObject == NULL)) { /* * Find out if there is a name substitution in the registry. * Note that we don't need to FastOpenUserProfileMapping() here since * PMAP_INPUT is a machine setting, not a user setting. */ FastGetProfileStringW(NULL, PMAP_INPUT, pDevTpl->pwszClassName, pDevTpl->pwszDefDevName, // if no substitution, use this default awchDeviceName, sizeof(awchDeviceName)/sizeof(WCHAR)); RtlInitUnicodeString(&DeviceName, awchDeviceName); pDeviceInfo = CreateDeviceInfo(DeviceType, &DeviceName, GDIF_NOTPNP); if (pDeviceInfo) { return TRUE; } } else { DeviceName.Length = 0; DeviceName.MaximumLength = sizeof(awchDeviceName); DeviceName.Buffer = awchDeviceName; RtlAppendUnicodeToString(&DeviceName, pDevTpl->pwszLegacyDevName); pwchNameIndex = &DeviceName.Buffer[(DeviceName.Length / sizeof(WCHAR)) - 1]; for (*pwchNameIndex = L'0'; *pwchNameIndex <= L'9'; (*pwchNameIndex)++) { CreateDeviceInfo(DeviceType, &DeviceName, GDIF_NOTPNP); } } return FALSE; }

VOID ProcessDeviceChanges (  DWORD  DeviceType  )

Definition at line 1191 of file w32/ntuser/kernel/pnp.c. References tagKEYBOARD_DEVICE_INFO::Attr, tagMOUSE_DEVICE_INFO::Attr, BEGINATOMICCHECK, BEGINATOMICDEVICEINFOLISTCHECK, CheckCritIn, CLEAR_GTERMF, CloseDevice(), DEVICE_TYPE_KEYBOARD, DEVICE_TYPE_MOUSE, DWORD, ENDATOMICCHECK, ENDATOMICDEVICEINFOLISTCHECK, EnterDeviceInfoListCrit(), EVENT_INCREMENT, FALSE, FreeDeviceInfo(), gbRemoteSession, GDIAF_ARRIVED, GDIAF_DEPARTED, GDIAF_IME_STATUS, GDIAF_PNPWAITING, GDIAF_QUERYREMOVE, GDIAF_RECONNECT, GDIAF_REFRESH_MOUSE, GDIAF_REMOVECANCELLED, GDIAF_RETRYREAD, giosbKbdControl, gKbdImeStatus, gKbdIoctlLEDSStatus, gKeyboardInfo, gklpBootTime, gnKeyboards, gnMice, gpDeviceInfoList, gpDispInfo, gpepCSRSS, gpsi, gptiRit, gRemoteClientKeyboardType, GTERMF_MOUSE, gTermIO, gwMouseOwnerButton, tagDISPLAYINFO::hDev, KeSetEvent(), tagDEVICEINFO::keyboard, LeaveDeviceInfoListCrit(), max, tagDEVICEINFO::mouse, NT_SUCCESS, NTSTATUS(), NULL, OpenDevice(), PpiFromProcess, PtiCurrentShared, tagTERMINAL::ptiDesktop, QueryDeviceInfo(), RegisterForDeviceChangeNotifications(), SET_GTERMF, SetDebugHotKeys(), SetGlobalCursorLevel(), StartDeviceRead(), Status, SYSMET, TRUE, UnregisterForDeviceChangeNotifications(), UpdateKeyLights(), USHORT, and VOID(). Referenced by RawInputThread(), and xxxDesktopThread(). { PDEVICEINFO pDeviceInfo; USHORT usOriginalActions; #if DBG int nChanges = 0; ULONG timeStartReadPrev; #endif /* * Reset summary information for all Mice and Keyboards */ DWORD nMice = 0; DWORD nWheels = 0; DWORD nMaxButtons = 0; int nKeyboards = 0; CheckCritIn(); BEGINATOMICCHECK(); UserAssert((PtiCurrentShared() == gptiRit) || (PtiCurrentShared() == gTermIO.ptiDesktop)); EnterDeviceInfoListCrit(); BEGINATOMICDEVICEINFOLISTCHECK(); /* * Look for devices to Create (those which have newly arrived) * and for devices to Terminate (these which have just departed) * and for device change notifications. * Make sure the actions are processed in the right order in case we * are being asked for more than one action per device: for example, * we sometimes get QueryRemove followed quickly by RemoveCancelled * and both actions arrive here together: we should do them in the * correct order. */ pDeviceInfo = gpDeviceInfoList; while (pDeviceInfo) { if (pDeviceInfo->type != DeviceType) { pDeviceInfo = pDeviceInfo->pNext; continue; } usOriginalActions = pDeviceInfo->usActions; UserAssert((usOriginalActions == 0) || (usOriginalActions & ~GDIAF_PNPWAITING)); /* * Refresh Mouse: * We read a MOUSE_ATTRIBUTES_CHANGED flag when a PS/2 mouse * is plugged back in. Find out the attributes of the device. */ if (pDeviceInfo->usActions & GDIAF_REFRESH_MOUSE) { pDeviceInfo->usActions &= ~GDIAF_REFRESH_MOUSE; UserAssert(pDeviceInfo->type == DEVICE_TYPE_MOUSE); #if DBG nChanges++; #endif TAGMSG1(DBGTAG_PNP, "QueryDeviceInfo: %lx", pDeviceInfo); QueryDeviceInfo(pDeviceInfo); } /* * QueryRemove: * Close the file object, but retain the DEVICEINFO struct and the * registration in case we later get a RemoveCancelled. */ if (pDeviceInfo->usActions & GDIAF_QUERYREMOVE) { pDeviceInfo->usActions &= ~GDIAF_QUERYREMOVE; #if DBG nChanges++; #endif TAGMSG1(DBGTAG_PNP, "QueryRemove: %lx", pDeviceInfo); CloseDevice(pDeviceInfo); } /* * New device arrived or RemoveCancelled: * If new device, Open it, register for notifications and start reading * If RemoveCancelled, unregister the old notfications first */ if (pDeviceInfo->usActions & (GDIAF_ARRIVED | GDIAF_REMOVECANCELLED)) { // Reopen the file object, (this is a new file object, of course), // Unregister for the old file, register with this new one. if (pDeviceInfo->usActions & GDIAF_REMOVECANCELLED) { pDeviceInfo->usActions &= ~GDIAF_REMOVECANCELLED; #if DBG nChanges++; #endif TAGMSG1(DBGTAG_PNP, "RemoveCancelled: %lx", pDeviceInfo); UnregisterForDeviceChangeNotifications(pDeviceInfo); } #if DBG if (pDeviceInfo->usActions & GDIAF_ARRIVED) { nChanges++; } #endif pDeviceInfo->usActions &= ~GDIAF_ARRIVED; if (OpenDevice(pDeviceInfo)) { PDEVICEINFO pDeviceInfoNext; RegisterForDeviceChangeNotifications(pDeviceInfo); if (!(gbRemoteSession && (pDeviceInfo->usActions & GDIAF_RECONNECT))) { pDeviceInfoNext = StartDeviceRead(pDeviceInfo); if (pDeviceInfoNext) { /* * pDeviceInfo wasa freed, move onto the next */ pDeviceInfo = pDeviceInfoNext; continue; } } pDeviceInfo->usActions &= ~GDIAF_RECONNECT; } else { /* * If the Open failed, we free the device here, and move on to * the next device. * Assert to catch re-open failure upon RemoveCancelled. */ #if DBG if ((usOriginalActions & GDIAF_ARRIVED) == 0) { RIPMSG2(RIP_WARNING, "Re-Open %#p failed status %x during RemoveCancelled", pDeviceInfo, pDeviceInfo->OpenStatus); } #endif pDeviceInfo = FreeDeviceInfo(pDeviceInfo); continue; } } /* * RemoveComplete: * Close the file object, if you have not already done so, Unregister. * FreeDeviceInfo here (which will actually request a free from the * reader or the PnP requestor thread), and move on to the next device. */ if (pDeviceInfo->usActions & GDIAF_DEPARTED) { pDeviceInfo->usActions &= ~GDIAF_DEPARTED; #if DBG nChanges++; #endif TAGMSG1(DBGTAG_PNP, "RemoveComplete: %lx (process %#x)", pDeviceInfo); CloseDevice(pDeviceInfo); UnregisterForDeviceChangeNotifications(pDeviceInfo); pDeviceInfo = FreeDeviceInfo(pDeviceInfo); continue; } if (pDeviceInfo->usActions & GDIAF_IME_STATUS) { pDeviceInfo->usActions &= ~GDIAF_IME_STATUS; #if DBG nChanges++; #endif if ((pDeviceInfo->type == DEVICE_TYPE_KEYBOARD) && (pDeviceInfo->handle)) { if (FUJITSU_KBD_CONSOLE(pDeviceInfo->keyboard.Attr.KeyboardIdentifier) || (gbRemoteSession && FUJITSU_KBD_REMOTE(gRemoteClientKeyboardType)) ) { /* * Fill up the KEYBOARD_IME_STATUS structure. */ ZwDeviceIoControlFile(pDeviceInfo->handle, NULL, NULL, NULL, &giosbKbdControl, IOCTL_KEYBOARD_SET_IME_STATUS, (PVOID)&gKbdImeStatus, sizeof(gKbdImeStatus), NULL, 0); } } } if (pDeviceInfo->usActions & GDIAF_RETRYREAD) { PDEVICEINFO pDeviceInfoNext; pDeviceInfo->usActions &= ~GDIAF_RETRYREAD; UserAssert(pDeviceInfo->ReadStatus == STATUS_INSUFFICIENT_RESOURCES); #if DBG timeStartReadPrev = pDeviceInfo->timeStartRead; #endif TAGMSG2(DBGTAG_PNP, "Retry Read %#p after %lx ticks", pDeviceInfo, pDeviceInfo->timeStartRead - timeStartReadPrev); pDeviceInfoNext = StartDeviceRead(pDeviceInfo); if (pDeviceInfoNext) { /* * pDeviceInfo wasa freed, move onto the next */ pDeviceInfo = pDeviceInfoNext; continue; } } /* * Gather summary information on open devices */ if (pDeviceInfo->handle) { switch (pDeviceInfo->type) { case DEVICE_TYPE_MOUSE: UserAssert(PtiCurrentShared() == gTermIO.ptiDesktop); if (pDeviceInfo->usActions & GDIAF_REFRESH_MOUSE) { pDeviceInfo->usActions &= ~GDIAF_REFRESH_MOUSE; #if DBG nChanges++; #endif } nMice++; nMaxButtons = max(nMaxButtons, pDeviceInfo->mouse.Attr.NumberOfButtons); switch(pDeviceInfo->mouse.Attr.MouseIdentifier) { case WHEELMOUSE_I8042_HARDWARE: case WHEELMOUSE_SERIAL_HARDWARE: case WHEELMOUSE_HID_HARDWARE: nWheels++; } break; case DEVICE_TYPE_KEYBOARD: UserAssert(PtiCurrentShared() == gptiRit); { NTSTATUS Status; // BUG BUG: why query each keyboard for indicators? They should all // be the same. #ifdef DIAGNOSE_IO gKbdIoctlLEDSStatus = #endif Status = ZwDeviceIoControlFile(pDeviceInfo->handle, NULL, NULL, NULL, &giosbKbdControl, IOCTL_KEYBOARD_QUERY_INDICATORS, NULL, 0, (PVOID)&gklpBootTime, sizeof(gklpBootTime)); UserAssertMsg2(NT_SUCCESS(Status), "IOCTL_KEYBOARD_QUERY_INDICATORS failed: DeviceInfo %#x, Status %#x", pDeviceInfo, Status); // BUG BUG, Don't handle multiple keyboards properly: the last // keyboard on the list is the one whose attributes we report! gKeyboardInfo = pDeviceInfo->keyboard.Attr; } nKeyboards++; break; default: // Add code for a new type of input device here RIPMSG2(RIP_ERROR, "pDeviceInfo %#p has strange type %d", pDeviceInfo, pDeviceInfo->type); break; } } /* * Notify the PnP thread that a change has been completed */ if (usOriginalActions & GDIAF_PNPWAITING) { KeSetEvent(pDeviceInfo->pkeHidChangeCompleted, EVENT_INCREMENT, FALSE); } pDeviceInfo = pDeviceInfo->pNext; } ENDATOMICDEVICEINFOLISTCHECK(); LeaveDeviceInfoListCrit(); switch (DeviceType) { case DEVICE_TYPE_MOUSE: /* * Apply summary information for Mice */ if (nMice) { if (gnMice == 0) { /* * We had no mouse before but we have one now: add a cursor */ SET_GTERMF(GTERMF_MOUSE); SYSMET(MOUSEPRESENT) = TRUE; SetGlobalCursorLevel(0); UserAssert(PpiFromProcess(gpepCSRSS)->ptiList->iCursorLevel == 0); UserAssert(PpiFromProcess(gpepCSRSS)->ptiList->pq->iCursorLevel == 0); GreMovePointer(gpDispInfo->hDev, gpsi->ptCursor.x, gpsi->ptCursor.y); } } else { if (gnMice != 0) { /* * We had a mouse before but we don't now: remove the cursor */ CLEAR_GTERMF(GTERMF_MOUSE); SYSMET(MOUSEPRESENT) = FALSE; SetGlobalCursorLevel(-1); /* * Don't leave mouse buttons stuck down, clear the global button * state here, otherwise weird stuff might happen. * Also do this in Alt-Tab processing and zzzCancelJournalling. */ #if DBG if (gwMouseOwnerButton) RIPMSG1(RIP_WARNING, "gwMouseOwnerButton=%x, being cleared forcibly\n", gwMouseOwnerButton); #endif gwMouseOwnerButton = 0; } } /* * Mouse button count represents the number of buttons on the mouse with * the most buttons. */ SYSMET(CMOUSEBUTTONS) = nMaxButtons; SYSMET(MOUSEWHEELPRESENT) = (nWheels > 0); gnMice = nMice; break; case DEVICE_TYPE_KEYBOARD: /* * Apply summary information for Keyboards */ if (nKeyboards > gnKeyboards) { /* * We have more keyboards, let set their LEDs properly */ UpdateKeyLights(FALSE); } if ((nKeyboards != 0) && (gnKeyboards == 0)) { /* * We had no keyboard but we have one now: set the system hotkeys. */ SetDebugHotKeys(); } gnKeyboards = nKeyboards; break; default: break; } ENDATOMICCHECK(); }

NTSTATUS QueryDeviceInfo (  PDEVICEINFO  pDeviceInfo  )

Definition at line 761 of file w32/ntuser/kernel/pnp.c. References aDeviceTemplate, tagDEVICE_TEMPLATE::cbAttr, tagDEVICE_TEMPLATE::IOCTL_Attr, NT_SUCCESS, NTSTATUS(), NULL, tagDEVICE_TEMPLATE::offAttr, PBYTE, and Status. Referenced by OpenDevice(), and ProcessDeviceChanges(). { NTSTATUS Status; PDEVICE_TEMPLATE pDevTpl = &aDeviceTemplate[pDeviceInfo->type]; #ifdef DIAGNOSE_IO pDeviceInfo->AttrStatus = #endif Status = ZwDeviceIoControlFile(pDeviceInfo->handle, NULL, NULL, NULL, &pDeviceInfo->iosb, pDevTpl->IOCTL_Attr, NULL, 0, (PVOID)((PBYTE)pDeviceInfo + pDevTpl->offAttr), pDevTpl->cbAttr); if (!NT_SUCCESS(Status)) { RIPMSG2(RIP_WARNING, "QueryDeviceInfo(%p): IOCTL failed - Status %lx", pDeviceInfo, Status); } TAGMSG1(DBGTAG_PNP, "IOCTL_*_QUERY_ATTRIBUTES returns Status %lx", Status); return Status; }

BOOL RegisterForDeviceChangeNotifications (  PDEVICEINFO  pDeviceInfo  )

Definition at line 929 of file w32/ntuser/kernel/pnp.c. References BOOL, CheckCritIn, DeviceNotify(), EventCategoryTargetDeviceChange, GDIF_NOTPNP, gptiRit, gpWin32kDriverObject, gTermIO, IoRegisterPlugPlayNotification(), KernelMode, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, ObReferenceObjectByHandle(), PsGetCurrentThread, PtiCurrentShared, tagTERMINAL::ptiDesktop, Status, and TRUE. Referenced by ProcessDeviceChanges(). { PFILE_OBJECT pFileObject; NTSTATUS Status; /* * In or Out of User critical section: * In when called from RIT ProcessDeviceChanges(); * Out when called from the DeviceNotify callback */ CheckCritIn(); UserAssert((PtiCurrentShared() == gptiRit) || (PtiCurrentShared() == gTermIO.ptiDesktop)); UserAssert(pDeviceInfo->handle); UserAssert(pDeviceInfo->OpenerProcess == PsGetCurrentThread()->Cid.UniqueProcess); if (pDeviceInfo->bFlags & GDIF_NOTPNP) { return TRUE; } Status = ObReferenceObjectByHandle(pDeviceInfo->handle, 0, NULL, KernelMode, (PVOID)&pFileObject, NULL); if (NT_SUCCESS(Status)) { Status = IoRegisterPlugPlayNotification ( EventCategoryTargetDeviceChange, // EventCategory 0, // EventCategoryFlags (PVOID)pFileObject, // EventCategoryData gpWin32kDriverObject, // DriverObject // (PDRIVER_NOTIFICATION_CALLBACK_ROUTINE) DeviceNotify, (PVOID)pDeviceInfo, // Context &pDeviceInfo->NotificationEntry); ObDereferenceObject(pFileObject); if (!NT_SUCCESS(Status)) { // This is only OK if ConnectMultiplePorts is on (ie: not a PnP device) RIPMSG3(RIP_ERROR, "IoRegisterPlugPlayNotification failed on device %.*ws, status %lx, email DoronH : #333453", pDeviceInfo->ustrName.Length / sizeof(WCHAR), pDeviceInfo->ustrName.Buffer, Status); } } else { // non-catastrophic error (won't be able to remove device) RIPMSG2(RIP_ERROR, "Can't get pFileObject from handle %lx, status %lx", pDeviceInfo->handle, Status); } return NT_SUCCESS(Status); }

VOID RequestDeviceChange (  PDEVICEINFO  pDeviceInfo, USHORT  usAction, BOOL  fInDeviceInfoListCrit )

Definition at line 1535 of file w32/ntuser/kernel/pnp.c. References aDeviceTemplate, CheckCritOut, CheckDeviceInfoListCritIn, CheckDeviceInfoListCritOut, EnterDeviceInfoListCrit(), EVENT_INCREMENT, ExIsResourceAcquiredExclusiveLite(), FALSE, FreeDeviceInfo(), GDIAF_FREEME, GDIAF_PNPWAITING, gpresDeviceInfoList, KernelMode, KeSetEvent(), KeWaitForSingleObject(), LeaveDeviceInfoListCrit(), NULL, tagDEVICE_TEMPLATE::pkeHidChange, VOID(), and WrUserRequest. Referenced by CreateDeviceInfo(), DeviceNotify(), NlsKbdSendIMENotification(), ProcessMouseInput(), and UpdateMouseInfo(). { PDEVICE_TEMPLATE pDevTpl = &aDeviceTemplate[pDeviceInfo->type]; UserAssert(pDevTpl->pkeHidChange != NULL); UserAssert((usAction & GDIAF_FREEME) == 0); UserAssert((pDeviceInfo->usActions & GDIAF_PNPWAITING) == 0); #if DBG if (pDeviceInfo->usActions != 0) { TAGMSG3(DBGTAG_PNP, "RequestDeviceChange(%#p, %x), but action %x pending", pDeviceInfo, usAction, pDeviceInfo->usActions); } /* * We can't ask for synchronized actions to be performed on the Device List * if we are holding the Device List lock or the User Critical Section: * ProcessDeviceChanges() requires both of these itself. */ if (usAction & GDIAF_PNPWAITING) { CheckDeviceInfoListCritOut(); CheckCritOut(); } #endif TAGMSG2(DBGTAG_PNP, "RequestDeviceChange(%p, %x)", pDeviceInfo, usAction); /* * Grab the DeviceInfoList critical section if we don't already have it */ UserAssert(!fInDeviceInfoListCrit == !ExIsResourceAcquiredExclusiveLite(gpresDeviceInfoList)); if (fInDeviceInfoListCrit) { CheckDeviceInfoListCritIn(); pDeviceInfo->usActions |= usAction; } else { EnterDeviceInfoListCrit(); pDeviceInfo->usActions |= usAction; LeaveDeviceInfoListCrit(); } if (usAction & GDIAF_PNPWAITING) { CheckDeviceInfoListCritOut(); KeSetEvent(pDevTpl->pkeHidChange, EVENT_INCREMENT, FALSE); KeWaitForSingleObject(pDeviceInfo->pkeHidChangeCompleted, WrUserRequest, KernelMode, FALSE, NULL); EnterDeviceInfoListCrit(); /* * Assert that nothing else cleared GDIAF_PNPWAITING - only do it here. * Check that the action we were waiting for actually occurred. */ UserAssert(pDeviceInfo->usActions & GDIAF_PNPWAITING); pDeviceInfo->usActions &= ~GDIAF_PNPWAITING; UserAssert((pDeviceInfo->usActions & usAction) == 0); if (pDeviceInfo->usActions & GDIAF_FREEME) { FreeDeviceInfo(pDeviceInfo); } LeaveDeviceInfoListCrit(); } else { KeSetEvent(pDevTpl->pkeHidChange, EVENT_INCREMENT, FALSE); } }

PDEVICEINFO StartDeviceRead (  PDEVICEINFO  pDeviceInfo  )

Definition at line 1099 of file w32/ntuser/kernel/pnp.c. References aDeviceTemplate, BOOL, tagDEVICE_TEMPLATE::cbData, EnterDeviceInfoListCrit(), ExIsResourceAcquiredExclusiveLite(), FreeDeviceInfo(), GDIAF_FREEME, GDIAF_RETRYREAD, GDIF_DBGREAD, GDIF_READING, gnRetryReadInput, gpresDeviceInfoList, InputApc(), ISTS, LeaveDeviceInfoListCrit(), LOGTIME, MAXIMUM_READ_RETRIES, NT_SUCCESS, NULL, tagDEVICE_TEMPLATE::offData, PBYTE, PsGetCurrentThread, and PZERO. Referenced by InputApc(), and ProcessDeviceChanges(). { PDEVICE_TEMPLATE pDevTpl; pDeviceInfo->bFlags |= GDIF_READING; /* * If this device needs freeing, abandon reading now and request the free. */ if (pDeviceInfo->usActions & GDIAF_FREEME) { BOOL fPreviouslyAcquired = ExIsResourceAcquiredExclusiveLite(gpresDeviceInfoList); if (!fPreviouslyAcquired) { EnterDeviceInfoListCrit(); } pDeviceInfo->bFlags &= ~GDIF_READING; pDeviceInfo = FreeDeviceInfo(pDeviceInfo); if (!fPreviouslyAcquired) { LeaveDeviceInfoListCrit(); } return pDeviceInfo; } /* * Initialize in case read fails */ pDeviceInfo->iosb.Status = STATUS_UNSUCCESSFUL; // catch concurrent writes? pDeviceInfo->iosb.Information = 0; pDevTpl = &aDeviceTemplate[pDeviceInfo->type]; UserAssert(pDeviceInfo->OpenerProcess == PsGetCurrentThread()->Cid.UniqueProcess); LOGTIME(pDeviceInfo->timeStartRead); #ifdef DIAGNOSE_IO pDeviceInfo->nReadsOutstanding++; #endif pDeviceInfo->ReadStatus = ZwReadFile( pDeviceInfo->handle, NULL, // hReadEvent InputApc, // InputApc() pDeviceInfo, // ApcContext &pDeviceInfo->iosb, (PVOID)((PBYTE)pDeviceInfo + pDevTpl->offData), pDevTpl->cbData, PZERO(LARGE_INTEGER), NULL); LOGTIME(pDeviceInfo->timeEndRead); #if DBG if (pDeviceInfo->bFlags & GDIF_DBGREAD) { TAGMSG2(DBGTAG_PNP, "ZwReadFile of Device handle %lx returned status %lx", pDeviceInfo->handle, pDeviceInfo->ReadStatus); } #endif if (!NT_SUCCESS(pDeviceInfo->ReadStatus)) { BOOL fPreviouslyAcquired = ExIsResourceAcquiredExclusiveLite(gpresDeviceInfoList); if (!fPreviouslyAcquired) { EnterDeviceInfoListCrit(); } /* * If insufficient resources, retry the read the next time the RIT * wakes up for the ID_TIMER event by incrementing gnRetryReadInput * (Cheaper than setting our own timer), * Else just abandon reading. */ if (pDeviceInfo->ReadStatus == STATUS_INSUFFICIENT_RESOURCES) { if (pDeviceInfo->nRetryRead++ < MAXIMUM_READ_RETRIES) { pDeviceInfo->usActions |= GDIAF_RETRYREAD; gnRetryReadInput++; } } else { pDeviceInfo->bFlags &= ~GDIF_READING; } #ifdef DIAGNOSE_IO pDeviceInfo->nReadsOutstanding--; #endif if (!fPreviouslyAcquired) { LeaveDeviceInfoListCrit(); } } else { pDeviceInfo->nRetryRead = 0; } if (!ISTS() && !NT_SUCCESS(pDeviceInfo->ReadStatus)) RIPMSG2(RIP_WARNING, "StartDeviceRead %#p failed Status %#x", pDeviceInfo, pDeviceInfo->ReadStatus); return NULL; }

BOOL UnregisterForDeviceChangeNotifications (  PDEVICEINFO  pDeviceInfo  )

Definition at line 981 of file w32/ntuser/kernel/pnp.c. References BOOL, CheckCritIn, FALSE, GDIF_NOTPNP, gptiRit, gTermIO, IoUnregisterPlugPlayNotification(), NT_SUCCESS, NTSTATUS(), NULL, PsGetCurrentThread, PtiCurrentShared, tagTERMINAL::ptiDesktop, Status, and TRUE. Referenced by ProcessDeviceChanges(). { NTSTATUS Status; CheckCritIn(); UserAssert((PtiCurrentShared() == gptiRit) || (PtiCurrentShared() == gTermIO.ptiDesktop)); UserAssert(pDeviceInfo->NotificationEntry); UserAssert(pDeviceInfo->OpenerProcess == PsGetCurrentThread()->Cid.UniqueProcess); if (pDeviceInfo->NotificationEntry == NULL) { /* * This happens for non-PnP devices or if the earlier * IoRegisterPlugPlayNotification() failed. Return now since * IoUnregisterPlugPlayNotification(NULL) will bluescreen. */ return TRUE; } // non-PnP devices should not have any NotificationEntry: UserAssert((pDeviceInfo->bFlags & GDIF_NOTPNP) == 0); TAGMSG3(DBGTAG_PNP, "UnregisterForDeviceChangeNotifications(): type %d (%lx %ws)", pDeviceInfo->type, pDeviceInfo, pDeviceInfo->ustrName.Buffer); Status = IoUnregisterPlugPlayNotification(pDeviceInfo->NotificationEntry); if (!NT_SUCCESS(Status)) { RIPMSG2(RIP_ERROR, "IoUnregisterPlugPlayNotification failed Status = %lx, DEVICEINFO %lx", Status, pDeviceInfo); return FALSE; } pDeviceInfo->NotificationEntry = 0; return TRUE; }

NTSTATUS Win32kPnPDriverEntry (  IN PDRIVER_OBJECT  DriverObject, IN PUNICODE_STRING  pustrRegistryPath )

Definition at line 90 of file w32/ntuser/kernel/pnp.c. References gpWin32kDriverObject. Referenced by xxxRegisterForDeviceClassNotifications(). { TAGMSG2(DBGTAG_PNP, "Win32kPnPDriverEntry(DriverObject = %lx, pustrRegistryPath = %#p)", DriverObject, pustrRegistryPath); // // File the pointer to our driver object away // gpWin32kDriverObject = DriverObject; return STATUS_SUCCESS; UNREFERENCED_PARAMETER(pustrRegistryPath); }

NTSTATUS xxxRegisterForDeviceClassNotifications (   )

Definition at line 639 of file w32/ntuser/kernel/pnp.c. References aDeviceTemplate, CheckCritIn, DEVICE_TYPE_MAX, DeviceClassCDROMNotify(), DeviceClassNotify(), DWORD, EnterCrit, EventCategoryDeviceInterfaceChange, gbRemoteSession, gpWin32kDriverObject, IO_NOTIFICATION_EVENT_CATEGORY, IoCreateDriver(), IoRegisterPlugPlayNotification(), L, LeaveCrit, NT_SUCCESS, NTSTATUS(), NULL, OpenMultiplePortDevice(), PDRIVER_NOTIFICATION_CALLBACK_ROUTINE, PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES, RtlInitUnicodeString(), Status, and Win32kPnPDriverEntry(). Referenced by RawInputThread(). { IO_NOTIFICATION_EVENT_CATEGORY eventCategory; ULONG eventFlags; PVOID RegistrationEntry; NTSTATUS Status; UNICODE_STRING ustrDriverName; DWORD DeviceType; CheckCritIn(); TAGMSG0(DBGTAG_PNP, "enter xxxRegisterForDeviceClassNotifications()"); /* * Remote hydra session indicates CreateDeviceInfo in xxxRemoteReconnect */ UserAssert(!gbRemoteSession); /* * This must be done before devices are registered for device notifications * which will occur as a result of CreateDeviceInfo()... */ RtlInitUnicodeString(&ustrDriverName, L"\\Driver\\Win32k"); Status = IoCreateDriver(&ustrDriverName, Win32kPnPDriverEntry); TAGMSG1(DBGTAG_PNP | RIP_THERESMORE, "IoCreateDriver returned status = %lx", Status); TAGMSG1(DBGTAG_PNP, "gpWin32kDriverObject = %lx", gpWin32kDriverObject); if (!NT_SUCCESS(Status)) { RIPMSG1(RIP_ERROR, "IoCreateDriver failed, status %lx", Status); Status = STATUS_SUCCESS; } UserAssert(gpWin32kDriverObject); // // We are only interested in DeviceClasses changing. // eventCategory = EventCategoryDeviceInterfaceChange; // // We want to be notified for all devices that are in the system. // those that are know now, and those that will arive later. // This allows us to have one code path for adding devices, and eliminates // the nasty race condition. If we were only interested in the devices // that exist at this one moment in time, and not future devices, we // would call IoGetDeviceClassAssociations. // eventFlags = PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES; /* * For all input device types: * If they are Multiple Port Devices (ie: not PnP) just open them * Else Register them for PnP notifications (they will be opened when the * arrival notification arrives. * If devices are already attached, we will received immediate notification * during the call to IoRegisterPlugPlayNotification, so we must LeaveCrit * because the callback routine DeviceClassNotify expects it. */ for (DeviceType = 0; DeviceType <= DEVICE_TYPE_MAX; DeviceType++) { if (!OpenMultiplePortDevice(DeviceType)) { /* * Make the registration */ TAGMSG1(DBGTAG_PNP, "Registering device type %d", DeviceType); LeaveCrit(); // for DeviceClassNotify Status = IoRegisterPlugPlayNotification ( eventCategory, eventFlags, (PVOID)aDeviceTemplate[DeviceType].pClassGUID, gpWin32kDriverObject, (PDRIVER_NOTIFICATION_CALLBACK_ROUTINE)DeviceClassNotify, LongToPtr( DeviceType ), &RegistrationEntry); EnterCrit(); TAGMSG1(DBGTAG_PNP, "Registration returned status %lx", Status); if (!NT_SUCCESS(Status)) { RIPMSG2(RIP_ERROR, "IoRegisterPlugPlayNotification(%d) failed, status %lx", DeviceType, Status); } } } // Now Register for CD_ROM notifications LeaveCrit(); // for DeviceClassNotify Status = IoRegisterPlugPlayNotification ( eventCategory, eventFlags, (PVOID) &CdRomClassGuid, gpWin32kDriverObject, (PDRIVER_NOTIFICATION_CALLBACK_ROUTINE)DeviceClassCDROMNotify, NULL, &RegistrationEntry); EnterCrit(); return Status; }

---

Variable Documentation

DEVICE_TEMPLATE aDeviceTemplate[DEVICE_TYPE_MAX+1]

Definition at line 17 of file w32/ntuser/kernel/pnp.c. Referenced by CreateDeviceInfo(), DeviceClassNotify(), InputApc(), OpenMultiplePortDevice(), QueryDeviceInfo(), RawInputThread(), RequestDeviceChange(), StartDeviceRead(), Win32kNtUserCleanup(), xxxDesktopThread(), and xxxRegisterForDeviceClassNotifications().

UCHAR DriveLetterChange[26]

Definition at line 69 of file w32/ntuser/kernel/pnp.c.

NTSTATUS gKbdIoctlLEDSStatus = -1

Definition at line 54 of file w32/ntuser/kernel/pnp.c. Referenced by ProcessDeviceChanges().

LIST_ENTRY gMediaChangeList

Definition at line 66 of file w32/ntuser/kernel/pnp.c. Referenced by DeviceCDROMNotify(), GetDeviceChangeInfo(), and InitializeMediaChange().

PFAST_MUTEX gMediaChangeMutex

Definition at line 67 of file w32/ntuser/kernel/pnp.c. Referenced by EnterMediaCrit(), InitializeMediaChange(), and LeaveMediaCrit().

HANDLE gpEventMediaChange = NULL

Definition at line 68 of file w32/ntuser/kernel/pnp.c. Referenced by DeviceCDROMNotify(), and InitializeMediaChange().

---