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); \
(_DeviceTreeTraverseContext)->Context = (_Context); }
Definition: compobj.c:4795
_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:965
◆ IOTRACE
◆ IsIrpSynchronous
| #define IsIrpSynchronous | ( | Irp, | |
| FileObject | |||
| ) |
Value:
((Irp->Flags & IRP_SYNCHRONOUS_API) || \
(!(FileObject) ? \
FALSE : \
FileObject->Flags & FO_SYNCHRONOUS_IO)) \
#define IRP_SYNCHRONOUS_API
◆ 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 524 of file io.h.
525{
528 PiActionResetDevice,
530 PiActionStartDevice,
531 PiActionQueryState,
532} DEVICE_ACTION;
enum _DEVICE_ACTION DEVICE_ACTION
◆ _IOP_DEVICE_LIST_OPERATION
◆ _IOP_TRANSFER_TYPE
| Enumerator | |
|---|---|
| IopReadTransfer | |
| IopWriteTransfer | |
| IopOtherTransfer | |
Definition at line 259 of file io.h.
260{
261 IopReadTransfer,
262 IopWriteTransfer,
263 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 512 of file io.h.
513{
514 RestrictedPublic = 1,
515 UnrestrictedPublic,
516 RestrictedPublicOpen,
518 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:105
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 2511 of file file.c.
2514{
2516 PFILE_OBJECT_EXTENSION FileObjectExtension;
2517
2519 {
2521 }
2522
2523 FileObjectExtension = FileObject->FileObjectExtension;
2524 if (Define)
2525 {
2526 /* If define, just set the new value if not value is set
2527 * Success will only contain old value. It is valid if it is NULL
2528 */
2529 Success = (ULONG_PTR)InterlockedCompareExchangePointer(&FileObjectExtension->FilterContext, FilterContext, NULL);
2530 }
2531 else
2532 {
2533 /* If not define, we want to reset filter context.
2534 * We will remove value (provided by the caller) and set NULL instead.
2535 * This will only success if caller provides correct previous value.
2536 * To catch whether it worked, we substract previous value to expect value:
2537 * If it matches (and thus, we reset), Success will contain 0
2538 * Otherwise, it will contain a non-zero value.
2539 */
2540 Success = (ULONG_PTR)InterlockedCompareExchangePointer(&FileObjectExtension->FilterContext, NULL, FilterContext) - (ULONG_PTR)FilterContext;
2541 }
2542
2543 /* If success isn't 0, it means we failed somewhere (set or unset) */
2545 {
2547 }
2548
2550}
_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:129
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:2658
Referenced by ObReferenceFileObjectForWrite().
◆ IoCreateDriverList()
◆ IoDestroyDriverList()
◆ IoGetFileObjectFilterContext()
| PVOID NTAPI IoGetFileObjectFilterContext | ( | IN PFILE_OBJECT | FileObject | ) |
Definition at line 2496 of file file.c.
2497{
2499 {
2500 PFILE_OBJECT_EXTENSION FileObjectExtension;
2501
2502 FileObjectExtension = FileObject->FileObjectExtension;
2504 }
2505
2507}
Referenced by FsRtlInsertPerFileObjectContext(), FsRtlLookupPerFileObjectContext(), FsRtlPTeardownPerFileObjectContexts(), and FsRtlRemovePerFileObjectContext().
◆ IoGetRelatedTargetDevice()
| NTSTATUS NTAPI IoGetRelatedTargetDevice | ( | IN PFILE_OBJECT | FileObject, |
| OUT PDEVICE_OBJECT * | DeviceObject | ||
| ) |
Definition at line 1607 of file device.c.
1609{
1612
1613 /* Call the internal helper function */
1616 {
1618 }
1620}
NTSTATUS NTAPI IopGetRelatedTargetDevice(IN PFILE_OBJECT FileObject, OUT PDEVICE_NODE *DeviceNode)
Definition: device.c:653
Definition: iotypes.h:875
Referenced by FsRtlNotifyVolumeEvent(), and NtSetVolumeInformationFile().
◆ IoInitCancelHandling()
◆ IoInitFileSystemImplementation()
◆ IoInitializeCrashDump()
Definition at line 649 of file iomgr.c.
Referenced by NtCreatePagingFile().
◆ IoInitShutdownNotification()
◆ IoInitSystem()
| BOOLEAN NTAPI IoInitSystem | ( | IN PLOADER_PARAMETER_BLOCK | LoaderBlock | ) |
Definition at line 465 of file iomgr.c.
466{
467 LARGE_INTEGER ExpireTime;
470 ANSI_STRING NtBootPath, RootString;
471
472 /* Initialize empty NT Boot Path */
474
475 /* Initialize the lookaside lists */
476 IopInitLookasideLists();
477
478 /* Initialize all locks and lists */
497
498 /* Initialize PnP notifications */
499 PiInitializeNotifications();
500
501 /* Initialize the reserve IRP */
503 {
506 }
507
508 /* Initialize Timer List Lock */
510
511 /* Initialize Timer List */
513
514 /* Initialize the DPC/Timer which will call the other Timer Routines */
515 ExpireTime.QuadPart = -10000000;
519
520 /* Create Object Types */
522 {
525 }
526
527 /* Create Object Directories */
529 {
532 }
533
534 /* Initialize PnP manager */
536
537 /* Initialize SHIM engine */
538 ApphelpCacheInitialize();
539
540 /* Initialize WMI */
541 WmiInitialize();
542
543 /* Initialize HAL Root Bus Driver */
544 HalInitPnpDriver();
545
546 /* Reenumerate what HAL has added (synchronously)
547 * This function call should eventually become a 2nd stage of the PnP initialization */
550 NULL,
551 NULL);
552
553 /* Make loader block available for the whole kernel */
554 IopLoaderBlock = LoaderBlock;
555
556 /* Load boot start drivers */
557 IopInitializeBootDrivers();
558
559 /* Call back drivers that asked for */
560 IopReinitializeBootDrivers();
561
562 /* Check if this was a ramdisk boot */
564 {
565 /* Initialize the ramdisk driver */
566 IopStartRamdisk(LoaderBlock);
567 }
568
569 /* No one should need loader block any longer */
571
572 /* Create ARC names for boot devices */
575 {
578 }
579
580 /* Mark the system boot partition */
582 {
585 }
586
587 /* The disk subsystem is initialized here and the SystemRoot is set too.
588 * We can finally load other drivers from the boot volume. */
590
591 /* Load system start drivers */
592 IopInitializeSystemDrivers();
594
595 /* Reinitialize drivers that requested it */
596 IopReinitializeDrivers();
597
598 /* Convert SystemRoot from ARC to NT path */
601 {
604 }
605
606 /* Set the ANSI_STRING for the root path */
608 RootString.Length = 0;
610 RootString.MaximumLength,
611 TAG_IO);
612
613 /* Convert the path into the ANSI_STRING */
616 {
619 }
620
621 /* Assign drive letters */
622 IoAssignDriveLetters(LoaderBlock,
623 &NtBootPath,
625 &RootString);
626
627 /* Update system root */
630 {
633 }
634
635 /* Load the System DLL and its entrypoints */
638 {
641 }
642
643 /* Return success */
645}
VOID FASTCALL IoAssignDriveLetters(IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock, IN PSTRING NtDeviceName, OUT PUCHAR NtSystemPath, OUT PSTRING NtSystemPathString)
Definition: ntoskrnl.c:36
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:395
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:840
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:2659
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:294
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 2450 of file file.c.
2455{
2457
2458 PAGED_CODE();
2459
2461
2463 do
2464 {
2466 {
2467 break;
2468 }
2470 Executive,
2471 WaitMode,
2472 Alertable,
2473 NULL);
2475
2478 {
2480 *LockFailed = FALSE;
2481 }
2482 else
2483 {
2485 {
2487 }
2488 *LockFailed = TRUE;
2489 }
2490
2492}
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:462
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 2178 of file file.c.
2183{
2187 PIO_STACK_LOCATION StackPtr;
2193
2194 /* If this isn't the last handle for the current process, quit */
2195 if (HandleCount != 1) return;
2196
2197 /* Check if the file is locked and has more then one handle opened */
2199 {
2200 /* Check if this is a direct open or not */
2202 {
2203 /* Get the attached device */
2205 }
2206 else
2207 {
2208 /* Get the FO's device */
2210 }
2211
2212 /* Check if this is a sync FO and lock it */
2214 {
2216 }
2217
2218 /* Go the FastIO path if possible, otherwise fall back to IRP */
2221 !DeviceObject->DriverObject->FastIoDispatch->FastIoUnlockAll(FileObject, PsGetCurrentProcess(), &IoStatusBlock, DeviceObject))
2222 {
2223 /* Clear and set up Events */
2226
2227 /* Allocate an IRP */
2229
2230 /* Set it up */
2239
2240 /* Set up Stack Pointer Data */
2245
2246 /* Queue the IRP */
2248
2249 /* Call the FS Driver */
2252 {
2253 /* Wait for completion */
2255 }
2256
2257 /* IO will unqueue & free for us */
2258 }
2259
2260 /* Release the lock if we were holding it */
2262 {
2264 }
2265 }
2266
2267 /* Make sure this is the last handle */
2268 if (SystemHandleCount != 1) return;
2269
2270 /* Check if this is a direct open or not */
2272 {
2273 /* Get the attached device */
2275 }
2276 else
2277 {
2278 /* Get the FO's device */
2280 }
2281
2282 /* Set the handle created flag */
2284
2285 /* Check if this is a sync FO and lock it */
2288 {
2290 }
2291
2292 /* Clear and set up Events */
2295
2296 /* Allocate an IRP */
2298
2299 /* Set it up */
2306
2307 /* Set up Stack Pointer Data */
2311
2312 /* Queue the IRP */
2314
2315 /* Update operation counts */
2317
2318 /* Call the FS Driver */
2321 {
2322 /* Wait for completion */
2324 }
2325
2326 /* Unqueue the IRP */
2330
2331 /* Free the IRP */
2333
2334 /* Release the lock if we were holding it */
2337 {
2339 }
2340}
_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:1539
PDEVICE_OBJECT NTAPI IoGetAttachedDevice(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1385
Definition: filtergraph.c:51
Definition: env_spec_w32.h:413
Definition: Bus_PDO_EvalMethod.c:93
Definition: env_spec_w32.h:870
Definition: ketypes.h:811
__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:744
VOID NTAPI IopDoNameTransmogrify(IN PIRP Irp, IN PFILE_OBJECT FileObject, IN PREPARSE_DATA_BUFFER DataBuffer)
Definition: file.c:170
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:689
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 ArcSystemString, ArcString, LanmanRedirector, LoaderPathNameA;
49
50 /* Check if we only have one disk on the machine */
52 &ArcDiskInfo->DiskSignatureListHead);
53
54 /* Create the global HAL partition name */
60
61 /* Create the global system partition 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 /* Build the boot strings */
89 RtlInitAnsiString(&ArcSystemString, LoaderBlock->ArcHalDeviceName);
90
91 /* If we are doing remote booting */
93 {
94 /* Yes, we have found boot device */
95 FoundBoot = TRUE;
96
97 /* Get NT device name */
101 {
103 }
104
105 /* Get ARC booting device name (in net(0) something) */
110 {
111 /* Map ARC to NT name */
112 IoAssignArcName(&BootDeviceName, &SystemDevice);
113 RtlFreeUnicodeString(&BootDeviceName);
114
115 /* Now, get loader path name */
116 RtlInitAnsiString(&LoaderPathNameA, LoaderBlock->NtHalPathName);
119 {
120 RtlFreeUnicodeString(&SystemDevice);
122 }
123
124 /* And set it has system partition */
125 IopStoreSystemPartitionInformation(&SystemDevice, &LoaderPathNameW);
126 }
127
128 RtlFreeUnicodeString(&SystemDevice);
129
130 /* Don't quit here, even if everything went fine!
131 * We need IopCreateArcNamesDisk to properly map
132 * devices with symlinks.
133 * It will return success if the mapping process went fine
134 * even if it didn't find boot device.
135 * It won't reset boot device finding status as well.
136 */
137 }
138
139 /* Loop every disk and try to find boot disk */
141 /* If it succeeded but we didn't find boot device, try to browse Cds */
143 {
145 }
146
147 /* Return success */
149}
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:416
NTSTATUS NTAPI IopCreateArcNamesCd(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: arcname.c:154
Definition: arc.h:267
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:182
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
_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:2274
Definition: iotypes.h:864
Referenced by IopCreateObjectTypes().
◆ IopDeleteFile()
Definition at line 1355 of file file.c.
1356{
1359 PIO_STACK_LOCATION StackPtr;
1367
1368 /* Check if the file has a device object */
1370 {
1371 /* Check if this is a direct open or not */
1373 {
1374 /* Get the attached device */
1376 }
1377 else
1378 {
1379 /* Use the file object's device object */
1381 }
1382
1383 /* Sanity check */
1386
1387 /* Check if the handle wasn't created yet */
1389 {
1390 /* Send the cleanup IRP */
1392 }
1393
1394 /* Clear and set up Events */
1397
1398 /* Allocate an IRP */
1400
1401 /* Set it up */
1407
1408 /* Set up Stack Pointer Data */
1412
1413 /* Queue the IRP */
1415
1416 /* Get the VPB and check if this isn't a direct open */
1419 {
1420 /* Dereference the VPB before the close */
1422 }
1423
1424 /* Check if the FS will never disappear by itself */
1426 {
1427 /* Dereference it */
1429 DereferenceDone = TRUE;
1430 }
1431
1432 /* Call the FS Driver */
1435 {
1436 /* Wait for completion */
1438 }
1439
1440 /* De-queue the IRP */
1444
1445 /* Free the IRP */
1447
1448 /* Clear the file name */
1450 {
1451 /*
1452 * Don't use TAG_IO_NAME since the FileObject's FileName
1453 * may have been re-allocated using a different tag
1454 * by a filesystem.
1455 */
1458 }
1459
1460 /* Check if the FO had a completion port */
1462 {
1463 /* Free it */
1466 }
1467
1468 /* Check if the FO had extension */
1470 {
1471 /* Release filter context structure if any */
1473 }
1474
1475 /* Check if dereference has been done yet */
1476 if (!DereferenceDone)
1477 {
1478 /* Dereference device object */
1480 }
1481 }
1482}
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:2178
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:281
Definition: ketypes.h:1415
Referenced by IopCreateObjectTypes().
◆ IopDereferenceDeviceObject()
Definition at line 462 of file device.c.
464{
465 /* Sanity check */
467
468 /* Dereference the device */
470
471 /*
472 * Check if we can unload it and it's safe to unload (or if we're forcing
473 * an unload, which is OK too).
474 */
475 ASSERT(!ForceUnload);
478 {
479 /* Unload it */
481 }
482}
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}
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
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: hwresource.cpp:163
Definition: nt_native.h:1099
Definition: nt_native.h:1148
Definition: nt_native.h:1165
_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 170 of file file.c.
173{
177 PWSTR NewBuffer;
178
179 PAGED_CODE();
180
188
189 /* First of all, validate data */
191 (DataBuffer->SymbolicLinkReparseBuffer.PrintNameLength +
192 DataBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength +
193 FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer[0])) > MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
194 {
196 }
197
198 /* Everything went right */
200 {
201 /* Compute buffer & length */
203 DataBuffer->MountPointReparseBuffer.SubstituteNameOffset);
204 Length = DataBuffer->MountPointReparseBuffer.SubstituteNameLength;
205
206 /* Check we don't overflow */
208 {
210 }
211 else
212 {
213 /* Compute how much memory we'll need */
215
216 /* Check if FileObject can already hold what we need */
218 {
219 NewBuffer = FileObject->FileName.Buffer;
220 }
221 else
222 {
223 /* Allocate otherwise */
226 {
228 }
229 }
230 }
231 }
232
233 /* Everything went right */
235 {
236 /* Copy the reserved data */
237 if (DataBuffer->Reserved)
238 {
240 (PWSTR)((ULONG_PTR)FileObject->FileName.Buffer + FileObject->FileName.Length - DataBuffer->Reserved),
241 DataBuffer->Reserved);
242 }
243
244 /* Then the buffer */
246 {
248 }
249
250 /* And finally replace buffer if new one was allocated */
253 {
255 {
256 /*
257 * Don't use TAG_IO_NAME since the FileObject's FileName
258 * may have been re-allocated using a different tag
259 * by a filesystem.
260 */
262 }
263
264 FileObject->FileName.Buffer = NewBuffer;
267 }
268 }
269
270 /* We don't need them anymore - it was allocated by the driver */
271 ExFreePool(DataBuffer);
272}
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}
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
NTSTATUS NTAPI IoGetDeviceInterfaces(IN CONST GUID *InterfaceClassGuid, IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL, IN ULONG Flags, OUT PWSTR *SymbolicLinkList)
Definition: deviface.c:454
_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: hwresource.cpp:160
INTERFACE_TYPE InterfaceType
Definition: hwresource.cpp:158
Definition: hwresource.cpp:27
UCHAR ShareDisposition
Definition: hwresource.cpp:29
union _CM_PARTIAL_RESOURCE_DESCRIPTOR::@393 u
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@393::@396 Interrupt
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@393::@398 Memory
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@393::@401 BusNumber
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@393::@399 Dma
Definition: hwresource.cpp:115
CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1]
Definition: hwresource.cpp:119
Definition: edit.c:58
struct _IO_RESOURCE_DESCRIPTOR::@21::@28 BusNumber
union _IO_RESOURCE_DESCRIPTOR::@21 u
struct _IO_RESOURCE_DESCRIPTOR::@21::@25 Dma
struct _IO_RESOURCE_DESCRIPTOR::@21::@22 Port
struct _IO_RESOURCE_DESCRIPTOR::@21::@24 Interrupt
struct _IO_RESOURCE_DESCRIPTOR::@21::@23 Memory
Definition: edit.c:121
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 1486 of file file.c.
1487{
1489
1490 /* Go down the stack to attempt to get the PDO */
1492 PDO = ((PEXTENDED_DEVOBJ_EXTENSION)PDO->DeviceObjectExtension)->AttachedTo);
1493
1494 return PDO;
1495}
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 */
140 {
141 ExFreePool(kvInfo);
143 }
144
149 {
150 ExFreePool(kvInfo);
152 }
153
156 driverName.Length);
158 ExFreePool(kvInfo);
159 }
160
161 /* Check whether we need to get ServiceName as well, either to construct
162 * the driver name (because we could not use "ObjectName"), or because
163 * it is requested by the caller. */
166 {
167 /* Retrieve the necessary buffer size */
168 ULONG infoLength;
171 {
174 }
175
176 /* Allocate the buffer and retrieve the data */
178 if (!basicInfo)
179 {
182 }
183
186 {
188 }
189
193 }
194
195 /* 2. There is no "ObjectName" - construct it ourselves. Depending on the driver type,
196 * it will be either "\Driver<ServiceName>" or "\FileSystem<ServiceName>" */
198 {
200
201 /* Retrieve the driver type */
202 ULONG driverType;
205 {
207 }
209 {
210 ExFreePool(kvInfo);
213 }
214
215 RtlMoveMemory(&driverType,
218 ExFreePool(kvInfo);
219
220 /* Compute the necessary driver name string size */
223 else
225
227 driverName.Length = 0;
228
229 /* Allocate and build it */
232 {
235 }
236
239 else
241
243 }
244
246 {
248
249 /* Allocate a copy for the caller */
252 {
255 }
260 }
261
262 *DriverName = driverName;
264
265Cleanup:
266 if (basicInfo)
268
271
273}
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
NTSTATUS NTAPI IopGetRegistryValue(IN HANDLE Handle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION *Information)
Definition: pnpmgr.c:1036
Definition: nt_native.h:1155
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:4533
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243
Referenced by 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 653 of file device.c.
655{
658 PDEVICE_RELATIONS DeviceRelations;
660
662
663 /* Get DeviceObject related to given FileObject */
666
667 /* Define input parameters */
672
673 /* Call the driver to query all relations (IRP_MJ_PNP) */
675 &Stack,
676 (PVOID)&DeviceRelations);
678
679 /* Make sure it's not NULL and contains only one object */
680 ASSERT(DeviceRelations);
682
683 /* Finally get the device node */
686
687 /* Free the DEVICE_RELATIONS structure, it's not needed anymore */
688 ExFreePool(DeviceRelations);
689
691}
NTSTATUS IopSynchronousCall(IN PDEVICE_OBJECT DeviceObject, IN PIO_STACK_LOCATION IoStackLocation, OUT PVOID *Information)
Definition: iotypes.h:2161
#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 1023 of file driver.c.
1024{
1025 PLIST_ENTRY ListHead, NextEntry, NextEntry2;
1026 PLDR_DATA_TABLE_ENTRY LdrEntry;
1028 UNICODE_STRING DriverName;
1032 PBOOT_DRIVER_LIST_ENTRY BootEntry;
1034
1035 /* Create the RAW FS built-in driver */
1037
1040 {
1041 /* Fail */
1042 return;
1043 }
1044
1045 /* Get highest group order index */
1048 {
1049 UNIMPLEMENTED_DBGBREAK();
1050 }
1051
1052 /* Allocate the group table */
1055 TAG_IO);
1057 {
1058 UNIMPLEMENTED_DBGBREAK();
1059 }
1060
1061 /* Initialize the group table lists */
1063
1064 /* Loop the boot modules */
1067 NextEntry != ListHead;
1068 NextEntry = NextEntry->Flink)
1069 {
1070 /* Get the entry */
1071 LdrEntry = CONTAINING_RECORD(NextEntry,
1072 LDR_DATA_TABLE_ENTRY,
1073 InLoadOrderLinks);
1074
1075 /* Check if the DLL needs to be initialized */
1077 {
1078 /* Call its entrypoint */
1080 }
1081 }
1082
1083 /* Loop the boot drivers */
1086 NextEntry != ListHead;
1087 NextEntry = NextEntry->Flink)
1088 {
1089 /* Get the entry */
1090 BootEntry = CONTAINING_RECORD(NextEntry,
1091 BOOT_DRIVER_LIST_ENTRY,
1092 Link);
1093
1094 // FIXME: TODO: This LdrEntry is to be used in a special handling
1095 // for SETUPLDR (a similar procedure is done on Windows), where
1096 // the loader would, under certain conditions, be loaded in the
1097 // SETUPLDR-specific code block below...
1098#if 0
1099 /* Get the driver loader entry */
1100 LdrEntry = BootEntry->LdrEntry;
1101#endif
1102
1103 /* Allocate our internal accounting structure */
1106 TAG_IO);
1108 {
1109 /* Zero it and initialize it */
1113
1114 /* Open the registry key */
1116 NULL,
1117 &BootEntry->RegistryPath,
1118 KEY_READ);
1120#if 0
1122#else // Hack still needed...
1125#endif
1126 {
1127 /* Save the handle */
1129
1130 /* Get the group oder index */
1132
1133 /* Get the tag position */
1135
1136 /* Insert it into the list, at the right place */
1140 {
1141 /* Get the driver info */
1142 DriverInfoTag = CONTAINING_RECORD(NextEntry2,
1143 DRIVER_INFORMATION,
1144 Link);
1145
1146 /* Check if we found the right tag position */
1148 {
1149 /* We're done */
1150 break;
1151 }
1152
1153 /* Next entry */
1154 NextEntry2 = NextEntry2->Flink;
1155 }
1156
1157 /* Insert us right before the next entry */
1158 NextEntry2 = NextEntry2->Blink;
1160 }
1161 }
1162 }
1163
1164 /* Loop each group index */
1166 {
1167 /* Loop each group table */
1170 NextEntry = NextEntry->Flink)
1171 {
1172 /* Get the entry */
1174 DRIVER_INFORMATION,
1175 Link);
1176
1177 /* Get the driver loader entry */
1179
1180 /* Initialize it */
1182 {
1183 // it does not make sense to enumerate the tree if there are no new devices added
1185 PiActionEnumRootDevices,
1186 NULL,
1187 NULL);
1188 }
1189 }
1190 }
1191
1192 /* HAL Root Bus is being initialized before loading the boot drivers so this may cause issues
1193 * when some devices are not being initialized with their drivers. This flag is used to delay
1194 * all actions with devices (except PnP root device) until boot drivers are loaded.
1195 * See PiQueueDeviceAction function
1196 */
1198
1200
1202 PiActionEnumDeviceTree,
1203 NULL,
1204 NULL);
1205}
_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:807
NTSTATUS NTAPI IoCreateDriver(_In_opt_ PUNICODE_STRING DriverName, _In_ PDRIVER_INITIALIZE InitializationFunction)
Definition: driver.c:1576
Definition: arc.h:246
Definition: ne2000.h:186
Definition: btrfs_drv.h:1876
struct _SETUP_LOADER_BLOCK * SetupLdrBlock
Definition: arc.h:558
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 443 of file driver.c.
448{
451
452 PAGED_CODE();
453
456 {
457 MmUnloadSystemImage(ModuleObject);
459 }
460
462
463 /*
464 * Retrieve the driver's PE image NT header and perform some sanity checks.
465 * NOTE: We suppose that since the driver has been successfully loaded,
466 * its NT and optional headers are all valid and have expected sizes.
467 */
469 ASSERT(NtHeaders);
470 // NOTE: ModuleObject->SizeOfImage is actually (number of PTEs)*PAGE_SIZE.
472 ASSERT(ModuleObject->EntryPoint == RVA(ModuleObject->DllBase, NtHeaders->OptionalHeader.AddressOfEntryPoint));
473
474 /* Obtain the registry path for the DriverInit routine */
475 PKEY_NAME_INFORMATION nameInfo;
476 ULONG infoLength;
479 {
481 if (nameInfo)
482 {
483 Status = ZwQueryKey(ServiceHandle,
484 KeyNameInformation,
485 nameInfo,
486 infoLength,
487 &infoLength);
489 {
493 }
494 else
495 {
497 }
498 }
499 else
500 {
502 }
503 }
504 else
505 {
507 }
508
510 {
512 RtlFreeUnicodeString(&DriverName);
513 MmUnloadSystemImage(ModuleObject);
515 }
516
517 /* Create the driver object */
519 OBJECT_ATTRIBUTES objAttrs;
520 PDRIVER_OBJECT driverObject;
521 InitializeObjectAttributes(&objAttrs,
522 &DriverName,
524 NULL,
525 NULL);
526
528 IoDriverObjectType,
529 &objAttrs,
530 KernelMode,
531 NULL,
532 ObjectSize,
533 0,
534 0,
535 (PVOID*)&driverObject);
537 {
540 RtlFreeUnicodeString(&DriverName);
541 MmUnloadSystemImage(ModuleObject);
544 }
545
547
548 RtlZeroMemory(driverObject, ObjectSize);
551
552 /* Set the legacy flag if this is not a WDM driver */
555
556 driverObject->DriverSection = ModuleObject;
557 driverObject->DriverStart = ModuleObject->DllBase;
558 driverObject->DriverSize = ModuleObject->SizeOfImage;
559 driverObject->DriverInit = ModuleObject->EntryPoint;
563
564 /* Loop all Major Functions */
566 {
567 /* Invalidate each function */
569 }
570
571 /* Add the Object and get its handle */
575 {
578 RtlFreeUnicodeString(&DriverName);
580 }
581
582 /* Now reference it */
584 0,
585 IoDriverObjectType,
586 KernelMode,
587 (PVOID*)&driverObject,
588 NULL);
589
590 /* Close the extra handle */
592
594 {
597 RtlFreeUnicodeString(&DriverName);
599 }
600
601 /* Set up the service key name buffer */
602 UNICODE_STRING serviceKeyName;
603 serviceKeyName.Length = 0;
604 // NULL-terminate for Windows compatibility
607 serviceKeyName.MaximumLength,
608 TAG_IO);
610 {
611 ObMakeTemporaryObject(driverObject);
612 ObDereferenceObject(driverObject);
615 RtlFreeUnicodeString(&DriverName);
617 }
618
619 /* Copy the name and set it in the driver extension */
623
624 /* Make a copy of the driver name to store in the driver object */
625 UNICODE_STRING driverNamePaged;
626 driverNamePaged.Length = 0;
627 // NULL-terminate for Windows compatibility
630 driverNamePaged.MaximumLength,
631 TAG_IO);
633 {
634 ObMakeTemporaryObject(driverObject);
635 ObDereferenceObject(driverObject);
637 RtlFreeUnicodeString(&DriverName);
639 }
640
641 RtlCopyUnicodeString(&driverNamePaged, &DriverName);
642 driverObject->DriverName = driverNamePaged;
643
644 /* Finally, call its init function */
646 *DriverEntryStatus = Status;
648 {
650 // return a special status value in case of failure
652 }
653
654 /* HACK: We're going to say if we don't have any DOs from DriverEntry, then we're not legacy.
655 * Other parts of the I/O manager depend on this behavior */
657 {
658 driverObject->Flags &= ~DRVO_LEGACY_DRIVER;
659 }
660
661 /* Windows does this fixup, keep it for compatibility */
663 {
664 /*
665 * Make sure the driver didn't set any dispatch entry point to NULL!
666 * Doing so is illegal; drivers shouldn't touch entry points they
667 * do not implement.
668 */
669
670 /* Check if it did so anyway */
672 {
673 /* Print a warning in the debug log */
676
677 /* Fix it up */
679 }
680 }
681
682 // TODO: for legacy drivers, unload the driver if it didn't create any DO
683
685 RtlFreeUnicodeString(&DriverName);
686
688 {
689 // if the driver entry has been failed, clear the object
690 ObMakeTemporaryObject(driverObject);
691 ObDereferenceObject(driverObject);
693 }
694
695 *OutDriverObject = driverObject;
696
698
699 /* Set the driver as initialized */
700 IopReadyDeviceObjects(driverObject);
701
703
705}
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:2218
PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION+1]
Definition: iotypes.h:2289
Definition: iotypes.h:984
Definition: ntddk_ex.h:181
Definition: winternl.h:1184
_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}
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:1031
INTERFACE_TYPE NTAPI IopDetermineDefaultInterfaceType(VOID)
Definition: pnpinit.c:41
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
Definition: io.h:417
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 1210 of file driver.c.
1211{
1212 PUNICODE_STRING *DriverList, *SavedList;
1213
1215
1216 /* HACK: No system drivers on the BootCD */
1218
1219 /* Get the driver list */
1220 SavedList = DriverList = CmGetSystemDriverList();
1221 ASSERT(DriverList);
1222
1223 /* Loop it */
1224 while (*DriverList)
1225 {
1226 /* Load the driver */
1227 ZwLoadDriver(*DriverList);
1228
1229 /* Free the entry */
1230 RtlFreeUnicodeString(*DriverList);
1231 ExFreePool(*DriverList);
1232
1233 /* Next entry */
1234 InbvIndicateProgress();
1235 DriverList++;
1236 }
1237
1238 /* Free the list */
1239 ExFreePool(SavedList);
1240
1242 PiActionEnumDeviceTree,
1243 NULL,
1244 NULL);
1245}
VOID NTAPI InbvIndicateProgress(VOID)
Gives some progress feedback, without specifying any explicit number of progress steps or percentage....
Definition: inbv.c:626
NTSTATUS PiPerformSyncDeviceAction(_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action)
Perfom a device operation synchronously via PiQueueDeviceAction.
Definition: devaction.c:2718
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 1938 of file driver.c.
1941{
1942 UNICODE_STRING ImagePath;
1944 PLDR_DATA_TABLE_ENTRY ModuleObject;
1946
1947 PKEY_VALUE_FULL_INFORMATION kvInfo;
1950 {
1952 {
1953 ExFreePool(kvInfo);
1955 }
1956
1961 {
1962 ExFreePool(kvInfo);
1964 }
1965
1968 ImagePath.Length);
1970 ExFreePool(kvInfo);
1971 }
1972 else
1973 {
1975 }
1976
1977 /*
1978 * Normalize the image path for all later processing.
1979 */
1982 {
1985 }
1986
1988
1989 KeEnterCriticalRegion();
1991
1992 /*
1993 * Load the driver module
1994 */
1997 RtlFreeUnicodeString(&ImagePath);
1998
2000 {
2003 KeLeaveCriticalRegion();
2005 }
2006
2007 // Display the loading message
2008 ULONG infoLength;
2011 {
2013 if (servName)
2014 {
2015 Status = ZwQueryKey(ServiceHandle,
2016 KeyBasicInformation,
2017 servName,
2018 infoLength,
2019 &infoLength);
2021 {
2023 .Length = servName->NameLength,
2024 .MaximumLength = servName->NameLength,
2025 .Buffer = servName->Name
2026 };
2027
2029 }
2031 }
2032 }
2033
2034 NTSTATUS driverEntryStatus;
2036 ServiceHandle,
2037 DriverObject,
2038 &driverEntryStatus);
2040 {
2042 }
2043
2045 KeLeaveCriticalRegion();
2046
2048}
#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:2938
static VOID FASTCALL IopDisplayLoadingMessage(_In_ PCUNICODE_STRING ServiceName)
Displays a driver-loading message in SOS mode.
Definition: driver.c:328
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:443
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:369
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}
static VOID ErrorMessage(_In_ DWORD dwErrorCode, _In_opt_ PCWSTR pszMsg,...)
Definition: attrib.c:33
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:332
Definition: iotypes.h:2016
Definition: iotypes.h:2000
Definition: nt_native.h:1269
Definition: winternl.h:1746
#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
struct _IO_STACK_LOCATION::@3978::@3998 MountVolume
union _IO_STACK_LOCATION::@1564 Parameters
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.
889{
892
893 PAGED_CODE();
894
896
898 Name,
900 ParentKey,
901 NULL);
902
904
906}
Definition: apinames.c:49
Referenced by CreateDeviceFromRegistry(), EnumerateDevices(), IoOpenDeviceRegistryKey(), IopCreateDeviceKeyPath(), IopEnumerateDetectedDevices(), IopGetParentIdPrefix(), IopInitializeBootDrivers(), IopInitializeBuiltinDriver(), IopInitializePlugPlayServices(), IopLoadUnloadDriverWorker(), IopSetServiceEnumData(), IopStoreSystemPartitionInformation(), IopUpdateControlKeyWithResources(), IopUpdateRootKey(), IoSetSystemPartition(), 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 324 of file file.c.
334{
342 PIO_STACK_LOCATION StackLoc;
343 IO_SECURITY_CONTEXT SecurityContext;
348 PDUMMY_FILE_OBJECT LocalFileObject;
349 PFILE_BASIC_INFORMATION FileBasicInfo;
351 KPROCESSOR_MODE CheckMode;
356 UNICODE_STRING FileString;
357 USHORT Attempt;
359 ParseObject, RemainingName);
360
362 {
363 /* Assume failure */
365
366 /* Validate the open packet */
368
369 /* Valide reparse point in case we traversed a mountpoint */
371 {
372 /* This is a reparse point we understand */
374
375 /* Make sure we're dealing with correct DO */
377 OriginalDeviceObject->DeviceType != FILE_DEVICE_CD_ROM &&
378 OriginalDeviceObject->DeviceType != FILE_DEVICE_VIRTUAL_DISK &&
379 OriginalDeviceObject->DeviceType != FILE_DEVICE_TAPE)
380 {
383 }
384 }
385
386 /* Check if we have a related file object */
388 {
389 /* Use the related file object's device object */
390 OriginalDeviceObject = OpenPacket->RelatedFileObject->DeviceObject;
391 }
392
393 /* Validate device status */
396 {
397 /* We failed, return status */
400 }
401
402 /* Map the generic mask and set the new mapping in the access state */
410
411 /* Check what kind of access checks to do */
414 {
415 /* Call is from user-mode or kernel is forcing checks */
416 CheckMode = UserMode;
417 }
418 else
419 {
420 /* Call is from the kernel */
421 CheckMode = KernelMode;
422 }
423
424 /* Check privilege for backup or restore operation */
426 &OpenPacket->CreateOptions,
427 CheckMode,
428 OpenPacket->Disposition);
429
430 /* Check if we are re-parsing */
433 {
434 /* Get granted access from the last call */
436 }
437
438 /* Check if this is a volume open */
441 !(RemainingName->Length))
442 {
443 /* It is */
444 VolumeOpen = TRUE;
445 }
446
447 /* Now check if we need access checks */
450 (!(OpenPacket->RelatedFileObject) || (VolumeOpen)) &&
451 !(OpenPacket->Override))
452 {
453 KeEnterCriticalRegion();
455
456 /* Check if a device object is being parsed */
458 {
459 /* Lock the subject context */
461 LockHeld = TRUE;
462
463 /* Do access check */
465 SecurityDescriptor,
466 &AccessState->SubjectSecurityContext,
467 LockHeld,
468 DesiredAccess,
469 0,
470 &Privileges,
471 &IoFileObjectType->
472 TypeInfo.GenericMapping,
473 UserMode,
474 &GrantedAccess,
475 &Status);
477 {
478 /* Append and free the privileges */
481 }
482
483 /* Check if we got access */
485 {
486 /* Update access state */
489 MAXIMUM_ALLOWED);
491 }
492
493 FileString.Length = 8;
494 FileString.MaximumLength = 8;
496
497 /* Do Audit/Alarm for open operation */
498 SeOpenObjectAuditAlarm(&FileString,
499 OriginalDeviceObject,
500 CompleteName,
501 OriginalDeviceObject->SecurityDescriptor,
502 AccessState,
503 FALSE,
504 AccessGranted,
505 UserMode,
506 &AccessState->GenerateOnClose);
507 }
508 else
509 {
510 /* Check if we need to do traverse validation */
512 ((OriginalDeviceObject->DeviceType == FILE_DEVICE_DISK) ||
513 (OriginalDeviceObject->DeviceType == FILE_DEVICE_CD_ROM)))
514 {
515 /* Check if this is a restricted token */
517 {
518 /* Do the FAST traverse check */
520 AccessState,
521 FILE_TRAVERSE,
522 UserMode);
523 }
524 else
525 {
526 /* Fail */
528 }
529
530 /* Check if we failed to get access */
532 {
533 /* Lock the subject context */
535 LockHeld = TRUE;
536
537 /* Do access check */
539 SecurityDescriptor,
540 &AccessState->SubjectSecurityContext,
541 LockHeld,
542 FILE_TRAVERSE,
543 0,
544 &Privileges,
545 &IoFileObjectType->
546 TypeInfo.GenericMapping,
547 UserMode,
548 &GrantedAccess,
549 &Status);
551 {
552 /* Append and free the privileges */
555 }
556 }
557
558 /* FIXME: Do Audit/Alarm for traverse check */
559 }
560 else
561 {
562 /* Access automatically granted */
564 }
565 }
566
568 KeLeaveCriticalRegion();
569
570 /* Check if we hold the lock */
571 if (LockHeld)
572 {
573 /* Release it */
575 }
576
577 /* Check if access failed */
579 {
580 /* Dereference the device and fail */
584 }
585 }
586
587 /* Check if we can simply use a dummy file */
589
590 /* Check if this is a direct open */
592 !(OpenPacket->RelatedFileObject) &&
594 FILE_READ_ATTRIBUTES |
595 READ_CONTROL |
596 ACCESS_SYSTEM_SECURITY |
597 WRITE_OWNER |
598 WRITE_DAC)) == 0) &&
599 !(UseDummyFile))
600 {
601 /* Remember this for later */
602 DirectOpen = TRUE;
603 }
604
605 /* Check if we have a related FO that wasn't a direct open */
608 {
609 /* The device object is the one we were given */
610 DeviceObject = ParseObject;
611
612 /* Check if the related FO had a VPB */
614 {
615 /* Yes, remember it */
617
618 /* Reference it */
620
621 /* Check if we were given a specific top level device to use */
623 {
625 }
626 }
627 }
628 else
629 {
630 /* Check if it has a VPB */
631 if ((OriginalDeviceObject->Vpb) && !(DirectOpen))
632 {
633 /* Check if the VPB is mounted, and mount it */
635 OriginalDeviceObject,
636 RemainingName,
637 &Status);
639
640 /* Get the VPB's device object */
642 }
643 else
644 {
645 /* The device object is the one we were given */
646 DeviceObject = OriginalDeviceObject;
647 }
648
649 /* If we weren't given a specific top level device, look for an attached device */
651 DeviceObject->AttachedDevice)
652 {
653 /* Get the attached device */
655 }
656 }
657
658 /* If we have a top level device hint, verify it */
660 {
663 {
667 }
668 }
669
670 /* If we traversed a mount point, reset the information */
672 {
674 }
675
676 /* Check if this is a secure FSD */
679 (!VolumeOpen))
680 {
682 GrantedAccess = 0;
683
684 KeEnterCriticalRegion();
686
687 /* Lock the subject context */
689
690 /* Do access check */
692 &AccessState->SubjectSecurityContext,
693 TRUE,
694 DesiredAccess,
695 0,
696 &Privileges,
698 UserMode,
699 &GrantedAccess,
700 &Status);
702 {
703 /* Append and free the privileges */
706 }
707
708 /* Check if we got access */
710 {
713 }
714
715 FileString.Length = 8;
716 FileString.MaximumLength = 8;
718
719 /* Do Audit/Alarm for open operation
720 * NOTA: we audit target device object
721 */
722 SeOpenObjectAuditAlarm(&FileString,
723 DeviceObject,
724 CompleteName,
725 OriginalDeviceObject->SecurityDescriptor,
726 AccessState,
727 FALSE,
728 AccessGranted,
729 UserMode,
730 &AccessState->GenerateOnClose);
731
733
735 KeLeaveCriticalRegion();
736
737 /* Check if access failed */
739 {
740 /* Dereference the device and fail */
744 }
745 }
746
747 /* Allocate the IRP */
750 {
751 /* Dereference the device and VPB, then fail */
755 }
756
757 /* Now set the IRP data */
768
769 /* Setup the security context */
770 SecurityContext.SecurityQos = SecurityQos;
774
775 /* Get the I/O Stack location */
777 StackLoc->Control = 0;
778
779 /* Check what kind of file this is */
781 {
782 /* Normal file */
784
785 /* Set the major function and EA Length */
788
789 /* Set the flags */
792 break;
793
794 /* Named pipe */
796
797 /* Set the named pipe MJ and set the parameters */
800 break;
801
802 /* Mailslot */
804
805 /* Set the mailslot MJ and set the parameters */
808 break;
809 }
810
811 /* Set the common data */
815 (OpenPacket->CreateOptions &
816 0xFFFFFF);
820
821 /* Check if we really need to create an object */
822 if (!UseDummyFile)
823 {
825
826 /* Tag on space for a file object extension */
829
830 /* Create the actual file object */
832 NULL,
833 Attributes,
834 NULL,
835 NULL);
837 IoFileObjectType,
838 &ObjectAttributes,
839 AccessMode,
840 NULL,
841 ObjectSize,
842 0,
843 0,
846 {
847 /* Create failed, free the IRP */
849
850 /* Dereference the device and VPB */
853
854 /* We failed, return status */
857 }
858
859 /* Clear the file object */
861
862 /* Check if this is Synch I/O */
865 {
866 /* Set the synch flag */
868
869 /* Check if it's also alertable */
871 {
872 /* It is, set the alertable flag */
874 }
875 }
876
877 /* Check if this is synch I/O */
879 {
880 /* Initialize the event */
882 }
883
884 /* Check if the caller requested no intermediate buffering */
886 {
887 /* Set the correct flag for the FSD to read */
889 }
890
891 /* Check if the caller requested write through support */
893 {
894 /* Set the correct flag for the FSD to read */
896 }
897
898 /* Check if the caller says the file will be only read sequentially */
900 {
901 /* Set the correct flag for the FSD to read */
903 }
904
905 /* Check if the caller believes the file will be only read randomly */
907 {
908 /* Set the correct flag for the FSD to read */
910 }
911
912 /* Check if we were asked to setup a file object extension */
914 {
915 PFILE_OBJECT_EXTENSION FileObjectExtension;
916
917 /* Make sure the file object knows it has an extension */
919
920 /* Initialize file object extension */
922 FileObject->FileObjectExtension = FileObjectExtension;
923
924 /* Add the top level device which we'll send the request to */
926 {
928 }
929 }
930 }
931 else
932 {
933 /* Use the dummy object instead */
934 LocalFileObject = OpenPacket->LocalFileObject;
936
937 /* Set it up */
941 }
942
943 /* Setup the file header */
947 FileObject->DeviceObject = OriginalDeviceObject;
948
949 /* Check if this is a direct device open */
951
952 /* Check if the caller wants case sensitivity */
954 {
955 /* Tell the driver about it */
957 }
958
959 /* Now set the file object */
962
963 /* Check if the file object has a name */
965 {
966 /* Setup the unicode string */
969 FileObject->FileName.MaximumLength,
970 TAG_IO_NAME);
972 {
973 /* Failed to allocate the name, free the IRP */
975
976 /* Dereference the device object and VPB */
979
980 /* Clear the FO and dereference it */
983
984 /* Fail */
986 }
987 }
988
989 /* Copy the name */
991
992 /* Initialize the File Object event and set the FO */
995
996 /* Queue the IRP and call the driver */
1000 {
1001 /* Wait for the driver to complete the create */
1003 Executive,
1004 KernelMode,
1005 FALSE,
1006 NULL);
1007
1008 /* Get the new status */
1010 }
1011 else
1012 {
1013 /* We'll have to complete it ourselves */
1016
1017 /* Handle name change if required */
1019 {
1020 /* Check this is a mount point */
1022 {
1023 PREPARSE_DATA_BUFFER ReparseData;
1024
1025 /* Reparse point attributes were passed by the driver in the auxiliary buffer */
1028
1032
1034 }
1035 }
1036
1037 /* Completion happens at APC_LEVEL */
1039
1040 /* Get the new I/O Status block ourselves */
1043
1044 /* Manually signal the even, we can't have any waiters */
1045 FileObject->Event.Header.SignalState = 1;
1046
1047 /* Now that we've signaled the events, de-associate the IRP */
1049
1050 /* Check if the IRP had an input buffer */
1053 {
1054 /* Free it. A driver might've tacked one on */
1056 }
1057
1058 /* Free the IRP and bring the IRQL back down */
1061 }
1062
1063 /* Copy the I/O Status */
1065
1066 /* The driver failed to create the file */
1068 {
1069 /* Check if we have a name and if so, free it */
1071 {
1072 /*
1073 * Don't use TAG_IO_NAME since the FileObject's FileName
1074 * may have been re-allocated using a different tag
1075 * by a filesystem.
1076 */
1079 FileObject->FileName.Length = 0;
1080 }
1081
1082 /* Clear its device object */
1084
1085 /* Save this now because the FO might go away */
1088
1089 /* Clear the file object in the open packet */
1091
1092 /* Dereference the file object */
1094
1095 /* Dereference the device object */
1097
1098 /* Unless the driver cancelled the open, dereference the VPB */
1100
1101 /* Set the status and return */
1104 }
1106 {
1109 {
1110 /* Update CompleteName with reparse info which got updated in IopDoNameTransmogrify() */
1112 {
1113 PWSTR NewCompleteName;
1114
1115 /* Allocate a new buffer for the string */
1118 {
1121 }
1122
1123 /* Release the old one */
1125 {
1126 /*
1127 * Don't use TAG_IO_NAME since the FileObject's FileName
1128 * may have been re-allocated using a different tag
1129 * by a filesystem.
1130 */
1131 ExFreePoolWithTag(CompleteName->Buffer, 0);
1132 }
1133
1134 /* And setup the new one */
1135 CompleteName->Buffer = NewCompleteName;
1136 CompleteName->MaximumLength = FileObject->FileName.Length;
1137 }
1138
1139 /* Copy our new complete name */
1141
1143 {
1145 }
1146 }
1147
1148 /* Check if we have a name and if so, free it */
1150 {
1151 /*
1152 * Don't use TAG_IO_NAME since the FileObject's FileName
1153 * may have been re-allocated using a different tag
1154 * by a filesystem.
1155 */
1158 FileObject->FileName.Length = 0;
1159 }
1160
1161 /* Clear its device object */
1163
1164 /* Clear the file object in the open packet */
1166
1167 /* Dereference the file object */
1169
1170 /* Dereference the device object */
1172
1173 /* Unless the driver cancelled the open, dereference the VPB */
1175
1177 {
1179
1180 /* Inform we traversed a mount point for later attempt */
1182 {
1183 OpenPacket->TraversedMountPoint = 1;
1184 }
1185
1186 /* In case we override checks, but got this on volume open, fail hard */
1188 {
1189 KeBugCheckEx(DRIVER_RETURNED_STATUS_REPARSE_FOR_VOLUME_OPEN,
1190 (ULONG_PTR)OriginalDeviceObject,
1192 (ULONG_PTR)CompleteName,
1193 OpenPacket->Information);
1194 }
1195
1196 /* Return to IO/OB so that information can be upgraded */
1198 }
1199
1200 /* Loop again and reattempt an opening */
1201 continue;
1202 }
1203
1204 break;
1205 }
1206
1209
1210 /* Get the owner of the File Object */
1212
1213 /*
1214 * It's possible that the device to whom we sent the IRP to
1215 * isn't actually the device that ended opening the file object
1216 * internally.
1217 */
1219 {
1220 /* We have to de-reference the VPB we had associated */
1222
1223 /* And re-associate with the actual one */
1226 }
1227
1228 /* Make sure we are not using a dummy */
1229 if (!UseDummyFile)
1230 {
1231 /* Check if this was a volume open */
1234 !(FileObject->FileName.Length))
1235 {
1236 /* All signs point to it, but make sure it was actually an FSD */
1238 (OwnerDevice->DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) ||
1239 (OwnerDevice->DeviceType == FILE_DEVICE_TAPE_FILE_SYSTEM) ||
1240 (OwnerDevice->DeviceType == FILE_DEVICE_FILE_SYSTEM))
1241 {
1242 /* The owner device is an FSD, so this is a volume open for real */
1244 }
1245 }
1246
1247 /* Reference the object and set the parse check */
1253 }
1254 else
1255 {
1256 /* Check if this was a query */
1258 {
1259 /* Check if the caller wants basic info only */
1261 {
1262 /* Allocate the buffer */
1264 sizeof(*FileBasicInfo),
1265 TAG_IO);
1266 if (FileBasicInfo)
1267 {
1268 /* Do the query */
1270 FileBasicInformation,
1271 sizeof(*FileBasicInfo),
1272 FileBasicInfo,
1273 &ReturnLength);
1275 {
1276 /* Copy the data */
1278 FileBasicInfo,
1279 ReturnLength);
1280 }
1281
1282 /* Free our buffer */
1284 }
1285 else
1286 {
1287 /* Fail */
1289 }
1290 }
1291 else
1292 {
1293 /* This is a full query */
1295 FileObject,
1298 OpenPacket->NetworkInformation,
1299 &ReturnLength);
1301 }
1302 }
1303
1304 /* Delete the file object */
1306
1307 /* Clear out the file */
1309
1310 /* Set and return status */
1314 }
1315}
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:275
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:170
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:357
Definition: nt_native.h:938
Definition: from_kernel.h:207
Definition: iotypes.h:2865
struct _IO_STACK_LOCATION::@3978::@3980 CreatePipe
struct _IO_STACK_LOCATION::@3978::@3981 CreateMailslot
struct _IO_STACK_LOCATION::@3978::@3979 Create
Definition: io.h:367
PFILE_NETWORK_OPEN_INFORMATION NetworkInformation
Definition: io.h:385
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 1319 of file file.c.
1329{
1332
1333 /* Validate the open packet */
1335
1336 /* Get the device object */
1338 OpenPacket->RelatedFileObject = ParseObject;
1339
1340 /* Call the main routine */
1342 ObjectType,
1343 AccessState,
1344 AccessMode,
1345 Attributes,
1346 CompleteName,
1347 RemainingName,
1348 OpenPacket,
1349 SecurityQos,
1350 Object);
1351}
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:324
Referenced by IopCreateObjectTypes().
◆ IopQueryDeviceCapabilities()
| NTSTATUS NTAPI IopQueryDeviceCapabilities | ( | PDEVICE_NODE | DeviceNode, |
| PDEVICE_CAPABILITIES | DeviceCaps | ||
| ) |
Definition at line 854 of file devaction.c.
856{
857 IO_STATUS_BLOCK StatusBlock;
860 HANDLE InstanceKey;
862
863 /* Set up the Header */
866 DeviceCaps->Version = 1;
867 DeviceCaps->Address = -1;
868 DeviceCaps->UINumber = -1;
869
870 /* Set up the Stack */
872 Stack.Parameters.DeviceCapabilities.Capabilities = DeviceCaps;
873
874 /* Send the IRP */
876 &StatusBlock,
878 &Stack);
880 {
882 {
884 }
886 }
887
888 /* Map device capabilities to capability flags */
889 DeviceNode->CapabilityFlags = 0;
890 if (DeviceCaps->LockSupported)
892
893 if (DeviceCaps->EjectSupported)
895
896 if (DeviceCaps->Removable)
898
899 if (DeviceCaps->DockDevice)
901
902 if (DeviceCaps->UniqueID)
904
905 if (DeviceCaps->SilentInstall)
907
908 if (DeviceCaps->RawDeviceOK)
910
911 if (DeviceCaps->SurpriseRemovalOK)
913
914 if (DeviceCaps->HardwareDisabled)
916
917 if (DeviceCaps->NonDynamic)
919
920 if (DeviceCaps->NoDisplayInUI)
922 else
923 DeviceNode->UserFlags &= ~DNUF_DONT_SHOW_IN_UI;
924
925 Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, REG_OPTION_NON_VOLATILE, &InstanceKey);
927 {
928 /* Set 'Capabilities' value */
930 Status = ZwSetValueKey(InstanceKey,
931 &ValueName,
932 0,
933 REG_DWORD,
934 &DeviceNode->CapabilityFlags,
936
937 /* Set 'UINumber' value */
939 {
941 Status = ZwSetValueKey(InstanceKey,
942 &ValueName,
943 0,
944 REG_DWORD,
945 &DeviceCaps->UINumber,
947 }
948
949 ZwClose(InstanceKey);
950 }
951
953}
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 1926 of file file.c.
1932{
1934 HasName,
1935 FALSE,
1936 ObjectNameInfo,
1937 Length,
1938 ReturnLength,
1939 PreviousMode);
1940}
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:1944
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 1944 of file file.c.
1951{
1952 POBJECT_NAME_INFORMATION LocalInfo;
1953 PFILE_NAME_INFORMATION LocalFileInfo;
1960 BOOLEAN NoObCall;
1961
1963
1964 /* Validate length */
1966 {
1967 /* Wrong length, fail */
1970 }
1971
1972 /* Allocate Buffer */
1975
1976 /* Query DOS name if the caller asked to */
1977 NoObCall = FALSE;
1978 if (QueryDosName)
1979 {
1981
1982 /* In case of a network file system, don't call mountmgr */
1984 {
1985 /* We'll store separator and terminator */
1988 {
1990 }
1991 else
1992 {
1998 }
1999 }
2000 /* Otherwise, call mountmgr to get DOS name */
2001 else
2002 {
2005 }
2006 }
2007
2008 /* Fall back if querying DOS name failed or if caller never wanted it ;-) */
2010 {
2011 /* Query the name */
2013 LocalInfo,
2014 Length,
2015 &LocalReturnLength);
2016 }
2017 else
2018 {
2019 NoObCall = TRUE;
2020 }
2021
2023 {
2024 /* Free the buffer and fail */
2027 }
2028
2029 /* Get buffer pointer */
2031
2032 _SEH2_TRY
2033 {
2034 /* Copy the information */
2035 if (QueryDosName && NoObCall)
2036 {
2038
2039 /* Copy structure first */
2040 RtlCopyMemory(ObjectNameInfo,
2041 LocalInfo,
2043 /* Name then */
2045 (Length >= LocalReturnLength ? LocalInfo->Name.Length : Length - sizeof(OBJECT_NAME_INFORMATION)));
2046
2048 {
2050 }
2051 }
2052 else
2053 {
2054 RtlCopyMemory(ObjectNameInfo,
2055 LocalInfo,
2056 (LocalReturnLength > Length) ?
2057 Length : LocalReturnLength);
2058 }
2059
2060 /* Set buffer pointer */
2061 ObjectNameInfo->Name.Buffer = p;
2062
2063 /* Advance in buffer */
2065
2066 /* Check if this already filled our buffer */
2068 {
2069 /* Set the length mismatch to true, so that we can return
2070 * the proper buffer size to the caller later
2071 */
2072 LengthMismatch = TRUE;
2073
2074 /* Save the initial buffer length value */
2075 *ReturnLength = LocalReturnLength;
2076 }
2077
2078 /* Now get the file name buffer and check the length needed */
2079 LocalFileInfo = (PFILE_NAME_INFORMATION)LocalInfo;
2081 LocalReturnLength +
2083
2084 /* Query the File name */
2087 {
2090 FileNameInformation,
2091 LocalFileInfo,
2092 &LocalReturnLength);
2093 }
2094 else
2095 {
2097 FileNameInformation,
2099 LocalFileInfo,
2100 &LocalReturnLength);
2101 }
2103 {
2104 /* Allow status that would mean it's not implemented in the storage stack */
2107 {
2108 _SEH2_LEAVE;
2109 }
2110
2111 /* In such case, zero output */
2113 LocalFileInfo->FileNameLength = 0;
2115 }
2116 else
2117 {
2118 /* We'll at least return the name length */
2120 {
2122 }
2123 }
2124
2125 /* If the provided buffer is too small, return the required size */
2126 if (LengthMismatch)
2127 {
2128 /* Add the required length */
2130
2131 /* Free the allocated buffer and return failure */
2133 _SEH2_LEAVE;
2134 }
2135
2136 /* Now calculate the new lengths left */
2137 FileLength = LocalReturnLength -
2140 (ULONG_PTR)ObjectNameInfo +
2141 LocalFileInfo->FileNameLength);
2142
2143 /* Don't copy the name if it's not valid */
2145 {
2146 /* Free the allocated buffer and return failure */
2148 _SEH2_LEAVE;
2149 }
2150
2151 /* Write the Name and null-terminate it */
2156
2157 /* Return the length needed */
2158 *ReturnLength = LocalReturnLength;
2159
2160 /* Setup the length and maximum length */
2164 ObjectNameInfo->Name.MaximumLength = (USHORT)ObjectNameInfo->Name.Length +
2166 }
2167 _SEH2_FINALLY
2168 {
2169 /* Free buffer and return */
2171 } _SEH2_END;
2172
2174}
struct _FILE_NAME_INFORMATION * PFILE_NAME_INFORMATION
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 PUNICODE_STRING DosName)
Definition: volume.c:1279
Definition: winternl.h:649
Definition: filecomp.c:348
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:2913
Definition: cmtypes.h:404
WCHAR SymbolicLinkName[ANYSIZE_ARRAY]
Definition: cmtypes.h:416
struct _PLUGPLAY_EVENT_BLOCK::@2393::@2395 DeviceClass
Definition: plugplay.c:16
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING SymbolicLinkName
Definition: wdfdevice.h:3739
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::@2393::@2397 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 840 of file arcname.c.
842{
846 WCHAR ArcNameBuffer[64];
849 HANDLE LinkHandle;
850
851 /* Create the Unicode name for the current ARC boot device */
856
857 /* Initialize the attributes and open the link */
859 &TargetName,
860 OBJ_CASE_INSENSITIVE,
861 NULL,
862 NULL);
865 &ObjectAttributes);
867 {
868 /* We failed, free the string */
871 }
872
873 /* Query the current \\SystemRoot */
874 ArcName.Buffer = ArcNameBuffer;
875 ArcName.Length = 0;
879 {
880 /* We failed, free the string */
883 }
884
885 /* Convert it to Ansi */
887 ArcString.Length = 0;
891
892 /* Close the link handle and free the name */
895
896 /* Setup the system root name again */
900
901 /* Open the symbolic link for it */
903 &LinkName,
904 OBJ_CASE_INSENSITIVE,
905 NULL,
906 NULL);
909 &ObjectAttributes);
911
912 /* Destroy it */
913 NtMakeTemporaryObject(LinkHandle);
915
916 /* Now create the new name for it */
918
919 /* Copy it into the passed parameter and null-terminate it */
920 RtlCopyString(NtBootPath, &ArcString);
922
923 /* Setup the Unicode-name for the new symbolic link value */
926 &LinkName,
928 NULL,
929 NULL);
932
933 /* Create it */
936 &ObjectAttributes,
937 &ArcName);
938
939 /* Free all the strings and close the handle and return success */
940 RtlFreeUnicodeString(&ArcName);
941 RtlFreeUnicodeString(&LinkName);
944}
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 1532 of file driver.c.
1533{
1534 PDRIVER_REINIT_ITEM ReinitItem;
1536
1537 /* Get the first entry and start looping */
1539 &DriverBootReinitListLock);
1541 {
1542 /* Get the item */
1544
1545 /* Increment reinitialization counter */
1547
1548 /* Remove the device object flag */
1550
1551 /* Call the routine */
1553 ReinitItem->Context,
1554 ReinitItem->DriverObject->
1555 DriverExtension->Count);
1556
1557 /* Free the entry */
1559
1560 /* Move to the next one */
1562 &DriverBootReinitListLock);
1563 }
1564
1565 /* Wait for all device actions being finished*/
1567}
PLIST_ENTRY NTAPI ExInterlockedRemoveHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:166
Definition: io.h:447
Referenced by IoInitSystem().
◆ IopReinitializeDrivers()
Definition at line 1496 of file driver.c.
1497{
1498 PDRIVER_REINIT_ITEM ReinitItem;
1500
1501 /* Get the first entry and start looping */
1503 &DriverReinitListLock);
1505 {
1506 /* Get the item */
1508
1509 /* Increment reinitialization counter */
1511
1512 /* Remove the device object flag */
1514
1515 /* Call the routine */
1517 ReinitItem->Context,
1518 ReinitItem->DriverObject->
1519 DriverExtension->Count);
1520
1521 /* Free the entry */
1523
1524 /* Move to the next one */
1526 &DriverReinitListLock);
1527 }
1528}
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:3776
◆ 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}
_Check_return_ long __cdecl atol(_In_z_ const char *_Str)
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
int _snwprintf(wchar_t *buffer, size_t count, const wchar_t *format,...)
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
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
#define SharedUserData
Definition: arc.h:238
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
_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 390 of file device.c.
391{
394
395 /* Check if deletion is pending */
397 {
399 {
401 return;
402 }
403
405 {
407 return;
408 }
409
410 /* Check if we have a Security Descriptor */
412 {
413 /* Dereference it */
415 }
416
417 /* Remove the device from the list */
419
420 /* Dereference the keep-alive */
422 }
423
424 /* We can't unload a non-PnP driver here */
426 {
428 return;
429 }
430
431 /* Return if we've already called unload (maybe we're in it?) */
433
434 /* We can't unload unless there's an unload handler */
436 {
437 DPRINT1("No DriverUnload function on PnP driver! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
438 return;
439 }
440
441 /* Bail if there are still devices present */
443 {
445 return;
446 }
447
449
450 /* Set the unload invoked flag */
452
453 /* Unload it */
455
456 /* Make object temporary so it can be deleted */
458}
VOID NTAPI IopEditDeviceList(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT DeviceObject, IN IOP_DEVICE_LIST_OPERATION Type)
Definition: device.c:334
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 695 of file device.c.
697{
700 PDEVICE_OBJECT LoopObject;
701
703
705 /* Simply loop on the device stack and try to find our hint */
707 for (LoopObject = BaseDeviceObject; ; LoopObject = LoopObject->AttachedDevice)
708 {
709 /* It was found, it's a success */
710 if (LoopObject == TopDeviceObjectHint)
711 {
713 break;
714 }
715
716 /* End of the stack, that's a failure - default */
718 {
719 break;
720 }
721 }
723
725}
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 NTAPI IopVerifyDiskSignature | ( | IN PDRIVE_LAYOUT_INFORMATION_EX | DriveLayout, |
| IN PARC_DISK_SIGNATURE | ArcDiskSignature, | ||
| OUT PULONG | Signature | ||
| ) |
Definition at line 948 of file arcname.c.
951{
952 /* First condition: having a valid partition table */
953 if (!ArcDiskSignature->ValidPartitionTable)
954 {
956 }
957
958 /* If that partition table is the MBR */
960 {
961 /* Then check MBR signature */
962 if (DriveLayout->Mbr.Signature == ArcDiskSignature->Signature)
963 {
964 /* And return it */
966 {
967 *Signature = DriveLayout->Mbr.Signature;
968 }
969
971 }
972 }
973 /* If that partition table is the GPT */
975 {
976 /* Check we are using GPT and compare GUID */
977 if (ArcDiskSignature->IsGpt &&
978 (((PULONG)ArcDiskSignature->GptSignature)[0] == DriveLayout->Gpt.DiskId.Data1 &&
979 ((PUSHORT)ArcDiskSignature->GptSignature)[2] == DriveLayout->Gpt.DiskId.Data2 &&
980 ((PUSHORT)ArcDiskSignature->GptSignature)[3] == DriveLayout->Gpt.DiskId.Data3 &&
981 ((PULONGLONG)ArcDiskSignature->GptSignature)[1] == ((PULONGLONG)DriveLayout->Gpt.DiskId.Data4)[0]))
982 {
983 /* There's no signature to give, so we just zero output */
985 {
986 *Signature = 0;
987 }
989 }
990 }
991
992 /* If we fall here, it means that something went wrong, so return that */
994}
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:382
__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:640
struct LOOKASIDE_ALIGN _NPAGED_LOOKASIDE_LIST * PNPAGED_LOOKASIDE_LIST
struct _KQUEUE * PKQUEUE
Referenced by IopDeviceFsIoControl(), NtLockFile(), and NtSetIoCompletion().
◆ IoShutdownSystem()
Definition at line 133 of file device.c.
134{
135 PLIST_ENTRY ListEntry;
137 PSHUTDOWN_ENTRY ShutdownEntry;
138 IO_STATUS_BLOCK StatusBlock;
142
143 /* Initialize an event to wait on */
145
146 /* What phase? */
147 if (Phase == 0)
148 {
149 /* Shutdown PnP */
150 IoShutdownPnpDevices();
151
152 /* Loop first-chance shutdown notifications */
154 &ShutdownListLock);
155 while (ListEntry)
156 {
157 /* Get the shutdown entry */
158 ShutdownEntry = CONTAINING_RECORD(ListEntry,
159 SHUTDOWN_ENTRY,
160 ShutdownList);
161
162 /* Get the attached device */
164
165 /* Build the shutdown IRP and call the driver */
167 DeviceObject,
168 NULL,
169 0,
170 NULL,
171 &Event,
172 &StatusBlock);
174 {
177 {
178 /* Wait on the driver */
180 }
181 }
182
183 /* Remove the flag */
185
186 /* Get rid of our reference to it */
188
189 /* Free the shutdown entry and reset the event */
192
193 /* Go to the next entry */
195 &ShutdownListLock);
196 }
197 }
198 else if (Phase == 1)
199 {
200 /* Acquire resource forever */
202
203 /* Shutdown disk file systems */
205
206 /* Shutdown cdrom file systems */
208
209 /* Shutdown tape filesystems */
211
212 /* Loop last-chance shutdown notifications */
214 &ShutdownListLock);
215 while (ListEntry)
216 {
217 /* Get the shutdown entry */
218 ShutdownEntry = CONTAINING_RECORD(ListEntry,
219 SHUTDOWN_ENTRY,
220 ShutdownList);
221
222 /* Get the attached device */
224
225 /* Build the shutdown IRP and call the driver */
227 DeviceObject,
228 NULL,
229 0,
230 NULL,
231 &Event,
232 &StatusBlock);
234 {
237 {
238 /* Wait on the driver */
240 }
241 }
242
243 /* Remove the flag */
245
246 /* Get rid of our reference to it */
248
249 /* Free the shutdown entry and reset the event */
252
253 /* Go to the next entry */
255 &ShutdownListLock);
256 }
257
258 }
259}
VOID NTAPI IopShutdownBaseFileSystems(IN PLIST_ENTRY ListHead)
Definition: volume.c:349
Definition: io.h:428
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}
Definition: _stack.h:55
NTSTATUS IopSynchronousCall(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_STACK_LOCATION IoStackLocation, _Out_ PVOID *Information)
Definition: pnpirp.c:14
Definition: notification.c:61
#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
320}
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 2718 of file devaction.c.
2721{
2722 KEVENT opFinished;
2724
2728
2730}
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:2659
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 2659 of file devaction.c.
2664{
2667
2669
2672
2674
2677 Request->CompletionEvent = CompletionEvent;
2678 Request->CompletionStatus = CompletionStatus;
2679
2682
2684 {
2686
2690
2692 return;
2693 }
2694
2696 {
2698 return;
2699 }
2703
2706}
static VOID NTAPI PipDeviceActionWorker(_In_opt_ PVOID Context)
Definition: devaction.c:2537
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 1089 of file devaction.c.
1092{
1093 PAGED_CODE();
1094
1095 LCID localeId;
1096
1097 // Get the Locale ID
1100 {
1102 return;
1103 }
1104
1105 // Step 1: Write the DeviceDesc value if does not exist
1106
1109
1110 status = ZwQueryValueKey(InstanceKey, &valDeviceDesc, KeyValueBasicInformation, NULL, 0, &len);
1112 {
1115
1117 {
1118 status = ZwSetValueKey(InstanceKey,
1119 &valDeviceDesc,
1120 0,
1121 REG_SZ,
1122 deviceDesc,
1124
1126 {
1128 }
1129 }
1130 else
1131 {
1132 // This key is mandatory, so even if the Irp fails, we still write it
1135
1136 status = ZwSetValueKey(InstanceKey,
1137 &valDeviceDesc,
1138 0,
1139 REG_SZ,
1140 unknownDeviceDesc.Buffer,
1141 unknownDeviceDesc.MaximumLength);
1143 {
1145 }
1146 }
1147
1148 if (deviceDesc)
1149 {
1150 ExFreePoolWithTag(deviceDesc, 0);
1151 }
1152 }
1153
1154 // Step 2: LocaltionInformation is overwritten unconditionally
1155
1158 localeId,
1160 &deviceLocationInfo);
1161
1163 {
1165
1166 status = ZwSetValueKey(InstanceKey,
1167 &valLocationInfo,
1168 0,
1169 REG_SZ,
1170 deviceLocationInfo,
1173 {
1175 }
1176 }
1177
1178 if (deviceLocationInfo)
1179 {
1180 ExFreePoolWithTag(deviceLocationInfo, 0);
1181 }
1182 else
1183 {
1185 }
1186}
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: hwresource.cpp:157
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@393::@402 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 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;
191 UNICODE_STRING DevicePath;
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 }
230 RtlInitEmptyUnicodeString(&DevicePath, NULL, 0);
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 }
373 RtlFreeUnicodeString(&DevicePath);
377}
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)
_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE QueryTable
Definition: rtlfuncs.h:4208
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
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:3275
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().
◆ 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 49 of file iomgr.c.
Referenced by IoGetFileObjectGenericMapping(), and IopCreateObjectTypes().
◆ IopMdlLookasideList
|
extern |
Definition at line 84 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().
