Include dependency graph for io.h:
Go to the source code of this file.
Classes | |
| struct | _FILE_OBJECT_EXTENSION |
| struct | _IOP_MINI_COMPLETION_PACKET |
| struct | _IO_UNLOAD_SAFE_COMPLETION_CONTEXT |
| struct | _IO_WORKITEM |
| struct | _IO_INTERRUPT |
| struct | _ERROR_LOG_ENTRY |
| struct | _EXTENDED_IO_REMOVE_LOCK |
| struct | _DUMMY_FILE_OBJECT |
| struct | _OPEN_PACKET |
| struct | _DRIVER_INFORMATION |
| struct | _IO_BUS_TYPE_GUID_LIST |
| struct | _SHUTDOWN_ENTRY |
| struct | _FS_CHANGE_NOTIFY_ENTRY |
| struct | _DRIVER_REINIT_ITEM |
| struct | _DEVICETREE_TRAVERSE_CONTEXT |
| struct | _RESERVE_IRP_ALLOCATOR |
Enumerations | |
| enum | _IOP_DEVICE_LIST_OPERATION { IopRemove , IopAdd } |
| enum | _IOP_TRANSFER_TYPE { IopReadTransfer , IopWriteTransfer , IopOtherTransfer } |
| enum | _COMPLETION_PACKET_TYPE { IopCompletionPacketIrp , IopCompletionPacketMini , IopCompletionPacketQuota } |
| enum | _SECURITY_DESCRIPTOR_TYPE { RestrictedPublic = 1 , UnrestrictedPublic , RestrictedPublicOpen , UnrestrictedPublicOpen , SystemDefault } |
| enum | _DEVICE_ACTION { PiActionEnumDeviceTree , PiActionEnumRootDevices , PiActionResetDevice , PiActionAddBootDevices , PiActionStartDevice , PiActionQueryState } |
Macro Definition Documentation
◆ _IO_DEBUG_
◆ ENUM_ROOT
| #define ENUM_ROOT L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum" |
◆ IO_API_DEBUG
◆ IO_CTL_DEBUG
◆ IO_FILE_DEBUG
◆ IO_IRP_DEBUG
◆ IO_METHOD_FROM_CTL_CODE
◆ IoGetDevObjExtension
| #define IoGetDevObjExtension | ( | DeviceObject | ) |
Value:
((DeviceObject)->DeviceObjectExtension))
struct _EXTENDED_DEVOBJ_EXTENSION * PEXTENDED_DEVOBJ_EXTENSION
◆ IoGetDrvObjExtension
| #define IoGetDrvObjExtension | ( | DriverObject | ) |
Value:
((DriverObject)->DriverExtension))
struct _EXTENDED_DRIVER_EXTENSION * PEXTENDED_DRIVER_EXTENSION
◆ IOP_CREATE_FILE_OBJECT_EXTENSION
◆ IOP_MAX_REPARSE_TRAVERSAL
◆ IOP_USE_TOP_LEVEL_DEVICE_HINT
◆ IopAllocateMdlFromLookaside
| #define IopAllocateMdlFromLookaside ObpAllocateObjectCreateInfoBuffer |
◆ IopDeviceNodeClearFlag
| #define IopDeviceNodeClearFlag | ( | DeviceNode, | |
| Flag | |||
| ) | ((DeviceNode)->Flags &= ~(Flag)) |
◆ IopDeviceNodeClearProblem
| #define IopDeviceNodeClearProblem | ( | DeviceNode, | |
| Problem | |||
| ) | ((DeviceNode)->Problem &= ~(Problem)) |
◆ IopDeviceNodeClearUserFlag
| #define IopDeviceNodeClearUserFlag | ( | DeviceNode, | |
| UserFlag | |||
| ) | ((DeviceNode)->UserFlags &= ~(UserFlag)) |
◆ IopDeviceNodeHasFlag
| #define IopDeviceNodeHasFlag | ( | DeviceNode, | |
| Flag | |||
| ) | (((DeviceNode)->Flags & (Flag)) > 0) |
◆ IopDeviceNodeHasProblem
| #define IopDeviceNodeHasProblem | ( | DeviceNode, | |
| Problem | |||
| ) | (((DeviceNode)->Problem & (Problem)) > 0) |
◆ IopDeviceNodeHasUserFlag
| #define IopDeviceNodeHasUserFlag | ( | DeviceNode, | |
| UserFlag | |||
| ) | (((DeviceNode)->UserFlags & (UserFlag)) > 0) |
◆ IopDeviceNodeSetFlag
| #define IopDeviceNodeSetFlag | ( | DeviceNode, | |
| Flag | |||
| ) | ((DeviceNode)->Flags |= (Flag)) |
◆ IopDeviceNodeSetProblem
| #define IopDeviceNodeSetProblem | ( | DeviceNode, | |
| Problem | |||
| ) | ((DeviceNode)->Problem |= (Problem)) |
◆ IopDeviceNodeSetUserFlag
| #define IopDeviceNodeSetUserFlag | ( | DeviceNode, | |
| UserFlag | |||
| ) | ((DeviceNode)->UserFlags |= (UserFlag)) |
◆ IopFreeMdlFromLookaside
| #define IopFreeMdlFromLookaside ObpFreeCapturedAttributes |
◆ IopInitDeviceTreeTraverseContext
| #define IopInitDeviceTreeTraverseContext | ( | _DeviceTreeTraverseContext, | |
| _DeviceNode, | |||
| _Action, | |||
| _Context | |||
| ) |
Value:
{ \
(_DeviceTreeTraverseContext)->FirstDeviceNode = \
(_DeviceNode); \
(_DeviceTreeTraverseContext)->Action = (_Action); \
_Check_return_ _In_z_ wchar_t const _Inout_opt_ _Deref_prepost_opt_z_ wchar_t ** _Context
Definition: corecrt_wstring.h:225
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:510
◆ IopIsValidPhysicalDeviceObject
| #define IopIsValidPhysicalDeviceObject | ( | PhysicalDeviceObject | ) |
Value:
(((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode) && \
(((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode->Flags & DNF_ENUMERATED))
Definition: iotypes.h:1084
◆ IOTRACE
◆ IsIrpSynchronous
| #define IsIrpSynchronous | ( | Irp, | |
| FileObject | |||
| ) |
Value:
◆ RD_FSCTL_FAILED
◆ RD_GUID_CONVERT_FAILED
◆ RD_NO_RAMDISK_DRIVER
◆ RD_NO_XIPROM_DESCRIPTOR
◆ RD_SYMLINK_CREATE_FAILED
◆ RD_SYSROOT_INIT_FAILED
Typedef Documentation
◆ COMPLETION_PACKET_TYPE
◆ DEVICE_ACTION
| typedef enum _DEVICE_ACTION DEVICE_ACTION |
◆ DEVICETREE_TRAVERSE_CONTEXT
◆ DEVICETREE_TRAVERSE_ROUTINE
| typedef NTSTATUS(* DEVICETREE_TRAVERSE_ROUTINE) (IN PDEVICE_NODE DeviceNode, IN PVOID Context) |
◆ DRIVER_INFORMATION
◆ DRIVER_REINIT_ITEM
◆ DUMMY_FILE_OBJECT
◆ ERROR_LOG_ENTRY
| typedef struct _ERROR_LOG_ENTRY ERROR_LOG_ENTRY |
◆ EXTENDED_IO_REMOVE_LOCK
◆ FILE_OBJECT_EXTENSION
◆ FS_CHANGE_NOTIFY_ENTRY
◆ IO_BUS_TYPE_GUID_LIST
◆ IO_INTERRUPT
| typedef struct _IO_INTERRUPT IO_INTERRUPT |
◆ IO_UNLOAD_SAFE_COMPLETION_CONTEXT
◆ IO_WORKITEM
| typedef struct _IO_WORKITEM IO_WORKITEM |
◆ IOP_DEVICE_LIST_OPERATION
◆ IOP_MINI_COMPLETION_PACKET
◆ IOP_TRANSFER_TYPE
| typedef enum _IOP_TRANSFER_TYPE IOP_TRANSFER_TYPE |
◆ OPEN_PACKET
| typedef struct _OPEN_PACKET OPEN_PACKET |
◆ PCOMPLETION_PACKET_TYPE
◆ PDEVICETREE_TRAVERSE_CONTEXT
◆ PDRIVER_INFORMATION
| typedef struct _DRIVER_INFORMATION * PDRIVER_INFORMATION |
◆ PDRIVER_REINIT_ITEM
| typedef struct _DRIVER_REINIT_ITEM * PDRIVER_REINIT_ITEM |
◆ PDUMMY_FILE_OBJECT
| typedef struct _DUMMY_FILE_OBJECT * PDUMMY_FILE_OBJECT |
◆ PERROR_LOG_ENTRY
| typedef struct _ERROR_LOG_ENTRY * PERROR_LOG_ENTRY |
◆ PEXTENDED_IO_REMOVE_LOCK
◆ PFILE_OBJECT_EXTENSION
◆ PFS_CHANGE_NOTIFY_ENTRY
◆ PIO_BUS_TYPE_GUID_LIST
◆ PIO_INTERRUPT
| typedef struct _IO_INTERRUPT * PIO_INTERRUPT |
◆ PIO_UNLOAD_SAFE_COMPLETION_CONTEXT
◆ PIOP_DEVICE_LIST_OPERATION
◆ PIOP_MINI_COMPLETION_PACKET
◆ PIOP_TRANSFER_TYPE
| typedef enum _IOP_TRANSFER_TYPE * PIOP_TRANSFER_TYPE |
◆ POPEN_PACKET
| typedef struct _OPEN_PACKET * POPEN_PACKET |
◆ PRESERVE_IRP_ALLOCATOR
◆ PSECURITY_DESCRIPTOR_TYPE
◆ PSHUTDOWN_ENTRY
| typedef struct _SHUTDOWN_ENTRY * PSHUTDOWN_ENTRY |
◆ RESERVE_IRP_ALLOCATOR
◆ SECURITY_DESCRIPTOR_TYPE
◆ SHUTDOWN_ENTRY
| typedef struct _SHUTDOWN_ENTRY SHUTDOWN_ENTRY |
Enumeration Type Documentation
◆ _COMPLETION_PACKET_TYPE
◆ _DEVICE_ACTION
| Enumerator | |
|---|---|
| PiActionEnumDeviceTree | |
| PiActionEnumRootDevices | |
| PiActionResetDevice | |
| PiActionAddBootDevices | |
| PiActionStartDevice | |
| PiActionQueryState | |
Definition at line 523 of file io.h.
524{
527 PiActionResetDevice,
529 PiActionStartDevice,
530 PiActionQueryState,
531} DEVICE_ACTION;
enum _DEVICE_ACTION DEVICE_ACTION
◆ _IOP_DEVICE_LIST_OPERATION
◆ _IOP_TRANSFER_TYPE
| Enumerator | |
|---|---|
| IopReadTransfer | |
| IopWriteTransfer | |
| IopOtherTransfer | |
Definition at line 258 of file io.h.
259{
260 IopReadTransfer,
261 IopWriteTransfer,
262 IopOtherTransfer
enum _IOP_TRANSFER_TYPE IOP_TRANSFER_TYPE
enum _IOP_TRANSFER_TYPE * PIOP_TRANSFER_TYPE
◆ _SECURITY_DESCRIPTOR_TYPE
| Enumerator | |
|---|---|
| RestrictedPublic | |
| UnrestrictedPublic | |
| RestrictedPublicOpen | |
| UnrestrictedPublicOpen | |
| SystemDefault | |
Definition at line 511 of file io.h.
512{
513 RestrictedPublic = 1,
514 UnrestrictedPublic,
515 RestrictedPublicOpen,
517 SystemDefault,
enum _SECURITY_DESCRIPTOR_TYPE SECURITY_DESCRIPTOR_TYPE
enum _SECURITY_DESCRIPTOR_TYPE * PSECURITY_DESCRIPTOR_TYPE
Function Documentation
◆ IoCancelThreadIo()
Definition at line 1146 of file irp.c.
1147{
1149 ULONG Retries = 3000;
1151 PLIST_ENTRY ListHead, NextEntry;
1153 PAGED_CODE();
1154
1155 /* Windows isn't using given thread, but using current. */
1157
1159 "%s - Canceling IRPs for Thread %p\n",
1160 __FUNCTION__,
1161 Thread);
1162
1163 /* Raise to APC to protect the IrpList */
1165
1166 /* Start by cancelling all the IRPs in the current thread queue. */
1168 NextEntry = ListHead->Flink;
1169 while (ListHead != NextEntry)
1170 {
1171 /* Get the IRP */
1173
1174 /* Cancel it */
1176
1177 /* Move to the next entry */
1178 NextEntry = NextEntry->Flink;
1179 }
1180
1181 /* Wait 100 milliseconds */
1182 Interval.QuadPart = -1000000;
1183
1184 /* Wait till all the IRPs are completed or cancelled. */
1186 {
1187 /* Now we can lower */
1189
1190 /* Wait a short while and then look if all our IRPs were completed. */
1192
1193 /*
1194 * Don't stay here forever if some broken driver doesn't complete
1195 * the IRP.
1196 */
1197 if (!(Retries--))
1198 {
1199 /* Print out a message and remove the IRP */
1201 IopDisassociateThreadIrp();
1202 }
1203
1204 /* Raise the IRQL Again */
1206 }
1207
1208 /* We're done, lower the IRQL */
1210}
Definition: Bus_PDO_EvalMethod.c:107
Definition: typedefs.h:120
Definition: typedefs.h:103
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
Referenced by PspExitThread().
◆ IoChangeFileObjectFilterContext()
| NTSTATUS NTAPI IoChangeFileObjectFilterContext | ( | IN PFILE_OBJECT | FileObject, |
| IN PVOID | FilterContext, | ||
| IN BOOLEAN | Define | ||
| ) |
Definition at line 2509 of file file.c.
2512{
2514 PFILE_OBJECT_EXTENSION FileObjectExtension;
2515
2517 {
2519 }
2520
2521 FileObjectExtension = FileObject->FileObjectExtension;
2522 if (Define)
2523 {
2524 /* If define, just set the new value if not value is set
2525 * Success will only contain old value. It is valid if it is NULL
2526 */
2527 Success = (ULONG_PTR)InterlockedCompareExchangePointer(&FileObjectExtension->FilterContext, FilterContext, NULL);
2528 }
2529 else
2530 {
2531 /* If not define, we want to reset filter context.
2532 * We will remove value (provided by the caller) and set NULL instead.
2533 * This will only success if caller provides correct previous value.
2534 * To catch whether it worked, we substract previous value to expect value:
2535 * If it matches (and thus, we reset), Success will contain 0
2536 * Otherwise, it will contain a non-zero value.
2537 */
2538 Success = (ULONG_PTR)InterlockedCompareExchangePointer(&FileObjectExtension->FilterContext, NULL, FilterContext) - (ULONG_PTR)FilterContext;
2539 }
2540
2541 /* If success isn't 0, it means we failed somewhere (set or unset) */
2543 {
2545 }
2546
2548}
_In_ PLIST_ENTRY _In_ PSTRING _In_ USHORT _In_opt_ PSTRING _In_opt_ PSTRING _In_ ULONG _In_ ULONG _In_opt_ PVOID _In_opt_ PVOID FilterContext
Definition: fsrtlfuncs.h:746
#define InterlockedCompareExchangePointer
Definition: interlocked.h:144
Definition: io.h:101
Referenced by FsRtlInsertPerFileObjectContext(), and FsRtlPTeardownPerFileObjectContexts().
◆ IoComputeDesiredAccessFileObject()
| NTSTATUS NTAPI IoComputeDesiredAccessFileObject | ( | IN PFILE_OBJECT | FileObject, |
| IN PACCESS_MASK | DesiredAccess | ||
| ) |
Definition at line 26 of file util.c.
28{
29 /* Assume failure */
30 *DesiredAccess = 0;
31
32 /* First check we really have a FileObject */
34 {
36 }
37
38 /* Then compute desired access:
39 * Check if the handle has either FILE_WRITE_DATA or FILE_APPEND_DATA was
40 * granted. However, if this is a named pipe, make sure we don't ask for
41 * FILE_APPEND_DATA as it interferes with the FILE_CREATE_PIPE_INSTANCE
42 * access right!
43 */
44 *DesiredAccess = ((!(FileObject->Flags & FO_NAMED_PIPE) ? FILE_APPEND_DATA : 0) | FILE_WRITE_DATA);
45
47}
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2664
Referenced by ObReferenceFileObjectForWrite().
◆ IoGetFileObjectFilterContext()
| PVOID NTAPI IoGetFileObjectFilterContext | ( | IN PFILE_OBJECT | FileObject | ) |
Definition at line 2494 of file file.c.
2495{
2497 {
2498 PFILE_OBJECT_EXTENSION FileObjectExtension;
2499
2500 FileObjectExtension = FileObject->FileObjectExtension;
2502 }
2503
2505}
Referenced by FsRtlInsertPerFileObjectContext(), FsRtlLookupPerFileObjectContext(), FsRtlPTeardownPerFileObjectContexts(), and FsRtlRemovePerFileObjectContext().
◆ IoGetRelatedTargetDevice()
| NTSTATUS NTAPI IoGetRelatedTargetDevice | ( | IN PFILE_OBJECT | FileObject, |
| OUT PDEVICE_OBJECT * | DeviceObject | ||
| ) |
Definition at line 1617 of file device.c.
1619{
1622
1623 /* Call the internal helper function */
1626 {
1628 }
1630}
NTSTATUS NTAPI IopGetRelatedTargetDevice(IN PFILE_OBJECT FileObject, OUT PDEVICE_NODE *DeviceNode)
Definition: device.c:654
Definition: iotypes.h:994
Referenced by FsRtlNotifyVolumeEvent(), and NtSetVolumeInformationFile().
◆ IoInitCancelHandling()
◆ IoInitFileSystemImplementation()
◆ IoInitializeCrashDump()
Definition at line 650 of file iomgr.c.
Referenced by NtCreatePagingFile().
◆ IoInitShutdownNotification()
◆ IoInitSystem()
| BOOLEAN NTAPI IoInitSystem | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 466 of file iomgr.c.
467{
468 LARGE_INTEGER ExpireTime;
471 ANSI_STRING NtBootPath, RootString;
472
473 /* Initialize empty NT Boot Path */
475
476 /* Initialize the lookaside lists */
477 IopInitLookasideLists();
478
479 /* Initialize all locks and lists */
498
499 /* Initialize PnP notifications */
500 PiInitializeNotifications();
501
502 /* Initialize the reserve IRP */
504 {
507 }
508
509 /* Initialize Timer List Lock */
511
512 /* Initialize Timer List */
514
515 /* Initialize the DPC/Timer which will call the other Timer Routines */
516 ExpireTime.QuadPart = -10000000;
520
521 /* Create Object Types */
523 {
526 }
527
528 /* Create Object Directories */
530 {
533 }
534
535 /* Initialize PnP manager */
537
538 /* Initialize SHIM engine */
539 ApphelpCacheInitialize();
540
541 /* Initialize WMI */
542 WmiInitialize();
543
544 /* Initialize HAL Root Bus Driver */
545 HalInitPnpDriver();
546
547 /* Reenumerate what HAL has added (synchronously)
548 * This function call should eventually become a 2nd stage of the PnP initialization */
551 NULL,
552 NULL);
553
554 /* Make loader block available for the whole kernel */
555 IopLoaderBlock = LoaderBlock;
556
557 /* Load boot start drivers */
558 IopInitializeBootDrivers();
559
560 /* Call back drivers that asked for */
561 IopReinitializeBootDrivers();
562
563 /* Check if this was a ramdisk boot */
565 {
566 /* Initialize the ramdisk driver */
567 IopStartRamdisk(LoaderBlock);
568 }
569
570 /* No one should need loader block any longer */
572
573 /* Create ARC names for boot devices */
576 {
579 }
580
581 /* Mark the system boot partition */
583 {
586 }
587
588 /* The disk subsystem is initialized here and the SystemRoot is set too.
589 * We can finally load other drivers from the boot volume. */
591
592 /* Load system start drivers */
593 IopInitializeSystemDrivers();
595
596 /* Reinitialize drivers that requested it */
597 IopReinitializeDrivers();
598
599 /* Convert SystemRoot from ARC to NT path */
602 {
605 }
606
607 /* Set the ANSI_STRING for the root path */
609 RootString.Length = 0;
611 RootString.MaximumLength,
612 TAG_IO);
613
614 /* Convert the path into the ANSI_STRING */
617 {
620 }
621
622 /* Assign drive letters */
623 IoAssignDriveLetters(LoaderBlock,
624 &NtBootPath,
626 &RootString);
627
628 /* Update system root */
631 {
634 }
635
636 /* Load the System DLL and its entrypoints */
639 {
642 }
643
644 /* Return success */
646}
VOID FASTCALL IoAssignDriveLetters(IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, OUT PSTRING NtSystemPathString)
Definition: ntoskrnl.c:40
Definition: bufpool.h:45
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:712
BOOLEAN NTAPI IopMarkBootPartition(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: iomgr.c:396
VOID NTAPI IopTimerDispatch(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: iotimer.c:32
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
BOOLEAN NTAPI IopInitializeReserveIrp(IN PRESERVE_IRP_ALLOCATOR ReserveIrpAllocator)
Definition: irp.c:549
NTSTATUS NTAPI IopInitializePlugPlayServices(VOID)
Definition: pnpinit.c:287
NTSTATUS NTAPI IopStartRamdisk(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: ramdisk.c:26
NTSTATUS NTAPI IopReassignSystemRoot(IN PLOADER_PARAMETER_BLOCK LoaderBlock, OUT PANSI_STRING NtBootPath)
Definition: arcname.c:839
VOID PiQueueDeviceAction(_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action, _In_opt_ PKEVENT CompletionEvent, _Out_opt_ NTSTATUS *CompletionStatus)
Queue a device operation to a worker thread.
Definition: devaction.c:2668
NTSTATUS NTAPI IopCreateArcNames(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: arcname.c:39
Definition: env_spec_w32.h:375
BOOLEAN NTAPI KeSetTimerEx(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN LONG Period, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:295
VOID NTAPI KeInitializeTimerEx(OUT PKTIMER Timer, IN TIMER_TYPE Type)
Definition: timerobj.c:244
Referenced by Phase1InitializationDiscard().
◆ IoInitVpbImplementation()
◆ IoOpenFileOnDevice()
◆ IoOpenSymlink()
◆ IopAbortInterruptedIrp()
Definition at line 67 of file irp.c.
69{
71 BOOLEAN CancelResult;
73 PAGED_CODE();
74
75 /* Raise IRQL to APC */
77
78 /* Check if nobody completed it yet */
80 {
81 /* First, cancel it */
84
85 /* Check if we cancelled it */
86 if (CancelResult)
87 {
88 /* Wait for the IRP to be cancelled */
89 Wait.QuadPart = -100000;
91 {
92 /* Delay indefintely */
94 }
95 }
96 else
97 {
98 /* No cancellation done, so wait for the I/O system to kill it */
99 KeWaitForSingleObject(EventObject,
100 Executive,
101 KernelMode,
102 FALSE,
103 NULL);
104 }
105 }
106 else
107 {
108 /* We got preempted, so give up */
110 }
111}
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
Referenced by IopFinalizeAsynchronousIo(), IopPerformSynchronousRequest(), IopQueryDeviceInformation(), IoSetInformation(), NtQueryInformationFile(), and NtSetInformationFile().
◆ IopAcquireFileObjectLock()
| NTSTATUS NTAPI IopAcquireFileObjectLock | ( | _In_ PFILE_OBJECT | FileObject, |
| _In_ KPROCESSOR_MODE | AccessMode, | ||
| _In_ BOOLEAN | Alertable, | ||
| _Out_ PBOOLEAN | LockFailed | ||
| ) |
Definition at line 2448 of file file.c.
2453{
2455
2456 PAGED_CODE();
2457
2459
2461 do
2462 {
2464 {
2465 break;
2466 }
2468 Executive,
2469 WaitMode,
2470 Alertable,
2471 NULL);
2473
2476 {
2478 *LockFailed = FALSE;
2479 }
2480 else
2481 {
2483 {
2485 }
2486 *LockFailed = TRUE;
2487 }
2488
2490}
Referenced by IopLockFileObject().
◆ IopAllocateIrpMustSucceed()
Definition at line 716 of file irp.c.
717{
721
722 /* Try to get an IRP */
726
727 /* If we fail, start looping till we may get one */
729 do {
730 i--;
731
732 /* First, sleep for 10ms */
733 Sleep.QuadPart = -10 * 1000 * 10;
735
736 /* Then, retry allocation */
741
743}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
Referenced by IoCancelFileOpen(), IopCloseFile(), and IopDeleteFile().
◆ IopAllocateReserveIrp()
Definition at line 573 of file irp.c.
574{
575 /* If we need a stack size higher than what was allocated, then fail */
577 {
579 }
580
581 /* Now, wait until the IRP becomes available and reserve it immediately */
583 {
585 Executive,
586 KernelMode,
587 FALSE,
588 NULL);
589 }
590
591 /* It's ours! Initialize it */
593
594 /* And return it to the caller */
596}
VOID NTAPI IoInitializeIrp(IN PIRP Irp, IN USHORT PacketSize, IN CCHAR StackSize)
Definition: irp.c:1854
#define IoSizeOfIrp(_StackSize)
Referenced by IoPageRead().
◆ IopAssignDeviceResources()
| NTSTATUS NTAPI IopAssignDeviceResources | ( | IN PDEVICE_NODE | DeviceNode | ) |
Definition at line 1116 of file pnpres.c.
1118{
1120 ULONG ListSize;
1121
1124 goto ByeBye;
1125
1127 {
1128 /* No resource needed for this device */
1133
1135 }
1136
1138 {
1140
1143 {
1145 goto ByeBye;
1146 }
1147
1149
1152 {
1156 }
1157 }
1158 else
1159 {
1160 /* We'll make this from the requirements */
1162 }
1163
1164 /* No resources requirements */
1166 goto Finish;
1167
1168 /* Call HAL to fixup our resource requirements list */
1170
1171 /* Add resource requirements that aren't in the list we already got */
1173 &DeviceNode->ResourceList);
1175 {
1176 DPRINT1("Failed to fixup a resource list from supplied resources for %wZ\n", &DeviceNode->InstancePath);
1178 goto ByeBye;
1179 }
1180
1181 /* IopFixupResourceListWithRequirements should NEVER give us a conflicting list */
1182 ASSERT(IopDetectResourceConflict(DeviceNode->ResourceList, FALSE, NULL) != STATUS_CONFLICTING_ADDRESSES);
1183
1184Finish:
1187 {
1190 goto ByeBye;
1191 }
1192
1195 goto ByeBye;
1196
1199 goto ByeBye;
1200
1202
1204
1205ByeBye:
1207 {
1210 }
1211
1213
1215}
NTSTATUS NTAPI HalAdjustResourceList(IN PIO_RESOURCE_REQUIREMENTS_LIST *ResourceList)
Definition: bus.c:26
ULONG NTAPI PnpDetermineResourceListSize(IN PCM_RESOURCE_LIST ResourceList)
Definition: pnpmgr.c:1237
PNP_DEVNODE_STATE PiSetDevNodeState(_In_ PDEVICE_NODE DeviceNode, _In_ PNP_DEVNODE_STATE NewState)
Definition: devnode.c:108
NTSTATUS IopUpdateResourceMapForPnPDevice(IN PDEVICE_NODE DeviceNode)
Definition: pnpres.c:961
NTSTATUS NTAPI IopFixupResourceListWithRequirements(IN PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList, OUT PCM_RESOURCE_LIST *ResourceList)
Definition: pnpres.c:219
static NTSTATUS IopTranslateDeviceResources(IN PDEVICE_NODE DeviceNode)
Definition: pnpres.c:969
static NTSTATUS IopUpdateControlKeyWithResources(IN PDEVICE_NODE DeviceNode)
Definition: pnpres.c:716
static NTSTATUS IopFilterResourceRequirements(IN PDEVICE_NODE DeviceNode)
Definition: pnpres.c:773
NTSTATUS NTAPI IopDetectResourceConflict(IN PCM_RESOURCE_LIST ResourceList, IN BOOLEAN Silent, OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor)
Definition: pnpres.c:1255
Referenced by IoReportDetectedDevice(), and PiDevNodeStateMachine().
◆ IopAttachFilterDrivers()
| NTSTATUS FASTCALL IopAttachFilterDrivers | ( | IN PDEVICE_NODE | DeviceNode, |
| IN HANDLE | EnumSubKey, | ||
| IN HANDLE | ClassKey, | ||
| IN BOOLEAN | Lower | ||
| ) |
◆ IopBootLog()
| VOID IopBootLog | ( | IN PUNICODE_STRING | DriverName, |
| IN BOOLEAN | Success | ||
| ) |
◆ IopCheckVpbMounted()
| PVPB NTAPI IopCheckVpbMounted | ( | IN POPEN_PACKET | OpenPacket, |
| IN PDEVICE_OBJECT | DeviceObject, | ||
| IN PUNICODE_STRING | RemainingName, | ||
| OUT PNTSTATUS | Status | ||
| ) |
Definition at line 76 of file volume.c.
80{
84
85 /* Lock the VPBs */
87
88 /* Set VPB mount settings */
92
93 /* Start looping until the VPB is mounted */
95 {
96 /* Release the lock */
98
99 /* Mount the volume */
101 Raw,
102 FALSE,
103 Alertable,
104 &Vpb);
105
106 /* Check if we failed or if we were alerted */
110 {
111 /* Dereference the device, since IopParseDevice referenced it */
113
114 /* Check if it was a total failure */
116
117 /* Otherwise we were alerted */
120 }
121 /*
122 * In case IopMountVolume returns a valid VPB
123 * Then, the volume is mounted, return it
124 */
126 {
128 }
129
130 /* Re-acquire the lock */
132 }
133
134 /* Make sure the VPB isn't locked */
137 {
138 /* We're locked, so fail */
141 }
142 else
143 {
144 /* Success! Reference the VPB */
145 Vpb->ReferenceCount++;
146 }
147
148 /* Release the lock and return the VPB */
151}
VOID NTAPI IopDereferenceDeviceObject(IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN ForceUnload)
Definition: device.c:463
NTSTATUS NTAPI IopMountVolume(IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN AllowRawMount, IN BOOLEAN DeviceIsLocked, IN BOOLEAN Alertable, OUT PVPB *Vpb)
Definition: volume.c:462
Definition: iotypes.h:189
Referenced by IopParseDevice().
◆ IopCleanupFailedIrp()
| NTSTATUS NTAPI IopCleanupFailedIrp | ( | IN PFILE_OBJECT | FileObject, |
| IN PKEVENT | EventObject, | ||
| IN PVOID Buffer | OPTIONAL | ||
| ) |
Definition at line 45 of file irp.c.
48{
49 PAGED_CODE();
50
51 /* Dereference the event */
53
54 /* Free a buffer, if any */
56
57 /* If this was a file opened for synch I/O, then unlock it */
59
60 /* Now dereference it and return */
63}
static __inline VOID IopUnlockFileObject(IN PFILE_OBJECT FileObject)
Definition: io_x.h:36
Referenced by IopDeviceFsIoControl(), IopGetSetSecurityObject(), IopQueryDeviceInformation(), IoSetInformation(), NtFlushBuffersFile(), NtLockFile(), NtNotifyChangeDirectoryFile(), NtQueryDirectoryFile(), NtQueryInformationFile(), NtQueryVolumeInformationFile(), NtReadFile(), NtSetInformationFile(), NtSetVolumeInformationFile(), NtUnlockFile(), and NtWriteFile().
◆ IopCloseFile()
| VOID NTAPI IopCloseFile | ( | IN PEPROCESS Process | OPTIONAL, |
| IN PVOID | Object, | ||
| IN ACCESS_MASK | GrantedAccess, | ||
| IN ULONG | ProcessHandleCount, | ||
| IN ULONG | SystemHandleCount | ||
| ) |
Definition at line 2176 of file file.c.
2181{
2185 PIO_STACK_LOCATION StackPtr;
2191
2192 /* If this isn't the last handle for the current process, quit */
2194
2195 /* Check if the file is locked and has more then one handle opened */
2197 {
2198 /* Check if this is a direct open or not */
2200 {
2201 /* Get the attached device */
2203 }
2204 else
2205 {
2206 /* Get the FO's device */
2208 }
2209
2210 /* Check if this is a sync FO and lock it */
2212 {
2214 }
2215
2216 /* Go the FastIO path if possible, otherwise fall back to IRP */
2219 !DeviceObject->DriverObject->FastIoDispatch->FastIoUnlockAll(FileObject, PsGetCurrentProcess(), &IoStatusBlock, DeviceObject))
2220 {
2221 /* Clear and set up Events */
2224
2225 /* Allocate an IRP */
2227
2228 /* Set it up */
2237
2238 /* Set up Stack Pointer Data */
2243
2244 /* Queue the IRP */
2246
2247 /* Call the FS Driver */
2250 {
2251 /* Wait for completion */
2253 }
2254
2255 /* IO will unqueue & free for us */
2256 }
2257
2258 /* Release the lock if we were holding it */
2260 {
2262 }
2263 }
2264
2265 /* Make sure this is the last handle */
2266 if (SystemHandleCount != 1) return;
2267
2268 /* Check if this is a direct open or not */
2270 {
2271 /* Get the attached device */
2273 }
2274 else
2275 {
2276 /* Get the FO's device */
2278 }
2279
2280 /* Set the handle created flag */
2282
2283 /* Check if this is a sync FO and lock it */
2286 {
2288 }
2289
2290 /* Clear and set up Events */
2293
2294 /* Allocate an IRP */
2296
2297 /* Set it up */
2304
2305 /* Set up Stack Pointer Data */
2309
2310 /* Queue the IRP */
2312
2313 /* Update operation counts */
2315
2316 /* Call the FS Driver */
2319 {
2320 /* Wait for completion */
2322 }
2323
2324 /* Unqueue the IRP */
2328
2329 /* Free the IRP */
2331
2332 /* Release the lock if we were holding it */
2335 {
2337 }
2338}
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
static __inline NTSTATUS IopLockFileObject(_In_ PFILE_OBJECT FileObject, _In_ KPROCESSOR_MODE WaitMode)
Definition: io_x.h:12
static __inline VOID IopUpdateOperationCount(IN IOP_TRANSFER_TYPE Type)
Definition: io_x.h:82
PIRP NTAPI IopAllocateIrpMustSucceed(IN CCHAR StackSize)
Definition: irp.c:716
PDEVICE_OBJECT NTAPI IoGetRelatedDeviceObject(IN PFILE_OBJECT FileObject)
Definition: device.c:1549
PDEVICE_OBJECT NTAPI IoGetAttachedDevice(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1386
Definition: filtergraph.c:51
Definition: env_spec_w32.h:413
Definition: Bus_PDO_EvalMethod.c:95
Definition: env_spec_w32.h:870
Definition: ketypes.h:863
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
#define IRP_CLOSE_OPERATION
#define IRP_MJ_CLEANUP
Referenced by IopCreateObjectTypes(), and IopDeleteFile().
◆ IopCompleteRequest()
| VOID NTAPI IopCompleteRequest | ( | IN PKAPC | Apc, |
| IN PKNORMAL_ROUTINE * | NormalRoutine, | ||
| IN PVOID * | NormalContext, | ||
| IN PVOID * | SystemArgument1, | ||
| IN PVOID * | SystemArgument2 | ||
| ) |
Definition at line 238 of file irp.c.
243{
249
250 /* Get data from the APC */
254 "%s - Completing IRP %p for %p\n",
255 __FUNCTION__,
256 Irp,
257 FileObject);
258
259 /* Sanity check */
261
262 /* Check if we have a file object */
264 {
265 /* Check if we're reparsing */
268 {
269 PREPARSE_DATA_BUFFER ReparseData;
270
272
276
278 }
279 }
280
281 /* Handle Buffered case first */
283 {
284 /* Check if we have an input buffer and if we succeeded */
288 {
289 _SEH2_TRY
290 {
291 /* Copy the buffer back to the user */
293 Irp->AssociatedIrp.SystemBuffer,
294 Irp->IoStatus.Information);
295 }
297 {
298 /* Fail the IRP */
300 }
301 _SEH2_END;
302 }
303
304 /* Also check if we should de-allocate it */
306 {
307 /* Deallocate it */
309 }
310 }
311
312 /* Now we got rid of these two... */
314
315 /* Check if there's an MDL */
317 {
318 /* Free it */
319 NextMdl = Mdl->Next;
321 }
322
323 /* No MDLs left */
325
326 /*
327 * Check if either the request was completed without any errors
328 * (but warnings are OK!), or if it was completed with an error, but
329 * did return from a pending I/O Operation and is not synchronous.
330 */
332 (Irp->PendingReturned &&
334 {
335 /* Get any information we need from the FO before we kill it */
337 {
338 /* Save Completion Data */
341 }
342
343 /* Check for UserIos */
345 {
346 /* Use SEH to make sure we don't write somewhere invalid */
347 _SEH2_TRY
348 {
349 /* Save the IOSB Information */
351 }
353 {
354 /* Ignore any error */
355 }
356 _SEH2_END;
357 }
358
359 /* Check if we have an event or a file object */
361 {
362 /* At the very least, this is a PKEVENT, so signal it always */
364
365 /* Check if we also have a File Object */
367 {
368 /* Check if this is an Asynch API */
370 {
371 /* Dereference the event */
373 }
374
375 /*
376 * Now, if this is a Synch I/O File Object, then this event is
377 * NOT an actual Executive Event, so we won't dereference it,
378 * and instead, we will signal the File Object
379 */
382 {
383 /* Signal the file object and set the status */
386 }
387
388 /*
389 * This could also be a create operation, in which case we want
390 * to make sure there's no APC fired.
391 */
393 {
394 /* Clear the APC Routine and remember this */
396 SignaledCreateRequest = TRUE;
397 }
398 }
399 }
401 {
402 /* Signal the file object and set the status */
405
406 /*
407 * This could also be a create operation, in which case we want
408 * to make sure there's no APC fired.
409 */
411 {
412 /* Clear the APC Routine and remember this */
414 SignaledCreateRequest = TRUE;
415 }
416 }
417
418 /* Update transfer count for everything but create operation */
420 {
422 {
423 /* Update write transfer count */
426 }
428 {
429 /* Update read transfer count */
432 }
433 else
434 {
435 /* Update other transfer count */
438 }
439 }
440
441 /* Now that we've signaled the events, de-associate the IRP */
443
444 /* Now check if a User APC Routine was requested */
446 {
447 /* Initialize it */
449 KeGetCurrentThread(),
451 IopFreeIrpKernelApc,
452 IopAbortIrpKernelApc,
454 Overlay.AsynchronousParameters.UserApcRoutine,
455 Irp->RequestorMode,
456 Irp->
457 Overlay.AsynchronousParameters.UserApcContext);
458
459 /* Queue it */
461 }
463 (Irp->Overlay.AsynchronousParameters.UserApcContext))
464 {
465 /* We have an I/O Completion setup... create the special Overlay */
469 }
470 else
471 {
472 /* Free the IRP since we don't need it anymore */
474 }
475
476 /* Check if we have a file object that wasn't part of a create */
478 {
479 /* Dereference it, since it's not needed anymore either */
481 }
482 }
483 else
484 {
485 /*
486 * Either we didn't return from the request, or we did return but this
487 * request was synchronous.
488 */
490 {
491 /* So we did return with a synch operation, was it the IRP? */
493 {
494 /* Yes, this IRP was synchronous, so return the I/O Status */
496
497 /* Now check if the user gave an event */
499 {
500 /* Signal it */
502 }
503 else
504 {
505 /* No event was given, so signal the FO instead */
507 }
508 }
509 else
510 {
511 /*
512 * It's not the IRP that was synchronous, it was the FO
513 * that was opened this way. Signal its event.
514 */
517 }
518 }
519
520 /* Now that we got here, we do this for incomplete I/Os as well */
522 {
523 /* Dereference the File Object unless this was a create */
525 }
526
527 /*
528 * Check if this was an Executive Event (remember that we know this
529 * by checking if the IRP is synchronous)
530 */
532 (FileObject) &&
534 {
535 /* This isn't a PKEVENT, so dereference it */
537 }
538
539 /* Now that we've signaled the events, de-associate the IRP */
541
542 /* Free the IRP as well */
544 }
545}
Definition: nsiface.idl:2307
static __inline VOID IopUpdateTransferCount(IN IOP_TRANSFER_TYPE Type, IN ULONG TransferCount)
Definition: io_x.h:116
VOID(NTAPI * PKNORMAL_ROUTINE)(IN PVOID NormalContext OPTIONAL, IN PVOID SystemArgument1 OPTIONAL, IN PVOID SystemArgument2 OPTIONAL)
Definition: ketypes.h:869
VOID NTAPI IopDoNameTransmogrify(IN PIRP Irp, IN PFILE_OBJECT FileObject, IN PREPARSE_DATA_BUFFER DataBuffer)
Definition: file.c:167
VOID NTAPI IopFreeIrpKernelApc(IN PKAPC Apc, IN PKNORMAL_ROUTINE *NormalRoutine, IN PVOID *NormalContext, IN PVOID *SystemArgument1, IN PVOID *SystemArgument2)
Definition: irp.c:25
BOOLEAN NTAPI KeInsertQueueApc(IN PKAPC Apc, IN PVOID SystemArgument1, IN PVOID SystemArgument2, IN KPRIORITY PriorityBoost)
Definition: apc.c:735
VOID NTAPI KeInitializeApc(IN PKAPC Apc, IN PKTHREAD Thread, IN KAPC_ENVIRONMENT TargetEnvironment, IN PKKERNEL_ROUTINE KernelRoutine, IN PKRUNDOWN_ROUTINE RundownRoutine OPTIONAL, IN PKNORMAL_ROUTINE NormalRoutine, IN KPROCESSOR_MODE Mode, IN PVOID Context)
Definition: apc.c:651
LONG NTAPI KeInsertQueue(IN PKQUEUE Queue, IN PLIST_ENTRY Entry)
Definition: queue.c:198
VOID NTAPI ObDereferenceObjectDeferDelete(IN PVOID Object)
Definition: obref.c:358
struct _REPARSE_DATA_BUFFER * PREPARSE_DATA_BUFFER
Definition: find_test.cpp:52
Definition: shellext.h:164
#define IRP_DEALLOCATE_BUFFER
#define IRP_INPUT_OPERATION
#define IRP_OB_QUERY_NAME
#define IRP_WRITE_OPERATION
#define IRP_CREATE_OPERATION
#define IRP_READ_OPERATION
#define IRP_BUFFERED_IO
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:741
Referenced by IofCompleteRequest(), IopPerformSynchronousRequest(), NtQueryInformationFile(), and NtSetInformationFile().
◆ IopCreateArcNames()
| NTSTATUS NTAPI IopCreateArcNames | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 39 of file arcname.c.
40{
44 BOOLEAN SingleDisk;
46 UNICODE_STRING SystemDevice, LoaderPathNameW, BootDeviceName;
47 PARC_DISK_INFORMATION ArcDiskInfo = LoaderBlock->ArcDiskInformation;
48 ANSI_STRING ArcString, LanmanRedirector, LoaderPathNameA;
49
50 /* Check if we only have one disk on the machine */
52 &ArcDiskInfo->DiskSignatureListHead);
53
54 /* Create the firmware system loader / HAL partition global name */
60
61 /* Create the OS boot partition global name */
67
68 /* Allocate memory for the string */
71 Length,
72 TAG_IO);
74 {
75 /* Copy the name */
77 LoaderBlock->ArcBootDeviceName,
78 Length);
79 }
80
81 /* Check if we only found a disk, but we're booting from CD-ROM */
83 {
84 /* Then disable single-disk mode, since there's a CD drive out there */
85 SingleDisk = FALSE;
86 }
87
88 /* If we are doing remote booting */
90 {
91 /* Yes, we have found boot device */
92 FoundBoot = TRUE;
93
94 /* Get NT device name */
98 {
100 }
101
102 /* Get ARC booting device name (in net(0) something) */
107 {
108 /* Map ARC to NT name */
109 IoAssignArcName(&BootDeviceName, &SystemDevice);
110 RtlFreeUnicodeString(&BootDeviceName);
111
112 /* Now, get loader path name */
113 RtlInitAnsiString(&LoaderPathNameA, LoaderBlock->NtHalPathName);
116 {
117 RtlFreeUnicodeString(&SystemDevice);
119 }
120
121 /* And set it has system partition */
122 IopStoreSystemPartitionInformation(&SystemDevice, &LoaderPathNameW);
123 }
124
125 RtlFreeUnicodeString(&SystemDevice);
126
127 /* Don't quit here, even if everything went fine!
128 * We need IopCreateArcNamesDisk to properly map
129 * devices with symlinks.
130 * It will return success if the mapping process went fine
131 * even if it didn't find boot device.
132 * It won't reset boot device finding status as well.
133 */
134 }
135
136 /* Loop every disk and try to find boot disk */
138 /* If it succeeded but we didn't find boot device, try to browse Cds */
140 {
142 }
143
144 /* Return success */
146}
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define ANSI_NULL
VOID IopStoreSystemPartitionInformation(_In_ PUNICODE_STRING NtSystemPartitionDeviceName, _In_ PUNICODE_STRING OsLoaderPathName)
Definition: iorsrce.c:860
NTSTATUS NTAPI IopCreateArcNamesDisk(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN BOOLEAN SingleDisk, OUT PBOOLEAN FoundBoot)
Definition: arcname.c:413
NTSTATUS NTAPI IopCreateArcNamesCd(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: arcname.c:151
Definition: arc.h:355
Definition: env_spec_w32.h:368
#define IoAssignArcName(_ArcName, _DeviceName)
Referenced by IoInitSystem().
◆ IopCreateDeviceKeyPath()
| NTSTATUS NTAPI IopCreateDeviceKeyPath | ( | IN PCUNICODE_STRING | RegistryPath, |
| IN ULONG | CreateOptions, | ||
| OUT PHANDLE | Handle | ||
| ) |
Definition at line 522 of file pnpmgr.c.
525{
530 PCWSTR Current, Last;
533
534 /* Assume failure */
536
537 /* Open root key for device instances */
540 {
543 }
544
547
548 /* Go up to the end of the string */
549 while (Current <= Last)
550 {
552 {
553 /* Not the end of the string and not a separator */
554 Current++;
555 continue;
556 }
557
558 /* Prepare relative key name */
562
563 /* Open key */
565 &KeyName,
567 hParent,
568 NULL);
571 &ObjectAttributes,
572 0,
573 NULL,
574 CreateOptions,
575 NULL);
576
577 /* Close parent key handle, we don't need it anymore */
578 if (hParent)
579 ZwClose(hParent);
580
581 /* Key opening/creating failed? */
583 {
586 }
587
588 /* Check if it is the end of the string */
589 if (Current == Last)
590 {
591 /* Yes, return success */
594 }
595
596 /* Start with this new parent key */
597 hParent = hKey;
598 Current++;
600 }
601
603}
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NTSTATUS NTAPI IopOpenRegistryKeyEx(PHANDLE KeyHandle, HANDLE ParentKey, PUNICODE_STRING Name, ACCESS_MASK DesiredAccess)
Definition: pnpmgr.c:885
Definition: umtypes.h:184
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2705
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
_Must_inspect_result_ _In_opt_ WDFKEY _In_ PCUNICODE_STRING _In_ ACCESS_MASK _In_ ULONG CreateOptions
Definition: wdfregistry.h:118
Referenced by IopInstallCriticalDevice(), IopQueryDeviceCapabilities(), IoReportDetectedDevice(), PiControlInitializeDevice(), and PiInitializeDevNode().
◆ IopCreateRegistryKeyEx()
| NTSTATUS NTAPI IopCreateRegistryKeyEx | ( | OUT PHANDLE | Handle, |
| IN HANDLE BaseHandle | OPTIONAL, | ||
| IN PUNICODE_STRING | KeyName, | ||
| IN ACCESS_MASK | DesiredAccess, | ||
| IN ULONG | CreateOptions, | ||
| OUT PULONG Disposition | OPTIONAL | ||
| ) |
◆ IopCreateVpb()
| NTSTATUS NTAPI IopCreateVpb | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 158 of file volume.c.
159{
161
162 /* Allocate the Vpb */
165 TAG_VPB);
167
168 /* Clear it so we don't waste time manually */
170
171 /* Set the Header and Device Field */
175
176 /* Link it to the Device Object */
179}
#define IO_TYPE_VPB
struct _VPB VPB
Referenced by IoCreateDevice(), and IoVerifyVolume().
◆ IopDeleteDevice()
Definition at line 52 of file device.c.
53{
56 PAGED_CODE();
57
58 /* Cleanup and free the device node */
61
62 /* Dereference the driver object, referenced in IoCreateDevice */
65}
PDEVICE_NODE FASTCALL IopGetDeviceNode(IN PDEVICE_OBJECT DeviceObject)
NTSTATUS IopFreeDeviceNode(IN PDEVICE_NODE DeviceNode)
Referenced by IopCreateObjectTypes().
◆ IopDeleteDriver()
Definition at line 77 of file driver.c.
78{
81 PAGED_CODE();
82
84
85 /* There must be no device objects remaining at this point */
87
88 /* Get the extension and loop them */
91 {
92 /* Get the next one */
93 NextDriverExtension = DriverExtension->NextExtension;
95
96 /* Move on */
97 DriverExtension = NextDriverExtension;
98 }
99
100 /* Check if the driver image is still loaded */
102 {
103 /* Unload it */
105 }
106
107 /* Check if it has a name */
109 {
110 /* Free it */
112 }
113
114 /* Check if it has a service key name */
116 {
117 /* Free it */
119 }
120}
Definition: iotypes.h:2276
Definition: iotypes.h:983
Referenced by IopCreateObjectTypes().
◆ IopDeleteFile()
Definition at line 1352 of file file.c.
1353{
1356 PIO_STACK_LOCATION StackPtr;
1364
1365 /* Check if the file has a device object */
1367 {
1368 /* Check if this is a direct open or not */
1370 {
1371 /* Get the attached device */
1373 }
1374 else
1375 {
1376 /* Use the file object's device object */
1378 }
1379
1380 /* Sanity check */
1383
1384 /* Check if the handle wasn't created yet */
1386 {
1387 /* Send the cleanup IRP */
1389 }
1390
1391 /* Clear and set up Events */
1394
1395 /* Allocate an IRP */
1397
1398 /* Set it up */
1404
1405 /* Set up Stack Pointer Data */
1409
1410 /* Queue the IRP */
1412
1413 /* Get the VPB and check if this isn't a direct open */
1416 {
1417 /* Dereference the VPB before the close */
1419 }
1420
1421 /* Check if the FS will never disappear by itself */
1423 {
1424 /* Dereference it */
1426 DereferenceDone = TRUE;
1427 }
1428
1429 /* Call the FS Driver */
1432 {
1433 /* Wait for completion */
1435 }
1436
1437 /* De-queue the IRP */
1441
1442 /* Free the IRP */
1444
1445 /* Clear the file name */
1447 {
1448 /*
1449 * Don't use TAG_IO_NAME since the FileObject's FileName
1450 * may have been re-allocated using a different tag
1451 * by a filesystem.
1452 */
1455 }
1456
1457 /* Check if the FO had a completion port */
1459 {
1460 /* Free it */
1463 }
1464
1465 /* Check if the FO had extension */
1467 {
1468 /* Release filter context structure if any */
1470 }
1471
1472 /* Check if dereference has been done yet */
1473 if (!DereferenceDone)
1474 {
1475 /* Dereference device object */
1477 }
1478 }
1479}
VOID NTAPI FsRtlPTeardownPerFileObjectContexts(IN PFILE_OBJECT FileObject)
Definition: filtrctx.c:28
VOID NTAPI IopCloseFile(IN PEPROCESS Process OPTIONAL, IN PVOID ObjectBody, IN ACCESS_MASK GrantedAccess, IN ULONG HandleCount, IN ULONG SystemHandleCount)
Definition: file.c:2176
Referenced by IopCreateObjectTypes(), and IopParseDevice().
◆ IopDeleteIoCompletion()
Definition at line 100 of file iocomp.c.
101{
103 PLIST_ENTRY FirstEntry;
104 PLIST_ENTRY CurrentEntry;
107
108 /* Rundown the Queue */
110 if (FirstEntry)
111 {
112 /* Loop the packets */
113 CurrentEntry = FirstEntry;
114 do
115 {
116 /* Get the Packet */
119 ListEntry);
120
121 /* Go to next Entry */
122 CurrentEntry = CurrentEntry->Flink;
123
124 /* Check if it's part of an IRP, or a separate packet */
126 {
127 /* Get the IRP and free it */
130 }
131 else
132 {
133 /* Use common routine */
135 }
136 } while (FirstEntry != CurrentEntry);
137 }
138}
VOID NTAPI IopFreeMiniPacket(PIOP_MINI_COMPLETION_PACKET Packet)
Definition: iocomp.c:63
Definition: io.h:280
Definition: ketypes.h:1717
Referenced by IopCreateObjectTypes().
◆ IopDereferenceDeviceObject()
Definition at line 463 of file device.c.
465{
466 /* Sanity check */
468
469 /* Dereference the device */
471
472 /*
473 * Check if we can unload it and it's safe to unload (or if we're forcing
474 * an unload, which is OK too).
475 */
476 ASSERT(!ForceUnload);
479 {
480 /* Unload it */
482 }
483}
Referenced by IoCreateStreamFileObjectEx(), IoCreateStreamFileObjectLite(), IopCheckVpbMounted(), IopDeleteFile(), and IopParseDevice().
◆ IopDereferenceVpbAndFree()
Definition at line 186 of file volume.c.
187{
189
190 /* Lock the VPBs and decrease references */
192 Vpb->ReferenceCount--;
193
194 /* Check if we're out of references */
197 {
198 /* Release VPB lock */
200
201 /* And free VPB */
203 }
204 else
205 {
206 /* Release VPB lock */
208 }
209}
Referenced by IopParseDevice(), and IoVerifyVolume().
◆ IopDetectResourceConflict()
| NTSTATUS NTAPI IopDetectResourceConflict | ( | IN PCM_RESOURCE_LIST | ResourceList, |
| IN BOOLEAN | Silent, | ||
| OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR | ConflictingDescriptor | ||
| ) |
Definition at line 1255 of file pnpres.c.
1259{
1263 ULONG KeyInformationLength, RequiredLength, KeyValueInformationLength, KeyNameInformationLength;
1264 PKEY_BASIC_INFORMATION KeyInformation;
1265 PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
1267 ULONG ChildKeyIndex1 = 0, ChildKeyIndex2, ChildKeyIndex3;
1269
1272 &KeyName,
1274 NULL,
1275 NULL);
1276 Status = ZwOpenKey(&ResourceMapKey, KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &ObjectAttributes);
1278 {
1279 /* The key is missing which means we are the first device */
1281 }
1282
1284 {
1285 Status = ZwEnumerateKey(ResourceMapKey,
1286 ChildKeyIndex1,
1287 KeyBasicInformation,
1288 NULL,
1289 0,
1290 &RequiredLength);
1292 break;
1294 {
1295 KeyInformationLength = RequiredLength;
1297 KeyInformationLength,
1298 TAG_IO);
1299 if (!KeyInformation)
1300 {
1303 }
1304
1305 Status = ZwEnumerateKey(ResourceMapKey,
1306 ChildKeyIndex1,
1307 KeyBasicInformation,
1308 KeyInformation,
1309 KeyInformationLength,
1310 &RequiredLength);
1311 }
1312 else
1314 ChildKeyIndex1++;
1316 {
1319 }
1320
1324 &KeyName,
1326 ResourceMapKey,
1327 NULL);
1328 Status = ZwOpenKey(&ChildKey2,
1330 &ObjectAttributes);
1334
1335 ChildKeyIndex2 = 0;
1337 {
1338 Status = ZwEnumerateKey(ChildKey2,
1339 ChildKeyIndex2,
1340 KeyBasicInformation,
1341 NULL,
1342 0,
1343 &RequiredLength);
1345 break;
1347 {
1348 KeyInformationLength = RequiredLength;
1350 KeyInformationLength,
1351 TAG_IO);
1352 if (!KeyInformation)
1353 {
1356 }
1357
1358 Status = ZwEnumerateKey(ChildKey2,
1359 ChildKeyIndex2,
1360 KeyBasicInformation,
1361 KeyInformation,
1362 KeyInformationLength,
1363 &RequiredLength);
1364 }
1365 else
1367 ChildKeyIndex2++;
1369 {
1372 }
1373
1377 &KeyName,
1379 ChildKey2,
1380 NULL);
1385
1386 ChildKeyIndex3 = 0;
1388 {
1389 Status = ZwEnumerateValueKey(ChildKey3,
1390 ChildKeyIndex3,
1392 NULL,
1393 0,
1394 &RequiredLength);
1396 break;
1398 {
1399 KeyValueInformationLength = RequiredLength;
1401 KeyValueInformationLength,
1402 TAG_IO);
1403 if (!KeyValueInformation)
1404 {
1407 }
1408
1409 Status = ZwEnumerateValueKey(ChildKey3,
1410 ChildKeyIndex3,
1412 KeyValueInformation,
1413 KeyValueInformationLength,
1414 &RequiredLength);
1415 }
1416 else
1419 {
1422 }
1423
1424 Status = ZwEnumerateValueKey(ChildKey3,
1425 ChildKeyIndex3,
1426 KeyValueBasicInformation,
1427 NULL,
1428 0,
1429 &RequiredLength);
1431 {
1432 KeyNameInformationLength = RequiredLength;
1435 TAG_IO);
1437 {
1440 }
1441
1442 Status = ZwEnumerateValueKey(ChildKey3,
1443 ChildKeyIndex3,
1444 KeyValueBasicInformation,
1445 KeyNameInformation,
1446 KeyNameInformationLength,
1447 &RequiredLength);
1448 }
1449 else
1451 ChildKeyIndex3++;
1453 {
1456 }
1457
1459
1460 /* Skip translated entries */
1462 {
1465 continue;
1466 }
1467
1469
1472 Silent,
1473 ConflictingDescriptor))
1474 {
1478 }
1479
1481 }
1482 }
1483 }
1484
1485cleanup:
1492
1495
1497}
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNICODE_NULL
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
static BOOLEAN IopCheckForResourceConflict(IN PCM_RESOURCE_LIST ResourceList1, IN PCM_RESOURCE_LIST ResourceList2, IN BOOLEAN Silent, OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor)
Definition: pnpres.c:1219
Definition: restypes.h:147
Definition: nt_native.h:1102
Definition: nt_native.h:1151
Definition: nt_native.h:1168
_Must_inspect_result_ _In_ WDFIORESREQLIST _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFIORESLIST * ResourceList
Definition: wdfresource.h:309
Referenced by IopAssignDeviceResources(), IopCheckDescriptorForConflict(), IoReportResourceForDetection(), and IoReportResourceUsage().
◆ IopDoNameTransmogrify()
| VOID NTAPI IopDoNameTransmogrify | ( | IN PIRP | Irp, |
| IN PFILE_OBJECT | FileObject, | ||
| IN PREPARSE_DATA_BUFFER | DataBuffer | ||
| ) |
Definition at line 167 of file file.c.
170{
174 PWSTR NewBuffer;
175
176 PAGED_CODE();
177
185
186 /* First of all, validate data */
188 (DataBuffer->SymbolicLinkReparseBuffer.PrintNameLength +
189 DataBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength +
190 FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer[0])) > MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
191 {
193 }
194
195 /* Everything went right */
197 {
198 /* Compute buffer & length */
200 DataBuffer->MountPointReparseBuffer.SubstituteNameOffset);
201 Length = DataBuffer->MountPointReparseBuffer.SubstituteNameLength;
202
203 /* Check we don't overflow */
205 {
207 }
208 else
209 {
210 /* Compute how much memory we'll need */
212
213 /* Check if FileObject can already hold what we need */
215 {
216 NewBuffer = FileObject->FileName.Buffer;
217 }
218 else
219 {
220 /* Allocate otherwise */
223 {
225 }
226 }
227 }
228 }
229
230 /* Everything went right */
232 {
233 /* Copy the reserved data */
234 if (DataBuffer->Reserved)
235 {
237 (PWSTR)((ULONG_PTR)FileObject->FileName.Buffer + FileObject->FileName.Length - DataBuffer->Reserved),
238 DataBuffer->Reserved);
239 }
240
241 /* Then the buffer */
243 {
245 }
246
247 /* And finally replace buffer if new one was allocated */
250 {
252 {
253 /*
254 * Don't use TAG_IO_NAME since the FileObject's FileName
255 * may have been re-allocated using a different tag
256 * by a filesystem.
257 */
259 }
260
261 FileObject->FileName.Buffer = NewBuffer;
264 }
265 }
266
267 /* We don't need them anymore - it was allocated by the driver */
268 ExFreePool(DataBuffer);
269}
Referenced by IopCompleteRequest(), and IopParseDevice().
◆ IopFetchConfigurationInformation()
| NTSTATUS IopFetchConfigurationInformation | ( | _Out_ PWSTR * | SymbolicLinkList, |
| _In_ GUID | Guid, | ||
| _In_ ULONG | ExpectedInterfaces, | ||
| _Out_ PULONG | Interfaces | ||
| ) |
Definition at line 821 of file iorsrce.c.
826{
828 ULONG interfaces = 0;
829 PWSTR symbolicLinkList;
830
831 /* Get the associated enabled interfaces with the given GUID */
834 {
835 /* Zero output and leave */
838
840 }
841
842 symbolicLinkList = *SymbolicLinkList;
843
844 /* Count the number of enabled interfaces by counting the number of symbolic links */
846 {
847 interfaces++;
848 symbolicLinkList += (wcslen(symbolicLinkList) + 1);
849 }
850
851 /* Matching result will define the result */
853 /* Finally, give back to the caller the number of found interfaces */
854 *Interfaces = interfaces;
855
857}
NTSTATUS NTAPI IoGetDeviceInterfaces(IN CONST GUID *InterfaceClassGuid, IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL, IN ULONG Flags, OUT PWSTR *SymbolicLinkList)
Definition: deviface.c:936
_In_opt_ PDEVICE_OBJECT _In_ ULONG _Outptr_result_nullonfailure_ _At_ * SymbolicLinkList(return==0, __drv_allocatesMem(Mem))) PZZWSTR *SymbolicLinkList
Referenced by IopCreateArcNamesCd(), and IopCreateArcNamesDisk().
◆ IopFixupResourceListWithRequirements()
| NTSTATUS NTAPI IopFixupResourceListWithRequirements | ( | IN PIO_RESOURCE_REQUIREMENTS_LIST | RequirementsList, |
| OUT PCM_RESOURCE_LIST * | ResourceList | ||
| ) |
Definition at line 219 of file pnpres.c.
222{
225 PIO_RESOURCE_LIST ResList;
226
227 /* Save the initial resource count when we got here so we can restore if an alternate fails */
229 OldCount = (*ResourceList)->List[0].PartialResourceList.Count;
230 else
231 OldCount = 0;
232
233 ResList = &RequirementsList->List[0];
234 for (i = 0; i < RequirementsList->AlternativeLists; i++, ResList = IopGetNextResourceList(ResList))
235 {
236 ULONG ii;
237
238 /* We need to get back to where we were before processing the last alternative list */
240 {
241 /* Just free it and kill the pointer */
244 }
245 else if (OldCount != 0)
246 {
247 PCM_RESOURCE_LIST NewList;
248
249 /* Let's resize it */
251
252 /* Allocate the new smaller list */
254 if (!NewList)
256
257 /* Copy the old stuff back */
259
260 /* Free the old one */
262
263 /* Store the pointer to the new one */
264 *ResourceList = NewList;
265 }
266
267 for (ii = 0; ii < ResList->Count; ii++)
268 {
269 ULONG iii;
270 PCM_PARTIAL_RESOURCE_LIST PartialList = (*ResourceList) ? &(*ResourceList)->List[0].PartialResourceList : NULL;
271 PIO_RESOURCE_DESCRIPTOR IoDesc = &ResList->Descriptors[ii];
273
274 /* Skip alternates if we don't need one */
276 {
278 continue;
279 }
280
281 /* Check if we couldn't satsify a requirement or its alternates */
283 {
285
286 /* Break out of this loop and try the next list */
287 break;
288 }
289
291 {
292 /* Partial resource descriptors can be of variable size (CmResourceTypeDeviceSpecific),
293 but only one is allowed and it must be the last one in the list! */
295
296 /* First check types */
298 continue;
299
301 {
303 /* Make sure it satisfies our vector range */
306 {
307 /* Found it */
308 Matched = TRUE;
309 }
310 else
311 {
316 }
317 break;
318
321 /* Make sure the length matches and it satisfies our address range */
323 (ULONGLONG)CmDesc->u.Memory.Start.QuadPart >= (ULONGLONG)IoDesc->u.Memory.MinimumAddress.QuadPart &&
324 (ULONGLONG)CmDesc->u.Memory.Start.QuadPart + CmDesc->u.Memory.Length - 1 <= (ULONGLONG)IoDesc->u.Memory.MaximumAddress.QuadPart)
325 {
326 /* Found it */
327 Matched = TRUE;
328 }
329 else
330 {
331 DPRINT("Memory/Port - Not a match! 0x%I64x with length 0x%x not inside 0x%I64x to 0x%I64x with length 0x%x\n",
337 }
338 break;
339
341 /* Make sure the length matches and it satisfies our bus number range */
345 {
346 /* Found it */
347 Matched = TRUE;
348 }
349 else
350 {
351 DPRINT("Bus Number - Not a match! 0x%x with length 0x%x not inside 0x%x to 0x%x with length 0x%x\n",
357 }
358 break;
359
361 /* Make sure it fits in our channel range */
364 {
365 /* Found it */
366 Matched = TRUE;
367 }
368 else
369 {
374 }
375 break;
376
377 default:
378 /* Other stuff is fine */
379 Matched = TRUE;
380 break;
381 }
382 }
383
384 /* Check if we found a matching descriptor */
385 if (!Matched)
386 {
387 PCM_RESOURCE_LIST NewList;
388 CM_PARTIAL_RESOURCE_DESCRIPTOR NewDesc;
389 PCM_PARTIAL_RESOURCE_DESCRIPTOR DescPtr;
391
392 /* Setup the new CM descriptor */
396
397 /* Let'se see if we can find a resource to satisfy this */
399 {
401 /* Find an available interrupt */
403 {
406
407 FoundResource = FALSE;
408 }
409 break;
410
412 /* Find an available port range */
414 {
418
419 FoundResource = FALSE;
420 }
421 break;
422
424 /* Find an available memory range */
426 {
430
431 FoundResource = FALSE;
432 }
433 break;
434
436 /* Find an available bus address range */
438 {
442
443 FoundResource = FALSE;
444 }
445 break;
446
448 /* Find an available DMA channel */
450 {
453
454 FoundResource = FALSE;
455 }
456 break;
457
458 default:
460 FoundResource = FALSE;
461 break;
462 }
463
464 /* Check if it's missing and required */
466 {
467 /* Break out of this loop and try the next list */
469 break;
470 }
471 else if (!FoundResource)
472 {
473 /* Try an alternate for this preferred descriptor */
474 AlternateRequired = TRUE;
475 continue;
476 }
477 else
478 {
479 /* Move on to the next preferred or required descriptor after this one */
480 AlternateRequired = FALSE;
481 }
482
483 /* Figure out what we need */
485 {
486 /* We need a new list */
488 if (!NewList)
490
491 /* Set it up */
492 NewList->Count = 1;
498
499 /* Set our pointer */
501 }
502 else
503 {
504 /* Allocate the new larger list */
505 NewList = ExAllocatePool(PagedPool, PnpDetermineResourceListSize(*ResourceList) + sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
506 if (!NewList)
508
509 /* Copy the old stuff back */
511
512 /* Set our pointer */
513 DescPtr = &NewList->List[0].PartialResourceList.PartialDescriptors[NewList->List[0].PartialResourceList.Count];
514
515 /* Increment the descriptor count */
517
518 /* Free the old list */
520 }
521
522 /* Copy the descriptor in */
523 *DescPtr = NewDesc;
524
525 /* Store the new list */
526 *ResourceList = NewList;
527 }
528 }
529
530 /* Check if we need an alternate with no resources left */
531 if (AlternateRequired)
532 {
534
535 /* Try the next alternate list */
536 continue;
537 }
538
539 /* We're done because we satisfied one of the alternate lists */
541 }
542
543 /* We ran out of alternates */
545
546 /* Free the list */
548 {
551 }
552
553 /* Fail */
555}
static BOOLEAN IopFindPortResource(IN PIO_RESOURCE_DESCRIPTOR IoDesc, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
Definition: pnpres.c:122
static BOOLEAN IopFindMemoryResource(IN PIO_RESOURCE_DESCRIPTOR IoDesc, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
Definition: pnpres.c:84
static BOOLEAN IopFindDmaResource(IN PIO_RESOURCE_DESCRIPTOR IoDesc, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
Definition: pnpres.c:160
static BOOLEAN IopFindInterruptResource(IN PIO_RESOURCE_DESCRIPTOR IoDesc, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
Definition: pnpres.c:188
FORCEINLINE PIO_RESOURCE_LIST IopGetNextResourceList(_In_ const IO_RESOURCE_LIST *ResourceList)
Definition: pnpres.c:17
static BOOLEAN IopFindBusNumberResource(IN PIO_RESOURCE_DESCRIPTOR IoDesc, OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
Definition: pnpres.c:51
CM_PARTIAL_RESOURCE_LIST PartialResourceList
Definition: restypes.h:144
Definition: restypes.h:8
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@384::@390 Dma
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@384::@387 Interrupt
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@384::@392 BusNumber
union _CM_PARTIAL_RESOURCE_DESCRIPTOR::@384 u
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@384::@389 Memory
Definition: restypes.h:96
CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1]
Definition: restypes.h:100
Definition: miniport.h:144
struct _IO_RESOURCE_DESCRIPTOR::@2218::@2221 Interrupt
struct _IO_RESOURCE_DESCRIPTOR::@2218::@2225 BusNumber
struct _IO_RESOURCE_DESCRIPTOR::@2218::@2220 Memory
struct _IO_RESOURCE_DESCRIPTOR::@2218::@2219 Port
struct _IO_RESOURCE_DESCRIPTOR::@2218::@2222 Dma
union _IO_RESOURCE_DESCRIPTOR::@2218 u
Definition: iotypes.h:2735
#define IO_RESOURCE_ALTERNATIVE
Referenced by IopAssignDeviceResources(), and IopLegacyResourceAllocation().
◆ IopFreeDeviceNode()
| NTSTATUS IopFreeDeviceNode | ( | IN PDEVICE_NODE | DeviceNode | ) |
Referenced by IopDeleteDevice(), and PiControlInitializeDevice().
◆ IopGetDeviceAttachmentBase()
| PDEVICE_OBJECT NTAPI IopGetDeviceAttachmentBase | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 1483 of file file.c.
1484{
1486
1487 /* Go down the stack to attempt to get the PDO */
1489 PDO = IoGetDevObjExtension(PDO)->AttachedTo;
1490
1491 return PDO;
1492}
Referenced by IopGetDevicePDO(), and IopVerifyDriverObjectOnStack().
◆ IopGetDeviceNode()
| PDEVICE_NODE FASTCALL IopGetDeviceNode | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Referenced by IoAssignResources(), IoGetDeviceProperty(), IoOpenDeviceRegistryKey(), IopDeleteDevice(), IopDeviceStatus(), IopGetDeviceDepth(), IopGetDeviceRelations(), IopGetRelatedTargetDevice(), IopPrepareDeviceForRemoval(), IopQueryRemoveDevice(), IopSendRemoveDevice(), IopSendSurpriseRemoval(), IoRequestDeviceEject(), PiEnumerateDevice(), PiInitializeDevNode(), PiNotifyTargetDeviceChange(), PipDeviceActionWorker(), PnpDeviceObjectToDeviceInstance(), PnpRootPnpControl(), and PnpRootRegisterDevice().
◆ IopGetDriverNames()
| NTSTATUS IopGetDriverNames | ( | _In_ HANDLE | ServiceHandle, |
| _Out_ PUNICODE_STRING | DriverName, | ||
| _Out_opt_ PUNICODE_STRING | ServiceName | ||
| ) |
Definition at line 123 of file driver.c.
127{
129 PKEY_VALUE_FULL_INFORMATION kvInfo;
131
132 PAGED_CODE();
133
134 /* 1. Check the "ObjectName" field in the driver's registry key (it has priority) */
137 {
138 /* We've got the ObjectName, use it as the driver name */
143 {
145 kvInfo->Type,
146 kvInfo->DataLength);
147 ExFreePool(kvInfo);
149 }
150
155 {
156 ExFreePool(kvInfo);
158 }
159
162 driverName.Length);
164 ExFreePool(kvInfo);
165 }
166
167 /* Check whether we need to get ServiceName as well, either to construct
168 * the driver name (because we could not use "ObjectName"), or because
169 * it is requested by the caller. */
172 {
173 /* Retrieve the necessary buffer size */
174 ULONG infoLength;
177 {
180 }
181
182 /* Allocate the buffer and retrieve the data */
184 if (!basicInfo)
185 {
188 }
189
192 {
194 }
195
199 }
200
201 /* 2. There is no "ObjectName" - construct it ourselves. Depending on the driver type,
202 * it will be either "\Driver<ServiceName>" or "\FileSystem<ServiceName>" */
204 {
206
207 /* Retrieve the driver type */
208 ULONG driverType;
211 {
213 }
215 {
216 ExFreePool(kvInfo);
219 }
220
221 RtlMoveMemory(&driverType,
224 ExFreePool(kvInfo);
225
226 /* Compute the necessary driver name string size */
229 else
231
233 driverName.Length = 0;
234
235 /* Allocate and build it */
238 {
241 }
242
245 else
247
249 }
250
252 {
254
255 /* Allocate a copy for the caller */
258 {
261 }
266 }
267
268 *DriverName = driverName;
270
271Cleanup:
272 if (basicInfo)
274
277
279}
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define UNICODE_STRING_MAX_BYTES
NTSTATUS NTAPI IopGetRegistryValue(IN HANDLE Handle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION *Information)
Definition: pnpmgr.c:1036
Definition: nt_native.h:1158
Referenced by IopInitializeDriverModule(), and PiAttachFilterDriversCallback().
◆ IopGetFileInformation()
| NTSTATUS NTAPI IopGetFileInformation | ( | IN PFILE_OBJECT | FileObject, |
| IN ULONG | Length, | ||
| IN FILE_INFORMATION_CLASS | FileInfoClass, | ||
| OUT PVOID | Buffer, | ||
| OUT PULONG | ReturnedLength | ||
| ) |
Definition at line 777 of file iofunc.c.
782{
789
790 PAGED_CODE();
791
792 /* Allocate an IRP */
797 {
800 }
801
802 /* Init event */
804
805 /* Setup the IRP */
814
818 Stack->Parameters.QueryFile.FileInformationClass = FileInfoClass;
820
821
822 /* Queue the IRP */
824
825 /* Call the driver */
828 {
831 }
832
835}
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG _In_ ULONG _Out_ PULONG ReturnedLength
Definition: batclass.h:188
Referenced by IopGetBasicInformationFile(), and IopQueryNameInternal().
◆ IopGetRegistryValue()
| NTSTATUS NTAPI IopGetRegistryValue | ( | IN HANDLE | Handle, |
| IN PWSTR | ValueName, | ||
| OUT PKEY_VALUE_FULL_INFORMATION * | Information | ||
| ) |
Definition at line 1036 of file pnpmgr.c.
1039{
1040 UNICODE_STRING ValueString;
1042 PKEY_VALUE_FULL_INFORMATION FullInformation;
1044 PAGED_CODE();
1045
1047
1049 &ValueString,
1050 KeyValueFullInformation,
1051 NULL,
1052 0,
1053 &Size);
1056 {
1058 }
1059
1062
1064 &ValueString,
1065 KeyValueFullInformation,
1066 FullInformation,
1067 Size,
1068 &Size);
1070 {
1071 ExFreePool(FullInformation);
1073 }
1074
1075 *Information = FullInformation;
1077}
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4539
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243
Referenced by IoGetDeviceInterfaceAlias(), IopGetDriverNames(), IopInitializeBuiltinDriver(), IopLoadDriver(), IopSetServiceEnumData(), PiAttachFilterDriversCallback(), PiCallDriverAddDevice(), PiGetDeviceRegistryProperty(), PiInitCacheGroupInformation(), PipGetDriverTagPriority(), and PpInitGetGroupOrderIndex().
◆ IopGetRelatedTargetDevice()
| NTSTATUS NTAPI IopGetRelatedTargetDevice | ( | IN PFILE_OBJECT | FileObject, |
| OUT PDEVICE_NODE * | DeviceNode | ||
| ) |
Definition at line 654 of file device.c.
656{
659 PDEVICE_RELATIONS DeviceRelations;
661
663
664 /* Get DeviceObject related to given FileObject */
667
668 /* Define input parameters */
673
674 /* Call the driver to query all relations (IRP_MJ_PNP) */
676 &Stack,
677 (PVOID)&DeviceRelations);
679
680 /* Make sure it's not NULL and contains only one object */
681 ASSERT(DeviceRelations);
683
684 /* Finally get the device node */
687
688 /* Free the DEVICE_RELATIONS structure, it's not needed anymore */
689 ExFreePool(DeviceRelations);
690
692}
NTSTATUS IopSynchronousCall(IN PDEVICE_OBJECT DeviceObject, IN PIO_STACK_LOCATION IoStackLocation, OUT PVOID *Information)
Definition: iotypes.h:2163
#define IRP_MN_QUERY_DEVICE_RELATIONS
Referenced by IoGetRelatedTargetDevice(), and IoRegisterPlugPlayNotification().
◆ IopGetSetSecurityObject()
| NTSTATUS NTAPI IopGetSetSecurityObject | ( | IN PVOID | ObjectBody, |
| IN SECURITY_OPERATION_CODE | OperationCode, | ||
| IN PSECURITY_INFORMATION | SecurityInformation, | ||
| IN OUT PSECURITY_DESCRIPTOR | SecurityDescriptor, | ||
| IN OUT PULONG | BufferLength, | ||
| OUT PSECURITY_DESCRIPTOR * | OldSecurityDescriptor, | ||
| IN POOL_TYPE | PoolType, | ||
| IN OUT PGENERIC_MAPPING | GenericMapping | ||
| ) |
Referenced by IopCreateObjectTypes().
◆ IopGetSystemPowerDeviceObject()
| NTSTATUS IopGetSystemPowerDeviceObject | ( | IN PDEVICE_OBJECT * | DeviceObject | ) |
Referenced by PopSetSystemPowerState().
◆ IopInitBootLog()
◆ IopInitDriverImplementation()
◆ IopInitErrorLog()
◆ IopInitializeBootDrivers()
Definition at line 1035 of file driver.c.
1036{
1037 PLIST_ENTRY ListHead, NextEntry, NextEntry2;
1038 PLDR_DATA_TABLE_ENTRY LdrEntry;
1040 UNICODE_STRING DriverName;
1044 PBOOT_DRIVER_LIST_ENTRY BootEntry;
1046
1047 /* Create the RAW FS built-in driver */
1049
1052 {
1053 /* Fail */
1054 return;
1055 }
1056
1057 /* Get highest group order index */
1060 {
1061 UNIMPLEMENTED_DBGBREAK();
1062 }
1063
1064 /* Allocate the group table */
1067 TAG_IO);
1069 {
1070 UNIMPLEMENTED_DBGBREAK();
1071 }
1072
1073 /* Initialize the group table lists */
1075
1076 /* Loop the boot modules */
1079 NextEntry != ListHead;
1080 NextEntry = NextEntry->Flink)
1081 {
1082 /* Get the entry */
1083 LdrEntry = CONTAINING_RECORD(NextEntry,
1084 LDR_DATA_TABLE_ENTRY,
1085 InLoadOrderLinks);
1086
1087 /* Check if the DLL needs to be initialized */
1089 {
1090 /* Call its entrypoint */
1092 }
1093 }
1094
1095 /* Loop the boot drivers */
1098 NextEntry != ListHead;
1099 NextEntry = NextEntry->Flink)
1100 {
1101 /* Get the entry */
1102 BootEntry = CONTAINING_RECORD(NextEntry,
1103 BOOT_DRIVER_LIST_ENTRY,
1104 Link);
1105
1106 // FIXME: TODO: This LdrEntry is to be used in a special handling
1107 // for SETUPLDR (a similar procedure is done on Windows), where
1108 // the loader would, under certain conditions, be loaded in the
1109 // SETUPLDR-specific code block below...
1110#if 0
1111 /* Get the driver loader entry */
1112 LdrEntry = BootEntry->LdrEntry;
1113#endif
1114
1115 /* Allocate our internal accounting structure */
1118 TAG_IO);
1120 {
1121 /* Zero it and initialize it */
1125
1126 /* Open the registry key */
1128 NULL,
1129 &BootEntry->RegistryPath,
1130 KEY_READ);
1132#if 0
1134#else // Hack still needed...
1137#endif
1138 {
1139 /* Save the handle */
1141
1142 /* Get the group oder index */
1144
1145 /* Get the tag position */
1147
1148 /* Insert it into the list, at the right place */
1152 {
1153 /* Get the driver info */
1154 DriverInfoTag = CONTAINING_RECORD(NextEntry2,
1155 DRIVER_INFORMATION,
1156 Link);
1157
1158 /* Check if we found the right tag position */
1160 {
1161 /* We're done */
1162 break;
1163 }
1164
1165 /* Next entry */
1166 NextEntry2 = NextEntry2->Flink;
1167 }
1168
1169 /* Insert us right before the next entry */
1170 NextEntry2 = NextEntry2->Blink;
1172 }
1173 }
1174 }
1175
1176 /* Loop each group index */
1178 {
1179 /* Loop each group table */
1182 NextEntry = NextEntry->Flink)
1183 {
1184 /* Get the entry */
1186 DRIVER_INFORMATION,
1187 Link);
1188
1189 /* Get the driver loader entry */
1191
1192 /* Initialize it */
1194 {
1195 // it does not make sense to enumerate the tree if there are no new devices added
1197 PiActionEnumRootDevices,
1198 NULL,
1199 NULL);
1200 }
1201 }
1202 }
1203
1204 /* HAL Root Bus is being initialized before loading the boot drivers so this may cause issues
1205 * when some devices are not being initialized with their drivers. This flag is used to delay
1206 * all actions with devices (except PnP root device) until boot drivers are loaded.
1207 * See PiQueueDeviceAction function
1208 */
1210
1212
1214 PiActionEnumDeviceTree,
1215 NULL,
1216 NULL);
1217}
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4715
NTSTATUS NTAPI IopOpenRegistryKeyEx(PHANDLE KeyHandle, HANDLE ParentKey, PUNICODE_STRING Name, ACCESS_MASK DesiredAccess)
Definition: pnpmgr.c:885
NTSTATUS NTAPI RawFsDriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
Definition: rawfs.c:1193
USHORT NTAPI PpInitGetGroupOrderIndex(IN HANDLE ServiceHandle)
Definition: pnpinit.c:149
USHORT NTAPI PipGetDriverTagPriority(IN HANDLE ServiceHandle)
Definition: pnpinit.c:192
NTSTATUS NTAPI MmCallDllInitialize(_In_ PLDR_DATA_TABLE_ENTRY LdrEntry, _In_ PLIST_ENTRY ModuleListHead)
Definition: sysldr.c:433
static BOOLEAN IopInitializeBuiltinDriver(IN PLDR_DATA_TABLE_ENTRY BootLdrEntry)
Definition: driver.c:813
NTSTATUS NTAPI IoCreateDriver(_In_opt_ PUNICODE_STRING DriverName, _In_ PDRIVER_INITIALIZE InitializationFunction)
Definition: driver.c:1588
Definition: arc.h:334
Definition: ne2000.h:183
Definition: btrfs_drv.h:1876
Referenced by IoInitSystem().
◆ IopInitializeDriverModule()
| NTSTATUS IopInitializeDriverModule | ( | _In_ PLDR_DATA_TABLE_ENTRY | ModuleObject, |
| _In_ HANDLE | ServiceHandle, | ||
| _Out_ PDRIVER_OBJECT * | OutDriverObject, | ||
| _Out_ NTSTATUS * | DriverEntryStatus | ||
| ) |
Initialize a loaded driver.
- Parameters
-
[in] ModuleObject Module object representing the driver. It can be retrieved by IopLoadServiceModule. Freed on failure, so in a such case this should not be accessed anymore [in] ServiceHandle Handle to a driver's CCS/Services/<ServiceName> key [out] DriverObject This contains the driver object if it was created (even with unsuccessfull result) [out] DriverEntryStatus This contains the status value returned by the driver's DriverEntry routine (will not be valid of the return value is not STATUS_SUCCESS or STATUS_FAILED_DRIVER_ENTRY)
- Returns
- Status of the operation
Definition at line 449 of file driver.c.
454{
457
458 PAGED_CODE();
459
462 {
463 MmUnloadSystemImage(ModuleObject);
465 }
466
468
469 /*
470 * Retrieve the driver's PE image NT header and perform some sanity checks.
471 * NOTE: We suppose that since the driver has been successfully loaded,
472 * its NT and optional headers are all valid and have expected sizes.
473 */
475 ASSERT(NtHeaders);
476 // NOTE: ModuleObject->SizeOfImage is actually (number of PTEs)*PAGE_SIZE.
478 ASSERT(ModuleObject->EntryPoint == RVA(ModuleObject->DllBase, NtHeaders->OptionalHeader.AddressOfEntryPoint));
479
480 /* Obtain the registry path for the DriverInit routine */
481 PKEY_NAME_INFORMATION nameInfo;
482 ULONG infoLength;
485 {
487 if (nameInfo)
488 {
489 Status = ZwQueryKey(ServiceHandle,
490 KeyNameInformation,
491 nameInfo,
492 infoLength,
493 &infoLength);
495 {
499 }
500 else
501 {
503 }
504 }
505 else
506 {
508 }
509 }
510 else
511 {
513 }
514
516 {
518 RtlFreeUnicodeString(&DriverName);
519 MmUnloadSystemImage(ModuleObject);
521 }
522
523 /* Create the driver object */
525 OBJECT_ATTRIBUTES objAttrs;
526 PDRIVER_OBJECT driverObject;
527 InitializeObjectAttributes(&objAttrs,
528 &DriverName,
530 NULL,
531 NULL);
532
534 IoDriverObjectType,
535 &objAttrs,
536 KernelMode,
537 NULL,
538 ObjectSize,
539 0,
540 0,
541 (PVOID*)&driverObject);
543 {
546 RtlFreeUnicodeString(&DriverName);
547 MmUnloadSystemImage(ModuleObject);
550 }
551
553
554 RtlZeroMemory(driverObject, ObjectSize);
557
558 /* Set the legacy flag if this is not a WDM driver */
561
562 driverObject->DriverSection = ModuleObject;
563 driverObject->DriverStart = ModuleObject->DllBase;
564 driverObject->DriverSize = ModuleObject->SizeOfImage;
565 driverObject->DriverInit = ModuleObject->EntryPoint;
569
570 /* Loop all Major Functions */
572 {
573 /* Invalidate each function */
575 }
576
577 /* Add the Object and get its handle */
581 {
584 RtlFreeUnicodeString(&DriverName);
586 }
587
588 /* Now reference it */
590 0,
591 IoDriverObjectType,
592 KernelMode,
593 (PVOID*)&driverObject,
594 NULL);
595
596 /* Close the extra handle */
598
600 {
603 RtlFreeUnicodeString(&DriverName);
605 }
606
607 /* Set up the service key name buffer */
608 UNICODE_STRING serviceKeyName;
609 serviceKeyName.Length = 0;
610 // NULL-terminate for Windows compatibility
613 serviceKeyName.MaximumLength,
614 TAG_IO);
616 {
617 ObMakeTemporaryObject(driverObject);
618 ObDereferenceObject(driverObject);
621 RtlFreeUnicodeString(&DriverName);
623 }
624
625 /* Copy the name and set it in the driver extension */
629
630 /* Make a copy of the driver name to store in the driver object */
631 UNICODE_STRING driverNamePaged;
632 driverNamePaged.Length = 0;
633 // NULL-terminate for Windows compatibility
636 driverNamePaged.MaximumLength,
637 TAG_IO);
639 {
640 ObMakeTemporaryObject(driverObject);
641 ObDereferenceObject(driverObject);
643 RtlFreeUnicodeString(&DriverName);
645 }
646
647 RtlCopyUnicodeString(&driverNamePaged, &DriverName);
648 driverObject->DriverName = driverNamePaged;
649
650 /* Finally, call its init function */
652 *DriverEntryStatus = Status;
654 {
656 // return a special status value in case of failure
658 }
659
660 /* HACK: We're going to say if we don't have any DOs from DriverEntry, then we're not legacy.
661 * Other parts of the I/O manager depend on this behavior */
663 {
664 driverObject->Flags &= ~DRVO_LEGACY_DRIVER;
665 }
666
667 /* Windows does this fixup, keep it for compatibility */
669 {
670 /*
671 * Make sure the driver didn't set any dispatch entry point to NULL!
672 * Doing so is illegal; drivers shouldn't touch entry points they
673 * do not implement.
674 */
675
676 /* Check if it did so anyway */
678 {
679 /* Print a warning in the debug log */
682
683 /* Fix it up */
685 }
686 }
687
688 // TODO: for legacy drivers, unload the driver if it didn't create any DO
689
691 RtlFreeUnicodeString(&DriverName);
692
694 {
695 // if the driver entry has been failed, clear the object
696 ObMakeTemporaryObject(driverObject);
697 ObDereferenceObject(driverObject);
699 }
700
701 *OutDriverObject = driverObject;
702
704
705 /* Set the driver as initialized */
706 IopReadyDeviceObjects(driverObject);
707
709
711}
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
#define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER
Definition: ntimage.h:462
VOID NTAPI IopReadyDeviceObjects(IN PDRIVER_OBJECT Driver)
Definition: device.c:34
VOID NTAPI MmFreeDriverInitialization(IN PLDR_DATA_TABLE_ENTRY LdrEntry)
Definition: sysldr.c:1673
NTSTATUS NTAPI IopInvalidDeviceRequest(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: driver.c:65
NTSTATUS IopGetDriverNames(_In_ HANDLE ServiceHandle, _Out_ PUNICODE_STRING DriverName, _Out_opt_ PUNICODE_STRING ServiceName)
Definition: driver.c:123
NTSTATUS NTAPI ObInsertObject(IN PVOID Object, IN PACCESS_STATE AccessState OPTIONAL, IN ACCESS_MASK DesiredAccess, IN ULONG ObjectPointerBias, OUT PVOID *NewObject OPTIONAL, OUT PHANDLE Handle)
Definition: obhandle.c:2935
NTSTATUS NTAPI ObCreateObject(IN KPROCESSOR_MODE ProbeMode OPTIONAL, IN POBJECT_TYPE Type, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, IN ULONG ObjectSize, IN ULONG PagedPoolCharge OPTIONAL, IN ULONG NonPagedPoolCharge OPTIONAL, OUT PVOID *Object)
Definition: oblife.c:1039
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
Definition: iotypes.h:2220
PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION+1]
Definition: iotypes.h:2291
Definition: iotypes.h:1103
Definition: ntddk_ex.h:181
Definition: winternl.h:2601
_In_ LPWSTR _In_ ULONG _In_ ULONG _In_ ULONG _Out_ DEVINFO _In_ HDEV _In_ LPWSTR _In_ HANDLE hDriver
Definition: winddi.h:3557
struct _DRIVER_OBJECT DRIVER_OBJECT
#define IO_TYPE_DRIVER
#define IRP_MJ_MAXIMUM_FUNCTION
#define ROUND_TO_PAGES(Size)
Referenced by IopInitializeBuiltinDriver(), and IopLoadDriver().
◆ IopInitializePlugPlayServices()
Definition at line 287 of file pnpinit.c.
288{
292 UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET");
295
296 /* Initialize locks and such */
301
302 /* Get the default interface */
304
305 /* Initialize arbiters */
308
309 /* Setup the group cache */
312
313 /* Open the current control set */
315 NULL,
316 &KeyName,
317 KEY_ALL_ACCESS);
319
320 /* Create the control key */
323 KeyHandle,
324 &KeyName,
325 KEY_ALL_ACCESS,
327 &Disposition);
329
330 /* Check if it's a new key */
332 {
333 HANDLE DeviceClassesHandle;
334
335 /* Create the device classes key */
338 ControlHandle,
339 &KeyName,
340 KEY_ALL_ACCESS,
342 &Disposition);
344
345 ZwClose(DeviceClassesHandle);
346 }
347
348 ZwClose(ControlHandle);
349
350 /* Create the enum key */
353 KeyHandle,
354 &KeyName,
355 KEY_ALL_ACCESS,
357 &Disposition);
359
360 /* Check if it's a new key */
362 {
363 /* FIXME: DACLs */
364 }
365
366 /* Create the root key */
367 ParentHandle = EnumHandle;
370 ParentHandle,
371 &KeyName,
372 KEY_ALL_ACCESS,
374 &Disposition);
375 NtClose(ParentHandle);
377 NtClose(EnumHandle);
378
379 /* Open the root key now */
382 NULL,
383 &KeyName,
384 KEY_ALL_ACCESS);
386 {
387 /* Create the root dev node */
390 EnumHandle,
391 &KeyName,
392 KEY_ALL_ACCESS,
394 NULL);
395 NtClose(EnumHandle);
397 }
398
399 /* Create the root driver */
402 {
405 }
406
407 /* Create the root PDO */
409 0,
410 NULL,
412 0,
413 FALSE,
414 &Pdo);
416 {
419 }
420
421 /* This is a bus enumerated device */
423
424 /* Create the root device node */
426
427 /* Set flags */
430
431 /* Create instance path */
433 {
436 }
437
439
441
442 /* Initialize PnP-Event notification support */
445
446 /* Initialize the Bus Type GUID List */
450
451 /* Initialize PnP root relations (this is a syncronous operation) */
453
454 /* Launch the firmware mapper */
457
458 /* Close the handle to the control set */
460
461 /* Initialize PnP root relations (this is a syncronous operation) */
463
464 /* We made it */
466}
DECLSPEC_NORETURN VOID NTAPI KeBugCheckEx(IN ULONG BugCheckCode, IN ULONG_PTR BugCheckParameter1, IN ULONG_PTR BugCheckParameter2, IN ULONG_PTR BugCheckParameter3, IN ULONG_PTR BugCheckParameter4)
Definition: debug.c:485
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
PDEVICE_NODE PipAllocateDeviceNode(IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS NTAPI PnpRootDriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
Definition: pnproot.c:1488
NTSTATUS NTAPI IopCreateRegistryKeyEx(OUT PHANDLE Handle, IN HANDLE BaseHandle OPTIONAL, IN PUNICODE_STRING KeyName, IN ACCESS_MASK DesiredAccess, IN ULONG CreateOptions, OUT PULONG Disposition OPTIONAL)
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1032
INTERFACE_TYPE NTAPI IopDetermineDefaultInterfaceType(VOID)
Definition: pnpinit.c:41
Definition: io.h:416
WDF_EXTERN_C_START typedef _Must_inspect_result_ _In_ WDFDRIVER _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT Pdo
Definition: wdfminiport.h:72
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
#define DO_BUS_ENUMERATED_DEVICE
Referenced by IoInitSystem().
◆ IopInitializeReserveIrp()
| BOOLEAN NTAPI IopInitializeReserveIrp | ( | IN PRESERVE_IRP_ALLOCATOR | ReserveIrpAllocator | ) |
Definition at line 549 of file irp.c.
550{
551 /* Our allocated stack size */
552 ReserveIrpAllocator->StackSize = 20;
553
554 /* Allocate the IRP now */
556 /* If we cannot, abort system boot */
558 {
560 }
561
562 /* It's not in use */
563 ReserveIrpAllocator->ReserveIrpInUse = 0;
564 /* And init the event */
566
567 /* All good, keep booting */
569}
Referenced by IoInitSystem().
◆ IopInitializeSystemDrivers()
Definition at line 1222 of file driver.c.
1223{
1224 PUNICODE_STRING *DriverList, *SavedList;
1225
1227
1228 /* HACK: No system drivers on the BootCD */
1230
1231 /* Get the driver list */
1232 SavedList = DriverList = CmGetSystemDriverList();
1233 ASSERT(DriverList);
1234
1235 /* Loop it */
1236 while (*DriverList)
1237 {
1238 /* Load the driver */
1239 ZwLoadDriver(*DriverList);
1240
1241 /* Free the entry */
1242 RtlFreeUnicodeString(*DriverList);
1243 ExFreePool(*DriverList);
1244
1245 /* Next entry */
1246 InbvIndicateProgress();
1247 DriverList++;
1248 }
1249
1250 /* Free the list */
1251 ExFreePool(SavedList);
1252
1254 PiActionEnumDeviceTree,
1255 NULL,
1256 NULL);
1257}
VOID NTAPI InbvIndicateProgress(VOID)
Gives some progress feedback, without specifying any explicit number of progress steps or percentage....
Definition: inbv.c:632
NTSTATUS PiPerformSyncDeviceAction(_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action)
Perfom a device operation synchronously via PiQueueDeviceAction.
Definition: devaction.c:2727
Referenced by IoInitSystem().
◆ IopInitiatePnpIrp()
| NTSTATUS NTAPI IopInitiatePnpIrp | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIO_STATUS_BLOCK | IoStatusBlock, | ||
| IN UCHAR | MinorFunction, | ||
| IN PIO_STACK_LOCATION | Stack | ||
| ) |
Referenced by IoGetDmaAdapter(), IopCancelPrepareDeviceForRemoval(), IopCreateDeviceInstancePath(), IopFilterResourceRequirements(), IopGetDeviceProperty(), IopGetDeviceRelations(), IopPrepareDeviceForRemoval(), IopQueryCompatibleIds(), IopQueryDeviceCapabilities(), IopQueryHardwareIds(), IoRequestDeviceEject(), PiInitializeDevNode(), and VideoPortCheckForDeviceExistence().
◆ IopInitPlugPlayEvents()
Definition at line 40 of file plugplay.c.
Referenced by IopInitializePlugPlayServices().
◆ IopInitTimerImplementation()
◆ IopLoadDriver()
| NTSTATUS IopLoadDriver | ( | _In_ HANDLE | ServiceHandle, |
| _Out_ PDRIVER_OBJECT * | DriverObject | ||
| ) |
Definition at line 1950 of file driver.c.
1953{
1954 UNICODE_STRING ImagePath;
1956 PLDR_DATA_TABLE_ENTRY ModuleObject;
1958
1959 PKEY_VALUE_FULL_INFORMATION kvInfo;
1962 {
1967 {
1969 kvInfo->Type,
1970 kvInfo->DataLength);
1971 ExFreePool(kvInfo);
1973 }
1974
1979 {
1980 ExFreePool(kvInfo);
1982 }
1983
1986 ImagePath.Length);
1988 ExFreePool(kvInfo);
1989 }
1990 else
1991 {
1993 }
1994
1995 /*
1996 * Normalize the image path for all later processing.
1997 */
2000 {
2003 }
2004
2006
2007 KeEnterCriticalRegion();
2009
2010 /*
2011 * Load the driver module
2012 */
2015 RtlFreeUnicodeString(&ImagePath);
2016
2018 {
2021 KeLeaveCriticalRegion();
2023 }
2024
2025 // Display the loading message
2026 ULONG infoLength;
2029 {
2031 if (servName)
2032 {
2033 Status = ZwQueryKey(ServiceHandle,
2034 KeyBasicInformation,
2035 servName,
2036 infoLength,
2037 &infoLength);
2039 {
2041 .Length = servName->NameLength,
2042 .MaximumLength = servName->NameLength,
2043 .Buffer = servName->Name
2044 };
2045
2047 }
2049 }
2050 }
2051
2052 NTSTATUS driverEntryStatus;
2054 ServiceHandle,
2055 DriverObject,
2056 &driverEntryStatus);
2058 {
2060 }
2061
2063 KeLeaveCriticalRegion();
2064
2066}
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
NTSTATUS NTAPI MmLoadSystemImage(IN PUNICODE_STRING FileName, IN PUNICODE_STRING NamePrefix OPTIONAL, IN PUNICODE_STRING LoadedName OPTIONAL, IN ULONG Flags, OUT PVOID *ModuleObject, OUT PVOID *ImageBaseAddress)
Definition: sysldr.c:2949
static VOID FASTCALL IopDisplayLoadingMessage(_In_ PCUNICODE_STRING ServiceName)
Displays a driver-loading message in SOS mode.
Definition: driver.c:334
NTSTATUS IopInitializeDriverModule(_In_ PLDR_DATA_TABLE_ENTRY ModuleObject, _In_ HANDLE ServiceHandle, _Out_ PDRIVER_OBJECT *OutDriverObject, _Out_ NTSTATUS *DriverEntryStatus)
Initialize a loaded driver.
Definition: driver.c:449
NTSTATUS FASTCALL IopNormalizeImagePath(_Inout_ _When_(return >=0, _At_(ImagePath->Buffer, _Post_notnull_ __drv_allocatesMem(Mem))) PUNICODE_STRING ImagePath, _In_ PUNICODE_STRING ServiceName)
Definition: driver.c:375
Referenced by IopLoadUnloadDriverWorker(), and PiAttachFilterDriversCallback().
◆ IopLogWorker()
Definition at line 148 of file error.c.
149{
150#define IO_ERROR_OBJECT_NAMES_LENGTH 100
151
155 PLIST_ENTRY ListEntry;
156 PERROR_LOG_ENTRY LogEntry;
159 ULONG RemainingLength;
161 PWCHAR NameString;
162 ULONG DriverNameLength, DeviceNameLength;
165 POBJECT_NAME_INFORMATION PoolObjectNameInfo;
167 ULONG ExtraStringLength;
169
170 PAGED_CODE();
171
173
174 /* Connect to the port */
176
177 /* Allocate the message */
180 {
181 /* Couldn't allocate, try again */
182 IopRestartLogWorker();
183 return;
184 }
185
186 /* Zero out the message and get the actual I/O structure */
189
190 /* Start loop */
192 {
193 /* Get an entry */
194 ListEntry = IopGetErrorLogEntry();
195 if (!ListEntry) break;
197
198 /* Get pointer to the log packet */
201
202 /* Calculate the total length of the message only */
206 LogEntry->Size;
207
208 /* Copy the packet */
210 Packet,
212
213 /* Set the timestamp and time */
216
217 /* Check if this message has any strings */
219 {
220 /* String buffer is after the current strings */
222 Packet->StringOffset;
223 }
224 else
225 {
226 /* Otherwise, string buffer is at the end */
228 }
229
230 /* Align the buffer */
232
233 /* Set the offset for the driver's name to the current buffer */
236
237 /* Check how much space we have left for the device string */
241
242 NameString = NULL;
243 DriverNameLength = 0; DeviceNameLength = 0;
244 PoolObjectNameInfo = NULL;
246
247 /* Now check if there is a driver object */
250 {
251 /* Check if the driver has a name, and use it if so */
253 {
255 DriverNameLength = DriverObject->DriverName.Length;
256 }
257 else
258 {
259 NameString = NULL;
260 DriverNameLength = 0;
261 }
262
263 /* Check if there isn't a valid name */
264 if (!DriverNameLength)
265 {
266 /* Query the name directly */
268 ObjectNameInfo,
270 &ReturnedLength);
272 {
273 /* We don't have a name */
274 DriverNameLength = 0;
275 }
276 else
277 {
278 NameString = ObjectNameInfo->Name.Buffer;
279 DriverNameLength = ObjectNameInfo->Name.Length;
280 }
281 }
282 }
283 else
284 {
285 /* Use default name */
288 }
289
290 /* Check if we have a driver name */
291 if (DriverNameLength)
292 {
293 /* Skip to the end of the driver's name */
295
296 /* Now we'll walk backwards and assume the minimum size */
298 p--;
300 {
301 /* No backslash found, keep going */
302 p--;
304 }
305
306 /* Now we probably hit the backslash itself, skip past it */
308 {
309 p++;
311 }
312
313 /*
314 * Now make sure that the driver name fits in the buffer, minus
315 * 3 NULL chars (driver name, device name, and remaining strings),
316 * and copy the driver name in the string buffer.
317 */
318 DriverNameLength = min(DriverNameLength,
321 }
322
323 /* Null-terminate the driver name */
326
327 /* Go to the next string buffer position */
328 StringBuffer += DriverNameLength;
329 RemainingLength -= DriverNameLength;
330
331 /* Update the string offset */
332 ErrorMessage->EntryData.StringOffset =
334
335 /* Check if we have a device object */
337 {
338 /* We do, query its name */
340 ObjectNameInfo,
342 &ReturnedLength);
344 {
345 /* Setup an empty name */
347
348 /* Check if we failed because our buffer wasn't large enough */
350 {
351 /* Then we'll allocate one... we really want this name! */
353 ReturnedLength,
354 TAG_IO);
355 if (PoolObjectNameInfo)
356 {
357 /* Query it again */
358 ObjectNameInfo = PoolObjectNameInfo;
360 ObjectNameInfo,
361 ReturnedLength,
362 &ReturnedLength);
364 {
365 /* Success, update the information */
366 ObjectNameInfo->Name.Length =
368 }
369 }
370 }
371 }
372
373 NameString = ObjectNameInfo->Name.Buffer;
374 DeviceNameLength = ObjectNameInfo->Name.Length;
375 }
376 else
377 {
378 /* No device object, setup an empty name */
380 DeviceNameLength = 0;
381 }
382
383 /*
384 * Now make sure that the device name fits in the buffer, minus
385 * 2 NULL chars (device name, and remaining strings), and copy
386 * the device name in the string buffer.
387 */
388 DeviceNameLength = min(DeviceNameLength,
391
392 /* Null-terminate the device name */
395
396 /* Free the buffer if we had one */
397 if (PoolObjectNameInfo)
398 {
400 PoolObjectNameInfo = NULL;
401 }
402
403 /* Go to the next string buffer position */
404 ErrorMessage->EntryData.NumberOfStrings++;
405 StringBuffer += DeviceNameLength;
406 RemainingLength -= DeviceNameLength;
407
408 /* Check if we have any extra strings */
410 {
411 /* Find out the size of the extra strings */
412 ExtraStringLength = LogEntry->Size -
414 Packet->StringOffset;
415
416 /* Round up the length */
418
419 /* Make sure that the extra strings fit in our buffer */
421 {
422 /* They wouldn't, so set normalize the length */
423 MessageLength -= ExtraStringLength - RemainingLength;
425 }
426
427 /* Now copy the extra strings */
430 ExtraStringLength);
431
432 /* Null-terminate them */
434 }
435
436 /* Set the driver name length */
438
439 /* Update the message length to include the driver and device names */
440 MessageLength += DriverNameLength + DeviceNameLength;
442
443 /* Now update it again for the size of the actual LPC */
446
447 /* Set the total and data lengths */
448 Message->Header.u1.s1.TotalLength =
451
452 /* Send the message */
455 {
456 /*
457 * An error happened while sending the message on the port.
458 * Close the port, requeue the log message on top of the list
459 * and restart the worker.
460 */
463
465 &LogEntry->ListEntry,
466 &IopLogListLock);
467
468 IopRestartLogWorker();
469 break;
470 }
471
472 /* NOTE: The following is basically 'IoFreeErrorLogEntry(Packet)' */
473
474 /* Dereference both objects */
477
478 /* Decrease the total allocation size and free the entry */
481 }
482
483 /* Free the LPC Message */
485}
VOID ErrorMessage(IN DWORD dwErrorCode, IN PCWSTR szFormat OPTIONAL,...)
Definition: error.c:26
PLIST_ENTRY NTAPI ExInterlockedInsertHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:114
NTSYSAPI NTSTATUS NTAPI ZwRequestPort(_In_ HANDLE PortHandle, _In_ PPORT_MESSAGE LpcMessage)
struct _OBJECT_NAME_INFORMATION OBJECT_NAME_INFORMATION
struct _OBJECT_NAME_INFORMATION * POBJECT_NAME_INFORMATION
struct _ERROR_LOG_ENTRY ERROR_LOG_ENTRY
#define IO_ERROR_OBJECT_NAMES_LENGTH
NTSTATUS NTAPI ObQueryNameString(IN PVOID Object, OUT POBJECT_NAME_INFORMATION ObjectNameInfo, IN ULONG Length, OUT PULONG ReturnLength)
Definition: obname.c:1207
Definition: iolog.h:18
Definition: io.h:331
Definition: iotypes.h:2016
Definition: iotypes.h:2000
Definition: nt_native.h:1272
Definition: winternl.h:3332
#define IO_TYPE_ERROR_MESSAGE
struct _IO_ERROR_LOG_MESSAGE IO_ERROR_LOG_MESSAGE
struct _IO_ERROR_LOG_PACKET * PIO_ERROR_LOG_PACKET
struct _IO_ERROR_LOG_PACKET IO_ERROR_LOG_PACKET
Referenced by IopLogDpcRoutine(), and IoWriteErrorLogEntry().
◆ IopMountVolume()
| NTSTATUS NTAPI IopMountVolume | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN BOOLEAN | AllowRawMount, | ||
| IN BOOLEAN | DeviceIsLocked, | ||
| IN BOOLEAN | Alertable, | ||
| OUT PVPB * | Vpb | ||
| ) |
Definition at line 462 of file volume.c.
467{
472 PIO_STACK_LOCATION StackPtr;
473 PLIST_ENTRY FsList, ListEntry;
474 LIST_ENTRY LocalList;
476 PDEVICE_OBJECT FileSystemDeviceObject, ParentFsDeviceObject;
477 ULONG FsStackOverhead, RegistrationOps;
478 PAGED_CODE();
479
480 /* Check if the device isn't already locked */
481 if (!DeviceIsLocked)
482 {
483 /* Lock it ourselves */
485 Executive,
486 KeGetPreviousMode(),
487 Alertable,
488 NULL);
490 {
491 /* Don't mount if we were interrupted */
493 }
494 }
495
496 /* Acquire the FS Lock*/
497 KeEnterCriticalRegion();
499
500 /* Make sure we weren't already mounted */
502 {
503 /* Initialize the event to wait on */
505
506 /* Remove the verify flag and get the actual device to mount */
507 DeviceObject->Flags &= ~DO_VERIFY_VOLUME;
509 {
510 /* Get the next one */
512 }
513
514 /* Reference it */
516
517 /* For a mount operation, this can only be a Disk, CD-ROM or tape */
520 {
521 /* Use the disk list */
522 FsList = &IopDiskFileSystemQueueHead;
523 }
525 {
526 /* Use the CD-ROM list */
527 FsList = &IopCdRomFileSystemQueueHead;
528 }
529 else
530 {
531 /* It's gotta be a tape... */
532 FsList = &IopTapeFileSystemQueueHead;
533 }
534
535 /* Now loop the fs list until one of the file systems accepts us */
537 ListEntry = FsList->Flink;
539 {
540 /*
541 * If we're not allowed to mount this volume and this is our last
542 * (but not only) chance to mount it...
543 */
544 if (!(AllowRawMount) &&
545 (ListEntry->Flink == FsList) &&
546 (ListEntry != FsList->Flink))
547 {
548 /* Then fail this mount request */
549 break;
550 }
551
552 /*
553 * Also check if this is a raw mount and there are other file
554 * systems on the list.
555 */
557 (ListEntry->Flink != FsList))
558 {
559 /* Then skip this entry */
560 ListEntry = ListEntry->Flink;
561 continue;
562 }
563
564 /* Get the Device Object for this FS */
565 FileSystemDeviceObject = CONTAINING_RECORD(ListEntry,
566 DEVICE_OBJECT,
567 Queue.ListEntry);
568 ParentFsDeviceObject = FileSystemDeviceObject;
569
570 /*
571 * If this file system device is attached to some other device,
572 * then we must make sure to increase the stack size for the IRP.
573 * The default is +1, for the FS device itself.
574 */
575 FsStackOverhead = 1;
576 while (FileSystemDeviceObject->AttachedDevice)
577 {
578 /* Get the next attached device and increase overhead */
579 FileSystemDeviceObject = FileSystemDeviceObject->
580 AttachedDevice;
581 FsStackOverhead++;
582 }
583
584 /* Clear the event */
586
587 /* Allocate the IRP */
589 (UCHAR)FsStackOverhead,
590 TRUE);
592 {
593 /* Fail */
595 break;
596 }
597
598 /* Setup the IRP */
604
605 /* Get the I/O Stack location and set it up */
609 StackPtr->Flags = AllowRawMount;
612 AttachedDeviceObject;
613
614 /* Save registration operations */
615 RegistrationOps = IopFsRegistrationOps;
616
617 /* Release locks */
620
621 /* Call the driver */
624 {
625 /* Wait on it */
627 Executive,
628 KernelMode,
629 FALSE,
630 NULL);
632 }
633
636
637 /* Check if mounting was successful */
639 {
640 /* Mount the VPB */
642 AttachedDeviceObject,
643 (DeviceObject->Vpb->Flags &
644 VPB_RAW_MOUNT));
645 }
646 else
647 {
648 /* Check if we failed because of the user */
651 {
652 /* Break out and fail */
653 break;
654 }
655
656 /* If there were registration operations in the meanwhile */
658 {
659 /* We need to setup a local list to pickup where we left */
661 ListEntry = &LocalList;
662
664 }
665
666 /* Otherwise, check if we need to load the FS driver */
668 {
669 /* We need to release the lock */
672
673 /* Release the device lock if we're holding it */
674 if (!DeviceIsLocked)
675 {
677 }
678
679 /* Leave critical section */
680 KeLeaveCriticalRegion();
681
682 /* Load the FS */
683 IopLoadFileSystemDriver(ParentFsDeviceObject);
684
685 /* Check if the device isn't already locked */
686 if (!DeviceIsLocked)
687 {
688 /* Lock it ourselves */
690 DeviceLock,
691 Executive,
692 KeGetPreviousMode(),
693 Alertable,
694 NULL);
697 {
698 /* Don't mount if we were interrupted */
701 }
702 }
703
704 /* Reacquire the lock */
705 KeEnterCriticalRegion();
707
708 /* When we released the lock, make sure nobody beat us */
710 {
711 /* Someone did, break out */
713 break;
714 }
715
716 /* Start over by setting a failure */
718
719 /* We need to setup a local list to pickup where we left */
721 ListEntry = &LocalList;
722 }
723
724 /*
725 * Check if we failed with any other error then an unrecognized
726 * volume, and if this request doesn't allow mounting the raw
727 * file system.
728 */
729 if (!(AllowRawMount) &&
732 {
733 /* Break out and give up */
734 break;
735 }
736 }
737
738 /* Go to the next FS entry */
739 ListEntry = ListEntry->Flink;
740 }
741
742 /* Dereference the device if we failed */
744 }
746 {
747 /* Someone wants to remove us */
749 }
750 else
751 {
752 /* Someone already mounted us */
754 }
755
756 /* Release the FS lock */
758 KeLeaveCriticalRegion();
759
760 /* Release the device lock if we're holding it */
762
763 /* Check if we failed to mount the boot partition */
766 ExpInitializationPhase < 2)
767 {
768 /* Bugcheck the system */
769 KeBugCheckEx(INACCESSIBLE_BOOT_DEVICE,
771 Status,
772 0,
773 0);
774 }
775
776 /* Return the mount status */
778}
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621
BOOLEAN NTAPI FsRtlIsTotalDeviceFailure(IN NTSTATUS NtStatus)
Definition: filter.c:37
ULONG FASTCALL IopInterlockedDecrementUlong(IN KSPIN_LOCK_QUEUE_NUMBER Queue, IN PULONG Ulong)
Definition: volume.c:331
ULONG FASTCALL IopInterlockedIncrementUlong(IN KSPIN_LOCK_QUEUE_NUMBER Queue, IN PULONG Ulong)
Definition: volume.c:313
VOID NTAPI IopLoadFileSystemDriver(IN PDEVICE_OBJECT DeviceObject)
Definition: volume.c:409
PVPB NTAPI IopMountInitializeVpb(IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT AttachedDeviceObject, IN BOOLEAN Raw)
Definition: volume.c:249
union _IO_STACK_LOCATION::@1670 Parameters
struct _IO_STACK_LOCATION::@4315::@4335 MountVolume
WDF_EXTERN_C_START typedef _Must_inspect_result_ _In_ WDFDRIVER _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT AttachedDeviceObject
Definition: wdfminiport.h:70
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define IRP_MOUNT_COMPLETION
#define IRP_SYNCHRONOUS_PAGING_IO
Referenced by IopCheckVpbMounted(), and IoVerifyVolume().
◆ IopOpenRegistryKeyEx()
| NTSTATUS NTAPI IopOpenRegistryKeyEx | ( | PHANDLE | KeyHandle, |
| HANDLE | ParentKey, | ||
| PUNICODE_STRING | Name, | ||
| ACCESS_MASK | DesiredAccess | ||
| ) |
Definition at line 885 of file pnpmgr.c.
Referenced by CreateDeviceFromRegistry(), EnumerateDevices(), IoOpenDeviceRegistryKey(), IopCreateDeviceKeyPath(), IopEnumerateDetectedDevices(), IopGetParentIdPrefix(), IopInitializeBootDrivers(), IopInitializeBuiltinDriver(), IopInitializePlugPlayServices(), IopLoadUnloadDriverWorker(), IopOpenOrCreateSymbolicLinkSubKeys(), IopSetServiceEnumData(), IopStoreSystemPartitionInformation(), IopUpdateControlKeyWithResources(), IopUpdateRootKey(), IoSetSystemPartition(), OpenRegistryHandlesFromSymbolicLink(), PiAttachFilterDriversCallback(), PiCallDriverAddDevice(), PiGetDeviceRegistryProperty(), PiInitCacheGroupInformation(), PipGetDriverTagPriority(), PiStartDeviceFinal(), PnpDeviceObjectToDeviceInstance(), and PnpRootCreateDevice().
◆ IopParseDevice()
| NTSTATUS NTAPI IopParseDevice | ( | IN PVOID | ParseObject, |
| IN PVOID | ObjectType, | ||
| IN OUT PACCESS_STATE | AccessState, | ||
| IN KPROCESSOR_MODE | AccessMode, | ||
| IN ULONG | Attributes, | ||
| IN OUT PUNICODE_STRING | CompleteName, | ||
| IN OUT PUNICODE_STRING | RemainingName, | ||
| IN OUT PVOID | Context, | ||
| IN PSECURITY_QUALITY_OF_SERVICE SecurityQos | OPTIONAL, | ||
| OUT PVOID * | Object | ||
| ) |
Definition at line 321 of file file.c.
331{
339 PIO_STACK_LOCATION StackLoc;
340 IO_SECURITY_CONTEXT SecurityContext;
345 PDUMMY_FILE_OBJECT LocalFileObject;
348 KPROCESSOR_MODE CheckMode;
353 UNICODE_STRING FileString;
354 USHORT Attempt;
356 ParseObject, RemainingName);
357
359 {
360 /* Assume failure */
362
363 /* Validate the open packet */
365
366 /* Valide reparse point in case we traversed a mountpoint */
368 {
369 /* This is a reparse point we understand */
371
372 /* Make sure we're dealing with correct DO */
374 OriginalDeviceObject->DeviceType != FILE_DEVICE_CD_ROM &&
375 OriginalDeviceObject->DeviceType != FILE_DEVICE_VIRTUAL_DISK &&
376 OriginalDeviceObject->DeviceType != FILE_DEVICE_TAPE)
377 {
380 }
381 }
382
383 /* Check if we have a related file object */
385 {
386 /* Use the related file object's device object */
387 OriginalDeviceObject = OpenPacket->RelatedFileObject->DeviceObject;
388 }
389
390 /* Validate device status */
393 {
394 /* We failed, return status */
397 }
398
399 /* Map the generic mask and set the new mapping in the access state */
407
408 /* Check what kind of access checks to do */
411 {
412 /* Call is from user-mode or kernel is forcing checks */
413 CheckMode = UserMode;
414 }
415 else
416 {
417 /* Call is from the kernel */
418 CheckMode = KernelMode;
419 }
420
421 /* Check privilege for backup or restore operation */
423 &OpenPacket->CreateOptions,
424 CheckMode,
425 OpenPacket->Disposition);
426
427 /* Check if we are re-parsing */
430 {
431 /* Get granted access from the last call */
433 }
434
435 /* Check if this is a volume open */
438 !(RemainingName->Length))
439 {
440 /* It is */
441 VolumeOpen = TRUE;
442 }
443
444 /* Now check if we need access checks */
447 (!(OpenPacket->RelatedFileObject) || (VolumeOpen)) &&
448 !(OpenPacket->Override))
449 {
450 KeEnterCriticalRegion();
452
453 /* Check if a device object is being parsed */
455 {
456 /* Lock the subject context */
458 LockHeld = TRUE;
459
460 /* Do access check */
462 SecurityDescriptor,
463 &AccessState->SubjectSecurityContext,
464 LockHeld,
465 DesiredAccess,
466 0,
467 &Privileges,
468 &IoFileObjectType->
469 TypeInfo.GenericMapping,
470 UserMode,
471 &GrantedAccess,
472 &Status);
474 {
475 /* Append and free the privileges */
478 }
479
480 /* Check if we got access */
482 {
483 /* Update access state */
486 MAXIMUM_ALLOWED);
488 }
489
490 FileString.Length = 8;
491 FileString.MaximumLength = 8;
493
494 /* Do Audit/Alarm for open operation */
495 SeOpenObjectAuditAlarm(&FileString,
496 OriginalDeviceObject,
497 CompleteName,
498 OriginalDeviceObject->SecurityDescriptor,
499 AccessState,
500 FALSE,
501 AccessGranted,
502 UserMode,
503 &AccessState->GenerateOnClose);
504 }
505 else
506 {
507 /* Check if we need to do traverse validation */
509 ((OriginalDeviceObject->DeviceType == FILE_DEVICE_DISK) ||
510 (OriginalDeviceObject->DeviceType == FILE_DEVICE_CD_ROM)))
511 {
512 /* Check if this is a restricted token */
514 {
515 /* Do the FAST traverse check */
517 AccessState,
518 FILE_TRAVERSE,
519 UserMode);
520 }
521 else
522 {
523 /* Fail */
525 }
526
527 /* Check if we failed to get access */
529 {
530 /* Lock the subject context */
532 LockHeld = TRUE;
533
534 /* Do access check */
536 SecurityDescriptor,
537 &AccessState->SubjectSecurityContext,
538 LockHeld,
539 FILE_TRAVERSE,
540 0,
541 &Privileges,
542 &IoFileObjectType->
543 TypeInfo.GenericMapping,
544 UserMode,
545 &GrantedAccess,
546 &Status);
548 {
549 /* Append and free the privileges */
552 }
553 }
554
555 /* FIXME: Do Audit/Alarm for traverse check */
556 }
557 else
558 {
559 /* Access automatically granted */
561 }
562 }
563
565 KeLeaveCriticalRegion();
566
567 /* Check if we hold the lock */
568 if (LockHeld)
569 {
570 /* Release it */
572 }
573
574 /* Check if access failed */
576 {
577 /* Dereference the device and fail */
581 }
582 }
583
584 /* Check if we can simply use a dummy file */
586
587 /* Check if this is a direct open */
589 !(OpenPacket->RelatedFileObject) &&
591 FILE_READ_ATTRIBUTES |
592 READ_CONTROL |
593 ACCESS_SYSTEM_SECURITY |
594 WRITE_OWNER |
595 WRITE_DAC)) == 0) &&
596 !(UseDummyFile))
597 {
598 /* Remember this for later */
599 DirectOpen = TRUE;
600 }
601
602 /* Check if we have a related FO that wasn't a direct open */
605 {
606 /* The device object is the one we were given */
607 DeviceObject = ParseObject;
608
609 /* Check if the related FO had a VPB */
611 {
612 /* Yes, remember it */
614
615 /* Reference it */
617
618 /* Check if we were given a specific top level device to use */
620 {
622 }
623 }
624 }
625 else
626 {
627 /* Check if it has a VPB */
628 if ((OriginalDeviceObject->Vpb) && !(DirectOpen))
629 {
630 /* Check if the VPB is mounted, and mount it */
632 OriginalDeviceObject,
633 RemainingName,
634 &Status);
636
637 /* Get the VPB's device object */
639 }
640 else
641 {
642 /* The device object is the one we were given */
643 DeviceObject = OriginalDeviceObject;
644 }
645
646 /* If we weren't given a specific top level device, look for an attached device */
648 DeviceObject->AttachedDevice)
649 {
650 /* Get the attached device */
652 }
653 }
654
655 /* If we have a top level device hint, verify it */
657 {
660 {
664 }
665 }
666
667 /* If we traversed a mount point, reset the information */
669 {
671 }
672
673 /* Check if this is a secure FSD */
676 (!VolumeOpen))
677 {
679 GrantedAccess = 0;
680
681 KeEnterCriticalRegion();
683
684 /* Lock the subject context */
686
687 /* Do access check */
689 &AccessState->SubjectSecurityContext,
690 TRUE,
691 DesiredAccess,
692 0,
693 &Privileges,
695 UserMode,
696 &GrantedAccess,
697 &Status);
699 {
700 /* Append and free the privileges */
703 }
704
705 /* Check if we got access */
707 {
710 }
711
712 FileString.Length = 8;
713 FileString.MaximumLength = 8;
715
716 /* Do Audit/Alarm for open operation
717 * NOTA: we audit target device object
718 */
719 SeOpenObjectAuditAlarm(&FileString,
720 DeviceObject,
721 CompleteName,
722 OriginalDeviceObject->SecurityDescriptor,
723 AccessState,
724 FALSE,
725 AccessGranted,
726 UserMode,
727 &AccessState->GenerateOnClose);
728
730
732 KeLeaveCriticalRegion();
733
734 /* Check if access failed */
736 {
737 /* Dereference the device and fail */
741 }
742 }
743
744 /* Allocate the IRP */
747 {
748 /* Dereference the device and VPB, then fail */
752 }
753
754 /* Now set the IRP data */
765
766 /* Setup the security context */
767 SecurityContext.SecurityQos = SecurityQos;
771
772 /* Get the I/O Stack location */
774 StackLoc->Control = 0;
775
776 /* Check what kind of file this is */
778 {
779 /* Normal file */
781
782 /* Set the major function and EA Length */
785
786 /* Set the flags */
789 break;
790
791 /* Named pipe */
793
794 /* Set the named pipe MJ and set the parameters */
797 break;
798
799 /* Mailslot */
801
802 /* Set the mailslot MJ and set the parameters */
805 break;
806 }
807
808 /* Set the common data */
812 (OpenPacket->CreateOptions &
813 0xFFFFFF);
817
818 /* Check if we really need to create an object */
819 if (!UseDummyFile)
820 {
822
823 /* Tag on space for a file object extension */
826
827 /* Create the actual file object */
829 NULL,
830 Attributes,
831 NULL,
832 NULL);
834 IoFileObjectType,
835 &ObjectAttributes,
836 AccessMode,
837 NULL,
838 ObjectSize,
839 0,
840 0,
843 {
844 /* Create failed, free the IRP */
846
847 /* Dereference the device and VPB */
850
851 /* We failed, return status */
854 }
855
856 /* Clear the file object */
858
859 /* Check if this is Synch I/O */
862 {
863 /* Set the synch flag */
865
866 /* Check if it's also alertable */
868 {
869 /* It is, set the alertable flag */
871 }
872 }
873
874 /* Check if this is synch I/O */
876 {
877 /* Initialize the event */
879 }
880
881 /* Check if the caller requested no intermediate buffering */
883 {
884 /* Set the correct flag for the FSD to read */
886 }
887
888 /* Check if the caller requested write through support */
890 {
891 /* Set the correct flag for the FSD to read */
893 }
894
895 /* Check if the caller says the file will be only read sequentially */
897 {
898 /* Set the correct flag for the FSD to read */
900 }
901
902 /* Check if the caller believes the file will be only read randomly */
904 {
905 /* Set the correct flag for the FSD to read */
907 }
908
909 /* Check if we were asked to setup a file object extension */
911 {
912 PFILE_OBJECT_EXTENSION FileObjectExtension;
913
914 /* Make sure the file object knows it has an extension */
916
917 /* Initialize file object extension */
919 FileObject->FileObjectExtension = FileObjectExtension;
920
921 /* Add the top level device which we'll send the request to */
923 {
925 }
926 }
927 }
928 else
929 {
930 /* Use the dummy object instead */
931 LocalFileObject = OpenPacket->LocalFileObject;
933
934 /* Set it up */
938 }
939
940 /* Setup the file header */
944 FileObject->DeviceObject = OriginalDeviceObject;
945
946 /* Check if this is a direct device open */
948
949 /* Check if the caller wants case sensitivity */
951 {
952 /* Tell the driver about it */
954 }
955
956 /* Now set the file object */
959
960 /* Check if the file object has a name */
962 {
963 /* Setup the unicode string */
966 FileObject->FileName.MaximumLength,
967 TAG_IO_NAME);
969 {
970 /* Failed to allocate the name, free the IRP */
972
973 /* Dereference the device object and VPB */
976
977 /* Clear the FO and dereference it */
980
981 /* Fail */
983 }
984 }
985
986 /* Copy the name */
988
989 /* Initialize the File Object event and set the FO */
992
993 /* Queue the IRP and call the driver */
997 {
998 /* Wait for the driver to complete the create */
1000 Executive,
1001 KernelMode,
1002 FALSE,
1003 NULL);
1004
1005 /* Get the new status */
1007 }
1008 else
1009 {
1010 /* We'll have to complete it ourselves */
1013
1014 /* Handle name change if required */
1016 {
1017 /* Check this is a mount point */
1019 {
1020 PREPARSE_DATA_BUFFER ReparseData;
1021
1022 /* Reparse point attributes were passed by the driver in the auxiliary buffer */
1025
1029
1031 }
1032 }
1033
1034 /* Completion happens at APC_LEVEL */
1036
1037 /* Get the new I/O Status block ourselves */
1040
1041 /* Manually signal the even, we can't have any waiters */
1042 FileObject->Event.Header.SignalState = 1;
1043
1044 /* Now that we've signaled the events, de-associate the IRP */
1046
1047 /* Check if the IRP had an input buffer */
1050 {
1051 /* Free it. A driver might've tacked one on */
1053 }
1054
1055 /* Free the IRP and bring the IRQL back down */
1058 }
1059
1060 /* Copy the I/O Status */
1062
1063 /* The driver failed to create the file */
1065 {
1066 /* Check if we have a name and if so, free it */
1068 {
1069 /*
1070 * Don't use TAG_IO_NAME since the FileObject's FileName
1071 * may have been re-allocated using a different tag
1072 * by a filesystem.
1073 */
1076 FileObject->FileName.Length = 0;
1077 }
1078
1079 /* Clear its device object */
1081
1082 /* Save this now because the FO might go away */
1085
1086 /* Clear the file object in the open packet */
1088
1089 /* Dereference the file object */
1091
1092 /* Dereference the device object */
1094
1095 /* Unless the driver cancelled the open, dereference the VPB */
1097
1098 /* Set the status and return */
1101 }
1103 {
1106 {
1107 /* Update CompleteName with reparse info which got updated in IopDoNameTransmogrify() */
1109 {
1110 PWSTR NewCompleteName;
1111
1112 /* Allocate a new buffer for the string */
1115 {
1118 }
1119
1120 /* Release the old one */
1122 {
1123 /*
1124 * Don't use TAG_IO_NAME since the FileObject's FileName
1125 * may have been re-allocated using a different tag
1126 * by a filesystem.
1127 */
1128 ExFreePoolWithTag(CompleteName->Buffer, 0);
1129 }
1130
1131 /* And setup the new one */
1132 CompleteName->Buffer = NewCompleteName;
1133 CompleteName->MaximumLength = FileObject->FileName.Length;
1134 }
1135
1136 /* Copy our new complete name */
1138
1140 {
1142 }
1143 }
1144
1145 /* Check if we have a name and if so, free it */
1147 {
1148 /*
1149 * Don't use TAG_IO_NAME since the FileObject's FileName
1150 * may have been re-allocated using a different tag
1151 * by a filesystem.
1152 */
1155 FileObject->FileName.Length = 0;
1156 }
1157
1158 /* Clear its device object */
1160
1161 /* Clear the file object in the open packet */
1163
1164 /* Dereference the file object */
1166
1167 /* Dereference the device object */
1169
1170 /* Unless the driver cancelled the open, dereference the VPB */
1172
1174 {
1176
1177 /* Inform we traversed a mount point for later attempt */
1179 {
1180 OpenPacket->TraversedMountPoint = 1;
1181 }
1182
1183 /* In case we override checks, but got this on volume open, fail hard */
1185 {
1186 KeBugCheckEx(DRIVER_RETURNED_STATUS_REPARSE_FOR_VOLUME_OPEN,
1187 (ULONG_PTR)OriginalDeviceObject,
1189 (ULONG_PTR)CompleteName,
1190 OpenPacket->Information);
1191 }
1192
1193 /* Return to IO/OB so that information can be upgraded */
1195 }
1196
1197 /* Loop again and reattempt an opening */
1198 continue;
1199 }
1200
1201 break;
1202 }
1203
1206
1207 /* Get the owner of the File Object */
1209
1210 /*
1211 * It's possible that the device to whom we sent the IRP to
1212 * isn't actually the device that ended opening the file object
1213 * internally.
1214 */
1216 {
1217 /* We have to de-reference the VPB we had associated */
1219
1220 /* And re-associate with the actual one */
1223 }
1224
1225 /* Make sure we are not using a dummy */
1226 if (!UseDummyFile)
1227 {
1228 /* Check if this was a volume open */
1231 !(FileObject->FileName.Length))
1232 {
1233 /* All signs point to it, but make sure it was actually an FSD */
1235 (OwnerDevice->DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) ||
1236 (OwnerDevice->DeviceType == FILE_DEVICE_TAPE_FILE_SYSTEM) ||
1237 (OwnerDevice->DeviceType == FILE_DEVICE_FILE_SYSTEM))
1238 {
1239 /* The owner device is an FSD, so this is a volume open for real */
1241 }
1242 }
1243
1244 /* Reference the object and set the parse check */
1250 }
1251 else
1252 {
1253 /* Check if this was a query */
1255 {
1256 /* Check if the caller wants basic info only */
1258 {
1259 /* Allocate the buffer */
1262 TAG_IO);
1264 {
1265 /* Do the query */
1267 FileBasicInformation,
1269 FileBasicInfo,
1270 &ReturnLength);
1272 {
1273 /* Copy the data */
1275 FileBasicInfo,
1276 ReturnLength);
1277 }
1278
1279 /* Free our buffer */
1281 }
1282 else
1283 {
1284 /* Fail */
1286 }
1287 }
1288 else
1289 {
1290 /* This is a full query */
1292 FileObject,
1295 OpenPacket->NetworkInformation,
1296 &ReturnLength);
1298 }
1299 }
1300
1301 /* Delete the file object */
1303
1304 /* Clear out the file */
1306
1307 /* Set and return status */
1311 }
1312}
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG ReturnLength
Definition: KdSystemDebugControl.c:34
BOOLEAN NTAPI SeAccessCheck(_In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ PSECURITY_SUBJECT_CONTEXT SubjectSecurityContext, _In_ BOOLEAN SubjectContextLocked, _In_ ACCESS_MASK DesiredAccess, _In_ ACCESS_MASK PreviouslyGrantedAccess, _Out_ PPRIVILEGE_SET *Privileges, _In_ PGENERIC_MAPPING GenericMapping, _In_ KPROCESSOR_MODE AccessMode, _Out_ PACCESS_MASK GrantedAccess, _Out_ PNTSTATUS AccessStatus)
Determines whether security access rights can be given to an object depending on the security descrip...
Definition: accesschk.c:1994
struct _DEVICE_OBJECT * PDEVICE_OBJECT
static __inline BOOLEAN IopValidateOpenPacket(IN POPEN_PACKET OpenPacket)
Definition: io_x.h:154
NTSTATUS NTAPI IoQueryFileInformation(IN PFILE_OBJECT FileObject, IN FILE_INFORMATION_CLASS FileInformationClass, IN ULONG Length, OUT PVOID FileInformation, OUT PULONG ReturnedLength)
Definition: iofunc.c:1274
NTSYSAPI VOID NTAPI RtlMapGenericMask(PACCESS_MASK AccessMask, PGENERIC_MAPPING GenericMapping)
struct _OPEN_PACKET * POPEN_PACKET
PVPB NTAPI IopCheckVpbMounted(IN POPEN_PACKET OpenPacket, IN PDEVICE_OBJECT DeviceObject, IN PUNICODE_STRING RemainingName, OUT PNTSTATUS Status)
Definition: volume.c:76
struct _FILE_OBJECT_EXTENSION FILE_OBJECT_EXTENSION
struct _FILE_OBJECT_EXTENSION * PFILE_OBJECT_EXTENSION
BOOLEAN NTAPI SeFastTraverseCheck(_In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ PACCESS_STATE AccessState, _In_ ACCESS_MASK DesiredAccess, _In_ KPROCESSOR_MODE AccessMode)
Determines whether security access rights can be given to an object depending on the security descrip...
Definition: accesschk.c:2138
NTSTATUS IopCheckTopDeviceHint(IN OUT PDEVICE_OBJECT *DeviceObject, IN POPEN_PACKET OpenPacket, BOOLEAN DirectOpen)
Definition: file.c:272
VOID NTAPI IopCheckBackupRestorePrivilege(IN PACCESS_STATE AccessState, IN OUT PULONG CreateOptions, IN KPROCESSOR_MODE PreviousMode, IN ULONG Disposition)
Definition: file.c:25
VOID NTAPI IopDoNameTransmogrify(IN PIRP Irp, IN PFILE_OBJECT FileObject, IN PREPARSE_DATA_BUFFER DataBuffer)
Definition: file.c:167
NTSTATUS NTAPI IopCheckDeviceAndDriver(IN POPEN_PACKET OpenPacket, IN PDEVICE_OBJECT DeviceObject)
Definition: file.c:135
VOID NTAPI SeSetAccessStateGenericMapping(_In_ PACCESS_STATE AccessState, _In_ PGENERIC_MAPPING GenericMapping)
Sets a new generic mapping for an allocated access state.
Definition: access.c:193
VOID NTAPI SeOpenObjectAuditAlarm(_In_ PUNICODE_STRING ObjectTypeName, _In_opt_ PVOID Object, _In_opt_ PUNICODE_STRING AbsoluteObjectName, _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ PACCESS_STATE AccessState, _In_ BOOLEAN ObjectCreated, _In_ BOOLEAN AccessGranted, _In_ KPROCESSOR_MODE AccessMode, _Out_ PBOOLEAN GenerateOnClose)
Creates an audit with alarm notification of an object that is being opened.
Definition: audit.c:1213
VOID NTAPI SeFreePrivileges(_In_ PPRIVILEGE_SET Privileges)
Frees a set of privileges.
Definition: priv.c:669
NTSTATUS NTAPI SeAppendPrivileges(_Inout_ PACCESS_STATE AccessState, _In_ PPRIVILEGE_SET Privileges)
Appends additional privileges.
Definition: priv.c:588
Definition: io.h:356
Definition: nt_native.h:941
Definition: from_kernel.h:207
Definition: iotypes.h:2867
struct _IO_STACK_LOCATION::@4315::@4317 CreatePipe
struct _IO_STACK_LOCATION::@4315::@4316 Create
struct _IO_STACK_LOCATION::@4315::@4318 CreateMailslot
Definition: io.h:366
PFILE_NETWORK_OPEN_INFORMATION NetworkInformation
Definition: io.h:384
Definition: setypes.h:85
VOID NTAPI SeLockSubjectContext(_In_ PSECURITY_SUBJECT_CONTEXT SubjectContext)
Locks both the referenced primary and client access tokens of a security subject context.
Definition: subject.c:107
VOID NTAPI SeUnlockSubjectContext(_In_ PSECURITY_SUBJECT_CONTEXT SubjectContext)
Unlocks both the referenced primary and client access tokens of a security subject context.
Definition: subject.c:138
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
Definition: wdfcommonbuffer.h:97
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:191
#define IRP_MJ_CREATE_NAMED_PIPE
#define IRP_MJ_CREATE_MAILSLOT
#define IO_TYPE_FILE
#define IRP_DEFER_IO_COMPLETION
_In_ PSECURITY_SUBJECT_CONTEXT _In_ BOOLEAN _In_ ACCESS_MASK _In_ ACCESS_MASK _Outptr_opt_ PPRIVILEGE_SET * Privileges
Definition: sefuncs.h:17
_In_opt_ PVOID _In_opt_ PUNICODE_STRING _In_ PSECURITY_DESCRIPTOR _In_ PACCESS_STATE _In_ BOOLEAN _In_ BOOLEAN AccessGranted
Definition: sefuncs.h:419
_In_opt_ PVOID _In_opt_ PUNICODE_STRING _In_ PSECURITY_DESCRIPTOR _In_ PACCESS_STATE AccessState
Definition: sefuncs.h:417
_In_ PSECURITY_SUBJECT_CONTEXT _In_ BOOLEAN _In_ ACCESS_MASK _In_ ACCESS_MASK _Outptr_opt_ PPRIVILEGE_SET _In_ PGENERIC_MAPPING _In_ KPROCESSOR_MODE _Out_ PACCESS_MASK GrantedAccess
Definition: sefuncs.h:20
Referenced by IopCreateObjectTypes(), and IopParseFile().
◆ IopParseFile()
| NTSTATUS NTAPI IopParseFile | ( | IN PVOID | ParseObject, |
| IN PVOID | ObjectType, | ||
| IN OUT PACCESS_STATE | AccessState, | ||
| IN KPROCESSOR_MODE | AccessMode, | ||
| IN ULONG | Attributes, | ||
| IN OUT PUNICODE_STRING | CompleteName, | ||
| IN OUT PUNICODE_STRING | RemainingName, | ||
| IN OUT PVOID Context | OPTIONAL, | ||
| IN PSECURITY_QUALITY_OF_SERVICE SecurityQos | OPTIONAL, | ||
| OUT PVOID * | Object | ||
| ) |
Definition at line 1316 of file file.c.
1326{
1329
1330 /* Validate the open packet */
1332
1333 /* Get the device object */
1335 OpenPacket->RelatedFileObject = ParseObject;
1336
1337 /* Call the main routine */
1339 ObjectType,
1340 AccessState,
1341 AccessMode,
1342 Attributes,
1343 CompleteName,
1344 RemainingName,
1345 OpenPacket,
1346 SecurityQos,
1347 Object);
1348}
NTSTATUS NTAPI IopParseDevice(IN PVOID ParseObject, IN PVOID ObjectType, IN OUT PACCESS_STATE AccessState, IN KPROCESSOR_MODE AccessMode, IN ULONG Attributes, IN OUT PUNICODE_STRING CompleteName, IN OUT PUNICODE_STRING RemainingName, IN OUT PVOID Context, IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL, OUT PVOID *Object)
Definition: file.c:321
Referenced by IopCreateObjectTypes().
◆ IopQueryDeviceCapabilities()
| NTSTATUS NTAPI IopQueryDeviceCapabilities | ( | PDEVICE_NODE | DeviceNode, |
| PDEVICE_CAPABILITIES | DeviceCaps | ||
| ) |
Definition at line 857 of file devaction.c.
859{
860 IO_STATUS_BLOCK StatusBlock;
863 HANDLE InstanceKey;
865
866 /* Set up the Header */
869 DeviceCaps->Version = 1;
870 DeviceCaps->Address = -1;
871 DeviceCaps->UINumber = -1;
872
873 /* Set up the Stack */
875 Stack.Parameters.DeviceCapabilities.Capabilities = DeviceCaps;
876
877 /* Send the IRP */
879 &StatusBlock,
881 &Stack);
883 {
885 {
887 }
889 }
890
891 /* Map device capabilities to capability flags */
892 DeviceNode->CapabilityFlags = 0;
893 if (DeviceCaps->LockSupported)
895
896 if (DeviceCaps->EjectSupported)
898
899 if (DeviceCaps->Removable)
901
902 if (DeviceCaps->DockDevice)
904
905 if (DeviceCaps->UniqueID)
907
908 if (DeviceCaps->SilentInstall)
910
911 if (DeviceCaps->RawDeviceOK)
913
914 if (DeviceCaps->SurpriseRemovalOK)
916
917 if (DeviceCaps->HardwareDisabled)
919
920 if (DeviceCaps->NonDynamic)
922
923 if (DeviceCaps->NoDisplayInUI)
925 else
926 DeviceNode->UserFlags &= ~DNUF_DONT_SHOW_IN_UI;
927
928 Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, REG_OPTION_NON_VOLATILE, &InstanceKey);
930 {
931 /* Set 'Capabilities' value */
933 Status = ZwSetValueKey(InstanceKey,
934 &ValueName,
935 0,
936 REG_DWORD,
937 &DeviceNode->CapabilityFlags,
939
940 /* Set 'UINumber' value */
942 {
944 Status = ZwSetValueKey(InstanceKey,
945 &ValueName,
946 0,
947 REG_DWORD,
948 &DeviceCaps->UINumber,
950 }
951
952 ZwClose(InstanceKey);
953 }
954
956}
NTSTATUS NTAPI IopCreateDeviceKeyPath(IN PCUNICODE_STRING RegistryPath, IN ULONG CreateOptions, OUT PHANDLE Handle)
Definition: pnpmgr.c:522
NTSTATUS NTAPI IopInitiatePnpIrp(IN PDEVICE_OBJECT DeviceObject, IN PIO_STATUS_BLOCK IoStatusBlock, IN UCHAR MinorFunction, IN PIO_STACK_LOCATION Stack)
#define IRP_MN_QUERY_CAPABILITIES
Referenced by IoGetDeviceProperty(), IopCreateDeviceInstancePath(), IoRequestDeviceEject(), and PiStartDeviceFinal().
◆ IopQueryName()
| NTSTATUS NTAPI IopQueryName | ( | IN PVOID | ObjectBody, |
| IN BOOLEAN | HasName, | ||
| OUT POBJECT_NAME_INFORMATION | ObjectNameInfo, | ||
| IN ULONG | Length, | ||
| OUT PULONG | ReturnLength, | ||
| IN KPROCESSOR_MODE | PreviousMode | ||
| ) |
Definition at line 1923 of file file.c.
1929{
1931 HasName,
1932 FALSE,
1933 ObjectNameInfo,
1934 Length,
1935 ReturnLength,
1936 PreviousMode);
1937}
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG _In_ KPROCESSOR_MODE PreviousMode
Definition: KdSystemDebugControl.c:35
NTSTATUS NTAPI IopQueryNameInternal(IN PVOID ObjectBody, IN BOOLEAN HasName, IN BOOLEAN QueryDosName, OUT POBJECT_NAME_INFORMATION ObjectNameInfo, IN ULONG Length, OUT PULONG ReturnLength, IN KPROCESSOR_MODE PreviousMode)
Definition: file.c:1941
Referenced by IopCreateObjectTypes().
◆ IopQueryNameInternal()
| NTSTATUS NTAPI IopQueryNameInternal | ( | IN PVOID | ObjectBody, |
| IN BOOLEAN | HasName, | ||
| IN BOOLEAN | QueryDosName, | ||
| OUT POBJECT_NAME_INFORMATION | ObjectNameInfo, | ||
| IN ULONG | Length, | ||
| OUT PULONG | ReturnLength, | ||
| IN KPROCESSOR_MODE | PreviousMode | ||
| ) |
Definition at line 1941 of file file.c.
1948{
1949 POBJECT_NAME_INFORMATION LocalInfo;
1950 PFILE_NAME_INFORMATION LocalFileInfo;
1957 BOOLEAN NoObCall;
1958
1960
1961 /* Validate length */
1963 {
1964 /* Wrong length, fail */
1967 }
1968
1969 /* Allocate Buffer */
1972
1973 /* Query DOS name if the caller asked to */
1974 NoObCall = FALSE;
1975 if (QueryDosName)
1976 {
1978
1979 /* In case of a network file system, don't call mountmgr */
1981 {
1982 /* We'll store separator and terminator */
1985 {
1987 }
1988 else
1989 {
1995 }
1996 }
1997 /* Otherwise, call mountmgr to get DOS name */
1998 else
1999 {
2002 }
2003 }
2004
2005 /* Fall back if querying DOS name failed or if caller never wanted it ;-) */
2007 {
2008 /* Query the name */
2010 LocalInfo,
2011 Length,
2012 &LocalReturnLength);
2013 }
2014 else
2015 {
2016 NoObCall = TRUE;
2017 }
2018
2020 {
2021 /* Free the buffer and fail */
2024 }
2025
2026 /* Get buffer pointer */
2028
2029 _SEH2_TRY
2030 {
2031 /* Copy the information */
2032 if (QueryDosName && NoObCall)
2033 {
2035
2036 /* Copy structure first */
2037 RtlCopyMemory(ObjectNameInfo,
2038 LocalInfo,
2040 /* Name then */
2042 (Length >= LocalReturnLength ? LocalInfo->Name.Length : Length - sizeof(OBJECT_NAME_INFORMATION)));
2043
2045 {
2047 }
2048 }
2049 else
2050 {
2051 RtlCopyMemory(ObjectNameInfo,
2052 LocalInfo,
2053 (LocalReturnLength > Length) ?
2054 Length : LocalReturnLength);
2055 }
2056
2057 /* Set buffer pointer */
2058 ObjectNameInfo->Name.Buffer = p;
2059
2060 /* Advance in buffer */
2062
2063 /* Check if this already filled our buffer */
2065 {
2066 /* Set the length mismatch to true, so that we can return
2067 * the proper buffer size to the caller later
2068 */
2069 LengthMismatch = TRUE;
2070
2071 /* Save the initial buffer length value */
2072 *ReturnLength = LocalReturnLength;
2073 }
2074
2075 /* Now get the file name buffer and check the length needed */
2076 LocalFileInfo = (PFILE_NAME_INFORMATION)LocalInfo;
2078 LocalReturnLength +
2080
2081 /* Query the File name */
2084 {
2087 FileNameInformation,
2088 LocalFileInfo,
2089 &LocalReturnLength);
2090 }
2091 else
2092 {
2094 FileNameInformation,
2096 LocalFileInfo,
2097 &LocalReturnLength);
2098 }
2100 {
2101 /* Allow status that would mean it's not implemented in the storage stack */
2104 {
2105 _SEH2_LEAVE;
2106 }
2107
2108 /* In such case, zero the output and reset the status */
2110 LocalFileInfo->FileNameLength = 0;
2113 }
2114 else
2115 {
2116 /* We'll at least return the name length */
2118 {
2120 }
2121 }
2122
2123 /* If the provided buffer is too small, return the required size */
2124 if (LengthMismatch)
2125 {
2126 /* Add the required length */
2128
2129 /* Free the allocated buffer and return failure */
2131 _SEH2_LEAVE;
2132 }
2133
2134 /* Now calculate the new lengths left */
2135 FileLength = LocalReturnLength -
2138 (ULONG_PTR)ObjectNameInfo +
2139 LocalFileInfo->FileNameLength);
2140
2141 /* Don't copy the name if it's not valid */
2143 {
2144 /* Free the allocated buffer and return failure */
2146 _SEH2_LEAVE;
2147 }
2148
2149 /* Write the Name and null-terminate it */
2154
2155 /* Return the length needed */
2156 *ReturnLength = LocalReturnLength;
2157
2158 /* Setup the length and maximum length */
2162 ObjectNameInfo->Name.MaximumLength = (USHORT)ObjectNameInfo->Name.Length +
2164 }
2165 _SEH2_FINALLY
2166 {
2167 /* Free buffer and return */
2169 } _SEH2_END;
2170
2172}
NTSTATUS NTAPI IopGetFileInformation(IN PFILE_OBJECT FileObject, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInfoClass, OUT PVOID Buffer, OUT PULONG ReturnedLength)
Definition: iofunc.c:777
NTSTATUS NTAPI IoVolumeDeviceToDosName(_In_ PVOID VolumeDeviceObject, _Out_ _When_(return==0, _At_(DosName->Buffer, __drv_allocatesMem(Mem))) PUNICODE_STRING DosName)
Definition: volume.c:1279
Definition: winternl.h:1591
Definition: filecomp.c:348
struct _FILE_NAME_INFORMATION * PFILE_NAME_INFORMATION
Referenced by IopQueryName(), and IoQueryFileDosDeviceName().
◆ IopQueueDeviceChangeEvent()
| NTSTATUS IopQueueDeviceChangeEvent | ( | _In_ const GUID * | EventGuid, |
| _In_ const GUID * | InterfaceClassGuid, | ||
| _In_ PUNICODE_STRING | SymbolicLinkName | ||
| ) |
Definition at line 52 of file plugplay.c.
56{
57 PPNP_EVENT_ENTRY EventEntry;
59 ULONG TotalSize;
60
61 /* Allocate a big enough buffer */
62 Copy.Length = 0;
64 TotalSize =
66 Copy.MaximumLength;
67
70 if (!EventEntry)
73
74 /* Fill the buffer with the event GUID */
78
79 /* Fill the interface class GUID */
81
82 /* Fill the symbolic link name */
85 EventEntry->Event.DeviceClass.SymbolicLinkName[SymbolicLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
86
88 &EventEntry->ListEntry);
90 0,
91 FALSE);
92
94}
_Must_inspect_result_ _In_ WDFDEVICE _In_ REFGUID EventGuid
Definition: fxdeviceapium.cpp:56
Definition: shobjidl.idl:3021
Definition: cmtypes.h:418
struct _PLUGPLAY_EVENT_BLOCK::@2568::@2570 DeviceClass
WCHAR SymbolicLinkName[ANYSIZE_ARRAY]
Definition: cmtypes.h:430
Definition: plugplay.c:16
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING SymbolicLinkName
Definition: wdfdevice.h:3745
Referenced by IoSetDeviceInterfaceState().
◆ IopQueueDeviceInstallEvent()
Definition at line 97 of file plugplay.c.
100{
101 PPNP_EVENT_ENTRY EventEntry;
103 ULONG TotalSize;
104
105 /* Allocate a big enough buffer */
106 Copy.Length = 0;
108 TotalSize =
110 Copy.MaximumLength;
111
114 if (!EventEntry)
117
118 /* Fill the buffer with the event GUID */
122
123 /* Fill the symbolic link name */
125 DeviceId->Buffer, DeviceId->Length);
127
129
131
133}
static BOOL InstallDevice(PCWSTR DeviceInstance, BOOL ShowWizard)
Definition: install.c:55
struct _PLUGPLAY_EVENT_BLOCK::@2568::@2572 InstallDevice
Referenced by PiControlInitializeDevice(), and PiInitializeDevNode().
◆ IopQueueTargetDeviceEvent()
Referenced by IopQueryRemoveDevice(), IopRemoveDevice(), IoRequestDeviceEject(), and PiStartDeviceFinal().
◆ IopReadyDeviceObjects()
| VOID NTAPI IopReadyDeviceObjects | ( | IN PDRIVER_OBJECT | Driver | ) |
Definition at line 34 of file device.c.
35{
37 PAGED_CODE();
38
39 /* Set the driver as initialized */
43 {
44 /* Set every device as initialized too */
45 DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
47 }
48}
Referenced by IopInitializeDriverModule().
◆ IopReassignSystemRoot()
| NTSTATUS NTAPI IopReassignSystemRoot | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock, |
| OUT PANSI_STRING | NtBootPath | ||
| ) |
Definition at line 839 of file arcname.c.
841{
845 WCHAR ArcNameBuffer[64];
848 HANDLE LinkHandle;
849
850 /* Create the Unicode name for the current ARC boot device */
855
856 /* Initialize the attributes and open the link */
858 &TargetName,
859 OBJ_CASE_INSENSITIVE,
860 NULL,
861 NULL);
864 &ObjectAttributes);
866 {
867 /* We failed, free the string */
870 }
871
872 /* Query the current \\SystemRoot */
873 ArcName.Buffer = ArcNameBuffer;
874 ArcName.Length = 0;
878 {
879 /* We failed, free the string */
882 }
883
884 /* Convert it to Ansi */
885 ArcString.Buffer = AnsiBuffer;
886 ArcString.Length = 0;
890
891 /* Close the link handle and free the name */
894
895 /* Setup the system root name again */
899
900 /* Open the symbolic link for it */
902 &LinkName,
903 OBJ_CASE_INSENSITIVE,
904 NULL,
905 NULL);
908 &ObjectAttributes);
910
911 /* Destroy it */
912 NtMakeTemporaryObject(LinkHandle);
914
915 /* Now create the new name for it */
917
918 /* Copy it into the passed parameter and null-terminate it */
919 RtlCopyString(NtBootPath, &ArcString);
921
922 /* Setup the Unicode-name for the new symbolic link value */
925 &LinkName,
927 NULL,
928 NULL);
931
932 /* Create it */
935 &ObjectAttributes,
936 &ArcName);
937
938 /* Free all the strings and close the handle and return success */
939 RtlFreeUnicodeString(&ArcName);
940 RtlFreeUnicodeString(&LinkName);
943}
NTSYSAPI VOID NTAPI RtlCopyString(PSTRING DestinationString, PSTRING SourceString)
NTSTATUS NTAPI NtMakeTemporaryObject(IN HANDLE ObjectHandle)
Definition: oblife.c:1473
NTSTATUS NTAPI NtQuerySymbolicLinkObject(IN HANDLE LinkHandle, OUT PUNICODE_STRING LinkTarget, OUT PULONG ResultLength OPTIONAL)
Definition: oblink.c:903
NTSTATUS NTAPI NtCreateSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN PUNICODE_STRING LinkTarget)
Definition: oblink.c:676
NTSTATUS NTAPI NtOpenSymbolicLinkObject(OUT PHANDLE LinkHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: oblink.c:831
Referenced by IoInitSystem().
◆ IopReferenceDeviceObject()
| NTSTATUS NTAPI IopReferenceDeviceObject | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
◆ IopReinitializeBootDrivers()
Definition at line 1544 of file driver.c.
1545{
1546 PDRIVER_REINIT_ITEM ReinitItem;
1548
1549 /* Get the first entry and start looping */
1551 &DriverBootReinitListLock);
1553 {
1554 /* Get the item */
1556
1557 /* Increment reinitialization counter */
1559
1560 /* Remove the device object flag */
1562
1563 /* Call the routine */
1565 ReinitItem->Context,
1566 ReinitItem->DriverObject->
1567 DriverExtension->Count);
1568
1569 /* Free the entry */
1571
1572 /* Move to the next one */
1574 &DriverBootReinitListLock);
1575 }
1576
1577 /* Wait for all device actions being finished*/
1579}
PLIST_ENTRY NTAPI ExInterlockedRemoveHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:166
Definition: io.h:446
Referenced by IoInitSystem().
◆ IopReinitializeDrivers()
Definition at line 1508 of file driver.c.
1509{
1510 PDRIVER_REINIT_ITEM ReinitItem;
1512
1513 /* Get the first entry and start looping */
1515 &DriverReinitListLock);
1517 {
1518 /* Get the item */
1520
1521 /* Increment reinitialization counter */
1523
1524 /* Remove the device object flag */
1526
1527 /* Call the routine */
1529 ReinitItem->Context,
1530 ReinitItem->DriverObject->
1531 DriverExtension->Count);
1532
1533 /* Free the entry */
1535
1536 /* Move to the next one */
1538 &DriverReinitListLock);
1539 }
1540}
Referenced by IoInitSystem(), and IopInitializeDriverModule().
◆ IopRemoveTimerFromTimerList()
Definition at line 70 of file iotimer.c.
71{
73
74 /* Lock Timers */
76
77 /* Remove Timer from the List and Drop the Timer Count if Enabled */
80
81 /* Unlock the Timers */
83}
Definition: cppunit_timer.h:24
Referenced by IoDeleteDevice().
◆ IopSaveBootLogToFile()
Definition at line 288 of file bootlog.c.
289{
290 PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
291 WCHAR ValueNameBuffer[8];
300
302 return;
303
305
307
310 {
313 return;
314 }
315
316 //Status = IopWriteLogFile(L"ReactOS "KERNEL_VERSION_STR);
317
319 {
322 return;
323 }
324
327 {
330 return;
331 }
332
333
336 BufferSize);
338 {
340 return;
341 }
342
346 &KeyName,
347 OBJ_CASE_INSENSITIVE,
348 NULL,
349 NULL);
351 KEY_ALL_ACCESS,
352 &ObjectAttributes);
354 {
355 ExFreePool(KeyInfo);
357 return;
358 }
359
361 {
362 swprintf(ValueNameBuffer,
364
366 ValueNameBuffer);
367
369 &ValueName,
371 KeyInfo,
372 BufferSize,
373 &ResultLength);
375 {
376 break;
377 }
378
380 {
382 ExFreePool(KeyInfo);
384 return;
385 }
386
389 {
391 ExFreePool(KeyInfo);
393 return;
394 }
395
396 /* Delete keys */
398 &ValueName);
399 }
400
402
403 ExFreePool(KeyInfo);
404
407
409}
NTSYSAPI NTSTATUS NTAPI ZwDeleteValueKey(__in IN HANDLE Key, __in IN PUNICODE_STRING ValueName)
struct _KEY_VALUE_PARTIAL_INFORMATION KEY_VALUE_PARTIAL_INFORMATION
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3782
◆ IopShutdownBaseFileSystems()
| VOID NTAPI IopShutdownBaseFileSystems | ( | IN PLIST_ENTRY | ListHead | ) |
Definition at line 349 of file volume.c.
350{
351 PLIST_ENTRY ListEntry;
353 IO_STATUS_BLOCK StatusBlock;
357
359
360 /* Get the first entry and start looping */
361 ListEntry = ListHead->Flink;
362 while (ListEntry != ListHead)
363 {
364 /* Get the device object */
366 DEVICE_OBJECT,
367 Queue.ListEntry);
368
369 /* Go to the next entry */
370 ListEntry = ListEntry->Flink;
371
372 /* Get the attached device */
374
377
378 /* Build the shutdown IRP and call the driver */
380 DeviceObject,
381 NULL,
382 0,
383 NULL,
384 &Event,
385 &StatusBlock);
387 {
390 {
391 /* Wait on the driver */
393 }
394 }
395
396 /* Reset the event */
398
401 }
402}
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
VOID NTAPI IopDecrementDeviceObjectRef(IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN UnloadIfUnused)
Definition: volume.c:33
#define IRP_MJ_SHUTDOWN
Referenced by IoShutdownSystem().
◆ IopStartBootLog()
◆ IopStartRamdisk()
| NTSTATUS NTAPI IopStartRamdisk | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 26 of file ramdisk.c.
27{
32 RAMDISK_CREATE_INPUT RamdiskCreate;
35 PLIST_ENTRY ListHead, NextEntry;
38
39 //
40 // Scan memory descriptors
41 //
43 ListHead = &LoaderBlock->MemoryDescriptorListHead;
44 NextEntry = ListHead->Flink;
45 while (NextEntry != ListHead)
46 {
47 //
48 // Get the descriptor
49 //
52 ListEntry);
53
54 //
55 // Needs to be a ROM/RAM descriptor
56 //
58
59 //
60 // Keep trying
61 //
62 NextEntry = NextEntry->Flink;
63 }
64
65 //
66 // Nothing found?
67 //
68 if (NextEntry == ListHead)
69 {
70 //
71 // Bugcheck -- no data
72 //
73 KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
76 0,
77 0);
78 }
79
80 //
81 // Setup the input buffer
82 //
87 RamdiskCreate.DiskOffset = 0;
89 RamdiskCreate.DiskGuid = RAMDISK_BOOTDISK_GUID;
92
93 //
94 // Check for commandline parameters
95 //
96 CommandLine = LoaderBlock->LoadOptions;
97 if (CommandLine)
98 {
99 //
100 // Make everything upper case
101 //
102 _strupr(CommandLine);
103
104 //
105 // Check for offset parameter
106 //
109 {
110 //
111 // Get to the actual value
112 //
114 if (OffsetValue)
115 {
116 //
117 // Set the offset
118 //
120 }
121 }
122
123 //
124 // Reduce the disk length
125 //
127
128 //
129 // Check for length parameter
130 //
133 {
134 //
135 // Get to the actual value
136 //
138 if (LengthValue)
139 {
140 //
141 // Set the offset
142 //
144 }
145 }
146 }
147
148 //
149 // Setup object attributes
150 //
153 &ObjectName,
155 NULL,
156 NULL);
157
158 //
159 // Open a handle to the driver
160 //
163 &ObjectAttributes,
164 &IoStatusBlock,
168 {
169 //
170 // Bugcheck -- no driver
171 //
172 KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
173 RD_NO_RAMDISK_DRIVER,
175 0,
176 0);
177 }
178
179 //
180 // Send create command
181 //
183 NULL,
184 NULL,
185 NULL,
186 &IoStatusBlock,
188 &RamdiskCreate,
189 sizeof(RamdiskCreate),
190 NULL,
191 0);
194 {
195 //
196 // Bugcheck -- driver failed
197 //
198 KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
199 RD_FSCTL_FAILED,
201 0,
202 0);
203 }
204
205 //
206 // Convert the GUID
207 //
210 {
211 //
212 // Bugcheck -- GUID convert failed
213 //
214 KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
216 Status,
217 0,
218 0);
219 }
220
221 //
222 // Build the symbolic link name and target
223 //
227 &GuidString);
228 SymbolicLinkName.Length = 38;
231
232 //
233 // Create the symbolic link
234 //
239 {
240 //
241 // Bugcheck -- symlink create failed
242 //
243 KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
245 Status,
246 0,
247 0);
248 }
249
250 //
251 // ReactOS hack (drive letter should not be hardcoded, and maybe set by mountmgr.sys)
252 //
253 {
254 ANSI_STRING AnsiPath;
258
262 RtlInitEmptyUnicodeString(&NtSystemRoot,
263 SharedUserData->NtSystemRoot,
267 {
268 KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
270 Status,
271 0,
272 0);
273 }
274 IoCreateSymbolicLink(&DriveLetter, &DeviceString);
275 }
276
277 //
278 // Wait for ramdisk relations being initialized
279 //
280
282
283 //
284 // We made it
285 //
287}
_ACRTIMP int __cdecl _snwprintf(wchar_t *, size_t, const wchar_t *,...)
Definition: wcs.c:1493
NTSYSAPI NTSTATUS NTAPI ZwOpenFile(_Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG ShareAccess, _In_ ULONG OpenOptions)
NTSYSAPI NTSTATUS NTAPI ZwDeviceIoControlFile(IN HANDLE DeviceHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL, IN PVOID UserApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN ULONG IoControlCode, IN PVOID InputBuffer, IN ULONG InputBufferSize, OUT PVOID OutputBuffer, IN ULONG OutputBufferSize)
NTSTATUS NTAPI IoCreateSymbolicLink(IN PUNICODE_STRING SymbolicLinkName, IN PUNICODE_STRING DeviceName)
Definition: symlink.c:23
#define SharedUserData
Definition: arc.h:326
Definition: ntddrdsk.h:72
_Must_inspect_result_ _In_ WDFUSBDEVICE _In_opt_ WDFREQUEST _In_opt_ PWDF_REQUEST_SEND_OPTIONS _In_ PWDF_USB_CONTROL_SETUP_PACKET _In_opt_ PWDF_MEMORY_DESCRIPTOR MemoryDescriptor
Definition: wdfusb.h:1339
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
_In_ PVOID _Out_opt_ PULONG_PTR _Outptr_opt_ PCUNICODE_STRING * ObjectName
Definition: cmfuncs.h:64
Referenced by IoInitSystem().
◆ IopStopBootLog()
◆ IopStoreSystemPartitionInformation()
| VOID IopStoreSystemPartitionInformation | ( | _In_ PUNICODE_STRING | NtSystemPartitionDeviceName, |
| _In_ PUNICODE_STRING | OsLoaderPathName | ||
| ) |
Definition at line 860 of file iorsrce.c.
863{
868 WCHAR LinkTargetBuffer[256];
869 UNICODE_STRING CmRegistryMachineSystemName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM");
870
871 ASSERT(NtSystemPartitionDeviceName->MaximumLength >= NtSystemPartitionDeviceName->Length + sizeof(WCHAR));
872 ASSERT(NtSystemPartitionDeviceName->Buffer[NtSystemPartitionDeviceName->Length / sizeof(WCHAR)] == UNICODE_NULL);
875
876 /* First define needed stuff to open NtSystemPartitionDeviceName symbolic link */
878 NtSystemPartitionDeviceName,
880 NULL,
881 NULL);
882
883 /* Open NtSystemPartitionDeviceName symbolic link */
885 SYMBOLIC_LINK_QUERY,
886 &ObjectAttributes);
888 {
890 return;
891 }
892
893 /* Prepare the string that will receive where symbolic link points to.
894 * We will zero the end of the string after having received it */
895 RtlInitEmptyUnicodeString(&LinkTarget, LinkTargetBuffer,
897
898 /* Query target */
900
901 /* We are done with symbolic link */
903
905 {
907 return;
908 }
909
910 /* As promised, we zero the end */
912
913 /* Open registry to save data (HKLM\SYSTEM) */
915 NULL,
916 &CmRegistryMachineSystemName,
917 KEY_ALL_ACCESS);
919 {
921 return;
922 }
923
924 /* Open or create the Setup subkey where we'll store in */
926
928 RegistryHandle,
929 &KeyName,
930 KEY_ALL_ACCESS,
932 NULL);
933
934 /* We're done with HKLM\SYSTEM */
936
938 {
940 return;
941 }
942
943 /* Prepare first data writing */
945
946 /* Write SystemPartition value which is the target of the symbolic link */
948 &KeyName,
949 0,
950 REG_SZ,
954 {
956 }
957
958 /* Prepare for second data writing */
960
961 /* Remove trailing slash if any (one slash only excepted) */
963 OsLoaderPathName->Buffer[(OsLoaderPathName->Length / sizeof(WCHAR)) - 1] == OBJ_NAME_PATH_SEPARATOR)
964 {
967 }
968
969 /* Then, write down data */
971 &KeyName,
972 0,
973 REG_SZ,
974 OsLoaderPathName->Buffer,
977 {
979 }
980
981 /* We're finally done! */
983}
NTSYSAPI NTSTATUS NTAPI ZwOpenSymbolicLinkObject(_Out_ PHANDLE SymbolicLinkHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes)
Referenced by IopCreateArcNames(), and IopCreateArcNamesDisk().
◆ IopSynchronousCall()
| NTSTATUS IopSynchronousCall | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PIO_STACK_LOCATION | IoStackLocation, | ||
| OUT PVOID * | Information | ||
| ) |
Referenced by IopGetRelatedTargetDevice(), IopInitiatePnpIrp(), IopSendEject(), and PiIrpSendRemoveCheckVpb().
◆ IopTraverseDeviceTree()
| NTSTATUS IopTraverseDeviceTree | ( | PDEVICETREE_TRAVERSE_CONTEXT | Context | ) |
Referenced by IopGetDeviceObjectFromDeviceInstance(), and PopSetSystemPowerState().
◆ IopUnloadDevice()
| VOID NTAPI IopUnloadDevice | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 391 of file device.c.
392{
395
396 /* Check if deletion is pending */
398 {
400 {
402 return;
403 }
404
406 {
408 return;
409 }
410
411 /* Check if we have a Security Descriptor */
413 {
414 /* Dereference it */
416 }
417
418 /* Remove the device from the list */
420
421 /* Dereference the keep-alive */
423 }
424
425 /* We can't unload a non-PnP driver here */
427 {
429 return;
430 }
431
432 /* Return if we've already called unload (maybe we're in it?) */
434
435 /* We can't unload unless there's an unload handler */
437 {
438 DPRINT1("No DriverUnload function on PnP driver! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
439 return;
440 }
441
442 /* Bail if there are still devices present */
444 {
446 return;
447 }
448
450
451 /* Set the unload invoked flag */
453
454 /* Unload it */
456
457 /* Make object temporary so it can be deleted */
459}
VOID NTAPI IopEditDeviceList(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT DeviceObject, IN IOP_DEVICE_LIST_OPERATION Type)
Definition: device.c:335
VOID NTAPI ObDereferenceSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN ULONG Count)
Definition: obsdcach.c:287
Referenced by IoDeleteDevice(), IoDetachDevice(), IopDecrementDeviceObjectRef(), and IopDereferenceDeviceObject().
◆ IopUpdateRootKey()
Definition at line 670 of file pnpmap.c.
671{
672 UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
674 UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
678
679 InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
680 Status = ZwCreateKey(&hEnum, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
682 {
685 }
686
687 InitializeObjectAttributes(&ObjectAttributes, &RootPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hEnum, NULL);
688 Status = ZwCreateKey(&hRoot, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
689 ZwClose(hEnum);
691 {
694 }
695
697 {
700 {
701 /* Nothing to do, don't return with an error status */
705 }
707 hEnum,
708 NULL,
709 hRoot,
710 TRUE,
711 NULL,
712 0,
713 NULL,
714 0);
715 ZwClose(hEnum);
716 }
717 else
718 {
719 /* Enumeration is disabled */
721 }
722
724
726}
static NTSTATUS IopEnumerateDetectedDevices(_In_ HANDLE hBaseKey, _In_opt_ PUNICODE_STRING RelativePath, _In_ HANDLE hRootKey, _In_ BOOLEAN EnumerateSubKeys, _In_opt_ PCM_FULL_RESOURCE_DESCRIPTOR BootResources, _In_opt_ ULONG BootResourcesLength, _In_ PCM_FULL_RESOURCE_DESCRIPTOR ParentBootResources, _In_ ULONG ParentBootResourcesLength)
Definition: pnpmap.c:153
Referenced by IopInitializePlugPlayServices().
◆ IopVerifyDeviceObjectOnStack()
| BOOLEAN NTAPI IopVerifyDeviceObjectOnStack | ( | IN PDEVICE_OBJECT | BaseDeviceObject, |
| IN PDEVICE_OBJECT | TopDeviceObjectHint | ||
| ) |
Definition at line 696 of file device.c.
698{
701 PDEVICE_OBJECT LoopObject;
702
704
706 /* Simply loop on the device stack and try to find our hint */
708 for (LoopObject = BaseDeviceObject; ; LoopObject = LoopObject->AttachedDevice)
709 {
710 /* It was found, it's a success */
711 if (LoopObject == TopDeviceObjectHint)
712 {
714 break;
715 }
716
717 /* End of the stack, that's a failure - default */
719 {
720 break;
721 }
722 }
724
726}
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by IoGetRelatedDeviceObject(), and IopCheckTopDeviceHint().
◆ IopVerifyDiskSignature()
| BOOLEAN IopVerifyDiskSignature | ( | _In_ PDRIVE_LAYOUT_INFORMATION_EX | DriveLayout, |
| _In_ PARC_DISK_SIGNATURE | ArcDiskSignature, | ||
| _Out_ PULONG | Signature | ||
| ) |
Definition at line 946 of file arcname.c.
950{
951 /* Fail if the partition table is invalid */
952 if (!ArcDiskSignature->ValidPartitionTable)
954
955 /* If the partition style is MBR */
957 {
958 /* Check the MBR signature */
959 if (DriveLayout->Mbr.Signature == ArcDiskSignature->Signature)
960 {
961 /* And return it */
963 *Signature = DriveLayout->Mbr.Signature;
965 }
966 }
967 /* If the partition style is GPT */
969 {
970 /* Verify whether the signature is GPT and compare the GUID */
971 if (ArcDiskSignature->IsGpt &&
973 {
974 /* There is no signature to return, just zero it */
976 *Signature = 0;
978 }
979 }
980
981 /* If we get there, something went wrong, so fail */
983}
Referenced by IoGetBootDiskInformation(), and IopCreateArcNamesDisk().
◆ IoSetIoCompletion()
| NTSTATUS NTAPI IoSetIoCompletion | ( | IN PVOID | IoCompletion, |
| IN PVOID | KeyContext, | ||
| IN PVOID | ApcContext, | ||
| IN NTSTATUS | IoStatus, | ||
| IN ULONG_PTR | IoStatusInformation, | ||
| IN BOOLEAN | Quota | ||
| ) |
Definition at line 147 of file iocomp.c.
153{
158
159 /* Get the P List */
161 PPLookasideList[LookasideCompletionList].P;
162
163 /* Try to allocate the Packet */
164 List->L.TotalAllocates++;
166
167 /* Check if that failed, use the L list if it did */
169 {
170 /* Let the balancer know */
171 List->L.AllocateMisses++;
172
173 /* Get L List */
175 PPLookasideList[LookasideCompletionList].L;
176
177 /* Try to allocate the Packet */
178 List->L.TotalAllocates++;
180 }
181
182 /* Still failed, use pool */
184 {
185 /* Let the balancer know */
186 List->L.AllocateMisses++;
187
188 /* Allocate from Nonpaged Pool */
190 }
191
192 /* Make sure we have one by now... */
194 {
195 /* Set up the Packet */
197 Packet->KeyContext = KeyContext;
200 Packet->IoStatusInformation = IoStatusInformation;
201
202 /* Insert the Queue */
204 }
205 else
206 {
207 /* Out of memory, fail */
209 }
210
211 /* Return Success */
213}
NTSTATUS NTAPI IoCompletion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Ctx)
Definition: control.c:383
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
_In_opt_ HANDLE _In_opt_ PIO_APC_ROUTINE _In_opt_ PVOID ApcContext
Definition: iofuncs.h:727
Definition: ketypes.h:654
struct LOOKASIDE_ALIGN _NPAGED_LOOKASIDE_LIST * PNPAGED_LOOKASIDE_LIST
struct _KQUEUE * PKQUEUE
Referenced by IopDeviceFsIoControl(), NtLockFile(), and NtSetIoCompletion().
◆ IoShutdownSystem()
Definition at line 134 of file device.c.
135{
136 PLIST_ENTRY ListEntry;
138 PSHUTDOWN_ENTRY ShutdownEntry;
139 IO_STATUS_BLOCK StatusBlock;
143
144 /* Initialize an event to wait on */
146
147 /* What phase? */
148 if (Phase == 0)
149 {
150 /* Shutdown PnP */
151 IoShutdownPnpDevices();
152
153 /* Loop first-chance shutdown notifications */
155 &ShutdownListLock);
156 while (ListEntry)
157 {
158 /* Get the shutdown entry */
159 ShutdownEntry = CONTAINING_RECORD(ListEntry,
160 SHUTDOWN_ENTRY,
161 ShutdownList);
162
163 /* Get the attached device */
165
166 /* Build the shutdown IRP and call the driver */
168 DeviceObject,
169 NULL,
170 0,
171 NULL,
172 &Event,
173 &StatusBlock);
175 {
178 {
179 /* Wait on the driver */
181 }
182 }
183
184 /* Remove the flag */
186
187 /* Get rid of our reference to it */
189
190 /* Free the shutdown entry and reset the event */
193
194 /* Go to the next entry */
196 &ShutdownListLock);
197 }
198 }
199 else if (Phase == 1)
200 {
201 /* Acquire resource forever */
203
204 /* Shutdown disk file systems */
206
207 /* Shutdown cdrom file systems */
209
210 /* Shutdown tape filesystems */
212
213 /* Loop last-chance shutdown notifications */
215 &ShutdownListLock);
216 while (ListEntry)
217 {
218 /* Get the shutdown entry */
219 ShutdownEntry = CONTAINING_RECORD(ListEntry,
220 SHUTDOWN_ENTRY,
221 ShutdownList);
222
223 /* Get the attached device */
225
226 /* Build the shutdown IRP and call the driver */
228 DeviceObject,
229 NULL,
230 0,
231 NULL,
232 &Event,
233 &StatusBlock);
235 {
238 {
239 /* Wait on the driver */
241 }
242 }
243
244 /* Remove the flag */
246
247 /* Get rid of our reference to it */
249
250 /* Free the shutdown entry and reset the event */
253
254 /* Go to the next entry */
256 &ShutdownListLock);
257 }
258
259 }
260}
VOID NTAPI IopShutdownBaseFileSystems(IN PLIST_ENTRY ListHead)
Definition: volume.c:349
Definition: io.h:427
Referenced by PopGracefulShutdown().
◆ PiClearDevNodeProblem()
| VOID PiClearDevNodeProblem | ( | _In_ PDEVICE_NODE | DeviceNode | ) |
◆ PiInitCacheGroupInformation()
Definition at line 94 of file pnpinit.c.
95{
98 PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
99 PUNICODE_STRING GroupTable;
101 UNICODE_STRING GroupString =
104
105 /* Open the registry key */
107 NULL,
108 &GroupString,
109 KEY_READ);
111 {
112 /* Get the list */
115
116 /* Make sure we got it */
118 {
119 /* Make sure it's valid */
121 (KeyValueInformation->DataLength))
122 {
123 /* Convert it to unicode strings */
125 &GroupTable,
126 &Count);
127
128 /* Cache it for later */
129 PiInitGroupOrderTable = GroupTable;
131 }
132 else
133 {
134 /* Fail */
136 }
137
138 /* Free the information */
139 ExFreePool(KeyValueInformation);
140 }
141 }
142
143 /* Return status */
145}
NTSTATUS NTAPI PnpRegMultiSzToUnicodeStrings(IN PKEY_VALUE_FULL_INFORMATION KeyValueInformation, OUT PUNICODE_STRING *UnicodeStringList, OUT PULONG UnicodeStringCount)
Definition: pnputil.c:47
Referenced by IopInitializePlugPlayServices().
◆ PiInitializeNotifications()
Definition at line 55 of file pnpnotify.c.
56{
60 InitializeListHead(&PiNotifyHwProfileListHead);
61 InitializeListHead(&PiNotifyDeviceInterfaceListHead);
62}
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
Referenced by IoInitSystem().
◆ PiInsertDevNode()
| VOID PiInsertDevNode | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _In_ PDEVICE_NODE | ParentNode | ||
| ) |
Definition at line 80 of file devnode.c.
83{
84 KIRQL oldIrql;
85
87
89 DeviceNode->Parent = ParentNode;
92 {
93 ParentNode->Child = DeviceNode;
94 ParentNode->LastChild = DeviceNode;
95 }
96 else
97 {
98 ParentNode->LastChild->Sibling = DeviceNode;
99 ParentNode->LastChild = DeviceNode;
100 }
102 DeviceNode->Level = ParentNode->Level + 1;
103
105}
Referenced by IoReportDetectedDevice(), PiControlInitializeDevice(), and PiEnumerateDevice().
◆ PiIrpCancelStopDevice()
| NTSTATUS PiIrpCancelStopDevice | ( | _In_ PDEVICE_NODE | DeviceNode | ) |
Definition at line 154 of file pnpirp.c.
156{
157 PAGED_CODE();
158
161
164 .MajorFunction = IRP_MJ_PNP,
165 .MinorFunction = IRP_MN_CANCEL_STOP_DEVICE
166 };
167
168 // in fact we don't care which status is returned here
172}
NTSTATUS IopSynchronousCall(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_STACK_LOCATION IoStackLocation, _Out_ PVOID *Information)
Definition: pnpirp.c:14
Definition: notification.c:70
Definition: format.c:80
#define IRP_MN_CANCEL_STOP_DEVICE
Referenced by PiDevNodeStateMachine().
◆ PiIrpQueryDeviceRelations()
| NTSTATUS PiIrpQueryDeviceRelations | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _In_ DEVICE_RELATION_TYPE | Type | ||
| ) |
Definition at line 176 of file pnpirp.c.
179{
180 PAGED_CODE();
181
184
186 .MajorFunction = IRP_MJ_PNP,
187 .MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS,
188 .Parameters.QueryDeviceRelations.Type = Type
189 };
190
191 // Vista+ does an asynchronous call
193 &stack,
197}
Referenced by PiDevNodeStateMachine().
◆ PiIrpQueryDeviceText()
| NTSTATUS PiIrpQueryDeviceText | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _In_ LCID | LocaleId, | ||
| _In_ DEVICE_TEXT_TYPE | Type, | ||
| _Out_ PWSTR * | DeviceText | ||
| ) |
Definition at line 253 of file pnpirp.c.
258{
259 PAGED_CODE();
260
263
264 ULONG_PTR longText;
266 .MajorFunction = IRP_MJ_PNP,
267 .MinorFunction = IRP_MN_QUERY_DEVICE_TEXT,
268 .Parameters.QueryDeviceText.DeviceTextType = Type,
269 .Parameters.QueryDeviceText.LocaleId = LocaleId
270 };
271
275 {
276 *DeviceText = (PVOID)longText;
277 }
278
280}
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_ PCUNICODE_STRING _In_ PCUNICODE_STRING _In_ LCID LocaleId
Definition: wdfpdo.h:437
#define IRP_MN_QUERY_DEVICE_TEXT
Referenced by PiSetDevNodeText().
◆ PiIrpQueryPnPDeviceState()
| NTSTATUS PiIrpQueryPnPDeviceState | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _Out_ PPNP_DEVICE_STATE | DeviceState | ||
| ) |
Definition at line 284 of file pnpirp.c.
287{
288 PAGED_CODE();
289
293
294 ULONG_PTR longState;
296 .MajorFunction = IRP_MJ_PNP,
297 .MinorFunction = IRP_MN_QUERY_PNP_DEVICE_STATE
298 };
299
303 {
304 *DeviceState = longState;
305 }
306
308}
#define IRP_MN_QUERY_PNP_DEVICE_STATE
Referenced by PiUpdateDeviceState().
◆ PiIrpQueryResourceRequirements()
| NTSTATUS PiIrpQueryResourceRequirements | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _Out_ PIO_RESOURCE_REQUIREMENTS_LIST * | Resources | ||
| ) |
Definition at line 227 of file pnpirp.c.
230{
231 PAGED_CODE();
232
234
235 ULONG_PTR longRes;
237 .MajorFunction = IRP_MJ_PNP,
238 .MinorFunction = IRP_MN_QUERY_RESOURCE_REQUIREMENTS
239 };
240
244 {
246 }
247
249}
Definition: main.cpp:19
#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS
Referenced by PiFakeResourceRebalance().
◆ PiIrpQueryResources()
| NTSTATUS PiIrpQueryResources | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _Out_ PCM_RESOURCE_LIST * | Resources | ||
| ) |
Definition at line 201 of file pnpirp.c.
204{
205 PAGED_CODE();
206
208
209 ULONG_PTR longRes;
211 .MajorFunction = IRP_MJ_PNP,
212 .MinorFunction = IRP_MN_QUERY_RESOURCES
213 };
214
218 {
220 }
221
223}
#define IRP_MN_QUERY_RESOURCES
Referenced by PiFakeResourceRebalance().
◆ PiIrpQueryStopDevice()
| NTSTATUS PiIrpQueryStopDevice | ( | _In_ PDEVICE_NODE | DeviceNode | ) |
Definition at line 133 of file pnpirp.c.
135{
136 PAGED_CODE();
137
140
143 .MajorFunction = IRP_MJ_PNP,
144 .MinorFunction = IRP_MN_QUERY_STOP_DEVICE
145 };
146
150}
#define IRP_MN_QUERY_STOP_DEVICE
Referenced by PiDevNodeStateMachine().
◆ PiIrpStartDevice()
| NTSTATUS PiIrpStartDevice | ( | _In_ PDEVICE_NODE | DeviceNode | ) |
Definition at line 87 of file pnpirp.c.
89{
90 PAGED_CODE();
91
94
97 .MajorFunction = IRP_MJ_PNP,
98 .MinorFunction = IRP_MN_START_DEVICE,
99 .Parameters.StartDevice.AllocatedResources = DeviceNode->ResourceList,
100 .Parameters.StartDevice.AllocatedResourcesTranslated = DeviceNode->ResourceListTranslated
101 };
102
103 // Vista+ does an asynchronous call
107}
#define IRP_MN_START_DEVICE
Referenced by PiDevNodeStateMachine().
◆ PiIrpStopDevice()
| NTSTATUS PiIrpStopDevice | ( | _In_ PDEVICE_NODE | DeviceNode | ) |
Definition at line 111 of file pnpirp.c.
113{
114 PAGED_CODE();
115
118
121 .MajorFunction = IRP_MJ_PNP,
122 .MinorFunction = IRP_MN_STOP_DEVICE
123 };
124
125 // Drivers should never fail a IRP_MN_STOP_DEVICE request
129}
#define IRP_MN_STOP_DEVICE
Referenced by PiDevNodeStateMachine().
◆ PiNotifyDeviceInterfaceChange()
| VOID PiNotifyDeviceInterfaceChange | ( | _In_ LPCGUID | Event, |
| _In_ LPCGUID | InterfaceClassGuid, | ||
| _In_ PUNICODE_STRING | SymbolicLinkName | ||
| ) |
Delivers the event to all drivers subscribed to EventCategoryDeviceInterfaceChange.
- Parameters
-
[in] Event The PnP event GUID [in] InterfaceClassGuid The GUID of an interface class [in] SymbolicLinkName Pointer to a string identifying the device interface name
Definition at line 161 of file pnpnotify.c.
165{
166 PAGED_CODE();
167
168 PDEVICE_INTERFACE_CHANGE_NOTIFICATION notifyStruct;
170 if (!notifyStruct)
171 {
172 return;
173 }
174
175 *notifyStruct = (DEVICE_INTERFACE_CHANGE_NOTIFICATION) {
176 .Version = 1,
181 };
182
184
186
189 {
191
193 {
195 continue;
196 }
197
199 }
200
203}
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
GUID InterfaceClassGuid
Definition: iotypes.h:971
struct _DEVICE_INTERFACE_CHANGE_NOTIFICATION DEVICE_INTERFACE_CHANGE_NOTIFICATION
Referenced by IoSetDeviceInterfaceState().
◆ PiNotifyHardwareProfileChange()
Delivers the event to all drivers subscribed to EventCategoryHardwareProfileChange PnP event.
Definition at line 214 of file pnpnotify.c.
216{
217 PAGED_CODE();
218
219 PHWPROFILE_CHANGE_NOTIFICATION notifyStruct;
221 if (!notifyStruct)
222 {
223 return;
224 }
225
226 *notifyStruct = (HWPROFILE_CHANGE_NOTIFICATION) {
227 .Version = 1,
230 };
231
233
235
238 {
240
242 }
243
246}
Definition: iotypes.h:975
struct _HWPROFILE_CHANGE_NOTIFICATION HWPROFILE_CHANGE_NOTIFICATION
◆ PiNotifyTargetDeviceChange()
| VOID PiNotifyTargetDeviceChange | ( | _In_ LPCGUID | Event, |
| _In_ PDEVICE_OBJECT | DeviceObject, | ||
| _In_opt_ PTARGET_DEVICE_CUSTOM_NOTIFICATION | CustomNotification | ||
| ) |
Delivers the event to all drivers subscribed to EventCategoryTargetDeviceChange PnP event.
- Parameters
-
[in] Event The PnP event GUID [in] DeviceObject The (target) device object [in] CustomNotification Pointer to a custom notification for GUID_PNP_CUSTOM_NOTIFICATION
Definition at line 258 of file pnpnotify.c.
262{
263 PAGED_CODE();
264
265 PVOID notificationStruct;
266 // just in case our device is removed during the operation
268
270 ASSERT(deviceNode);
271
273 {
274 PTARGET_DEVICE_REMOVAL_NOTIFICATION notifStruct;
276 if (!notifStruct)
277 {
278 return;
279 }
280
281 *notifStruct = (TARGET_DEVICE_REMOVAL_NOTIFICATION) {
282 .Version = 1,
285 };
286
287 notificationStruct = notifStruct;
288
290 }
291 else
292 {
293 ASSERT(CustomNotification);
294 // assuming everythng else is correct
295
296 notificationStruct = CustomNotification;
297
299 }
300
302
305 {
307
308 // put the file object from our saved entry to this particular notification's struct
309 ((PTARGET_DEVICE_REMOVAL_NOTIFICATION)notificationStruct)->FileObject = nEntry->FileObject;
310 // so you don't need to look at the definition ;)
313
315 }
316
318 if (notificationStruct != CustomNotification)
321}
Definition: iotypes.h:1008
struct _TARGET_DEVICE_REMOVAL_NOTIFICATION TARGET_DEVICE_REMOVAL_NOTIFICATION
struct _TARGET_DEVICE_REMOVAL_NOTIFICATION * PTARGET_DEVICE_REMOVAL_NOTIFICATION
Referenced by IopCancelRemoveDevice(), IopQueryRemoveDevice(), IopSendRemoveDevice(), and PpSetCustomTargetEvent().
◆ PipAllocateDeviceNode()
| PDEVICE_NODE PipAllocateDeviceNode | ( | IN PDEVICE_OBJECT | PhysicalDeviceObject | ) |
◆ PipCallDriverAddDevice()
| NTSTATUS NTAPI PipCallDriverAddDevice | ( | IN PDEVICE_NODE | DeviceNode, |
| IN BOOLEAN | LoadDriver, | ||
| IN PDRIVER_OBJECT | DriverObject | ||
| ) |
◆ PiPerformSyncDeviceAction()
| NTSTATUS PiPerformSyncDeviceAction | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ DEVICE_ACTION | Action | ||
| ) |
Perfom a device operation synchronously via PiQueueDeviceAction.
- Parameters
-
[in] DeviceObject The device object [in] Action The action
- Returns
- Status of the operation
Definition at line 2727 of file devaction.c.
2730{
2731 KEVENT opFinished;
2733
2737
2739}
VOID PiQueueDeviceAction(_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action, _In_opt_ PKEVENT CompletionEvent, _Out_opt_ NTSTATUS *CompletionStatus)
Queue a device operation to a worker thread.
Definition: devaction.c:2668
Referenced by IopInitializeSystemDrivers(), IoSynchronousInvalidateDeviceRelations(), and PiControlSyncDeviceAction().
◆ PipGetDriverTagPriority()
Definition at line 192 of file pnpinit.c.
193{
197 PKEY_VALUE_FULL_INFORMATION KeyValueInformationTag;
198 PKEY_VALUE_FULL_INFORMATION KeyValueInformationGroupOrderList;
201 PULONG GroupOrder;
204 UNICODE_STRING GroupString =
207
208 /* Open the key */
211
212 /* Read the group */
215
216 /* Make sure we have a group */
218 (KeyValueInformation->DataLength))
219 {
220 /* Convert to unicode string */
225 }
226
227 /* Now read the tag */
230
231 /* Make sure we have a tag */
233 (KeyValueInformationTag->DataLength))
234 {
235 /* Read it */
237 KeyValueInformationTag->DataOffset);
238 }
239
240 /* We can get rid of this now */
241 ExFreePool(KeyValueInformationTag);
242
243 /* Now let's read the group's tag order */
245 Group.Buffer,
246 &KeyValueInformationGroupOrderList);
247
248 /* We can get rid of this now */
249Quickie:
253
254 /* We're on the success path -- validate the tag order*/
256 (KeyValueInformationGroupOrderList->DataLength))
257 {
258 /* Get the order array */
260 KeyValueInformationGroupOrderList->DataOffset);
261
262 /* Get the count */
263 Count = *GroupOrder;
265 KeyValueInformationGroupOrderList->DataLength);
266
267 /* Now loop each tag */
268 GroupOrder++;
270 {
271 /* If we found it, we're out */
273
274 /* Try the next one */
275 GroupOrder++;
276 }
277 }
278
279 /* Last buffer to free */
280 ExFreePool(KeyValueInformationGroupOrderList);
282}
BOOLEAN NTAPI PnpRegSzToString(IN PWCHAR RegSzData, IN ULONG RegSzLength, OUT PUSHORT StringLength OPTIONAL)
Definition: pnputil.c:171
Referenced by IopInitializeBootDrivers().
◆ PiQueueDeviceAction()
| VOID PiQueueDeviceAction | ( | _In_ PDEVICE_OBJECT | DeviceObject, |
| _In_ DEVICE_ACTION | Action, | ||
| _In_opt_ PKEVENT | CompletionEvent, | ||
| _Out_opt_ NTSTATUS * | CompletionStatus | ||
| ) |
Queue a device operation to a worker thread.
- Parameters
-
[in] DeviceObject The device object [in] Action The action [in] CompletionEvent The completion event object (optional) [out] CompletionStatus Status returned be the action will be written here
Definition at line 2668 of file devaction.c.
2673{
2676
2678
2681
2683
2686 Request->CompletionEvent = CompletionEvent;
2687 Request->CompletionStatus = CompletionStatus;
2688
2691
2693 {
2695
2699
2701 return;
2702 }
2703
2705 {
2707 return;
2708 }
2712
2715}
static VOID NTAPI PipDeviceActionWorker(_In_opt_ PVOID Context)
Definition: devaction.c:2546
Definition: devaction.c:56
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:723
Referenced by IoInitSystem(), IoInvalidateDeviceRelations(), IoInvalidateDeviceState(), IopInitializeBootDrivers(), IopInitializeBuiltinDriver(), IopInitializePlugPlayServices(), IopInitializeSystemDrivers(), IoReportDetectedDevice(), and PiPerformSyncDeviceAction().
◆ PiSetDevNodeProblem()
| VOID PiSetDevNodeProblem | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _In_ UINT32 | Problem | ||
| ) |
Definition at line 132 of file devnode.c.
Referenced by PiAttachFilterDriversCallback(), PiCallDriverAddDevice(), PiDevNodeStateMachine(), and PiUpdateDeviceState().
◆ PiSetDevNodeState()
| PNP_DEVNODE_STATE PiSetDevNodeState | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _In_ PNP_DEVNODE_STATE | NewState | ||
| ) |
Definition at line 108 of file devnode.c.
111{
112 KIRQL oldIrql;
113
115
117 if (prevState != NewState)
118 {
119 DeviceNode->State = NewState;
120 DeviceNode->PreviousState = prevState;
123 }
124
126
128 return prevState;
129}
enum _PNP_DEVNODE_STATE PNP_DEVNODE_STATE
Referenced by IopAssignDeviceResources(), IopInitializePlugPlayServices(), IopQueryRemoveChildDevices(), IopSendRemoveDevice(), IoReportDetectedDevice(), PiCallDriverAddDevice(), PiControlInitializeDevice(), PiDevNodeStateMachine(), PiEnumerateDevice(), PiInitializeDevNode(), PiStartDeviceFinal(), and PiUpdateDeviceState().
◆ PiSetDevNodeText()
| VOID PiSetDevNodeText | ( | _In_ PDEVICE_NODE | DeviceNode, |
| _In_ HANDLE | InstanceKey | ||
| ) |
Sets the DeviceNode's DeviceDesc and LocationInformation registry values.
Definition at line 1092 of file devaction.c.
1095{
1096 PAGED_CODE();
1097
1098 LCID localeId;
1099
1100 // Get the Locale ID
1103 {
1105 return;
1106 }
1107
1108 // Step 1: Write the DeviceDesc value if does not exist
1109
1112
1113 status = ZwQueryValueKey(InstanceKey, &valDeviceDesc, KeyValueBasicInformation, NULL, 0, &len);
1115 {
1118
1120 {
1121 status = ZwSetValueKey(InstanceKey,
1122 &valDeviceDesc,
1123 0,
1124 REG_SZ,
1125 deviceDesc,
1127
1129 {
1131 }
1132 }
1133 else
1134 {
1135 // This key is mandatory, so even if the Irp fails, we still write it
1138
1139 status = ZwSetValueKey(InstanceKey,
1140 &valDeviceDesc,
1141 0,
1142 REG_SZ,
1143 unknownDeviceDesc.Buffer,
1144 unknownDeviceDesc.MaximumLength);
1146 {
1148 }
1149 }
1150
1151 if (deviceDesc)
1152 {
1153 ExFreePoolWithTag(deviceDesc, 0);
1154 }
1155 }
1156
1157 // Step 2: LocaltionInformation is overwritten unconditionally
1158
1161 localeId,
1163 &deviceLocationInfo);
1164
1166 {
1168
1169 status = ZwSetValueKey(InstanceKey,
1170 &valLocationInfo,
1171 0,
1172 REG_SZ,
1173 deviceLocationInfo,
1176 {
1178 }
1179 }
1180
1181 if (deviceLocationInfo)
1182 {
1183 ExFreePoolWithTag(deviceLocationInfo, 0);
1184 }
1185 else
1186 {
1188 }
1189}
NTSYSAPI NTSTATUS NTAPI ZwQueryDefaultLocale(_In_ BOOLEAN UserProfile, _Out_ PLCID DefaultLocaleId)
NTSTATUS PiIrpQueryDeviceText(_In_ PDEVICE_NODE DeviceNode, _In_ LCID LocaleId, _In_ DEVICE_TEXT_TYPE Type, _Out_ PWSTR *DeviceText)
Definition: pnpirp.c:253
Referenced by IoReportDetectedDevice(), and PiInitializeDevNode().
◆ PnpDetermineResourceListSize()
| ULONG NTAPI PnpDetermineResourceListSize | ( | IN PCM_RESOURCE_LIST | ResourceList | ) |
Definition at line 1237 of file pnpmgr.c.
1238{
1240 PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
1241 PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
1242
1243 /* If we don't have one, that's easy */
1245
1246 /* Start with the minimum size possible */
1248
1249 /* Loop each full descriptor */
1250 FullDescriptor = ResourceList->List;
1252 {
1253 /* Start with the minimum size possible */
1256
1257 /* Loop each partial descriptor */
1260 {
1261 /* Start with the minimum size possible */
1263
1264 /* Check if there is extra data */
1266 {
1267 /* Add that data */
1269 }
1270
1271 /* The size of partial descriptors is bigger */
1272 PartialSize += EntrySize;
1273
1274 /* Go to the next partial descriptor */
1276 }
1277
1278 /* The size of full descriptors is bigger */
1279 FinalSize += PartialSize;
1280
1281 /* Go to the next full descriptor */
1283 }
1284
1285 /* Return the final size */
1286 return FinalSize;
1287}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR CM_PARTIAL_RESOURCE_DESCRIPTOR
Definition: restypes.h:141
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@384::@393 DeviceSpecificData
Referenced by IoGetDeviceProperty(), IopAssignDeviceResources(), IopFixupResourceListWithRequirements(), IopSetDeviceInstanceData(), IopTranslateDeviceResources(), IopUpdateControlKeyWithResources(), and IopUpdateResourceMap().
◆ PnpInit2()
◆ PnpRegMultiSzToUnicodeStrings()
| NTSTATUS NTAPI PnpRegMultiSzToUnicodeStrings | ( | IN PKEY_VALUE_FULL_INFORMATION | KeyValueInformation, |
| OUT PUNICODE_STRING * | UnicodeStringList, | ||
| OUT PULONG | UnicodeStringCount | ||
| ) |
Definition at line 47 of file pnputil.c.
50{
55
56 /* Validate the key information */
58
59 /* Set the pointers */
61 KeyValueInformation->DataOffset);
63
64 /* Loop the data */
66 {
67 /* If we find a NULL, that means one string is done */
69 {
70 /* Add to our string count */
71 Count++;
72
73 /* Check for a double-NULL, which means we're done */
75 }
76
77 /* Go to the next character */
78 p++;
79 }
80
81 /* If we looped the whole list over, we missed increment a string, do it */
83
84 /* Allocate the list now that we know how big it is */
87 'sUpP');
89
90 /* Set pointers for second loop */
92 KeyValueInformation->DataOffset);
93
94 /* Loop again, to do the copy this time */
96 {
97 /* If we find a NULL, that means one string is done */
99 {
100 /* Check how long this string is */
102
103 /* Allocate the buffer */
105 n,
106 'sUpP');
108 {
109 /* Back out of everything */
112 }
113
114 /* Copy the string into the buffer */
116
117 /* Set the lengths */
120
121 /* One more entry done */
122 i++;
123
124 /* Check for a double-NULL, which means we're done */
126
127 /* New string */
128 ps = p + 1;
129 }
130
131 /* New string */
132 p++;
133 }
134
135 /* Check if we've reached the last string */
137 {
138 /* Calculate the string length */
140
141 /* Allocate the buffer for it */
143 n +
145 'sUpP');
147 {
148 /* Back out of everything */
151 }
152
153 /* Make sure there's an actual string here */
155
156 /* Null-terminate the string ourselves */
158
159 /* Set the lengths */
162 }
163
164 /* And we're done */
165 *UnicodeStringCount = Count;
167}
VOID NTAPI PnpFreeUnicodeStringList(IN PUNICODE_STRING UnicodeStringList, IN ULONG StringCount)
Definition: pnputil.c:21
Referenced by PiInitCacheGroupInformation().
◆ PnpRegSzToString()
| BOOLEAN NTAPI PnpRegSzToString | ( | IN PWCHAR | RegSzData, |
| IN ULONG | RegSzLength, | ||
| OUT PUSHORT StringLength | OPTIONAL | ||
| ) |
Definition at line 171 of file pnputil.c.
174{
176
177 /* Find the end */
180 {
182 {
183 break;
184 }
185 }
186
187 /* Return the length. Truncation can happen but is of no consequence. */
188 if (StringLength)
189 {
191 }
193}
Referenced by IoGetDeviceInterfaceAlias(), PipGetDriverTagPriority(), and PpInitGetGroupOrderIndex().
◆ PnpRootCreateDevice()
| NTSTATUS PnpRootCreateDevice | ( | IN PUNICODE_STRING | ServiceName, |
| OUT PDEVICE_OBJECT * | PhysicalDeviceObject, | ||
| OUT PUNICODE_STRING | FullInstancePath | ||
| ) |
Definition at line 184 of file pnproot.c.
188{
189 PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
190 PPNPROOT_PDO_DEVICE_EXTENSION PdoDeviceExtension;
192 WCHAR InstancePath[5];
195 ULONG NextInstance;
196 UNICODE_STRING EnumKeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\" REGSTR_PATH_SYSTEMENUM);
200
201 DeviceExtension = &PnpRootDOExtension;
203
205
206 DevicePath.Length = 0;
209 DevicePath.MaximumLength,
210 TAG_PNP_ROOT);
212 {
216 }
219
220 /* Initialize a PNPROOT_DEVICE structure */
223 {
227 }
231
234 {
236 &Device->DeviceID,
238 EnumHandle,
239 NULL);
240 Status = ZwCreateKey(&DeviceKeyHandle, KEY_SET_VALUE, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
242 }
243
245 {
248 }
249
250tryagain:
255
257 (PWSTR)DeviceKeyHandle,
258 QueryTable,
259 NULL,
260 NULL);
261 for (NextInstance = 0; NextInstance <= 9999; NextInstance++)
262 {
266 break;
267 }
268
269 if (NextInstance > 9999)
270 {
274 }
275
279 {
282 (PWSTR)DeviceKeyHandle,
284 goto tryagain;
285 }
286
287 NextInstance++;
289 (PWSTR)DeviceKeyHandle,
291 REG_DWORD,
292 &NextInstance,
293 sizeof(NextInstance));
295 {
298 }
299
300 // "0000" or higher
302 {
305 }
306
307 /* Finish creating the instance path in the registry */
309 &Device->InstanceID,
311 DeviceKeyHandle,
312 NULL);
313 Status = ZwCreateKey(&InstanceKeyHandle, KEY_QUERY_VALUE, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
315 {
318 }
319
320 /* Just close the handle */
322
323 // generate the full device instance path
324 FullInstancePath->MaximumLength = Device->DeviceID.Length + sizeof(L'\\') + Device->InstanceID.Length;
325 FullInstancePath->Length = 0;
327 if (!FullInstancePath->Buffer)
328 {
331 }
332
336
337 /* Initialize a device object */
340 {
344 }
345
349
351 Device->Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
352
353 InsertTailList(
354 &DeviceExtension->DeviceListHead,
355 &Device->ListEntry);
356 DeviceExtension->DeviceListCount++;
357
359 DPRINT("Created PDO %p (%wZ\\%wZ)\n", *PhysicalDeviceObject, &Device->DeviceID, &Device->InstanceID);
362
363cleanup:
366 {
372 }
377}
_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE QueryTable
Definition: rtlfuncs.h:4211
struct _PNPROOT_PDO_DEVICE_EXTENSION * PPNPROOT_PDO_DEVICE_EXTENSION
static NTSTATUS LocateChildDevice(IN PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension, IN PCUNICODE_STRING DeviceId, IN PCWSTR InstanceId, OUT PPNPROOT_DEVICE *ChildDevice OPTIONAL)
Definition: pnproot.c:70
NTSTATUS PnpRootCreateDeviceObject(OUT PDEVICE_OBJECT *DeviceObject)
Definition: pnproot.c:167
Definition: pnproot.c:23
Definition: pnproot.c:50
Definition: pnproot.c:43
Definition: nt_native.h:108
NTSYSAPI NTSTATUS WINAPI RtlDeleteRegistryValue(ULONG, PCWSTR, PCWSTR)
NTSYSAPI NTSTATUS WINAPI RtlWriteRegistryValue(ULONG, PCWSTR, PCWSTR, ULONG, PVOID, ULONG)
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
Referenced by IoReportDetectedDevice().
◆ PnpRootCreateDeviceObject()
| NTSTATUS PnpRootCreateDeviceObject | ( | OUT PDEVICE_OBJECT * | DeviceObject | ) |
Definition at line 167 of file pnproot.c.
Referenced by PiControlInitializeDevice(), PnpRootCreateDevice(), and PnpRootQueryDeviceRelations().
◆ PnpRootDriverEntry()
| NTSTATUS NTAPI PnpRootDriverEntry | ( | IN PDRIVER_OBJECT | DriverObject, |
| IN PUNICODE_STRING | RegistryPath | ||
| ) |
Definition at line 1488 of file pnproot.c.
1491{
1492#if MI_TRACE_PFNS
1495#endif
1496
1498
1500
1502
1503#if MI_TRACE_PFNS
1506#endif
1509
1510#if MI_TRACE_PFNS
1512 0,
1513 &PfnDumpDeviceName,
1514 FILE_DEVICE_UNKNOWN,
1515 0,
1516 FALSE,
1517 &IopPfnDumpDeviceObject);
1519 {
1521 }
1522 else
1523 {
1524 IopPfnDumpDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
1525 }
1526#endif
1527
1529}
static NTSTATUS NTAPI PnpRootPowerControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pnproot.c:1418
static NTSTATUS NTAPI PnpRootPnpControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pnproot.c:1395
NTSTATUS NTAPI PnpRootAddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
Definition: pnproot.c:1449
#define IRP_MJ_POWER
Referenced by IopInitializePlugPlayServices().
◆ PnpRootInitializeDevExtension()
Definition at line 1440 of file pnproot.c.
1441{
1445}
Referenced by IopInitializePlugPlayServices().
◆ PnpRootRegisterDevice()
| NTSTATUS PnpRootRegisterDevice | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 107 of file pnproot.c.
109{
111 PPNPROOT_PDO_DEVICE_EXTENSION PdoDeviceExtension;
114 PWSTR InstancePath;
115 UNICODE_STRING InstancePathCopy;
116
119
122 {
125 }
126
128 ASSERT(InstancePath);
129
131 {
132 RtlFreeUnicodeString(&InstancePathCopy);
135 }
136
137 InstancePath[0] = UNICODE_NULL;
138
140 {
141 RtlFreeUnicodeString(&InstancePathCopy);
145 }
146
148
150
151 PdoDeviceExtension = DeviceObject->DeviceExtension;
154
157 &Device->ListEntry);
158 DeviceExtension->DeviceListCount++;
160
161 RtlFreeUnicodeString(&InstancePathCopy);
162
164}
Referenced by IoReportDetectedDevice(), and PiControlInitializeDevice().
◆ PpInitGetGroupOrderIndex()
Definition at line 149 of file pnpinit.c.
150{
152 PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
156 PAGED_CODE();
157
158 /* Make sure we have a cache */
160
161 /* If we don't have a handle, the rest is easy -- return the count */
163
164 /* Otherwise, get the group value */
167
168 /* Make sure we have a valid string */
171
172 /* Convert to unicode string */
177
178 /* Loop the groups */
180 {
181 /* Try to find a match */
183 }
184
185 /* We're done */
186 ExFreePool(KeyValueInformation);
188}
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
Referenced by IopInitializeBootDrivers().
◆ PpInitSystem()
Definition at line 1142 of file pnpmgr.c.
1143{
1144 /* Check the initialization phase */
1146 {
1147 case 0:
1148
1149 /* Do Phase 0 */
1151
1152 case 1:
1153
1154 /* Do Phase 1 */
1156 //return PiInitPhase1();
1157
1158 default:
1159
1160 /* Don't know any other phase! Bugcheck! */
1161 KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
1163 }
1164}
Referenced by ExpInitializeExecutive(), and Phase1InitializationDiscard().
◆ RawFsDriverEntry()
| NTSTATUS NTAPI RawFsDriverEntry | ( | IN PDRIVER_OBJECT | DriverObject, |
| IN PUNICODE_STRING | RegistryPath | ||
| ) |
Definition at line 1193 of file rawfs.c.
1195{
1198
1200
1201 /* Create the raw disk device */
1204 0,
1205 &DeviceName,
1207 0,
1208 FALSE,
1209 &RawDiskDeviceObject);
1211 {
1213 }
1214
1215 /* Create the raw CDROM device */
1218 0,
1219 &DeviceName,
1221 0,
1222 FALSE,
1223 &RawCdromDeviceObject);
1225 {
1228 }
1229
1230 /* Create the raw tape device */
1233 0,
1234 &DeviceName,
1236 0,
1237 FALSE,
1238 &RawTapeDeviceObject);
1240 {
1244 }
1245
1246 /* Set Direct I/O for all devices */
1250
1251 /* Set generic stubs */
1262
1263 /* Shutdown and unload */
1266
1267 /* Register the file systems */
1271
1272#if 0 // FIXME: DriverUnload is never called
1273 /* Reference device objects */
1277#endif
1279}
VOID NTAPI IoRegisterFileSystem(IN PDEVICE_OBJECT DeviceObject)
Definition: volume.c:987
NTSTATUS NTAPI RawShutdown(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: rawfs.c:1157
NTSTATUS NTAPI RawDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: rawfs.c:1047
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3281
Referenced by IopInitializeBootDrivers().
◆ RawFsIsRawFileSystemDeviceObject()
| BOOLEAN RawFsIsRawFileSystemDeviceObject | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Variable Documentation
◆ _HalDispatchTable
|
extern |
◆ _IoFileObjectType
|
extern |
◆ IoCompletionType
|
extern |
Definition at line 16 of file iocomp.c.
Referenced by IopCreateObjectTypes(), NtCreateIoCompletion(), NtOpenIoCompletion(), NtQueryIoCompletion(), NtRemoveIoCompletion(), NtSetInformationFile(), and NtSetIoCompletion().
◆ IopAutoReboot
|
extern |
Definition at line 46 of file iomgr.c.
Referenced by KeBugCheckWithTf().
◆ IopBusTypeGuidList
|
extern |
◆ IopCompletionMapping
|
extern |
Definition at line 20 of file iocomp.c.
Referenced by IopCreateObjectTypes().
◆ IopDeviceActionLock
|
extern |
Definition at line 49 of file devaction.c.
Referenced by IopInitializePlugPlayServices(), PipDeviceActionWorker(), and PiQueueDeviceAction().
◆ IopDeviceActionRequestList
|
extern |
Definition at line 46 of file devaction.c.
Referenced by IopInitializePlugPlayServices(), PipDeviceActionWorker(), and PiQueueDeviceAction().
◆ IopDeviceTreeLock
|
extern |
Definition at line 19 of file devnode.c.
Referenced by IopCancelRemoveChildDevices(), IopFreeDeviceNode(), IopGetSystemPowerDeviceObject(), IopInitializePlugPlayServices(), IopQueryRemoveChildDevices(), IopSendRemoveChildDevices(), PiDevNodeStateMachine(), PiInsertDevNode(), and PiSetDevNodeState().
◆ IopErrorLogListHead
|
extern |
◆ IopFileMapping
|
extern |
Definition at line 50 of file iomgr.c.
Referenced by IoGetFileObjectGenericMapping(), and IopCreateObjectTypes().
◆ IopMdlLookasideList
|
extern |
Definition at line 85 of file iomgr.c.
Referenced by IopInitLookasideLists().
◆ IopNumTriageDumpDataBlocks
◆ IopReserveIrpAllocator
|
extern |
Definition at line 19 of file irp.c.
Referenced by IofCompleteRequest(), IoInitSystem(), IopAllocateReserveIrp(), and IopFreeReserveIrp().
◆ IopRootDeviceNode
|
extern |
Definition at line 18 of file devnode.c.
Referenced by IoInitSystem(), IopGetDeviceNodeStatus(), IopGetDeviceObjectFromDeviceInstance(), IopGetRelatedDevice(), IopInitializeBootDrivers(), IopInitializePlugPlayServices(), IopInitializeSystemDrivers(), IoReportDetectedDevice(), PiControlInitializeDevice(), PnpRootPnpControl(), PoInitSystem(), PopQuerySystemPowerStateTraverse(), PopSetSystemPowerState(), and PopSetSystemPowerStateTraverse().
◆ IopRootDriverObject
|
extern |
Definition at line 26 of file pnpmgr.c.
Referenced by IopInitializePlugPlayServices(), PnpRootCreateDeviceObject(), and PnpRootDriverEntry().
◆ IopTraceLevel
◆ IopTriageDumpDataBlocks
◆ IoRemoteBootClient
|
extern |
Definition at line 70 of file init.c.
Referenced by ExpInitializeExecutive(), IopCreateArcNames(), and xHalIoAssignDriveLetters().
◆ PnpBusTypeGuidList
|
extern |
Definition at line 27 of file pnpmgr.c.
Referenced by IopGetBusTypeGuidIndex(), IopInitializePlugPlayServices(), and PnpBusTypeGuidGet().
