00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
#include "iop.h"
00027
#pragma hdrstop
00028
#include <ioevent.h>
00029
00030
00031
#if defined(_X86_)
00032
VOID
00033
RtlAssert(
00034 IN PVOID FailedAssertion,
00035 IN PVOID FileName,
00036 IN ULONG LineNumber,
00037 IN PCHAR Message OPTIONAL
00038 );
00039
#endif
00040
00041
00042 #define IsFileLocal( FileObject ) ( !((FileObject)->DeviceObject->Characteristics & FILE_REMOTE_DEVICE) )
00043
00044 typedef LINK_TRACKING_INFORMATION
FILE_VOLUMEID_WITH_TYPE, *
PFILE_VOLUMEID_WITH_TYPE;
00045
00046 typedef struct _TRACKING_BUFFER {
00047 FILE_TRACKING_INFORMATION
TrackingInformation;
00048 UCHAR
Buffer[256];
00049 }
TRACKING_BUFFER, *
PTRACKING_BUFFER;
00050
00051 typedef struct _REMOTE_LINK_BUFFER {
00052 REMOTE_LINK_TRACKING_INFORMATION
TrackingInformation;
00053 UCHAR
Buffer[256];
00054 }
REMOTE_LINK_BUFFER, *
PREMOTE_LINK_BUFFER;
00055
00056 PIRP IopDeadIrp;
00057
00058
NTSTATUS
00059
IopResurrectDriver(
00060
PDRIVER_OBJECT DriverObject
00061 );
00062
00063
VOID
00064
IopUserRundown(
00065 IN
PKAPC Apc
00066 );
00067
00068
VOID
00069
IopMarshalIds(
00070 OUT PTRACKING_BUFFER TrackingBuffer,
00071 IN PFILE_VOLUMEID_WITH_TYPE TargetVolumeId,
00072 IN PFILE_OBJECTID_BUFFER TargetObjectId,
00073 IN PFILE_TRACKING_INFORMATION TrackingInfo
00074 );
00075
00076
VOID
00077
IopUnMarshalIds(
00078 IN FILE_TRACKING_INFORMATION * TrackingInformation,
00079 OUT FILE_VOLUMEID_WITH_TYPE * TargetVolumeId,
00080 OUT GUID * TargetObjectId,
00081 OUT GUID * TargetMachineId
00082 );
00083
00084
NTSTATUS
00085
IopBootLogToFile(
00086 PUNICODE_STRING String
00087 );
00088
00089
VOID
00090
IopCopyBootLogRegistryToFile(
00091 VOID
00092 );
00093
00094
#ifdef ALLOC_PRAGMA
00095
#pragma alloc_text(PAGE, IopAbortRequest)
00096
#pragma alloc_text(PAGE, IopAcquireFileObjectLock)
00097
#pragma alloc_text(PAGE, IopAllocateIrpCleanup)
00098
#pragma alloc_text(PAGE, IopCancelAlertedRequest)
00099
#pragma alloc_text(PAGE, IopCheckGetQuotaBufferValidity)
00100
#pragma alloc_text(PAGE, IopConnectLinkTrackingPort)
00101
#pragma alloc_text(PAGE, IopDeallocateApc)
00102
#pragma alloc_text(PAGE, IopExceptionCleanup)
00103
#pragma alloc_text(PAGE, IopGetDriverNameFromKeyNode)
00104
#pragma alloc_text(PAGE, IopGetFileName)
00105
#pragma alloc_text(PAGE, IopGetRegistryKeyInformation)
00106
#pragma alloc_text(PAGE, IopGetRegistryValue)
00107
#pragma alloc_text(PAGE, IopGetRegistryValues)
00108
#pragma alloc_text(PAGE, IopGetSetObjectId)
00109
#pragma alloc_text(PAGE, IopGetVolumeId)
00110
#pragma alloc_text(PAGE, IopInvalidateVolumesForDevice)
00111
#pragma alloc_text(PAGE, IopIsSameMachine)
00112
#pragma alloc_text(PAGE, IopLoadDriver)
00113
#pragma alloc_text(PAGE, IopLoadFileSystemDriver)
00114
#pragma alloc_text(PAGE, IopLoadUnloadDriver)
00115
#pragma alloc_text(PAGE, IopMountVolume)
00116
#pragma alloc_text(PAGE, IopMarshalIds)
00117
#pragma alloc_text(PAGE, IopOpenLinkOrRenameTarget)
00118
#pragma alloc_text(PAGE, IopOpenRegistryKey)
00119
#pragma alloc_text(PAGE, IopQueryXxxInformation)
00120
#pragma alloc_text(PAGE, IopReadyDeviceObjects)
00121
#pragma alloc_text(PAGE, IopSendMessageToTrackService)
00122
#pragma alloc_text(PAGE, IopSetEaOrQuotaInformationFile)
00123
#pragma alloc_text(PAGE, IopSetRemoteLink)
00124
#pragma alloc_text(PAGE, IopSynchronousApiServiceTail)
00125
#pragma alloc_text(PAGE, IopSynchronousServiceTail)
00126
#pragma alloc_text(PAGE, IopTrackLink)
00127
#pragma alloc_text(PAGE, IopUnMarshalIds)
00128
#pragma alloc_text(PAGE, IopUserCompletion)
00129
#pragma alloc_text(PAGE, IopUserRundown)
00130
#pragma alloc_text(PAGE, IopXxxControlFile)
00131
#pragma alloc_text(PAGE, IopLookupBusStringFromID)
00132
#pragma alloc_text(PAGE, IopInitializeBootLogging)
00133
#pragma alloc_text(PAGE, IopBootLog)
00134
#pragma alloc_text(PAGE, IopCopyBootLogRegistryToFile)
00135
#pragma alloc_text(PAGE, IopBootLogToFile)
00136
#endif
00137
00138
00139
00140
00141
00142
00143
VOID
00144 IopAbortRequest(
00145 IN
PKAPC Apc
00146 )
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166 {
00167
PAGED_CODE();
00168
00169
00170
00171
00172
00173
IopCompleteRequest( Apc,
00174 &Apc->NormalRoutine,
00175 &Apc->NormalContext,
00176 &Apc->SystemArgument1,
00177 &Apc->SystemArgument2 );
00178 }
00179
00180
NTSTATUS
00181 IopAcquireFileObjectLock(
00182 IN
PFILE_OBJECT FileObject,
00183 IN KPROCESSOR_MODE RequestorMode,
00184 IN BOOLEAN Alertable,
00185 OUT PBOOLEAN Interrupted
00186 )
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213 {
00214
NTSTATUS status;
00215
00216
PAGED_CODE();
00217
00218
00219
00220
00221
00222
00223 *Interrupted =
FALSE;
00224
00225
00226
00227
00228
00229 InterlockedIncrement (&FileObject->Waiters);
00230
00231
for (;;) {
00232
if (!FileObject->Busy) {
00233
00234
00235
00236
00237
00238
if (
IopAcquireFastLock ( FileObject ) ) {
00239
00240
00241
00242
00243
00244 InterlockedDecrement (&FileObject->Waiters);
00245
return STATUS_SUCCESS;
00246 }
00247 }
00248
00249
00250
00251
00252
00253
00254 status =
KeWaitForSingleObject( &FileObject->Lock,
00255
Executive,
00256 RequestorMode,
00257 Alertable,
00258 (PLARGE_INTEGER)
NULL );
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
if (status == STATUS_USER_APC || status == STATUS_ALERTED) {
00270 InterlockedDecrement (&FileObject->Waiters);
00271
00272
if (!FileObject->Busy && FileObject->Waiters) {
00273
KeSetEvent( &FileObject->Lock, 0,
FALSE );
00274
00275 }
00276 *Interrupted =
TRUE;
00277
return status;
00278 }
00279 }
00280 }
00281
00282
00283
VOID
00284 IopAllocateIrpCleanup(
00285 IN
PFILE_OBJECT FileObject,
00286 IN
PKEVENT EventObject OPTIONAL
00287 )
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310 {
00311
PAGED_CODE();
00312
00313
00314
00315
00316
00317
if (ARGUMENT_PRESENT( EventObject )) {
00318
ObDereferenceObject( EventObject );
00319 }
00320
00321
00322
00323
00324
00325
00326
if (FileObject->Flags &
FO_SYNCHRONOUS_IO) {
00327
IopReleaseFileObjectLock( FileObject );
00328 }
00329
00330
ObDereferenceObject( FileObject );
00331
00332
return;
00333 }
00334
00335
PIRP
00336 IopAllocateIrpMustSucceed(
00337 IN CCHAR StackSize
00338 )
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362 {
00363
PIRP irp;
00364
USHORT packetSize;
00365
00366
00367
00368
00369
00370
00371 irp =
IoAllocateIrp(StackSize,
FALSE);
00372
if (!irp) {
00373 packetSize =
IoSizeOfIrp(StackSize);
00374 irp =
ExAllocatePoolWithTag(
NonPagedPoolMustSucceed, packetSize, ' prI');
00375
IoInitializeIrp(irp, packetSize, StackSize);
00376 irp->
AllocationFlags |=
IRP_ALLOCATED_MUST_SUCCEED;
00377 }
00378
00379
return irp;
00380 }
00381
00382
VOID
00383 IopApcHardError(
00384 IN PVOID StartContext
00385 )
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405 {
00406
PIOP_APC_HARD_ERROR_PACKET packet;
00407
00408 packet = StartContext;
00409
00410
IopRaiseHardError( packet->
Irp, packet->
Vpb, packet->
RealDeviceObject );
00411
00412
ExFreePool( packet );
00413 }
00414
00415
00416
VOID
00417 IopCancelAlertedRequest(
00418 IN
PKEVENT Event,
00419 IN
PIRP Irp
00420 )
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446 {
00447 KIRQL irql;
00448 LARGE_INTEGER deltaTime;
00449 BOOLEAN canceled;
00450
00451
PAGED_CODE();
00452
00453
00454
00455
00456
00457
00458
KeRaiseIrql(
APC_LEVEL, &irql );
00459
00460
00461
00462
00463
00464
00465
if (
KeReadStateEvent(
Event ) == 0) {
00466
00467
00468
00469
00470
00471 canceled =
IoCancelIrp(
Irp );
00472
00473
KeLowerIrql( irql );
00474
00475
if (canceled) {
00476
00477
00478
00479
00480
00481
00482
00483 deltaTime.QuadPart = - 10 * 1000 * 10;
00484
00485
while (
KeReadStateEvent(
Event ) == 0) {
00486
00487
KeDelayExecutionThread(
KernelMode,
FALSE, &deltaTime );
00488
00489 }
00490
00491 }
else {
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503 (
VOID)
KeWaitForSingleObject(
Event,
00504
Executive,
00505
KernelMode,
00506
FALSE,
00507 (PLARGE_INTEGER)
NULL );
00508
00509 }
00510
00511 }
else {
00512
00513
00514
00515
00516
00517
00518
KeLowerIrql( irql );
00519
00520 }
00521 }
00522
00523
NTSTATUS
00524 IopCheckGetQuotaBufferValidity(
00525 IN PFILE_GET_QUOTA_INFORMATION QuotaBuffer,
00526 IN ULONG QuotaLength,
00527 OUT PULONG_PTR ErrorOffset
00528 )
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556 {
00557
00558
#define GET_OFFSET_LENGTH( CurrentSid, SidBase ) ( (ULONG) ((PCHAR) CurrentSid - (PCHAR) SidBase) )
00559
00560 LONG tempLength;
00561 LONG entrySize;
00562 PFILE_GET_QUOTA_INFORMATION sids;
00563
00564
PAGED_CODE();
00565
00566
00567
00568
00569
00570
00571 sids = QuotaBuffer;
00572 tempLength = QuotaLength;
00573
00574
for (;;) {
00575
00576
00577
00578
00579
00580
if ((tempLength < (LONG) (FIELD_OFFSET(FILE_GET_QUOTA_INFORMATION, Sid.SubAuthority) +
00581
sizeof (sids->Sid.SubAuthority))) ||
00582 !
RtlValidSid( &sids->Sid)) {
00583
00584 *ErrorOffset =
GET_OFFSET_LENGTH( sids, QuotaBuffer );
00585
return STATUS_QUOTA_LIST_INCONSISTENT;
00586 }
00587
00588
00589
00590
00591
00592 entrySize = FIELD_OFFSET( FILE_GET_QUOTA_INFORMATION, Sid ) +
RtlLengthSid( (&sids->Sid) );
00593
00594
if (sids->NextEntryOffset) {
00595
00596
00597
00598
00599
00600
00601
00602
if (entrySize > (LONG) sids->NextEntryOffset ||
00603 sids->NextEntryOffset & (
sizeof( ULONG ) - 1)) {
00604 *ErrorOffset =
GET_OFFSET_LENGTH( sids, QuotaBuffer );
00605
return STATUS_QUOTA_LIST_INCONSISTENT;
00606
00607 }
else {
00608
00609
00610
00611
00612
00613
00614
00615 tempLength -= sids->NextEntryOffset;
00616
if (tempLength < 0) {
00617 *ErrorOffset =
GET_OFFSET_LENGTH( sids, QuotaBuffer );
00618
return STATUS_QUOTA_LIST_INCONSISTENT;
00619 }
00620 sids = (PFILE_GET_QUOTA_INFORMATION) ((PCHAR) sids + sids->NextEntryOffset);
00621 }
00622
00623 }
else {
00624
00625
00626
00627
00628
00629
00630
00631 tempLength -= entrySize;
00632
break;
00633 }
00634 }
00635
00636
00637
00638
00639
00640
00641
00642
if (tempLength < 0) {
00643 *ErrorOffset =
GET_OFFSET_LENGTH( sids, QuotaBuffer );
00644
return STATUS_QUOTA_LIST_INCONSISTENT;
00645 }
00646
00647
00648
00649
00650
00651
00652
return STATUS_SUCCESS;
00653 }
00654
00655
00656
VOID
00657 IopCompleteUnloadOrDelete(
00658 IN
PDEVICE_OBJECT DeviceObject,
00659 IN KIRQL Irql
00660 )
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689 {
00690
PDRIVER_OBJECT driverObject;
00691
PDEVICE_OBJECT deviceObject;
00692
PDEVICE_OBJECT baseDeviceObject;
00693
PDEVICE_OBJECT attachedDeviceObject;
00694
PDEVOBJ_EXTENSION deviceExtension;
00695
PDEVICE_NODE deviceNode;
00696
00697 BOOLEAN unload =
TRUE;
00698
00699 driverObject = DeviceObject->DriverObject;
00700
00701
if (DeviceObject->DeviceObjectExtension->ExtensionFlags &
DOE_REMOVE_PENDING) {
00702
00703
00704
00705
00706
00707
00708 baseDeviceObject =
IopGetDeviceAttachmentBase( DeviceObject );
00709 deviceExtension = baseDeviceObject->
DeviceObjectExtension;
00710 deviceNode = (
PDEVICE_NODE)deviceExtension->
DeviceNode;
00711
00712
ASSERT(deviceNode !=
NULL);
00713
00714
00715
00716
00717
00718
00719
ASSERT(deviceNode->
Flags &
DNF_REMOVE_PENDING_CLOSES);
00720
00721
00722
00723
00724
00725
00726 attachedDeviceObject = baseDeviceObject;
00727
while (attachedDeviceObject !=
NULL) {
00728
00729
if (attachedDeviceObject->
ReferenceCount != 0) {
00730
00731
00732
00733
00734
00735
00736 ExReleaseSpinLock( &
IopDatabaseLock, Irql );
00737
00738
return;
00739 }
00740 attachedDeviceObject = attachedDeviceObject->
AttachedDevice;
00741 }
00742
00743
00744
00745
00746
00747
00748 attachedDeviceObject = baseDeviceObject;
00749
while (attachedDeviceObject !=
NULL) {
00750
00751 deviceExtension = attachedDeviceObject->
DeviceObjectExtension;
00752
00753 deviceExtension->
ExtensionFlags &= ~
DOE_REMOVE_PENDING;
00754 deviceExtension->
ExtensionFlags |=
DOE_REMOVE_PROCESSED;
00755
00756 attachedDeviceObject = attachedDeviceObject->
AttachedDevice;
00757 }
00758
00759
00760
00761
00762
00763
00764 ExReleaseSpinLock( &
IopDatabaseLock, Irql );
00765
00766
IopChainDereferenceComplete( baseDeviceObject );
00767
00768
return;
00769 }
00770
00771
if (DeviceObject->DeviceObjectExtension->ExtensionFlags &
DOE_DELETE_PENDING) {
00772
00773
if ((DeviceObject->DeviceObjectExtension->ExtensionFlags &
00774
DOE_UNLOAD_PENDING) == 0 ||
00775 driverObject->
Flags &
DRVO_UNLOAD_INVOKED) {
00776
00777 unload =
FALSE;
00778 }
00779
00780
00781
00782
00783
00784
00785
if (DeviceObject->AttachedDevice) {
00786
PFAST_IO_DISPATCH fastIoDispatch = DeviceObject->AttachedDevice->DriverObject->FastIoDispatch;
00787
PDEVICE_OBJECT attachedDevice = DeviceObject->AttachedDevice;
00788
00789
00790
00791
00792
00793
00794 DeviceObject->ReferenceCount++;
00795
00796 ExReleaseSpinLock( &
IopDatabaseLock, Irql );
00797
00798
if (fastIoDispatch &&
00799 fastIoDispatch->
SizeOfFastIoDispatch > FIELD_OFFSET(
FAST_IO_DISPATCH, FastIoDetachDevice ) &&
00800 fastIoDispatch->
FastIoDetachDevice) {
00801 (fastIoDispatch->
FastIoDetachDevice)( attachedDevice, DeviceObject );
00802 }
00803
00804 ExAcquireSpinLock( &
IopDatabaseLock, &Irql );
00805
00806
00807
00808
00809
00810 DeviceObject->ReferenceCount--;
00811
00812
if (DeviceObject->AttachedDevice ||
00813 DeviceObject->ReferenceCount != 0) {
00814
00815
00816 ExReleaseSpinLock( &
IopDatabaseLock, Irql );
00817
return;
00818 }
00819 }
00820
00821 ExReleaseSpinLock( &
IopDatabaseLock, Irql );
00822
00823
00824
00825
00826
00827
00828
if (DeviceObject->SecurityDescriptor != (PSECURITY_DESCRIPTOR)
NULL) {
00829
ExFreePool( DeviceObject->SecurityDescriptor );
00830 }
00831
00832
00833
00834
00835
00836
IopInsertRemoveDevice( DeviceObject->DriverObject, DeviceObject,
FALSE );
00837
00838
00839
00840
00841
00842
ObDereferenceObject( DeviceObject );
00843
00844
00845
00846
00847
00848
if (!unload) {
00849
return;
00850 }
00851
00852
00853
00854
00855
00856
00857 ExAcquireSpinLock( &
IopDatabaseLock, &Irql );
00858
00859
if (driverObject->
Flags &
DRVO_UNLOAD_INVOKED) {
00860
00861
00862
00863
00864
00865 ExReleaseSpinLock( &
IopDatabaseLock, Irql );
00866
return;
00867 }
00868 }
00869
00870
00871
00872
00873
00874
00875
00876 deviceObject = driverObject->
DeviceObject;
00877
00878
while (deviceObject) {
00879
if (deviceObject->
ReferenceCount || deviceObject->
AttachedDevice ||
00880 deviceObject->
DeviceObjectExtension->
ExtensionFlags & (
DOE_DELETE_PENDING |
DOE_REMOVE_PENDING)) {
00881 unload =
FALSE;
00882
break;
00883 }
00884 deviceObject = deviceObject->
NextDevice;
00885 }
00886
00887
if (unload) {
00888 driverObject->
Flags |=
DRVO_UNLOAD_INVOKED;
00889 }
00890
00891 ExReleaseSpinLock( &
IopDatabaseLock, Irql );
00892
00893
00894
00895
00896
00897
00898
if (unload) {
00899
LOAD_PACKET loadPacket;
00900
00901
KeInitializeEvent( &loadPacket.
Event, NotificationEvent,
FALSE );
00902 loadPacket.
DriverObject = driverObject;
00903
ExInitializeWorkItem( &loadPacket.
WorkQueueItem,
00904
IopLoadUnloadDriver,
00905 &loadPacket );
00906
ExQueueWorkItem( &loadPacket.
WorkQueueItem,
DelayedWorkQueue );
00907 (
VOID)
KeWaitForSingleObject( &loadPacket.
Event,
00908
Executive,
00909
KernelMode,
00910
FALSE,
00911 (PLARGE_INTEGER)
NULL );
00912
00913
ObMakeTemporaryObject( driverObject );
00914
ObDereferenceObject( driverObject );
00915 }
00916 }
00917
00918
VOID
00919 IopCompletePageWrite(
00920 IN
PKAPC Apc,
00921 IN PKNORMAL_ROUTINE *NormalRoutine,
00922 IN PVOID *NormalContext,
00923 IN PVOID *SystemArgument1,
00924 IN PVOID *SystemArgument2
00925 )
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963 {
00964
PIRP irp;
00965 PIO_APC_ROUTINE apcRoutine;
00966 PVOID apcContext;
00967 PIO_STATUS_BLOCK ioStatus;
00968
00969 UNREFERENCED_PARAMETER( NormalRoutine );
00970 UNREFERENCED_PARAMETER( NormalContext );
00971 UNREFERENCED_PARAMETER( SystemArgument1 );
00972 UNREFERENCED_PARAMETER( SystemArgument2 );
00973
00974
00975
00976
00977
00978 irp = CONTAINING_RECORD( Apc,
IRP, Tail.Apc );
00979
00980
00981
00982
00983
00984
00985
00986
if (!irp->
PendingReturned &&
NT_ERROR( irp->
IoStatus.Status )) {
00987
IoFreeIrp( irp );
00988
return;
00989 }
00990
00991
00992
00993
00994
00995 *irp->
UserIosb = irp->
IoStatus;
00996
00997
00998
00999
01000
01001
01002 apcRoutine = irp->
Overlay.AsynchronousParameters.UserApcRoutine;
01003 apcContext = irp->
Overlay.AsynchronousParameters.UserApcContext;
01004 ioStatus = irp->
UserIosb;
01005
01006
IoFreeIrp( irp );
01007
01008
01009
01010
01011
01012 apcRoutine( apcContext, ioStatus, 0 );
01013
01014
return;
01015 }
01016
01017
01018
VOID
01019 IopCompleteRequest(
01020 IN
PKAPC Apc,
01021 IN PKNORMAL_ROUTINE *NormalRoutine,
01022 IN PVOID *NormalContext,
01023 IN PVOID *SystemArgument1,
01024 IN PVOID *SystemArgument2
01025 )
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080 {
01081
#define SynchronousIo( Irp, FileObject ) ( \
01082
(Irp->Flags & IRP_SYNCHRONOUS_API) || \
01083
(FileObject == NULL ? 0 : FileObject->Flags & FO_SYNCHRONOUS_IO) )
01084
01085
PIRP irp;
01086
PMDL mdl, nextMdl;
01087
PETHREAD thread;
01088
PFILE_OBJECT fileObject;
01089
NTSTATUS status;
01090
01091 UNREFERENCED_PARAMETER( NormalRoutine );
01092 UNREFERENCED_PARAMETER( NormalContext );
01093
01094
01095
01096
01097
01098
01099
01100 irp = CONTAINING_RECORD( Apc,
IRP, Tail.Apc );
01101 thread =
PsGetCurrentThread();
01102 fileObject = (
PFILE_OBJECT) *SystemArgument1;
01103
01104
IOVP_COMPLETE_REQUEST(Apc, SystemArgument1, SystemArgument2);
01105
01106
01107
01108
01109
01110
01111
01112
ASSERT( irp->
IoStatus.Status != 0xffffffff );
01113
01114
01115
01116
01117
01118
if ( *SystemArgument2 !=
NULL ) {
01119
01120 PREPARSE_DATA_BUFFER reparseBuffer =
NULL;
01121
01122
01123
01124
01125
01126
if ( irp->
IoStatus.Status == STATUS_REPARSE &&
01127 irp->
IoStatus.Information == IO_REPARSE_TAG_MOUNT_POINT ) {
01128
01129 reparseBuffer = (PREPARSE_DATA_BUFFER) *SystemArgument2;
01130
01131
ASSERT( reparseBuffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT );
01132
ASSERT( reparseBuffer->ReparseDataLength < MAXIMUM_REPARSE_DATA_BUFFER_SIZE );
01133
ASSERT( reparseBuffer->Reserved < MAXIMUM_REPARSE_DATA_BUFFER_SIZE );
01134
01135
IopDoNameTransmogrify( irp,
01136 fileObject,
01137 reparseBuffer );
01138 }
01139 }
01140
01141
01142
01143
01144
01145
01146
01147
if (irp->
Flags &
IRP_BUFFERED_IO) {
01148
01149
01150
01151
01152
01153
01154
01155
if (irp->
Flags &
IRP_INPUT_OPERATION &&
01156 irp->
IoStatus.Status != STATUS_VERIFY_REQUIRED &&
01157 !
NT_ERROR( irp->
IoStatus.Status )) {
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
try {
01168 RtlCopyMemory( irp->
UserBuffer,
01169 irp->
AssociatedIrp.SystemBuffer,
01170 irp->
IoStatus.Information );
01171 } except(
IopExceptionFilter(GetExceptionInformation(), &status)) {
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181
01182
if (status == STATUS_MULTIPLE_FAULT_VIOLATION) {
01183 irp->
Tail.Overlay.OriginalFileObject = fileObject;
01184 irp->
Flags |=
IRP_RETRY_IO_COMPLETION;
01185
return;
01186 }
01187 irp->
IoStatus.Status = GetExceptionCode();
01188 }
01189 }
01190
01191
01192
01193
01194
01195
if (irp->
Flags &
IRP_DEALLOCATE_BUFFER) {
01196
ExFreePool( irp->
AssociatedIrp.SystemBuffer );
01197 }
01198 }
01199
01200 irp->
Flags &= ~(
IRP_DEALLOCATE_BUFFER|
IRP_BUFFERED_IO);
01201
01202
01203
01204
01205
01206
01207
01208
if (irp->
MdlAddress) {
01209
for (mdl = irp->
MdlAddress; mdl !=
NULL; mdl = nextMdl) {
01210 nextMdl = mdl->
Next;
01211
IoFreeMdl( mdl );
01212 }
01213 }
01214
01215 irp->
MdlAddress =
NULL;
01216
01217
01218
01219
01220
01221
01222
01223
if (!
NT_ERROR( irp->
IoStatus.Status ) ||
01224 (
NT_ERROR( irp->
IoStatus.Status ) &&
01225 irp->
PendingReturned &&
01226 !
SynchronousIo( irp, fileObject ))) {
01227
01228 PVOID port =
NULL;
01229 PVOID key;
01230 BOOLEAN createOperation =
FALSE;
01231
01232
01233
01234
01235
01236
01237
if (fileObject && fileObject->
CompletionContext) {
01238 port = fileObject->
CompletionContext->
Port;
01239 key = fileObject->
CompletionContext->
Key;
01240 }
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254
try {
01255
01256
01257
01258
01259
01260
01261
01262
01263
#if defined(_M_ALPHA) && !defined(NT_UP)
01264
#define MEMORY_BARRIER() __MB()
01265
#else
01266
#define MEMORY_BARRIER()
01267
#endif
01268
01269
#if defined(_WIN64)
01270
PIO_STATUS_BLOCK32 UserIosb32;
01271
01272
01273
01274
01275
if ((ULONG_PTR)(irp->
Overlay.AsynchronousParameters.UserApcRoutine) & 1) {
01276 UserIosb32 = (PIO_STATUS_BLOCK32)irp->
UserIosb;
01277
01278 UserIosb32->Information = (ULONG)irp->
IoStatus.Information;
01279
MEMORY_BARRIER();
01280 UserIosb32->Status = (
NTSTATUS)irp->
IoStatus.Status;
01281 }
else {
01282 irp->
UserIosb->Information = irp->
IoStatus.Information;
01283
MEMORY_BARRIER();
01284 irp->
UserIosb->Status = irp->
IoStatus.Status;
01285 }
01286
#else
01287
irp->
UserIosb->Information = irp->
IoStatus.Information;
01288
MEMORY_BARRIER();
01289 irp->
UserIosb->Status = irp->
IoStatus.Status;
01290
#endif
01291
01292 } except(
IopExceptionFilter(GetExceptionInformation(), &status)) {
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
if (status == STATUS_MULTIPLE_FAULT_VIOLATION) {
01304 irp->
Tail.Overlay.OriginalFileObject = fileObject;
01305 irp->
Flags |=
IRP_RETRY_IO_COMPLETION;
01306
return;
01307 }
01308 }
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
if (irp->
UserEvent) {
01333 (
VOID)
KeSetEvent( irp->
UserEvent, 0,
FALSE );
01334
if (fileObject) {
01335
if (!(irp->
Flags &
IRP_SYNCHRONOUS_API)) {
01336
ObDereferenceObject( irp->
UserEvent );
01337 }
01338
if (fileObject->
Flags &
FO_SYNCHRONOUS_IO && !(irp->
Flags &
IRP_OB_QUERY_NAME)) {
01339 (
VOID)
KeSetEvent( &fileObject->
Event, 0,
FALSE );
01340 fileObject->
FinalStatus = irp->
IoStatus.Status;
01341 }
01342
if (irp->
Flags &
IRP_CREATE_OPERATION) {
01343 createOperation =
TRUE;
01344 irp->
Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)
NULL;
01345 }
01346 }
01347 }
else if (fileObject) {
01348 (
VOID)
KeSetEvent( &fileObject->
Event, 0,
FALSE );
01349 fileObject->
FinalStatus = irp->
IoStatus.Status;
01350
if (irp->
Flags &
IRP_CREATE_OPERATION) {
01351 createOperation =
TRUE;
01352 irp->
Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)
NULL;
01353 }
01354 }
01355
01356
01357
01358
01359
01360
if (!(irp->
Flags &
IRP_CREATE_OPERATION)) {
01361
if (irp->
Flags &
IRP_READ_OPERATION) {
01362
IopUpdateReadTransferCount( (ULONG) irp->
IoStatus.Information );
01363 }
else if (irp->
Flags &
IRP_WRITE_OPERATION) {
01364
IopUpdateWriteTransferCount( (ULONG) irp->
IoStatus.Information );
01365 }
else {
01366
01367
01368
01369
01370
if (!((ULONG) irp->
IoStatus.Information & 0x80000000)) {
01371
IopUpdateOtherTransferCount( (ULONG) irp->
IoStatus.Information );
01372 }
01373 }
01374 }
01375
01376
01377
01378
01379
01380
IopDequeueThreadIrp( irp );
01381
01382
01383
01384
01385
01386
01387
#ifdef _WIN64
01388
01389
01390
01391
01392 irp->
Overlay.AsynchronousParameters.UserApcRoutine =
01393 (PIO_APC_ROUTINE)((LONG_PTR)(irp->
Overlay.AsynchronousParameters.UserApcRoutine) & ~1);
01394
#endif
01395
01396
if (irp->
Overlay.AsynchronousParameters.UserApcRoutine) {
01397
KeInitializeApc( &irp->
Tail.Apc,
01398 &thread->
Tcb,
01399
CurrentApcEnvironment,
01400
IopUserCompletion,
01401 (
PKRUNDOWN_ROUTINE)
IopUserRundown,
01402 (
PKNORMAL_ROUTINE) irp->
Overlay.AsynchronousParameters.UserApcRoutine,
01403 irp->
RequestorMode,
01404 irp->
Overlay.AsynchronousParameters.UserApcContext );
01405
01406
KeInsertQueueApc( &irp->
Tail.Apc,
01407 irp->
UserIosb,
01408
NULL,
01409 2 );
01410
01411 }
else if (port && irp->
Overlay.AsynchronousParameters.UserApcContext) {
01412
01413
01414
01415
01416
01417
01418 irp->
Tail.CompletionKey = key;
01419 irp->
Tail.Overlay.PacketType =
IopCompletionPacketIrp;
01420
01421
KeInsertQueue( (
PKQUEUE) port,
01422 &irp->
Tail.Overlay.ListEntry );
01423
01424 }
else {
01425
01426
01427
01428
01429
01430
IoFreeIrp( irp );
01431 }
01432
01433
if (fileObject && !createOperation) {
01434
01435
01436
01437
01438
01439
ObDereferenceObject( fileObject );
01440 }
01441
01442 }
else {
01443
01444
if (irp->
PendingReturned && fileObject) {
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464
if (irp->
Flags &
IRP_SYNCHRONOUS_API) {
01465 *irp->
UserIosb = irp->
IoStatus;
01466
if (irp->
UserEvent) {
01467 (
VOID)
KeSetEvent( irp->
UserEvent, 0,
FALSE );
01468 }
else {
01469 (
VOID)
KeSetEvent( &fileObject->
Event, 0,
FALSE );
01470 }
01471 }
else {
01472 fileObject->
FinalStatus = irp->
IoStatus.Status;
01473 (
VOID)
KeSetEvent( &fileObject->
Event, 0,
FALSE );
01474 }
01475 }
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488
if (fileObject) {
01489
if (!(irp->
Flags &
IRP_CREATE_OPERATION)) {
01490
ObDereferenceObject( fileObject );
01491 }
01492 }
01493
01494
if (irp->
UserEvent &&
01495 fileObject &&
01496 !(irp->
Flags &
IRP_SYNCHRONOUS_API)) {
01497
ObDereferenceObject( irp->
UserEvent );
01498 }
01499
01500
IopDequeueThreadIrp( irp );
01501
IoFreeIrp( irp );
01502 }
01503 }
01504
01505
VOID
01506 IopConnectLinkTrackingPort(
01507 IN PVOID Parameter
01508 )
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529 {
01530
#define MESSAGE_SIZE ( (2 * sizeof( FILE_VOLUMEID_WITH_TYPE )) + \
01531
sizeof( FILE_OBJECTID_BUFFER ) + \
01532
sizeof( GUID ) + \
01533
sizeof( NTSTATUS ) + \
01534
sizeof( ULONG ) )
01535
01536
PLINK_TRACKING_PACKET ltp;
01537 HANDLE serviceHandle;
01538
NTSTATUS status;
01539
01540
PAGED_CODE();
01541
01542
01543
01544
01545 ltp = (
PLINK_TRACKING_PACKET) Parameter;
01546
01547
01548
01549
01550
01551
01552 status = STATUS_SUCCESS;
01553
if (!
IopLinkTrackingServiceObject) {
01554
01555 UNICODE_STRING portName;
01556 ULONG maxMessageLength;
01557 SECURITY_QUALITY_OF_SERVICE dynamicQos;
01558
01559
if (
KeReadStateEvent(
IopLinkTrackingServiceEvent )) {
01560
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571 dynamicQos.ImpersonationLevel = SecurityImpersonation;
01572 dynamicQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
01573 dynamicQos.EffectiveOnly =
TRUE;
01574
01575
01576
01577
01578
01579
RtlInitUnicodeString( &portName,
L"\\Security\\TRKWKS_PORT" );
01580
01581 status =
NtConnectPort( &serviceHandle,
01582 &portName,
01583 &dynamicQos,
01584 (PPORT_VIEW)
NULL,
01585 (PREMOTE_PORT_VIEW)
NULL,
01586 &maxMessageLength,
01587 (PVOID)
NULL,
01588 (PULONG)
NULL );
01589
if (
NT_SUCCESS( status )) {
01590
if (maxMessageLength >=
MESSAGE_SIZE) {
01591 status =
ObReferenceObjectByHandle( serviceHandle,
01592 0,
01593
LpcPortObjectType,
01594
KernelMode,
01595 &
IopLinkTrackingServiceObject,
01596
NULL );
01597
NtClose( serviceHandle );
01598 }
else {
01599
NtClose( serviceHandle );
01600 status = STATUS_INVALID_PARAMETER;
01601 }
01602 }
01603
01604 }
else {
01605
01606
01607
01608
01609
01610 status = STATUS_OBJECT_NAME_NOT_FOUND;
01611 }
01612 }
01613
01614
01615
01616
01617
01618 ltp->
FinalStatus = status;
01619
KeSetEvent( <p->
Event, 0,
FALSE );
01620 }
01621
01622
VOID
01623 IopDisassociateThreadIrp(
01624 VOID
01625 )
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647 {
01648 KIRQL irql;
01649 KIRQL spIrql;
01650
PIRP irp;
01651
PETHREAD thread;
01652 PLIST_ENTRY entry;
01653
PIO_STACK_LOCATION irpSp;
01654
PDEVICE_OBJECT deviceObject;
01655
PDRIVER_OBJECT driverObject;
01656 WCHAR buffer[512];
01657 POBJECT_NAME_INFORMATION nameInformation;
01658 ULONG nameLength;
01659
NTSTATUS status;
01660 ULONG response;
01661 PIO_ERROR_LOG_PACKET errorLogEntry;
01662
01663
01664
01665
01666
01667
01668
KeRaiseIrql(
APC_LEVEL, &irql );
01669
01670 thread =
PsGetCurrentThread();
01671
01672
01673
01674
01675
01676
01677
01678
if (IsListEmpty( &thread->
IrpList )) {
01679
KeLowerIrql( irql );
01680
return;
01681 }
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694
01695
01696 ExAcquireSpinLock( &
IopCompletionLock, &spIrql );
01697
01698
01699
01700
01701
01702
01703 entry = thread->
IrpList.Flink;
01704 irp = CONTAINING_RECORD( entry,
IRP, ThreadListEntry );
01705
01706
if (irp->
CurrentLocation == irp->
StackCount + 2) {
01707
01708
01709
01710
01711
01712
01713
01714 ExReleaseSpinLock( &
IopCompletionLock, spIrql );
01715
KeLowerIrql( irql );
01716
return;
01717 }
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01735
01736
IopDeadIrp = irp;
01737
01738 irp->
Tail.Overlay.Thread = (
PETHREAD)
NULL;
01739 entry = RemoveHeadList( &thread->
IrpList );
01740
01741
01742
01743 InitializeListHead (&(irp)->ThreadListEntry);
01744
01745 irpSp =
IoGetCurrentIrpStackLocation( irp );
01746
if (irp->CurrentLocation <= irp->StackCount) {
01747 deviceObject = irpSp->
DeviceObject;
01748 }
else {
01749 deviceObject = (
PDEVICE_OBJECT)
NULL;
01750 }
01751 ExReleaseSpinLock( &
IopCompletionLock, spIrql );
01752
KeLowerIrql( irql );
01753
01754
01755
01756
01757
01758
01759
if (deviceObject) {
01760 errorLogEntry =
IoAllocateErrorLogEntry(deviceObject,
sizeof(IO_ERROR_LOG_PACKET));
01761
if (errorLogEntry) {
01762 errorLogEntry->ErrorCode = IO_DRIVER_CANCEL_TIMEOUT;
01763
IoWriteErrorLogEntry(errorLogEntry);
01764 }
01765 }
01766
01767
return;
01768 }
01769
01770
VOID
01771 IopDeallocateApc(
01772 IN
PKAPC Apc,
01773 IN PKNORMAL_ROUTINE *NormalRoutine,
01774 IN PVOID *NormalContext,
01775 IN PVOID *SystemArgument1,
01776 IN PVOID *SystemArgument2
01777 )
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803
01804
01805 {
01806 UNREFERENCED_PARAMETER( NormalRoutine );
01807 UNREFERENCED_PARAMETER( NormalContext );
01808 UNREFERENCED_PARAMETER( SystemArgument1 );
01809 UNREFERENCED_PARAMETER( SystemArgument2 );
01810
01811
PAGED_CODE();
01812
01813
01814
01815
01816
01817
ExFreePool( Apc );
01818 }
01819
01820
VOID
01821 IopDropIrp(
01822 IN
PIRP Irp,
01823 IN
PFILE_OBJECT FileObject
01824 )
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846 {
01847
PMDL mdl;
01848
PMDL nextMdl;
01849
01850
01851
01852
01853
01854
if (
Irp->
Flags &
IRP_DEALLOCATE_BUFFER) {
01855
ExFreePool(
Irp->
AssociatedIrp.SystemBuffer );
01856 }
01857
01858
if (
Irp->
MdlAddress) {
01859
for (mdl =
Irp->
MdlAddress; mdl; mdl = nextMdl) {
01860 nextMdl = mdl->
Next;
01861
IoFreeMdl( mdl );
01862 }
01863 }
01864
01865
if (
Irp->
UserEvent &&
01866 FileObject &&
01867 !(
Irp->
Flags &
IRP_SYNCHRONOUS_API)) {
01868
ObDereferenceObject(
Irp->
UserEvent );
01869 }
01870
01871
if (FileObject && !(
Irp->
Flags &
IRP_CREATE_OPERATION)) {
01872
ObDereferenceObject( FileObject );
01873 }
01874
01875
01876
01877
01878
01879
IoFreeIrp(
Irp );
01880 }
01881
01882 LONG
01883 IopExceptionFilter(
01884 IN PEXCEPTION_POINTERS ExceptionPointer,
01885 OUT PNTSTATUS ExceptionCode
01886 )
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910 {
01911
01912
01913
01914
01915
01916 *ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
01917
if (*ExceptionCode == STATUS_IN_PAGE_ERROR &&
01918 ExceptionPointer->ExceptionRecord->NumberParameters >= 3) {
01919 *ExceptionCode = (LONG) ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
01920 }
01921
01922
01923
01924
01925
01926
if (*ExceptionCode == STATUS_DATATYPE_MISALIGNMENT) {
01927 *ExceptionCode = STATUS_DATATYPE_MISALIGNMENT_ERROR;
01928 }
01929
01930
return EXCEPTION_EXECUTE_HANDLER;
01931 }
01932
01933
VOID
01934 IopExceptionCleanup(
01935 IN
PFILE_OBJECT FileObject,
01936 IN
PIRP Irp,
01937 IN
PKEVENT EventObject OPTIONAL,
01938 IN
PKEVENT KernelEvent OPTIONAL
01939 )
01940
01941
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958
01959
01960
01961
01962
01963
01964
01965
01966
01967
01968
01969
01970
01971
01972
01973
01974
01975
01976
01977
01978
01979
01980 {
01981
PAGED_CODE();
01982
01983
01984
01985
01986
01987
if (
Irp->
AssociatedIrp.SystemBuffer !=
NULL) {
01988
ExFreePool(
Irp->
AssociatedIrp.SystemBuffer );
01989 }
01990
01991
01992
01993
01994
01995
if (
Irp->
MdlAddress !=
NULL) {
01996
IoFreeMdl(
Irp->
MdlAddress );
01997 }
01998
01999
02000
02001
02002
02003
IoFreeIrp(
Irp );
02004
02005
02006
02007
02008
02009
02010
02011
if (FileObject->Flags &
FO_SYNCHRONOUS_IO) {
02012
IopReleaseFileObjectLock( FileObject );
02013 }
02014
02015
if (ARGUMENT_PRESENT( EventObject )) {
02016
ObDereferenceObject( EventObject );
02017 }
02018
02019
if (ARGUMENT_PRESENT( KernelEvent )) {
02020
ExFreePool( KernelEvent );
02021 }
02022
02023
ObDereferenceObject( FileObject );
02024
02025
return;
02026 }
02027
02028
VOID
02029 IopFreeIrpAndMdls(
02030 IN
PIRP Irp
02031 )
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041
02042
02043
02044
02045
02046
02047
02048
02049
02050 {
02051
PMDL mdl;
02052
PMDL nextMdl;
02053
02054
02055
02056
02057
02058
for (mdl =
Irp->
MdlAddress; mdl != (
PMDL)
NULL; mdl = nextMdl) {
02059 nextMdl = mdl->
Next;
02060
IoFreeMdl( mdl );
02061 }
02062
02063
02064
02065
02066
02067
IoFreeIrp(
Irp );
02068
return;
02069 }
02070
02071
NTSTATUS
02072 IopGetDriverNameFromKeyNode(
02073 IN HANDLE KeyHandle,
02074 OUT PUNICODE_STRING DriverName
02075 )
02076
02077
02078
02079
02080
02081
02082
02083
02084
02085
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098 {
02099 PKEY_VALUE_FULL_INFORMATION keyValueInformation;
02100 PKEY_BASIC_INFORMATION keyBasicInformation;
02101 ULONG keyBasicLength;
02102
NTSTATUS status;
02103
02104
PAGED_CODE();
02105
02106
02107
02108
02109
02110
02111
02112 status =
IopGetRegistryValue( KeyHandle,
02113
L"ObjectName",
02114 &keyValueInformation );
02115
02116
if (
NT_SUCCESS( status )) {
02117
02118 PWSTR src, dst;
02119 ULONG i;
02120
02121
02122
02123
02124
02125
02126
02127
if (!keyValueInformation->DataLength) {
02128
ExFreePool( keyValueInformation );
02129
return STATUS_ILL_FORMED_SERVICE_ENTRY;
02130 }
02131
02132 DriverName->Length = (
USHORT) (keyValueInformation->DataLength -
sizeof( WCHAR ));
02133 DriverName->MaximumLength = (
USHORT) keyValueInformation->DataLength;
02134
02135 src = (PWSTR) ((PUCHAR) keyValueInformation + keyValueInformation->DataOffset);
02136 dst = (PWSTR) keyValueInformation;
02137
for (i = DriverName->Length; i; i--) {
02138 *dst++ = *src++;
02139 }
02140
02141 DriverName->Buffer = (PWSTR) keyValueInformation;
02142
02143 }
else {
02144
02145 PULONG driverType;
02146 PWSTR baseObjectName;
02147 UNICODE_STRING remainderName;
02148
02149
02150
02151
02152
02153
02154
02155 status =
IopGetRegistryValue( KeyHandle,
02156
L"Type",
02157 &keyValueInformation );
02158
if (!
NT_SUCCESS( status ) || !keyValueInformation->DataLength) {
02159
02160
02161
02162
02163
02164
02165
02166
if (
NT_SUCCESS( status )) {
02167
ExFreePool( keyValueInformation );
02168 }
02169
02170
return STATUS_ILL_FORMED_SERVICE_ENTRY;
02171 }
02172
02173
02174
02175
02176
02177
02178 baseObjectName =
L"\\Driver\\";
02179 DriverName->Length = 8*2;
02180
02181 driverType = (PULONG) ((PUCHAR) keyValueInformation + keyValueInformation->DataOffset);
02182
02183
if (*driverType == FileSystemType ||
02184 *driverType == RecognizerType) {
02185 baseObjectName =
L"\\FileSystem\\";
02186 DriverName->Length = 12*2;
02187 }
02188
02189
02190
02191
02192
02193
02194
02195 status = ZwQueryKey( KeyHandle,
02196 KeyBasicInformation,
02197 (PVOID)
NULL,
02198 0,
02199 &keyBasicLength );
02200
02201 keyBasicInformation =
ExAllocatePool(
NonPagedPool, keyBasicLength );
02202
if (!keyBasicInformation) {
02203
ExFreePool( keyValueInformation );
02204
return STATUS_INSUFFICIENT_RESOURCES;
02205 }
02206
02207 status = ZwQueryKey( KeyHandle,
02208 KeyBasicInformation,
02209 keyBasicInformation,
02210 keyBasicLength,
02211 &keyBasicLength );
02212
if (!
NT_SUCCESS( status )) {
02213
ExFreePool( keyBasicInformation );
02214
ExFreePool( keyValueInformation );
02215
return status;
02216 }
02217
02218
02219
02220
02221
02222
02223 DriverName->MaximumLength = (
USHORT) (DriverName->Length + keyBasicInformation->NameLength);
02224 DriverName->Buffer =
ExAllocatePool(
NonPagedPool,
02225 DriverName->MaximumLength );
02226
if (!DriverName->Buffer) {
02227
ExFreePool( keyBasicInformation );
02228
ExFreePool( keyValueInformation );
02229
return STATUS_INSUFFICIENT_RESOURCES;
02230 }
02231
02232
02233
02234
02235
02236 DriverName->Length = 0;
02237
RtlAppendUnicodeToString( DriverName, baseObjectName );
02238 remainderName.Length = (
USHORT) keyBasicInformation->NameLength;
02239 remainderName.MaximumLength = remainderName.Length;
02240 remainderName.Buffer = &keyBasicInformation->Name[0];
02241
RtlAppendUnicodeStringToString( DriverName, &remainderName );
02242
ExFreePool( keyBasicInformation );
02243
ExFreePool( keyValueInformation );
02244 }
02245
02246
02247
02248
02249
02250
02251
02252
return STATUS_SUCCESS;
02253 }
02254
02255
NTSTATUS
02256 IopGetFileName(
02257 IN
PFILE_OBJECT FileObject,
02258 IN ULONG Length,
02259 OUT PVOID FileInformation,
02260 OUT PULONG ReturnedLength
02261 )
02262
02263
02264
02265
02266
02267
02268
02269
02270
02271
02272
02273
02274
02275
02276
02277
02278
02279
02280
02281
02282
02283
02284
02285
02286
02287
02288
02289
02290
02291
02292 {
02293
02294
PIRP irp;
02295
NTSTATUS status;
02296
PDEVICE_OBJECT deviceObject;
02297
KEVENT event;
02298
PIO_STACK_LOCATION irpSp;
02299 IO_STATUS_BLOCK localIoStatus;
02300
02301
PAGED_CODE();
02302
02303
02304
02305
02306
02307
02308
02309
ObReferenceObject( FileObject );
02310
02311
02312
02313
02314
02315
02316
02317
02318
KeInitializeEvent( &event, SynchronizationEvent,
FALSE );
02319
02320
02321
02322
02323
02324 deviceObject =
IoGetRelatedDeviceObject( FileObject );
02325
02326
02327
02328
02329
02330 irp =
IoAllocateIrp( deviceObject->
StackSize,
FALSE );
02331
if (!irp) {
02332
02333
02334
02335
02336
02337
02338
IopAllocateIrpCleanup( FileObject, (
PKEVENT)
NULL );
02339
return STATUS_INSUFFICIENT_RESOURCES;
02340 }
02341
02342 irp->
Tail.Overlay.OriginalFileObject = FileObject;
02343 irp->
Tail.Overlay.Thread =
PsGetCurrentThread();
02344 irp->
RequestorMode =
KernelMode;
02345
02346
02347
02348
02349
02350
02351
02352
02353 irp->
UserEvent = &event;
02354 irp->
Flags =
IRP_SYNCHRONOUS_API |
IRP_OB_QUERY_NAME;
02355 irp->
UserIosb = &localIoStatus;
02356 irp->
Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)
NULL;
02357
02358
02359
02360
02361
02362
02363 irpSp =
IoGetNextIrpStackLocation( irp );
02364 irpSp->
MajorFunction =
IRP_MJ_QUERY_INFORMATION;
02365 irpSp->
FileObject = FileObject;
02366
02367
02368
02369
02370
02371
02372 irp->
AssociatedIrp.SystemBuffer = FileInformation;
02373 irp->
Flags |=
IRP_BUFFERED_IO;
02374
02375
02376
02377
02378
02379
02380 irpSp->
Parameters.QueryFile.Length = Length;
02381 irpSp->
Parameters.QueryFile.FileInformationClass = FileNameInformation;
02382
02383
02384
02385
02386
02387
IopQueueThreadIrp( irp );
02388
02389
02390
02391
02392
02393 status =
IoCallDriver( deviceObject, irp );
02394
02395
02396
02397
02398
02399
02400
if (status == STATUS_PENDING) {
02401 (
VOID)
KeWaitForSingleObject( &event,
02402
Executive,
02403
KernelMode,
02404
FALSE,
02405 (PLARGE_INTEGER)
NULL );
02406 status = localIoStatus.Status;
02407 }
02408
02409 *ReturnedLength = (ULONG) localIoStatus.Information;
02410
return status;
02411 }
02412
02413 BOOLEAN
02414 IopGetMountFlag(
02415 IN
PDEVICE_OBJECT DeviceObject
02416 )
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426
02427
02428
02429
02430
02431
02432
02433
02434
02435
02436
02437
02438 {
02439 KIRQL irql;
02440 BOOLEAN deviceMounted =
FALSE;
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450 ExAcquireFastLock( &
IopVpbSpinLock, &irql );
02451
if (DeviceObject->Vpb) {
02452
if (DeviceObject->Vpb->Flags &
VPB_MOUNTED) {
02453 deviceMounted =
TRUE;
02454 }
02455 }
02456 ExReleaseFastLock( &
IopVpbSpinLock, irql );
02457
02458
return deviceMounted;
02459 }
02460
02461
NTSTATUS
02462 IopGetRegistryKeyInformation(
02463 IN HANDLE KeyHandle,
02464 OUT PKEY_FULL_INFORMATION *Information
02465 )
02466
02467
02468
02469
02470
02471
02472
02473
02474
02475
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485
02486
02487
02488
02489
02490
02491 {
02492
NTSTATUS status;
02493 PKEY_FULL_INFORMATION infoBuffer;
02494 ULONG keyInfoLength;
02495
02496
PAGED_CODE();
02497
02498
02499
02500
02501
02502
02503 status = ZwQueryKey( KeyHandle,
02504 KeyFullInformation,
02505 (PVOID)
NULL,
02506 0,
02507 &keyInfoLength );
02508
if (status != STATUS_BUFFER_OVERFLOW &&
02509 status != STATUS_BUFFER_TOO_SMALL) {
02510
return status;
02511 }
02512
02513
02514
02515
02516
02517 infoBuffer =
ExAllocatePool(
NonPagedPool, keyInfoLength );
02518
if (!infoBuffer) {
02519
return STATUS_INSUFFICIENT_RESOURCES;
02520 }
02521
02522
02523
02524
02525
02526 status = ZwQueryKey( KeyHandle,
02527 KeyFullInformation,
02528 infoBuffer,
02529 keyInfoLength,
02530 &keyInfoLength );
02531
if (!
NT_SUCCESS( status )) {
02532
ExFreePool( infoBuffer );
02533
return status;
02534 }
02535
02536
02537
02538
02539
02540
02541 *Information = infoBuffer;
02542
return STATUS_SUCCESS;
02543 }
02544
02545
NTSTATUS
02546 IopGetRegistryValue(
02547 IN HANDLE KeyHandle,
02548 IN PWSTR ValueName,
02549 OUT PKEY_VALUE_FULL_INFORMATION *Information
02550 )
02551
02552
02553
02554
02555
02556
02557
02558
02559
02560
02561
02562
02563
02564
02565
02566
02567
02568
02569
02570
02571
02572
02573
02574
02575
02576
02577 {
02578 UNICODE_STRING unicodeString;
02579
NTSTATUS status;
02580 PKEY_VALUE_FULL_INFORMATION infoBuffer;
02581 ULONG keyValueLength;
02582
02583
PAGED_CODE();
02584
02585
RtlInitUnicodeString( &unicodeString,
ValueName );
02586
02587
02588
02589
02590
02591
02592 status = ZwQueryValueKey( KeyHandle,
02593 &unicodeString,
02594 KeyValueFullInformation,
02595 (PVOID)
NULL,
02596 0,
02597 &keyValueLength );
02598
if (status != STATUS_BUFFER_OVERFLOW &&
02599 status != STATUS_BUFFER_TOO_SMALL) {
02600
return status;
02601 }
02602
02603
02604
02605
02606
02607 infoBuffer =
ExAllocatePool(
NonPagedPool, keyValueLength );
02608
if (!infoBuffer) {
02609
return STATUS_INSUFFICIENT_RESOURCES;
02610 }
02611
02612
02613
02614
02615
02616 status = ZwQueryValueKey( KeyHandle,
02617 &unicodeString,
02618 KeyValueFullInformation,
02619 infoBuffer,
02620 keyValueLength,
02621 &keyValueLength );
02622
if (!
NT_SUCCESS( status )) {
02623
ExFreePool( infoBuffer );
02624
return status;
02625 }
02626
02627
02628
02629
02630
02631
02632 *Information = infoBuffer;
02633
return STATUS_SUCCESS;
02634 }
02635
02636
NTSTATUS
02637 IopGetRegistryValues(
02638 IN HANDLE KeyHandle,
02639 IN PKEY_VALUE_FULL_INFORMATION *ValueList
02640 )
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668
02669
02670 {
02671
NTSTATUS status;
02672
02673
PAGED_CODE();
02674
02675
02676
02677
02678
02679 *ValueList =
NULL;
02680 *(ValueList + 1) =
NULL;
02681 *(ValueList + 2) =
NULL;
02682
02683
02684
02685
02686
02687
02688
02689
02690 status =
IopGetRegistryValue( KeyHandle,
02691
L"Identifier",
02692 ValueList );
02693
02694
if (!
NT_SUCCESS( status ) && (status != STATUS_OBJECT_NAME_NOT_FOUND)) {
02695
return status;
02696 }
02697
02698 status =
IopGetRegistryValue( KeyHandle,
02699
L"Configuration Data",
02700 ++ValueList );
02701
02702
if (!
NT_SUCCESS( status ) && (status != STATUS_OBJECT_NAME_NOT_FOUND)) {
02703
return status;
02704 }
02705
02706 status =
IopGetRegistryValue( KeyHandle,
02707
L"Component Information",
02708 ++ValueList );
02709
02710
if (!
NT_SUCCESS( status ) && (status != STATUS_OBJECT_NAME_NOT_FOUND)) {
02711
return status;
02712 }
02713
02714
return STATUS_SUCCESS;
02715 }
02716
02717
NTSTATUS
02718 IopGetSetObjectId(
02719 IN
PFILE_OBJECT FileObject,
02720 IN OUT PVOID Buffer,
02721 IN ULONG Length,
02722 IN ULONG Function
02723 )
02724
02725
02726
02727
02728
02729
02730
02731
02732
02733
02734
02735
02736
02737
02738
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748
02749
02750
02751
02752
02753
02754
02755
02756
02757
02758
02759 {
02760 IO_STATUS_BLOCK ioStatus;
02761
NTSTATUS status;
02762
PIRP irp;
02763
KEVENT event;
02764
PIO_STACK_LOCATION irpSp;
02765
PDEVICE_OBJECT deviceObject;
02766
02767
PAGED_CODE();
02768
02769
02770
02771
02772
02773
02774
KeInitializeEvent( &event,
02775 NotificationEvent,
02776
FALSE );
02777
02778
02779
02780
02781
02782
02783 deviceObject =
IoGetRelatedDeviceObject( FileObject );
02784
02785 irp =
IoBuildDeviceIoControlRequest( Function,
02786 deviceObject,
02787
NULL,
02788 0,
02789
NULL,
02790 0,
02791
FALSE,
02792 &event,
02793 &ioStatus );
02794
if (!irp) {
02795
return STATUS_INSUFFICIENT_RESOURCES;
02796 }
02797
02798
02799
02800
02801
02802
02803 irp->
Flags |=
IRP_SYNCHRONOUS_API;
02804 irp->
UserBuffer =
Buffer;
02805 irp->
AssociatedIrp.SystemBuffer =
Buffer;
02806 irp->
Tail.Overlay.OriginalFileObject = FileObject;
02807
02808 irpSp =
IoGetNextIrpStackLocation( irp );
02809 irpSp->
FileObject = FileObject;
02810 irpSp->
MajorFunction =
IRP_MJ_FILE_SYSTEM_CONTROL;
02811 irpSp->
MinorFunction =
IRP_MN_KERNEL_CALL;
02812
02813
if (Function == FSCTL_LMR_GET_LINK_TRACKING_INFORMATION ||
02814 Function == FSCTL_CREATE_OR_GET_OBJECT_ID ||
02815 Function == FSCTL_GET_OBJECT_ID ) {
02816 irpSp->
Parameters.FileSystemControl.OutputBufferLength = Length;
02817 }
else {
02818 irpSp->
Parameters.FileSystemControl.InputBufferLength = Length;
02819 }
02820
02821
02822
02823
02824
02825
02826
ObReferenceObject( FileObject );
02827
02828
02829
02830
02831
02832 status =
IoCallDriver( deviceObject, irp );
02833
02834
02835
02836
02837
02838
if (status == STATUS_PENDING) {
02839 status =
KeWaitForSingleObject( &event,
02840
Executive,
02841
KernelMode,
02842
FALSE,
02843 (PLARGE_INTEGER)
NULL );
02844 status = ioStatus.Status;
02845 }
02846
02847
return status;
02848 }
02849
02850
NTSTATUS
02851 IopGetVolumeId(
02852 IN
PFILE_OBJECT FileObject,
02853 IN OUT PFILE_VOLUMEID_WITH_TYPE ObjectId,
02854 IN ULONG Length
02855 )
02856
02857
02858
02859
02860
02861
02862
02863
02864
02865
02866
02867
02868
02869
02870
02871
02872
02873
02874
02875
02876
02877
02878
02879 {
02880 IO_STATUS_BLOCK ioStatus;
02881
NTSTATUS status;
02882
PIRP irp;
02883
KEVENT event;
02884
PIO_STACK_LOCATION irpSp;
02885
PDEVICE_OBJECT deviceObject;
02886 FILE_FS_OBJECTID_INFORMATION volumeId;
02887
02888
PAGED_CODE();
02889
02890
02891
02892
02893
02894
02895
KeInitializeEvent( &event,
02896 NotificationEvent,
02897
FALSE );
02898
02899
02900
02901
02902
02903
02904 deviceObject =
IoGetRelatedDeviceObject( FileObject );
02905
02906 irp =
IoBuildDeviceIoControlRequest( 0,
02907 deviceObject,
02908
NULL,
02909 0,
02910
NULL,
02911 0,
02912
FALSE,
02913 &event,
02914 &ioStatus );
02915
if (!irp) {
02916
return STATUS_INSUFFICIENT_RESOURCES;
02917 }
02918
02919
02920
02921
02922
02923
02924 irp->
Flags |=
IRP_SYNCHRONOUS_API;
02925 irp->
UserBuffer = &volumeId;
02926 irp->
AssociatedIrp.SystemBuffer = &volumeId;
02927 irp->
Tail.Overlay.OriginalFileObject = FileObject;
02928
02929 irpSp =
IoGetNextIrpStackLocation( irp );
02930 irpSp->
FileObject = FileObject;
02931 irpSp->
MajorFunction =
IRP_MJ_QUERY_VOLUME_INFORMATION;
02932 irpSp->
Parameters.QueryVolume.Length =
sizeof( volumeId );
02933 irpSp->
Parameters.QueryVolume.FsInformationClass = FileFsObjectIdInformation;
02934
02935
02936
02937
02938
02939
02940
ObReferenceObject( FileObject );
02941
02942
02943
02944
02945
02946 status =
IoCallDriver( deviceObject, irp );
02947
02948
02949
02950
02951
02952
if (status == STATUS_PENDING) {
02953 status =
KeWaitForSingleObject( &event,
02954
Executive,
02955
KernelMode,
02956
FALSE,
02957 (PLARGE_INTEGER)
NULL );
02958 status = ioStatus.Status;
02959 }
02960
02961
02962
02963
02964
02965
02966
if (
NT_SUCCESS( status )) {
02967 ObjectId->Type = NtfsLinkTrackingInformation;
02968 RtlCopyMemory( ObjectId->VolumeId,
02969 &volumeId.ObjectId,
02970
sizeof( GUID ) );
02971 }
02972
02973
return status;
02974 }
02975
02976
VOID
02977 IopHardErrorThread(
02978 IN PVOID StartContext
02979 )
02980
02981
02982
02983
02984
02985
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996
02997
02998 {
02999 KIRQL oldIrql;
03000 PVOID entry;
03001 ULONG parameterPresent;
03002 ULONG_PTR errorParameter;
03003 ULONG errorResponse;
03004 BOOLEAN MoreEntries;
03005
PIOP_HARD_ERROR_PACKET hardErrorPacket;
03006
03007 UNREFERENCED_PARAMETER( StartContext );
03008
03009
03010
03011
03012
03013
03014
03015 MoreEntries =
TRUE;
03016
03017
do {
03018
03019 (
VOID)
KeWaitForSingleObject( &
IopHardError.
WorkQueueSemaphore,
03020
Executive,
03021
KernelMode,
03022
FALSE,
03023 (PLARGE_INTEGER)
NULL );
03024
03025 ExAcquireFastLock( &
IopHardError.
WorkQueueSpinLock, &oldIrql );
03026
03027
03028
03029
03030
03031
03032 entry = RemoveHeadList( &
IopHardError.
WorkQueue );
03033
03034 hardErrorPacket = CONTAINING_RECORD( entry,
03035
IOP_HARD_ERROR_PACKET,
03036 WorkQueueLinks );
03037
03038
IopCurrentHardError = hardErrorPacket;
03039
03040 ExReleaseFastLock( &
IopHardError.
WorkQueueSpinLock, oldIrql );
03041
03042
03043
03044
03045
03046 errorParameter = (ULONG_PTR) &hardErrorPacket->String;
03047 parameterPresent = (hardErrorPacket->String.Buffer !=
NULL);
03048
03049
if (
ExReadyForErrors) {
03050 (
VOID)
ExRaiseHardError( hardErrorPacket->ErrorStatus,
03051 parameterPresent,
03052 parameterPresent,
03053 parameterPresent ? &errorParameter :
NULL,
03054 OptionOk,
03055 &errorResponse );
03056 }
03057
03058
03059
03060
03061
03062 ExAcquireFastLock( &
IopHardError.
WorkQueueSpinLock, &oldIrql );
03063
03064
IopCurrentHardError =
NULL;
03065
03066
if ( IsListEmpty( &
IopHardError.
WorkQueue ) ) {
03067
IopHardError.
ThreadStarted =
FALSE;
03068 MoreEntries =
FALSE;
03069 }
03070
03071 ExReleaseFastLock( &
IopHardError.
WorkQueueSpinLock, oldIrql );
03072
03073
03074
03075
03076
03077
if (hardErrorPacket->String.Buffer) {
03078
ExFreePool( hardErrorPacket->String.Buffer );
03079 }
03080
03081
ExFreePool( hardErrorPacket );
03082
03083 }
while ( MoreEntries );
03084 }
03085
03086
NTSTATUS
03087 IopInvalidDeviceRequest(
03088 IN
PDEVICE_OBJECT DeviceObject,
03089 IN
PIRP Irp
03090 )
03091
03092
03093
03094
03095
03096
03097
03098
03099
03100
03101
03102
03103
03104
03105
03106
03107
03108
03109
03110
03111
03112
03113
03114
03115
03116
03117 {
03118 UNREFERENCED_PARAMETER( DeviceObject );
03119
03120
03121
03122
03123
03124
03125
if ((
IoGetCurrentIrpStackLocation(
Irp))->MajorFunction ==
IRP_MJ_POWER) {
03126
PoStartNextPowerIrp(
Irp);
03127 }
03128
Irp->
IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
03129
IoCompleteRequest(
Irp,
IO_NO_INCREMENT );
03130
return STATUS_INVALID_DEVICE_REQUEST;
03131 }
03132
03133 BOOLEAN
03134 IopIsSameMachine(
03135 IN
PFILE_OBJECT SourceFile,
03136 IN HANDLE TargetFile
03137 )
03138
03139
03140
03141
03142
03143
03144
03145
03146
03147
03148
03149
03150
03151
03152
03153
03154
03155
03156
03157
03158
03159 {
03160
PDEVICE_OBJECT deviceObject;
03161
PFAST_IO_DISPATCH fastIoDispatch;
03162
NTSTATUS status = STATUS_NOT_SAME_DEVICE;
03163 IO_STATUS_BLOCK ioStatus;
03164 HANDLE target = TargetFile;
03165
03166
PAGED_CODE();
03167
03168
03169
03170
03171
03172
03173
03174
03175
03176
03177
03178
03179 deviceObject =
IoGetRelatedDeviceObject( SourceFile );
03180
03181 fastIoDispatch = deviceObject->
DriverObject->
FastIoDispatch;
03182
if (fastIoDispatch && fastIoDispatch->
FastIoDeviceControl) {
03183
if (fastIoDispatch->
FastIoDeviceControl( SourceFile,
03184
TRUE,
03185 (PVOID) &target,
03186
sizeof( target ),
03187 (PVOID)
NULL,
03188 0,
03189 IOCTL_LMR_ARE_FILE_OBJECTS_ON_SAME_SERVER,
03190 &ioStatus,
03191 deviceObject )) {
03192 status = ioStatus.Status;
03193 }
03194 }
03195
03196
return status == STATUS_SUCCESS;
03197 }
03198
03199
NTSTATUS
03200 IopLoadDriver(
03201 IN HANDLE KeyHandle,
03202 IN BOOLEAN CheckForSafeBoot
03203 )
03204
03205
03206
03207
03208
03209
03210
03211
03212
03213
03214
03215
03216
03217
03218
03219
03220
03221
03222
03223
03224
03225
03226
03227
03228 {
03229
NTSTATUS status;
03230 PLIST_ENTRY nextEntry;
03231 PLDR_DATA_TABLE_ENTRY driverEntry;
03232 PKEY_BASIC_INFORMATION keyBasicInformation =
NULL;
03233 PKEY_VALUE_FULL_INFORMATION keyValueInformation =
NULL;
03234 ULONG keyBasicLength;
03235 UNICODE_STRING baseName;
03236 UNICODE_STRING serviceName = {0, 0,
NULL};
03237 OBJECT_ATTRIBUTES objectAttributes;
03238 PVOID sectionPointer;
03239 UNICODE_STRING driverName;
03240
PDRIVER_OBJECT driverObject;
03241 PIMAGE_NT_HEADERS ntHeaders;
03242 PVOID imageBaseAddress;
03243 ULONG_PTR entryPoint;
03244 HANDLE driverHandle;
03245 ULONG i;
03246 POBJECT_NAME_INFORMATION registryPath;
03247
#if DBG
03248
LARGE_INTEGER stime, etime;
03249 ULONG dtime;
03250
#endif
03251
03252
PAGED_CODE();
03253
03254 driverName.Buffer = (PWSTR)
NULL;
03255
03256
03257
03258
03259
03260
03261
03262
03263 status =
NtQueryKey( KeyHandle,
03264 KeyBasicInformation,
03265 (PVOID)
NULL,
03266 0,
03267 &keyBasicLength );
03268
if (status != STATUS_BUFFER_OVERFLOW &&
03269 status != STATUS_BUFFER_TOO_SMALL) {
03270 status = STATUS_ILL_FORMED_SERVICE_ENTRY;
03271
goto IopLoadExit;
03272 }
03273
03274 keyBasicInformation =
ExAllocatePool(
NonPagedPool,
03275 keyBasicLength + (4 * 2) );
03276
if (!keyBasicInformation) {
03277 status = STATUS_INSUFFICIENT_RESOURCES;
03278
goto IopLoadExit;
03279 }
03280
03281 status =
NtQueryKey( KeyHandle,
03282 KeyBasicInformation,
03283 keyBasicInformation,
03284 keyBasicLength,
03285 &keyBasicLength );
03286
if (!
NT_SUCCESS( status )) {
03287
goto IopLoadExit;
03288 }
03289
03290
03291
03292
03293
03294
03295 baseName.Length = (
USHORT) keyBasicInformation->NameLength;
03296 baseName.MaximumLength = (
USHORT) (baseName.Length + (4 * 2));
03297 baseName.Buffer = &keyBasicInformation->Name[0];
03298
03299 serviceName.Buffer =
ExAllocatePool(
PagedPool, baseName.Length +
sizeof(UNICODE_NULL));
03300
if (serviceName.Buffer) {
03301 serviceName.Length = baseName.Length;
03302 serviceName.MaximumLength = serviceName.Length +
sizeof(UNICODE_NULL);
03303 RtlMoveMemory(serviceName.Buffer, baseName.Buffer, baseName.Length);
03304 serviceName.Buffer[serviceName.Length /
sizeof(WCHAR)] = UNICODE_NULL;
03305 }
03306
#if DBG
03307
else {
03308
DbgPrint(
"IopLoadDriver: No memory available for Service Keyname\n");
03309 }
03310
#endif
03311
03312
RtlAppendUnicodeToString( &baseName,
L".SYS" );
03313
03314
if (CheckForSafeBoot &&
InitSafeBootMode) {
03315
03316 BOOLEAN GroupIsGood =
FALSE;
03317 UNICODE_STRING string;
03318 PKEY_VALUE_PARTIAL_INFORMATION keyValue;
03319 UCHAR nameBuffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + 64];
03320 ULONG length;
03321
03322
RtlInitUnicodeString( &string,
L"Group" );
03323 keyValue = (PKEY_VALUE_PARTIAL_INFORMATION)nameBuffer;
03324 RtlZeroMemory(nameBuffer,
sizeof(nameBuffer));
03325
03326 status =
NtQueryValueKey(
03327 KeyHandle,
03328 &string,
03329 KeyValuePartialInformation,
03330 keyValue,
03331
sizeof(nameBuffer),
03332 &length
03333 );
03334
if (
NT_SUCCESS(status)) {
03335
03336 string.Length = (
USHORT)(keyValue->DataLength -
sizeof(WCHAR));
03337 string.MaximumLength = string.Length;
03338 string.Buffer = (PWSTR)keyValue->Data;
03339
03340
if (
IopSafebootDriverLoad(&string)) {
03341 GroupIsGood =
TRUE;
03342 }
03343 }
03344
03345
if (!GroupIsGood && !
IopSafebootDriverLoad(&baseName)) {
03346
03347
03348
03349
03350
IopBootLog(&baseName,
FALSE);
03351
03352
DbgPrint(
"SAFEBOOT: skipping device = %wZ(%wZ)\n",&baseName,&string);
03353
return STATUS_SUCCESS;
03354 }
03355
03356 }
03357
03358
03359
03360
03361
03362
03363
ExAcquireResourceShared( &
PsLoadedModuleResource,
TRUE );
03364 nextEntry =
PsLoadedModuleList.Flink;
03365
while (nextEntry != &
PsLoadedModuleList) {
03366
03367
03368
03369
03370
03371 driverEntry = CONTAINING_RECORD( nextEntry,
03372 LDR_DATA_TABLE_ENTRY,
03373 InLoadOrderLinks );
03374
03375
03376
03377
03378
03379
03380
if ((driverEntry->Flags & LDRP_ENTRY_PROCESSED) &&
03381
RtlEqualString( (PSTRING) &baseName,
03382 (PSTRING) &driverEntry->FullDllName,
03383
TRUE )) {
03384 status = STATUS_IMAGE_ALREADY_LOADED;
03385
ExReleaseResource( &
PsLoadedModuleResource );
03386
03387
03388
IopBootLog(&baseName,
TRUE);
03389
03390
goto IopLoadExit;
03391 }
03392
03393 nextEntry = nextEntry->Flink;
03394 }
03395
ExReleaseResource( &
PsLoadedModuleResource );
03396
03397
03398
03399
03400
03401
03402
03403
03404
03405
03406 status =
IopGetRegistryValue( KeyHandle,
03407
L"ImagePath",
03408 &keyValueInformation );
03409
03410
if (
NT_SUCCESS( status ) && keyValueInformation->DataLength) {
03411
03412
03413
03414
03415
03416
03417
ExFreePool( keyBasicInformation );
03418 keyBasicInformation =
NULL;
03419 baseName.Length = (
USHORT) keyValueInformation->DataLength;
03420
if (baseName.Length > 0) {
03421 baseName.Length -=
sizeof( WCHAR );
03422 }
03423 baseName.MaximumLength = baseName.Length;
03424 baseName.Buffer = (PWSTR) ((PUCHAR) keyValueInformation + keyValueInformation->DataOffset);
03425
03426
if (baseName.Buffer[0] !=
L'\\') {
03427
03428 UNICODE_STRING prefixName;
03429 UNICODE_STRING tmpName;
03430 PWCHAR fileName;
03431
03432
RtlInitUnicodeString( &prefixName,
L"\\SystemRoot\\" );
03433 fileName =
ExAllocatePool(
NonPagedPool,
03434 prefixName.Length + baseName.Length );
03435
if (!fileName) {
03436 status = STATUS_INSUFFICIENT_RESOURCES;
03437
goto IopLoadExit;
03438 }
03439
03440 tmpName.Length = baseName.Length;
03441 tmpName.Buffer = baseName.Buffer;
03442 baseName.MaximumLength = (
USHORT) (prefixName.Length + baseName.Length);
03443 baseName.Length = 0;
03444 baseName.Buffer = fileName;
03445
03446
RtlAppendUnicodeStringToString( &baseName, &prefixName );
03447
RtlAppendUnicodeStringToString( &baseName, &tmpName );
03448
03449
ExFreePool( keyValueInformation );
03450 keyValueInformation = (PKEY_VALUE_FULL_INFORMATION) fileName;
03451 }
03452
03453 }
else {
03454
03455 UNICODE_STRING prefixName;
03456 UNICODE_STRING fileName;
03457
03458
RtlInitUnicodeString( &prefixName,
L"\\SystemRoot\\System32\\Drivers\\" );
03459
03460
03461
03462
03463
03464
03465
03466
if (
NT_SUCCESS( status )) {
03467
ExFreePool( keyValueInformation );
03468 }
03469
03470
03471
03472
03473
03474
03475
03476 keyValueInformation =
ExAllocatePool(
NonPagedPool,
03477 baseName.MaximumLength +
03478 prefixName.Length );
03479
if (!keyValueInformation) {
03480 status = STATUS_INSUFFICIENT_RESOURCES;
03481
goto IopLoadExit;
03482 }
03483
03484 fileName.Length = baseName.Length;
03485 fileName.MaximumLength = baseName.MaximumLength;
03486 fileName.Buffer = baseName.Buffer;
03487
03488 baseName.Length = 0;
03489 baseName.MaximumLength = (
USHORT) (fileName.Length + prefixName.Length);
03490 baseName.Buffer = (PWSTR) keyValueInformation;
03491
03492
RtlAppendUnicodeStringToString( &baseName, &prefixName );
03493
RtlAppendUnicodeStringToString( &baseName, &fileName );
03494
03495
ExFreePool( keyBasicInformation );
03496 keyBasicInformation =
NULL;
03497 }
03498
03499
03500
03501
03502
03503 status =
IopGetDriverNameFromKeyNode( KeyHandle,
03504 &driverName );
03505
if (!
NT_SUCCESS( status )) {
03506
goto IopLoadExit;
03507 }
03508
03509 InitializeObjectAttributes( &objectAttributes,
03510 &driverName,
03511 OBJ_PERMANENT,
03512 (HANDLE)
NULL,
03513 (PSECURITY_DESCRIPTOR)
NULL );
03514
03515
03516
03517
03518
03519
03520 status =
MmLoadSystemImage( &baseName,
03521
NULL,
03522
NULL,
03523
FALSE,
03524 §ionPointer,
03525 (PVOID *) &imageBaseAddress );
03526
03527
if (!
NT_SUCCESS( status )) {
03528
03529
03530
03531
03532
03533
if (status != STATUS_IMAGE_ALREADY_LOADED) {
03534
03535
IopBootLog(&baseName,
FALSE);
03536
03537
goto IopLoadExit;
03538 }
03539
03540
03541
03542
03543
03544 status =
ObOpenObjectByName( &objectAttributes,
03545
IoDriverObjectType,
03546
KernelMode,
03547
NULL,
03548 0,
03549
NULL,
03550 &driverHandle );
03551
03552
03553
if (!
NT_SUCCESS( status )) {
03554
03555
IopBootLog(&baseName,
FALSE);
03556
03557
goto IopLoadExit;
03558 }
03559
03560
03561
03562
03563
03564
03565 status =
ObReferenceObjectByHandle( driverHandle,
03566 0,
03567
IoDriverObjectType,
03568 KeGetPreviousMode(),
03569 (PVOID *) &driverObject,
03570 (
POBJECT_HANDLE_INFORMATION)
NULL );
03571
03572
NtClose( driverHandle );
03573
03574
if (!
NT_SUCCESS( status )) {
03575
IopBootLog(&baseName,
FALSE);
03576
goto IopLoadExit;
03577 }
03578
03579 status =
IopResurrectDriver( driverObject );
03580
03581
03582
03583
03584
03585
03586
03587
03588
ObDereferenceObject( driverObject );
03589
IopBootLog(&baseName,
FALSE);
03590
goto IopLoadExit;
03591 }
else {
03592
03593 ntHeaders =
RtlImageNtHeader( imageBaseAddress );
03594
03595
03596
03597
03598
03599
03600 status =
IopPrepareDriverLoading (&serviceName, KeyHandle, ntHeaders);
03601
if (!
NT_SUCCESS(status)) {
03602
MmUnloadSystemImage(sectionPointer);
03603
IopBootLog(&baseName,
FALSE);
03604
goto IopLoadExit;
03605 }
03606
03607 }
03608
03609
03610
03611
03612
03613
03614 status =
ObCreateObject( KeGetPreviousMode(),
03615
IoDriverObjectType,
03616 &objectAttributes,
03617
KernelMode,
03618 (PVOID)
NULL,
03619 (ULONG) (
sizeof(
DRIVER_OBJECT ) +
sizeof (
DRIVER_EXTENSION )),
03620 0,
03621 0,
03622 (PVOID *) &driverObject );
03623
03624
if (!
NT_SUCCESS( status )) {
03625
IopBootLog(&baseName,
FALSE);
03626
goto IopLoadExit;
03627 }
03628
03629
03630
03631
03632
03633 RtlZeroMemory( driverObject,
sizeof(
DRIVER_OBJECT ) +
sizeof (
DRIVER_EXTENSION) );
03634 driverObject->DriverExtension = (
PDRIVER_EXTENSION) (driverObject + 1);
03635 driverObject->DriverExtension->DriverObject = driverObject;
03636
03637
for (i = 0; i <=
IRP_MJ_MAXIMUM_FUNCTION; i++) {
03638 driverObject->MajorFunction[i] =
IopInvalidDeviceRequest;
03639 }
03640
03641 driverObject->Type =
IO_TYPE_DRIVER;
03642 driverObject->Size =
sizeof(
DRIVER_OBJECT );
03643 ntHeaders =
RtlImageNtHeader( imageBaseAddress );
03644 entryPoint = ntHeaders->OptionalHeader.AddressOfEntryPoint;
03645 entryPoint += (ULONG_PTR) imageBaseAddress;
03646
if (!(ntHeaders->OptionalHeader.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_WDM_DRIVER)) {
03647 driverObject->Flags |=
DRVO_LEGACY_DRIVER;
03648 }
03649 driverObject->DriverInit = (
PDRIVER_INITIALIZE) entryPoint;
03650 driverObject->DriverSection = sectionPointer;
03651 driverObject->DriverStart = imageBaseAddress;
03652 driverObject->DriverSize = ntHeaders->OptionalHeader.SizeOfImage;
03653
03654 status =
ObInsertObject( driverObject,
03655 (
PACCESS_STATE)
NULL,
03656 FILE_READ_DATA,
03657 0,
03658 (PVOID *)
NULL,
03659 &driverHandle );
03660
if (!
NT_SUCCESS( status )) {
03661
IopBootLog(&baseName,
FALSE);
03662
goto IopLoadExit;
03663 }
03664
03665
03666
03667
03668
03669
03670 status =
ObReferenceObjectByHandle( driverHandle,
03671 0,
03672
IoDriverObjectType,
03673 KeGetPreviousMode(),
03674 (PVOID *) &driverObject,
03675 (
POBJECT_HANDLE_INFORMATION)
NULL );
03676
03677
NtClose( driverHandle );
03678
03679
03680
03681
03682
03683
03684 driverObject->HardwareDatabase =
03685 &
CmRegistryMachineHardwareDescriptionSystemName;
03686
03687
03688
03689
03690
03691
03692 driverObject->DriverName.Buffer =
ExAllocatePool(
PagedPool,
03693 driverName.MaximumLength );
03694
if (driverObject->DriverName.Buffer) {
03695 driverObject->DriverName.MaximumLength = driverName.MaximumLength;
03696 driverObject->DriverName.Length = driverName.Length;
03697
03698 RtlCopyMemory( driverObject->DriverName.Buffer,
03699 driverName.Buffer,
03700 driverName.MaximumLength );
03701 }
03702
03703
03704
03705
03706
03707
03708 registryPath =
ExAllocatePool(
NonPagedPool,
PAGE_SIZE );
03709
if (!registryPath) {
03710
ObMakeTemporaryObject( driverObject );
03711
ObDereferenceObject( driverObject );
03712 status = STATUS_INSUFFICIENT_RESOURCES;
03713
goto IopLoadExit;
03714 }
03715
03716 status =
NtQueryObject( KeyHandle,
03717 ObjectNameInformation,
03718 registryPath,
03719
PAGE_SIZE,
03720 &i );
03721
if (!
NT_SUCCESS( status )) {
03722
ObMakeTemporaryObject( driverObject );
03723
ObDereferenceObject( driverObject );
03724
ExFreePool( registryPath );
03725
goto IopLoadExit;
03726 }
03727
03728
#if DBG
03729
KeQuerySystemTime (&stime);
03730
#endif
03731
03732
03733
03734
03735
03736
if (serviceName.Buffer) {
03737 driverObject->DriverExtension->ServiceKeyName.Buffer =
03738
ExAllocatePool(
NonPagedPool, serviceName.MaximumLength );
03739
if (driverObject->DriverExtension->ServiceKeyName.Buffer) {
03740 driverObject->DriverExtension->ServiceKeyName.MaximumLength = serviceName.MaximumLength;
03741 driverObject->DriverExtension->ServiceKeyName.Length = serviceName.Length;
03742
03743 RtlCopyMemory( driverObject->DriverExtension->ServiceKeyName.Buffer,
03744 serviceName.Buffer,
03745 serviceName.MaximumLength );
03746 }
03747 }
03748
03749
03750
03751
03752
03753
PERFINFO_DRIVER_INIT(driverObject);
03754
03755 status = driverObject->DriverInit( driverObject, ®istryPath->Name );
03756
03757
PERFINFO_DRIVER_INIT_COMPLETE(driverObject);
03758
03759
#if DBG
03760
03761
03762
03763
03764
03765
KeQuerySystemTime (&etime);
03766 dtime = (ULONG) ((etime.QuadPart - stime.QuadPart) / 1000000);
03767
03768
if (dtime > 50) {
03769
DbgPrint(
"IOLOAD: Driver %wZ took %d.%ds to %s\n",
03770 &driverName,
03771 dtime/10,
03772 dtime%10,
03773
NT_SUCCESS(status) ?
"initialize" :
"fail initialization"
03774 );
03775
03776 }
03777
#endif
03778
03779
03780
03781
03782
03783
for (i = 0; i <=
IRP_MJ_MAXIMUM_FUNCTION; i++) {
03784
if (driverObject->MajorFunction[i] ==
NULL) {
03785
ASSERT(driverObject->MajorFunction[i] !=
NULL);
03786 driverObject->MajorFunction[i] =
IopInvalidDeviceRequest;
03787 }
03788 }
03789
03790
03791
03792
03793
03794
03795
ExFreePool( registryPath );
03796
03797
03798
03799
03800
03801
03802
03803
if (
NT_SUCCESS(status) && !
IopIsLegacyDriver(driverObject)) {
03804
if (driverObject->DeviceObject ==
NULL &&
03805 serviceName.Buffer &&
03806 !
IopIsAnyDeviceInstanceEnabled(&serviceName,
NULL,
FALSE) &&
03807 !(driverObject->Flags &
DRVO_REINIT_REGISTERED)) {
03808
IopDriverLoadingFailed(KeyHandle,
NULL);
03809 status = STATUS_PLUGPLAY_NO_DEVICE;
03810 }
else {
03811
03812
03813
03814
03815
03816
03817
IopDeleteLegacyKey(driverObject);
03818
if (
PnPInitialized) {
03819 status =
IopStartDriverDevices(driverObject);
03820 }
03821 }
03822
if (!
NT_SUCCESS(status)) {
03823
if (driverObject->DriverUnload) {
03824 driverObject->Flags |=
DRVO_UNLOAD_INVOKED;
03825 driverObject->DriverUnload(driverObject);
03826
IopBootLog(&baseName,
FALSE);
03827 }
else {
03828
#if DBG
03829
DbgPrint(
"IopLoadDriver: A PnP driver %wZ does not support DriverUnload routine.\n", &driverName);
03830
03831
#endif
03832
}
03833 }
03834 }
03835
03836
if (!
NT_SUCCESS( status )) {
03837
ObMakeTemporaryObject( driverObject );
03838
ObDereferenceObject( driverObject );
03839 }
else {
03840
03841
03842
03843
03844
03845
IopBootLog(&baseName,
TRUE);
03846
MmFreeDriverInitialization( driverObject->DriverSection );
03847
IopReadyDeviceObjects( driverObject );
03848 }
03849
03850 IopLoadExit:
03851
03852
03853
03854
03855
03856
03857
if (driverName.Buffer !=
NULL) {
03858
ExFreePool( driverName.Buffer );
03859 }
03860
03861
if (keyValueInformation !=
NULL) {
03862
ExFreePool( keyValueInformation );
03863 }
03864
03865
if (keyBasicInformation !=
NULL) {
03866
ExFreePool( keyBasicInformation );
03867 }
03868
03869
if (serviceName.Buffer !=
NULL) {
03870
ExFreePool(serviceName.Buffer);
03871 }
03872
03873
03874
03875
03876
03877
03878
03879
if (!
NT_SUCCESS( status ) && (status != STATUS_PLUGPLAY_NO_DEVICE)) {
03880
03881
NTSTATUS lStatus;
03882 PULONG errorControl;
03883
03884
if (status != STATUS_IMAGE_ALREADY_LOADED) {
03885
03886
03887
03888
03889
03890
03891
03892
IopDriverLoadingFailed(KeyHandle,
NULL);
03893 lStatus =
IopGetRegistryValue( KeyHandle,
03894
L"ErrorControl",
03895 &keyValueInformation );
03896
if (!
NT_SUCCESS( lStatus ) || !keyValueInformation->DataLength) {
03897
if (
NT_SUCCESS( lStatus )) {
03898
ExFreePool( keyValueInformation );
03899 }
03900 }
else {
03901 errorControl = (PULONG) ((PUCHAR) keyValueInformation + keyValueInformation->DataOffset);
03902
CmBootLastKnownGood( *errorControl );
03903
ExFreePool( keyValueInformation );
03904 }
03905 }
03906 }
03907
03908
03909
03910
03911
03912
03913
NtClose( KeyHandle );
03914
return status;
03915 }
03916
03917
03918
PDEVICE_OBJECT
03919 IopGetDeviceAttachmentBase(
03920 IN
PDEVICE_OBJECT DeviceObject
03921 )
03922
03923
03924
03925
03926
03927
03928
03929
03930
03931
03932
03933
03934
03935
03936
03937
03938
03939
03940
03941
03942
03943
03944
03945 {
03946
PDEVICE_OBJECT baseDeviceObject;
03947
PDEVOBJ_EXTENSION deviceExtension;
03948
03949
03950
03951
03952
03953
03954 baseDeviceObject = DeviceObject;
03955 deviceExtension = baseDeviceObject->
DeviceObjectExtension;
03956
while (deviceExtension->
AttachedTo !=
NULL) {
03957
03958 baseDeviceObject = deviceExtension->
AttachedTo;
03959 deviceExtension = baseDeviceObject->
DeviceObjectExtension;
03960 }
03961
03962
return baseDeviceObject;
03963 }
03964
03965
03966
PDEVICE_OBJECT
03967 IopGetDeviceAttachmentBaseRef(
03968 IN
PDEVICE_OBJECT DeviceObject
03969 )
03970
03971
03972
03973
03974
03975
03976
03977
03978
03979
03980
03981
03982
03983
03984
03985
03986
03987
03988
03989
03990
03991
03992
03993
03994 {
03995
PDEVICE_OBJECT baseDeviceObject;
03996 KIRQL irql;
03997
03998
03999
04000
04001
04002
04003 ExAcquireSpinLock( &
IopDatabaseLock, &irql );
04004
04005
04006
04007
04008
04009 baseDeviceObject =
IopGetDeviceAttachmentBase( DeviceObject );
04010
04011
04012
04013
04014
04015
ObReferenceObject( baseDeviceObject );
04016 ExReleaseSpinLock( &
IopDatabaseLock, irql );
04017
04018
return baseDeviceObject;
04019 }
04020
04021
VOID
04022 IopDecrementDeviceObjectRef(
04023 IN
PDEVICE_OBJECT DeviceObject,
04024 IN BOOLEAN AlwaysUnload
04025 )
04026
04027
04028
04029
04030
04031
04032
04033
04034
04035
04036
04037
04038
04039
04040
04041
04042
04043
04044
04045
04046
04047
04048
04049
04050 {
04051 KIRQL irql;
04052
04053
04054
04055
04056
04057
04058
04059 ExAcquireSpinLock( &
IopDatabaseLock, &irql );
04060
04061
ASSERT( DeviceObject->ReferenceCount > 0 );
04062
04063 DeviceObject->ReferenceCount--;
04064
04065
if (!DeviceObject->ReferenceCount && (AlwaysUnload ||
04066 DeviceObject->DeviceObjectExtension->ExtensionFlags &
04067 (
DOE_DELETE_PENDING |
DOE_UNLOAD_PENDING |
DOE_REMOVE_PENDING))) {
04068
04069
IopCompleteUnloadOrDelete( DeviceObject, irql );
04070 }
else {
04071 ExReleaseSpinLock( &
IopDatabaseLock, irql );
04072 }
04073
04074 }
04075
04076
VOID
04077 IopLoadFileSystemDriver(
04078 IN
PDEVICE_OBJECT DeviceObject
04079 )
04080
04081
04082
04083
04084
04085
04086
04087
04088
04089
04090
04091
04092
04093
04094
04095
04096
04097
04098
04099
04100
04101 {
04102
KEVENT event;
04103
NTSTATUS status;
04104 IO_STATUS_BLOCK ioStatus;
04105
PIRP irp;
04106
PIO_STACK_LOCATION irpSp;
04107
PDEVICE_OBJECT attachedDevice;
04108
04109
PAGED_CODE();
04110
04111 attachedDevice = DeviceObject;
04112
while (attachedDevice->
AttachedDevice) {
04113 attachedDevice = attachedDevice->
AttachedDevice;
04114 }
04115
04116
04117
04118
04119
04120
04121
KeInitializeEvent( &event, NotificationEvent,
FALSE );
04122
04123 irp =
IoBuildDeviceIoControlRequest(
IRP_MJ_DEVICE_CONTROL,
04124 attachedDevice,
04125 (PVOID)
NULL,
04126 0,
04127 (PVOID)
NULL,
04128 0,
04129
FALSE,
04130 &event,
04131 &ioStatus );
04132
if (irp) {
04133
04134
04135
04136
04137
04138
04139 irpSp =
IoGetNextIrpStackLocation( irp );
04140 irpSp->
MajorFunction =
IRP_MJ_FILE_SYSTEM_CONTROL;
04141 irpSp->
MinorFunction =
IRP_MN_LOAD_FILE_SYSTEM;
04142
04143
04144
04145
04146
04147 status =
IoCallDriver( attachedDevice, irp );
04148
if (status == STATUS_PENDING) {
04149 (
VOID)
KeWaitForSingleObject( &event,
04150
Executive,
04151
KernelMode,
04152
FALSE,
04153 (PLARGE_INTEGER)
NULL );
04154 }
04155 }
04156
04157
04158
04159
04160
04161
04162
04163
IopDecrementDeviceObjectRef(DeviceObject,
TRUE);
04164
04165
return;
04166 }
04167
04168
VOID
04169 IopLoadUnloadDriver(
04170 IN PVOID Parameter
04171 )
04172
04173
04174
04175
04176
04177
04178
04179
04180
04181
04182
04183
04184
04185
04186
04187
04188
04189
04190
04191
04192
04193
04194 {
04195
PLOAD_PACKET loadPacket;
04196
NTSTATUS status;
04197 HANDLE keyHandle;
04198
04199
PAGED_CODE();
04200
04201
04202
04203
04204
04205 loadPacket = (
PLOAD_PACKET) Parameter;
04206
04207
04208
04209
04210
04211
04212
04213
04214
if (loadPacket->
DriverObject) {
04215
04216 loadPacket->
DriverObject->
DriverUnload( loadPacket->
DriverObject );
04217 status = STATUS_SUCCESS;
04218
04219 }
else {
04220
04221 PLIST_ENTRY entry;
04222
PREINIT_PACKET reinitEntry;
04223
04224
04225
04226
04227
04228
04229
04230
04231 status =
IopOpenRegistryKey( &keyHandle,
04232 (HANDLE)
NULL,
04233 loadPacket->
DriverServiceName,
04234 KEY_READ,
04235
FALSE );
04236
if (
NT_SUCCESS( status )) {
04237
04238
04239
04240
04241
04242
04243
04244 status =
IopLoadDriver( keyHandle,
TRUE );
04245
04246
04247
04248
04249
04250
04251
04252
while (entry =
ExInterlockedRemoveHeadList( &
IopDriverReinitializeQueueHead, &
IopDatabaseLock )) {
04253 reinitEntry = CONTAINING_RECORD( entry,
REINIT_PACKET, ListEntry );
04254
04255 reinitEntry->
DriverObject->
DriverExtension->
Count++;
04256 reinitEntry->
DriverObject->
Flags &= ~
DRVO_REINIT_REGISTERED;
04257 reinitEntry->
DriverReinitializationRoutine( reinitEntry->
DriverObject,
04258 reinitEntry->
Context,
04259 reinitEntry->
DriverObject->
DriverExtension->
Count );
04260
04261
#if 0
04262
reinitEntry->
DriverObject->Count++;
04263 reinitEntry->
DriverReinitializationRoutine( reinitEntry->
DriverObject,
04264 reinitEntry->
Context,
04265 reinitEntry->
DriverObject->Count );
04266
#endif // _PNP_POWER_
04267
ExFreePool( reinitEntry );
04268 }
04269 }
04270 }
04271
04272
04273
04274
04275
04276
04277 loadPacket->
FinalStatus = status;
04278 (
VOID)
KeSetEvent( &loadPacket->
Event, 0,
FALSE );
04279 }
04280
04281
NTSTATUS
04282 IopMountVolume(
04283 IN
PDEVICE_OBJECT DeviceObject,
04284 IN BOOLEAN AllowRawMount,
04285 IN BOOLEAN DeviceLockAlreadyHeld,
04286 IN BOOLEAN Alertable
04287 )
04288
04289
04290
04291
04292
04293
04294
04295
04296
04297
04298
04299
04300
04301
04302
04303
04304
04305
04306
04307
04308
04309
04310
04311
04312
04313
04314
04315
04316
04317
04318
04319
04320 {
04321
NTSTATUS status;
04322
KEVENT event;
04323
PIRP irp;
04324
PDEVICE_OBJECT fsDeviceObject;
04325
PDEVICE_OBJECT attachedDevice;
04326 PLIST_ENTRY entry;
04327 PLIST_ENTRY queueHeader;
04328 IO_STATUS_BLOCK ioStatus;
04329
PIO_STACK_LOCATION irpSp;
04330 ULONG extraStack;
04331 LIST_ENTRY
dummy;
04332 ULONG rawMountOnly;
04333
04334
PAGED_CODE();
04335
04336
04337
04338
04339
04340
04341
04342
if (!DeviceLockAlreadyHeld) {
04343
04344 status =
KeWaitForSingleObject( &DeviceObject->DeviceLock,
04345
Executive,
04346 KeGetPreviousMode(),
04347 Alertable,
04348 (PLARGE_INTEGER)
NULL );
04349
04350
04351
04352
04353
04354
04355
04356
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
04357
04358
return status;
04359 }
04360 }
04361
04362
04363
04364
04365
04366
04367
04368 (
VOID)
ExAcquireResourceShared( &
IopDatabaseResource,
TRUE );
04369
04370
04371
04372
04373
04374
04375
04376
if ((DeviceObject->Vpb->Flags & (
VPB_MOUNTED |
VPB_REMOVE_PENDING)) == 0) {
04377
04378
04379
04380
04381
04382
04383
04384
KeInitializeEvent( &event, NotificationEvent,
FALSE );
04385 status = STATUS_UNSUCCESSFUL;
04386 DeviceObject->Flags &= ~
DO_VERIFY_VOLUME;
04387
04388
04389
04390
04391
04392
04393
04394 attachedDevice = DeviceObject;
04395
while (attachedDevice->
AttachedDevice) {
04396 attachedDevice = attachedDevice->
AttachedDevice;
04397 }
04398
04399
04400
04401
04402
04403
ObReferenceObject( attachedDevice );
04404
04405
04406
04407
04408
04409
04410
if (DeviceObject->DeviceType == FILE_DEVICE_DISK ||
04411 DeviceObject->DeviceType == FILE_DEVICE_VIRTUAL_DISK) {
04412 queueHeader = &
IopDiskFileSystemQueueHead;
04413 }
else if (DeviceObject->DeviceType == FILE_DEVICE_CD_ROM) {
04414 queueHeader = &
IopCdRomFileSystemQueueHead;
04415 }
else {
04416 queueHeader = &
IopTapeFileSystemQueueHead;
04417 }
04418
04419 rawMountOnly = (DeviceObject->Vpb->Flags &
VPB_RAW_MOUNT);
04420
04421
04422
04423
04424
04425
04426
for (entry = queueHeader->Flink;
04427 entry != queueHeader && !
NT_SUCCESS( status );
04428 entry = entry->Flink) {
04429
04430
PDEVICE_OBJECT savedFsDeviceObject;
04431
04432
04433
04434
04435
04436
04437
04438
04439
if (!AllowRawMount && entry->Flink == queueHeader && entry != queueHeader->Flink) {
04440
break;
04441 }
04442
04443
04444
04445
04446
04447
if (rawMountOnly && (entry->Flink != queueHeader)) {
04448
continue;
04449 }
04450
04451 fsDeviceObject = CONTAINING_RECORD( entry,
DEVICE_OBJECT, Queue.ListEntry );
04452 savedFsDeviceObject = fsDeviceObject;
04453
04454
04455
04456
04457
04458
04459
04460
04461
04462
04463 extraStack = 1;
04464
04465
while (fsDeviceObject->AttachedDevice) {
04466 fsDeviceObject = fsDeviceObject->
AttachedDevice;
04467 extraStack++;
04468 }
04469
04470
04471
04472
04473
04474
04475
04476
04477
04478
04479
KeClearEvent( &event );
04480
04481
04482
04483
04484
04485
04486
04487
04488 irp =
IopAllocateIrpMustSucceed( (CCHAR) (attachedDevice->
StackSize + extraStack) );
04489 irp->
Flags =
IRP_MOUNT_COMPLETION |
IRP_SYNCHRONOUS_PAGING_IO;
04490 irp->
RequestorMode =
KernelMode;
04491 irp->
UserEvent = &event;
04492 irp->
UserIosb = &ioStatus;
04493 irp->
Tail.Overlay.Thread =
PsGetCurrentThread();
04494 irpSp =
IoGetNextIrpStackLocation( irp );
04495 irpSp->
MajorFunction =
IRP_MJ_FILE_SYSTEM_CONTROL;
04496 irpSp->
MinorFunction =
IRP_MN_MOUNT_VOLUME;
04497 irpSp->
Flags = AllowRawMount;
04498 irpSp->
Parameters.MountVolume.Vpb = DeviceObject->Vpb;
04499 irpSp->
Parameters.MountVolume.DeviceObject = attachedDevice;
04500
04501 status =
IoCallDriver( fsDeviceObject, irp );
04502
04503
04504
04505
04506
04507
if (
NT_SUCCESS( status )) {
04508 (
VOID)
KeWaitForSingleObject( &event,
04509
Executive,
04510
KernelMode,
04511
FALSE,
04512 (PLARGE_INTEGER)
NULL );
04513 }
else {
04514
04515
04516
04517
04518
04519 ioStatus.Status = status;
04520 ioStatus.Information = 0;
04521 }
04522
04523
04524
04525
04526
04527
if (
NT_SUCCESS( ioStatus.Status )) {
04528 status = ioStatus.Status;
04529 DeviceObject->Vpb->Flags =
VPB_MOUNTED;
04530
04531
04532
04533
04534
04535
04536
if (rawMountOnly) {
04537 DeviceObject->Vpb->Flags |=
VPB_RAW_MOUNT;
04538 }
04539 DeviceObject->Vpb->DeviceObject->StackSize = (UCHAR) (attachedDevice->
StackSize + 1);
04540
04541 }
else {
04542
04543
04544
04545
04546
04547
04548
04549
04550 status = ioStatus.Status;
04551
if (
IoIsErrorUserInduced(status) &&
04552 ioStatus.Information ==
IOP_ABORT) {
04553
break;
04554 }
04555
04556
04557
04558
04559
04560
04561
04562
04563
04564
if (status == STATUS_FS_DRIVER_REQUIRED) {
04565
04566
04567
04568
04569
04570
04571
04572
ExInterlockedAddUlong( &savedFsDeviceObject->
ReferenceCount,
04573 1,
04574 &
IopDatabaseLock );
04575
04576
04577
04578
04579
04580
04581
ExReleaseResource( &
IopDatabaseResource );
04582
04583
if (!DeviceLockAlreadyHeld) {
04584
KeSetEvent( &DeviceObject->DeviceLock, 0,
FALSE );
04585 }
04586
IopLoadFileSystemDriver( savedFsDeviceObject );
04587
04588
04589
04590
04591
04592
04593
04594
04595
if (!DeviceLockAlreadyHeld) {
04596 status =
KeWaitForSingleObject( &DeviceObject->DeviceLock,
04597
Executive,
04598 KeGetPreviousMode(),
04599 Alertable,
04600 (PLARGE_INTEGER)
NULL );
04601
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
04602
04603
04604
04605
04606
04607
04608
ObDereferenceObject( attachedDevice );
04609
04610
return status;
04611 }
04612 }
04613
04614
04615 (
VOID)
ExAcquireResourceShared( &
IopDatabaseResource,
TRUE );
04616
04617
if (DeviceObject->Vpb->Flags &
VPB_MOUNTED) {
04618
04619
04620
04621
04622
04623 status = STATUS_SUCCESS;
04624
break;
04625 }
04626
04627
04628
04629
04630
04631
04632
dummy.Flink = queueHeader->Flink;
04633 entry = &
dummy;
04634 status = STATUS_UNRECOGNIZED_VOLUME;
04635 }
04636
04637
04638
04639
04640
04641
04642
04643
if (!AllowRawMount && (status != STATUS_UNRECOGNIZED_VOLUME) &&
04644
FsRtlIsTotalDeviceFailure(status)) {
04645
break;
04646 }
04647 }
04648 }
04649
04650
if (!
NT_SUCCESS(status)) {
04651
04652
04653
04654
04655
04656
04657
ObDereferenceObject( attachedDevice );
04658
04659 }
04660
04661 }
else if((DeviceObject->Vpb->Flags &
VPB_REMOVE_PENDING) != 0) {
04662
04663
04664
04665
04666
04667 status = STATUS_DEVICE_DOES_NOT_EXIST;
04668
04669 }
else {
04670
04671
04672
04673
04674
04675
04676 status = STATUS_SUCCESS;
04677 }
04678
04679
ExReleaseResource( &
IopDatabaseResource );
04680
04681
04682
04683
04684
04685
04686
04687
if (!DeviceLockAlreadyHeld) {
04688
KeSetEvent( &DeviceObject->DeviceLock, 0,
FALSE );
04689 }
04690
04691
04692
04693
04694
04695
04696
04697
04698
04699
if (!
NT_SUCCESS( status ) &&
04700 DeviceObject->Flags &
DO_SYSTEM_BOOT_PARTITION &&
04701
InitializationPhase < 2) {
04702
KeBugCheckEx( INACCESSIBLE_BOOT_DEVICE, (ULONG_PTR) DeviceObject, status, 0, 0 );
04703 }
04704
04705
return status;
04706 }
04707
04708
04709
NTSTATUS
04710 IopInvalidateVolumesForDevice(
04711 IN
PDEVICE_OBJECT DeviceObject
04712 )
04713
04714
04715
04716
04717
04718
04719
04720
04721
04722
04723
04724
04725
04726
04727
04728
04729
04730
04731
04732
04733 {
04734
NTSTATUS status;
04735
NTSTATUS finalStatus;
04736
KEVENT event;
04737
PIRP irp;
04738
PDEVICE_OBJECT fsDeviceObject;
04739
PDEVICE_OBJECT attachedDevice;
04740
PFILE_OBJECT storageFileObject;
04741 HANDLE storageHandle;
04742 PLIST_ENTRY entry;
04743 PLIST_ENTRY queueHeader;
04744 IO_STATUS_BLOCK ioStatus;
04745
PIO_STACK_LOCATION irpSp;
04746
04747
PAGED_CODE();
04748
04749
04750
04751
04752
04753
04754
KeEnterCriticalRegion();
04755 (
VOID)
ExAcquireResourceShared( &
IopDatabaseResource,
TRUE );
04756
04757
04758
04759
04760
04761
04762 attachedDevice = DeviceObject;
04763
while (attachedDevice->
AttachedDevice) {
04764 attachedDevice = attachedDevice->
AttachedDevice;
04765 }
04766
04767
04768
04769
04770
04771
04772
04773
04774
04775
try {
04776
04777 storageFileObject =
NULL;
04778 storageFileObject =
IoCreateStreamFileObjectLite(
NULL, attachedDevice );
04779 storageFileObject->
Vpb = attachedDevice->
Vpb;
04780
04781 storageHandle =
NULL;
04782 status =
ObOpenObjectByPointer( storageFileObject,
04783 OBJ_KERNEL_HANDLE,
04784
NULL,
04785 0,
04786
IoFileObjectType,
04787
KernelMode,
04788 &storageHandle );
04789
04790 } except(
EXCEPTION_EXECUTE_HANDLER) {
04791
04792 status = GetExceptionCode();
04793 }
04794
04795
if (
NT_SUCCESS( status )) {
04796
04797
04798
04799
04800
04801
04802
if (DeviceObject->DeviceType == FILE_DEVICE_DISK ||
04803 DeviceObject->DeviceType == FILE_DEVICE_VIRTUAL_DISK) {
04804 queueHeader = &
IopDiskFileSystemQueueHead;
04805 }
else if (DeviceObject->DeviceType == FILE_DEVICE_CD_ROM) {
04806 queueHeader = &
IopCdRomFileSystemQueueHead;
04807 }
else {
04808 queueHeader = &
IopTapeFileSystemQueueHead;
04809 }
04810
04811
04812
04813
04814
04815
04816
KeInitializeEvent( &event, NotificationEvent,
FALSE );
04817 finalStatus = STATUS_SUCCESS;
04818
04819
04820
04821
04822
04823
04824
04825
for (entry = queueHeader->Flink;
04826 entry != queueHeader;
04827 entry = entry->Flink) {
04828
04829
04830
04831
04832
04833
04834
04835
if (entry->Flink == queueHeader) {
04836
break;
04837 }
04838
04839 fsDeviceObject = CONTAINING_RECORD( entry,
DEVICE_OBJECT, Queue.ListEntry );
04840
04841
04842
04843
04844
04845
04846
while (fsDeviceObject->
AttachedDevice) {
04847 fsDeviceObject = fsDeviceObject->
AttachedDevice;
04848 }
04849
04850
04851
04852
04853
04854
04855
04856
04857
04858
KeClearEvent( &event );
04859
04860
04861
04862
04863
04864 irp =
IoBuildDeviceIoControlRequest( FSCTL_INVALIDATE_VOLUMES,
04865 fsDeviceObject,
04866 &storageHandle,
04867
sizeof(HANDLE),
04868
NULL,
04869 0,
04870
FALSE,
04871 &event,
04872 &ioStatus );
04873
04874
if (irp ==
NULL) {
04875
04876 finalStatus = STATUS_INSUFFICIENT_RESOURCES;
04877
break;
04878 }
04879
04880 irpSp =
IoGetNextIrpStackLocation( irp );
04881 irpSp->
MajorFunction =
IRP_MJ_FILE_SYSTEM_CONTROL;
04882
04883 status =
IoCallDriver( fsDeviceObject, irp );
04884
04885
04886
04887
04888
04889
if (status == STATUS_PENDING) {
04890 (
VOID)
KeWaitForSingleObject( &event,
04891
Executive,
04892
KernelMode,
04893
FALSE,
04894 (PLARGE_INTEGER)
NULL );
04895
04896 status = ioStatus.Status;
04897
04898 }
else {
04899
04900
04901
04902
04903
04904 ioStatus.Status = status;
04905 ioStatus.Information = 0;
04906 }
04907
04908
04909
04910
04911
04912
04913
04914
if (status == STATUS_INVALID_DEVICE_REQUEST ||
04915 status == STATUS_NOT_IMPLEMENTED) {
04916
04917 status = STATUS_SUCCESS;
04918 }
04919
04920
04921
04922
04923
04924
if (
NT_SUCCESS( finalStatus ) && !
NT_SUCCESS( status )) {
04925 finalStatus = status;
04926 }
04927 }
04928
04929
if (storageFileObject) {
04930
ObDereferenceObject( storageFileObject );
04931
if (storageHandle) {
04932 ZwClose( storageHandle );
04933 }
04934 }
04935
04936 status = finalStatus;
04937 }
04938
04939
ExReleaseResource( &
IopDatabaseResource );
04940
KeLeaveCriticalRegion();
04941
04942
return status;
04943 }
04944
04945
04946 BOOLEAN
04947 IopNotifyPnpWhenChainDereferenced(
04948 IN
PDEVICE_OBJECT *PhysicalDeviceObjects,
04949 IN ULONG DeviceObjectCount,
04950 IN BOOLEAN Query,
04951 OUT
PDEVICE_OBJECT *VetoingDevice
04952 )
04953
04954
04955
04956
04957
04958
04959
04960
04961
04962
04963
04964
04965
04966
04967
04968
04969
04970
04971
04972
04973
04974
04975
04976
04977
04978
04979
04980
04981
04982
04983
04984
04985
04986
04987
04988
04989
04990
04991
04992
04993
04994
04995
04996
04997
04998
04999
05000
05001
05002
05003 {
05004
PDEVOBJ_EXTENSION deviceExtension;
05005
PDEVICE_OBJECT deviceObject;
05006
PDEVICE_OBJECT attachedDeviceObject;
05007
PDEVICE_NODE deviceNode;
05008 ULONG referenced;
05009 ULONG pass1SetFlag;
05010 ULONG pass1ClearFlag;
05011 LONG i;
05012 KIRQL irql;
05013
05014 ExAcquireSpinLock( &
IopDatabaseLock, &irql );
05015
05016
if (Query) {
05017 pass1SetFlag =
DOE_REMOVE_PROCESSED;
05018 pass1ClearFlag = 0;
05019 }
else {
05020 pass1SetFlag =
DOE_REMOVE_PENDING;
05021 pass1ClearFlag =
DOE_REMOVE_PROCESSED;
05022 }
05023
05024
for (i = 0; i < (LONG)DeviceObjectCount; i++) {
05025 deviceObject = PhysicalDeviceObjects[i];
05026 deviceExtension = deviceObject->
DeviceObjectExtension;
05027
05028 deviceNode = (
PDEVICE_NODE)deviceExtension->
DeviceNode;
05029
05030
ASSERT( deviceNode !=
NULL );
05031
05032
05033
05034
05035
05036
05037
05038
05039
05040
05041
05042
05043
05044
05045
05046 referenced = 0;
05047 attachedDeviceObject = deviceObject;
05048
do {
05049 deviceExtension = attachedDeviceObject->
DeviceObjectExtension;
05050
05051
ASSERT(deviceExtension !=
NULL);
05052
ASSERT(!(deviceExtension->
ExtensionFlags & pass1SetFlag));
05053
05054
05055 deviceExtension->
ExtensionFlags &= ~pass1ClearFlag;
05056 deviceExtension->
ExtensionFlags |= pass1SetFlag;
05057 referenced |= attachedDeviceObject->
ReferenceCount;
05058
05059 attachedDeviceObject = attachedDeviceObject->
AttachedDevice;
05060
05061 }
while (attachedDeviceObject !=
NULL);
05062
05063
if (!Query && referenced == 0) {
05064
05065
05066
05067
05068
05069
05070
05071
05072 attachedDeviceObject = deviceObject;
05073
do {
05074 deviceExtension = attachedDeviceObject->
DeviceObjectExtension;
05075
05076 deviceExtension->
ExtensionFlags &= ~
DOE_REMOVE_PENDING;
05077 deviceExtension->
ExtensionFlags |=
DOE_REMOVE_PROCESSED;
05078
05079 attachedDeviceObject = attachedDeviceObject->
AttachedDevice;
05080
05081 }
while (attachedDeviceObject !=
NULL);
05082
05083 ExReleaseSpinLock( &
IopDatabaseLock, irql );
05084
05085
IopChainDereferenceComplete( deviceObject );
05086
05087 ExAcquireSpinLock( &
IopDatabaseLock, &irql );
05088 }
else if (Query && referenced != 0) {
05089
break;
05090 }
05091 }
05092
05093
if (Query && referenced != 0) {
05094
05095
if (VetoingDevice !=
NULL) {
05096 *VetoingDevice = deviceObject;
05097 }
05098
05099
for (; i >= 0; i--) {
05100 deviceObject = PhysicalDeviceObjects[i];
05101 deviceExtension = deviceObject->
DeviceObjectExtension;
05102
05103
05104
05105
05106
05107
05108 attachedDeviceObject = deviceObject;
05109
do {
05110 deviceExtension = attachedDeviceObject->
DeviceObjectExtension;
05111
05112 deviceExtension->
ExtensionFlags &= ~
DOE_REMOVE_PROCESSED;
05113
05114 attachedDeviceObject = attachedDeviceObject->
AttachedDevice;
05115
05116 }
while (attachedDeviceObject !=
NULL);
05117 }
05118 }
05119
05120 ExReleaseSpinLock( &
IopDatabaseLock, irql );
05121
05122
return !Query || referenced != 0;
05123 }
05124
05125
NTSTATUS
05126 IopOpenLinkOrRenameTarget(
05127 OUT PHANDLE TargetHandle,
05128 IN
PIRP Irp,
05129 IN PVOID RenameBuffer,
05130 IN
PFILE_OBJECT FileObject
05131 )
05132
05133
05134
05135
05136
05137
05138
05139
05140
05141
05142
05143
05144
05145
05146
05147
05148
05149
05150
05151
05152
05153
05154
05155
05156
05157
05158
05159
05160
05161
05162
05163
05164
05165
05166
05167
05168
05169
05170
05171
05172
05173
05174 {
05175
NTSTATUS status;
05176 IO_STATUS_BLOCK ioStatus;
05177 HANDLE handle;
05178 OBJECT_ATTRIBUTES objectAttributes;
05179 UNICODE_STRING newFileName;
05180
PIO_STACK_LOCATION irpSp;
05181
PFILE_OBJECT targetFileObject;
05182
OBJECT_HANDLE_INFORMATION handleInformation;
05183 PFILE_RENAME_INFORMATION renameBuffer = RenameBuffer;
05184
05185
PAGED_CODE();
05186
05187
ASSERT(
sizeof( FILE_RENAME_INFORMATION ) ==
05188
sizeof( FILE_LINK_INFORMATION ) );
05189
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION, ReplaceIfExists ) ==
05190 FIELD_OFFSET( FILE_LINK_INFORMATION, ReplaceIfExists ) );
05191
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION, RootDirectory ) ==
05192 FIELD_OFFSET( FILE_LINK_INFORMATION, RootDirectory ) );
05193
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION, FileNameLength ) ==
05194 FIELD_OFFSET( FILE_LINK_INFORMATION, FileNameLength ) );
05195
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION,
FileName ) ==
05196 FIELD_OFFSET( FILE_LINK_INFORMATION,
FileName ) );
05197
05198
ASSERT(
sizeof( FILE_RENAME_INFORMATION ) ==
05199
sizeof( FILE_MOVE_CLUSTER_INFORMATION ) );
05200
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION, ReplaceIfExists ) ==
05201 FIELD_OFFSET( FILE_MOVE_CLUSTER_INFORMATION, ClusterCount ) );
05202
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION, RootDirectory ) ==
05203 FIELD_OFFSET( FILE_MOVE_CLUSTER_INFORMATION, RootDirectory ) );
05204
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION, FileNameLength ) ==
05205 FIELD_OFFSET( FILE_MOVE_CLUSTER_INFORMATION, FileNameLength ) );
05206
ASSERT( FIELD_OFFSET( FILE_RENAME_INFORMATION,
FileName ) ==
05207 FIELD_OFFSET( FILE_MOVE_CLUSTER_INFORMATION,
FileName ) );
05208
05209
05210
05211
05212
05213
05214 newFileName.Length = (
USHORT) renameBuffer->FileNameLength;
05215 newFileName.MaximumLength = (
USHORT) renameBuffer->FileNameLength;
05216 newFileName.Buffer = renameBuffer->FileName;
05217
05218 InitializeObjectAttributes( &objectAttributes,
05219 &newFileName,
05220 FileObject->Flags &
FO_OPENED_CASE_SENSITIVE ? 0 : OBJ_CASE_INSENSITIVE,
05221 renameBuffer->RootDirectory,
05222 (PSECURITY_DESCRIPTOR)
NULL );
05223
05224 status =
IoCreateFile( &handle,
05225 FILE_WRITE_DATA | SYNCHRONIZE,
05226 &objectAttributes,
05227 &ioStatus,
05228 (PLARGE_INTEGER)
NULL,
05229 0,
05230 FILE_SHARE_READ | FILE_SHARE_WRITE,
05231 FILE_OPEN,
05232 FILE_OPEN_FOR_BACKUP_INTENT,
05233 (PVOID)
NULL,
05234 0
L,
05235
CreateFileTypeNone,
05236 (PVOID)
NULL,
05237
IO_NO_PARAMETER_CHECKING |
05238
IO_OPEN_TARGET_DIRECTORY |
05239
IO_FORCE_ACCESS_CHECK );
05240
if (
NT_SUCCESS( status )) {
05241
05242
05243
05244
05245
05246 irpSp =
IoGetNextIrpStackLocation(
Irp );
05247
if (irpSp->
Parameters.SetFile.FileInformationClass == FileLinkInformation &&
05248 !renameBuffer->ReplaceIfExists &&
05249 ioStatus.Information == FILE_EXISTS) {
05250
05251
05252
05253
05254
05255
05256
NtClose( handle );
05257 status = STATUS_OBJECT_NAME_COLLISION;
05258
05259 }
else {
05260
05261
05262
05263
05264
05265
05266
05267 status =
ObReferenceObjectByHandle( handle,
05268 FILE_WRITE_DATA,
05269
IoFileObjectType,
05270
UserMode,
05271 (PVOID *) &targetFileObject,
05272 &handleInformation );
05273
if (
NT_SUCCESS( status )) {
05274
05275
ObDereferenceObject( targetFileObject );
05276
05277
if (
IoGetRelatedDeviceObject( targetFileObject) !=
05278
IoGetRelatedDeviceObject( FileObject )) {
05279
05280
05281
05282
05283
05284
05285
NtClose( handle );
05286 status = STATUS_NOT_SAME_DEVICE;
05287
05288 }
else {
05289
05290
05291
05292
05293
05294
05295 irpSp->
Parameters.SetFile.FileObject = targetFileObject;
05296 *TargetHandle = handle;
05297 status = STATUS_SUCCESS;
05298
05299 }
05300
05301 }
else {
05302
05303
05304
05305
05306
05307
05308
05309
05310
NtClose( handle );
05311
05312 }
05313
05314 }
05315 }
05316
05317
05318
05319
05320
05321
return status;
05322 }
05323
05324
NTSTATUS
05325 IopOpenRegistryKey(
05326 OUT PHANDLE Handle,
05327 IN HANDLE BaseHandle OPTIONAL,
05328 IN PUNICODE_STRING KeyName,
05329 IN ACCESS_MASK DesiredAccess,
05330 IN BOOLEAN Create
05331 )
05332
05333
05334
05335
05336
05337
05338
05339
05340
05341
05342
05343
05344
05345
05346
05347
05348
05349
05350
05351
05352
05353
05354
05355
05356
05357
05358
05359
05360 {
05361 OBJECT_ATTRIBUTES objectAttributes;
05362 ULONG disposition;
05363
05364
PAGED_CODE();
05365
05366
05367
05368
05369
05370 InitializeObjectAttributes( &objectAttributes,
05371
KeyName,
05372 OBJ_CASE_INSENSITIVE,
05373 BaseHandle,
05374 (PSECURITY_DESCRIPTOR)
NULL );
05375
05376
05377
05378
05379
05380
05381
if (
Create) {
05382
return ZwCreateKey(
Handle,
05383 DesiredAccess,
05384 &objectAttributes,
05385 0,
05386 (PUNICODE_STRING)
NULL,
05387 REG_OPTION_VOLATILE,
05388 &disposition );
05389 }
else {
05390
return ZwOpenKey(
Handle,
05391 DesiredAccess,
05392 &objectAttributes );
05393 }
05394 }
05395
05396
NTSTATUS
05397 IopQueryXxxInformation(
05398 IN
PFILE_OBJECT FileObject,
05399 IN ULONG InformationClass,
05400 IN ULONG Length,
05401 OUT PVOID Information,
05402 OUT PULONG ReturnedLength,
05403 IN BOOLEAN FileInformation
05404 )
05405
05406
05407
05408
05409
05410
05411
05412
05413
05414
05415
05416
05417
05418
05419
05420
05421
05422
05423
05424
05425
05426
05427
05428
05429
05430
05431
05432
05433
05434
05435
05436
05437
05438
05439
05440 {
05441
PIRP irp;
05442
NTSTATUS status;
05443
PDEVICE_OBJECT deviceObject;
05444
KEVENT event;
05445
PIO_STACK_LOCATION irpSp;
05446 IO_STATUS_BLOCK localIoStatus;
05447 BOOLEAN synchronousIo;
05448
05449
PAGED_CODE();
05450
05451
05452
05453
05454
05455
05456
05457
ObReferenceObject( FileObject );
05458
05459
05460
05461
05462
05463
05464
05465
05466
if (FileObject->Flags &
FO_SYNCHRONOUS_IO) {
05467
05468 BOOLEAN interrupted;
05469
05470
if (!
IopAcquireFastLock( FileObject )) {
05471 status =
IopAcquireFileObjectLock( FileObject,
05472
KernelMode,
05473 (BOOLEAN) ((FileObject->Flags &
FO_ALERTABLE_IO) != 0),
05474 &interrupted );
05475
if (interrupted) {
05476
ObDereferenceObject( FileObject );
05477
return status;
05478 }
05479 }
05480
KeClearEvent( &FileObject->Event );
05481 synchronousIo =
TRUE;
05482 }
else {
05483
KeInitializeEvent( &event, SynchronizationEvent,
FALSE );
05484 synchronousIo =
FALSE;
05485 }
05486
05487
05488
05489
05490
05491 deviceObject =
IoGetRelatedDeviceObject( FileObject );
05492
05493
05494
05495
05496
05497
05498
05499 irp =
IoAllocateIrp( deviceObject->
StackSize,
TRUE );
05500
if (!irp) {
05501
05502
05503
05504
05505
05506
05507
IopAllocateIrpCleanup( FileObject, (
PKEVENT)
NULL );
05508
05509
return STATUS_INSUFFICIENT_RESOURCES;
05510 }
05511 irp->
Tail.Overlay.OriginalFileObject = FileObject;
05512 irp->
Tail.Overlay.Thread =
PsGetCurrentThread();
05513 irp->
RequestorMode =
KernelMode;
05514
05515
05516
05517
05518
05519
if (synchronousIo) {
05520 irp->
UserEvent = (
PKEVENT)
NULL;
05521 }
else {
05522 irp->
UserEvent = &event;
05523 irp->
Flags =
IRP_SYNCHRONOUS_API;
05524 }
05525 irp->
UserIosb = &localIoStatus;
05526 irp->
Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)
NULL;
05527
05528
05529
05530
05531
05532
05533 irpSp =
IoGetNextIrpStackLocation( irp );
05534 irpSp->
MajorFunction = FileInformation ?
05535
IRP_MJ_QUERY_INFORMATION :
05536
IRP_MJ_QUERY_VOLUME_INFORMATION;
05537 irpSp->
FileObject = FileObject;
05538
05539
05540
05541
05542
05543
05544 irp->
AssociatedIrp.SystemBuffer = Information;
05545 irp->
Flags |=
IRP_BUFFERED_IO;
05546
05547
05548
05549
05550
05551
05552
if (FileInformation) {
05553 irpSp->
Parameters.QueryFile.Length = Length;
05554 irpSp->
Parameters.QueryFile.FileInformationClass = InformationClass;
05555 }
else {
05556 irpSp->
Parameters.QueryVolume.Length = Length;
05557 irpSp->
Parameters.QueryVolume.FsInformationClass = InformationClass;
05558 }
05559
05560
05561
05562
05563
05564
IopQueueThreadIrp( irp );
05565
05566
05567
05568
05569
05570 status =
IoCallDriver( deviceObject, irp );
05571
05572
05573
05574
05575
05576
05577
05578
05579
if (synchronousIo) {
05580
if (status == STATUS_PENDING) {
05581 status =
KeWaitForSingleObject( &FileObject->Event,
05582
Executive,
05583
KernelMode,
05584 (BOOLEAN) ((FileObject->Flags &
FO_ALERTABLE_IO) != 0),
05585 (PLARGE_INTEGER)
NULL );
05586
if (status == STATUS_ALERTED) {
05587
IopCancelAlertedRequest( &FileObject->Event, irp );
05588 }
05589 status = FileObject->FinalStatus;
05590 }
05591
IopReleaseFileObjectLock( FileObject );
05592
05593 }
else {
05594
05595
05596
05597
05598
05599
05600
05601
05602
if (status == STATUS_PENDING) {
05603 (
VOID)
KeWaitForSingleObject( &event,
05604
Executive,
05605
KernelMode,
05606
FALSE,
05607 (PLARGE_INTEGER)
NULL );
05608 status = localIoStatus.Status;
05609 }
05610 }
05611
05612 *ReturnedLength = (ULONG) localIoStatus.Information;
05613
return status;
05614 }
05615
05616
VOID
05617 IopRaiseHardError(
05618 IN PVOID NormalContext,
05619 IN PVOID SystemArgument1,
05620 IN PVOID SystemArgument2
05621 )
05622
05623
05624
05625
05626
05627
05628
05629
05630
05631
05632
05633
05634
05635
05636
05637
05638
05639
05640
05641
05642
05643
05644
05645
05646
05647
05648 {
05649 ULONG_PTR parameters[2];
05650 ULONG numberOfParameters;
05651 ULONG parameterMask;
05652 ULONG response;
05653
NTSTATUS status;
05654
PIRP irp = (
PIRP) NormalContext;
05655
PVPB vpb = (
PVPB) SystemArgument1;
05656
PDEVICE_OBJECT realDeviceObject = (
PDEVICE_OBJECT) SystemArgument2;
05657
05658 ULONG length;
05659 POBJECT_NAME_INFORMATION objectName;
05660
05661 UNICODE_STRING labelName;
05662
05663
05664
05665
05666
05667
05668
05669
05670
ObQueryNameString( realDeviceObject,
NULL, 0, &length );
05671
05672
if ((objectName =
ExAllocatePool(
PagedPool, length)) ==
NULL) {
05673
05674 status = STATUS_INSUFFICIENT_RESOURCES;
05675
05676 }
else {
05677
05678 status = STATUS_SUCCESS;
05679 }
05680
05681
if (!
NT_SUCCESS( status ) ||
05682 !
NT_SUCCESS( status =
ObQueryNameString( realDeviceObject,
05683 objectName,
05684 length,
05685 &response ) )) {
05686
05687
05688
05689
05690
05691
05692
05693
if (objectName) {
05694
ExFreePool( objectName );
05695 }
05696
05697 irp->
IoStatus.Status = status;
05698 irp->
IoStatus.Information = 0;
05699
05700
IoCompleteRequest( irp,
IO_DISK_INCREMENT );
05701
05702
return;
05703 }
05704
05705
05706
05707
05708
05709
05710
if (vpb !=
NULL && vpb->
Flags &
VPB_MOUNTED) {
05711
05712 labelName.Buffer = &vpb->
VolumeLabel[0];
05713 labelName.Length = vpb->
VolumeLabelLength;
05714 labelName.MaximumLength =
MAXIMUM_VOLUME_LABEL_LENGTH;
05715
05716 }
else {
05717
05718
RtlInitUnicodeString( &labelName,
NULL );
05719 }
05720
05721
05722
05723
05724
05725
05726
switch( irp->
IoStatus.Status ) {
05727
05728
case STATUS_MEDIA_WRITE_PROTECTED:
05729
case STATUS_WRONG_VOLUME:
05730
05731 numberOfParameters = 2;
05732 parameterMask = 3;
05733
05734 parameters[0] = (ULONG_PTR) &labelName;
05735 parameters[1] = (ULONG_PTR) &objectName->Name;
05736
05737
break;
05738
05739
case STATUS_DEVICE_NOT_READY:
05740
case STATUS_IO_TIMEOUT:
05741
case STATUS_NO_MEDIA_IN_DEVICE:
05742
case STATUS_UNRECOGNIZED_MEDIA:
05743
05744 numberOfParameters = 1;
05745 parameterMask = 1;
05746
05747 parameters[0] = (ULONG_PTR) &objectName->Name;
05748 parameters[1] = 0;
05749
05750
break;
05751
05752
default:
05753
05754 numberOfParameters = 0;
05755 parameterMask = 0;
05756
05757 }
05758
05759
05760
05761
05762
05763
if (
ExReadyForErrors) {
05764 status =
ExRaiseHardError( irp->
IoStatus.Status,
05765 numberOfParameters,
05766 parameterMask,
05767 parameters,
05768 OptionCancelTryContinue,
05769 &response );
05770
05771 }
else {
05772
05773 status = STATUS_UNSUCCESSFUL;
05774 response = ResponseReturnToCaller;
05775 }
05776
05777
05778
05779
05780
05781
05782
ExFreePool( objectName );
05783
05784
05785
05786
05787
05788
05789
05790
if (!
NT_SUCCESS( status ) || response != ResponseTryAgain) {
05791
05792
05793
05794
05795
05796
05797
05798
05799
if (response == ResponseCancel) {
05800
PIO_STACK_LOCATION irpSp =
IoGetCurrentIrpStackLocation( irp );
05801
if (irpSp->
MajorFunction ==
IRP_MJ_FILE_SYSTEM_CONTROL &&
05802 irpSp->
MinorFunction ==
IRP_MN_MOUNT_VOLUME) {
05803 irp->
IoStatus.Information =
IOP_ABORT;
05804 }
else {
05805 irp->
IoStatus.Status = STATUS_REQUEST_ABORTED;
05806 }
05807 }
05808
05809
05810
05811
05812
05813
05814
05815
if (irp->
Flags &
IRP_INPUT_OPERATION) {
05816 irp->
IoStatus.Information = 0;
05817 }
05818
05819
IoCompleteRequest( irp,
IO_DISK_INCREMENT );
05820
05821 }
else {
05822
05823
PIO_STACK_LOCATION irpSp =
IoGetCurrentIrpStackLocation( irp );
05824
PDEVICE_OBJECT fsDeviceObject = irpSp->
DeviceObject;
05825
PDRIVER_OBJECT driverObject = fsDeviceObject->
DriverObject;
05826
05827
05828
05829
05830
05831
PERFINFO_DRIVER_MAJORFUNCTION_CALL(irp, irpSp, driverObject);
05832
05833 driverObject->
MajorFunction[irpSp->
MajorFunction]( fsDeviceObject,
05834 irp );
05835
05836
PERFINFO_DRIVER_MAJORFUNCTION_RETURN(irp, irpSp, driverObject);
05837 }
05838 }
05839
05840
VOID
05841 IopRaiseInformationalHardError(
05842 IN PVOID NormalContext,
05843 IN PVOID SystemArgument1,
05844 IN PVOID SystemArgument2
05845 )
05846
05847
05848
05849
05850
05851
05852
05853
05854
05855
05856
05857
05858
05859
05860
05861
05862
05863
05864
05865
05866
05867
05868
05869 {
05870 ULONG parameterPresent;
05871 ULONG_PTR errorParameter;
05872 ULONG errorResponse;
05873
PIOP_HARD_ERROR_PACKET hardErrorPacket;
05874
05875 UNREFERENCED_PARAMETER( SystemArgument1 );
05876 UNREFERENCED_PARAMETER( SystemArgument2 );
05877
05878 hardErrorPacket = (
PIOP_HARD_ERROR_PACKET) NormalContext;
05879
05880
05881
05882
05883
05884 errorParameter = (ULONG_PTR) &hardErrorPacket->
String;
05885
05886 parameterPresent = (hardErrorPacket->
String.Buffer !=
NULL);
05887
05888
if (
ExReadyForErrors) {
05889 (
VOID)
ExRaiseHardError( hardErrorPacket->
ErrorStatus,
05890 parameterPresent,
05891 parameterPresent,
05892 parameterPresent ? &errorParameter :
NULL,
05893 OptionOk,
05894 &errorResponse );
05895 }
05896
05897
05898
05899
05900
05901
if (hardErrorPacket->
String.Buffer) {
05902
ExFreePool( hardErrorPacket->
String.Buffer );
05903 }
05904
05905
ExFreePool( hardErrorPacket );
05906 InterlockedDecrement(&
IopHardError.
NumPendingApcPopups);
05907 }
05908
05909
VOID
05910 IopReadyDeviceObjects(
05911 IN
PDRIVER_OBJECT DriverObject
05912 )
05913
05914
05915
05916
05917
05918
05919
05920
05921
05922
05923
05924
05925
05926
05927
05928
05929
05930
05931
05932
05933 {
05934
PDEVICE_OBJECT deviceObject = DriverObject->DeviceObject;
05935
05936
PAGED_CODE();
05937
05938
05939
05940
05941
05942
05943 DriverObject->Flags |=
DRVO_INITIALIZED;
05944
while (deviceObject) {
05945 deviceObject->
Flags &= ~
DO_DEVICE_INITIALIZING;
05946 deviceObject = deviceObject->
NextDevice;
05947 }
05948 }
05949
05950
NTSTATUS
05951 IopResurrectDriver(
05952
PDRIVER_OBJECT DriverObject
05953 )
05954
05955
05956
05957
05958
05959
05960
05961
05962
05963
05964
05965
05966
05967
05968
05969
05970
05971
05972
05973
05974
05975
05976 {
05977
PDEVICE_OBJECT deviceObject = DriverObject->
DeviceObject;
05978 KIRQL irql;
05979
05980
05981
05982
05983
05984
05985 ExAcquireSpinLock( &
IopDatabaseLock, &irql );
05986
05987
if (DriverObject->
Flags &
DRVO_UNLOAD_INVOKED || !deviceObject ||
05988 !(deviceObject->
DeviceObjectExtension->
ExtensionFlags &
DOE_UNLOAD_PENDING)) {
05989
05990 ExReleaseSpinLock( &
IopDatabaseLock, irql );
05991
return STATUS_IMAGE_ALREADY_LOADED;
05992 }
05993
05994
05995
05996
05997
05998
05999
while (deviceObject) {
06000 deviceObject->
DeviceObjectExtension->
ExtensionFlags &= ~
DOE_UNLOAD_PENDING;
06001 deviceObject = deviceObject->
NextDevice;
06002 }
06003
06004 ExReleaseSpinLock( &
IopDatabaseLock, irql );
06005
return STATUS_SUCCESS;
06006
06007 }
06008
06009
VOID
06010 IopMarshalIds(
06011 OUT PTRACKING_BUFFER TrackingBuffer,
06012 IN PFILE_VOLUMEID_WITH_TYPE TargetVolumeId,
06013 IN PFILE_OBJECTID_BUFFER TargetObjectId,
06014 IN PFILE_TRACKING_INFORMATION TrackingInfo
06015 )
06016
06017
06018
06019
06020
06021
06022
06023
06024
06025
06026
06027
06028
06029
06030
06031
06032
06033
06034
06035
06036
06037
06038
06039 {
06040 ULONG ObjectInformationLength = 0;
06041
06042 TrackingBuffer->TrackingInformation.DestinationFile = (HANDLE)
NULL;
06043
06044 RtlZeroMemory( &TrackingBuffer->TrackingInformation.ObjectInformation[ ObjectInformationLength ],
06045
sizeof(TargetVolumeId->Type) );
06046
06047 RtlCopyMemory( &TrackingBuffer->TrackingInformation.ObjectInformation[ ObjectInformationLength ],
06048 &TargetVolumeId->Type,
06049
sizeof(TargetVolumeId->Type) );
06050 ObjectInformationLength +=
sizeof(TargetVolumeId->Type);
06051
06052 RtlCopyMemory( &TrackingBuffer->TrackingInformation.ObjectInformation[ ObjectInformationLength ],
06053 &TargetVolumeId->VolumeId[0],
06054
sizeof(TargetVolumeId->VolumeId) );
06055 ObjectInformationLength +=
sizeof(TargetVolumeId->VolumeId);
06056
06057 RtlCopyMemory( &TrackingBuffer->TrackingInformation.ObjectInformation[ ObjectInformationLength ],
06058 &TargetObjectId->ObjectId[0],
06059
sizeof(TargetObjectId->ObjectId) );
06060 ObjectInformationLength +=
sizeof(TargetObjectId->ObjectId);
06061
06062 RtlCopyMemory( &TrackingBuffer->TrackingInformation.ObjectInformation[ ObjectInformationLength ],
06063 &TrackingInfo->ObjectInformation[0],
06064 TrackingInfo->ObjectInformationLength );
06065 ObjectInformationLength += TrackingInfo->ObjectInformationLength;
06066
06067 TrackingBuffer->TrackingInformation.ObjectInformationLength = ObjectInformationLength;
06068
06069 }
06070
06071
VOID
06072 IopUnMarshalIds(
06073 IN FILE_TRACKING_INFORMATION * TrackingInformation,
06074 OUT FILE_VOLUMEID_WITH_TYPE * TargetVolumeId,
06075 OUT GUID * TargetObjectId,
06076 OUT GUID * TargetMachineId
06077 )
06078
06079
06080
06081
06082
06083
06084
06085
06086
06087
06088
06089
06090
06091
06092
06093
06094
06095
06096
06097
06098 {
06099 ULONG ObjectInformationLength = 0;
06100
06101 RtlCopyMemory( &TargetVolumeId->Type,
06102 &TrackingInformation->ObjectInformation[ ObjectInformationLength ],
06103
sizeof(TargetVolumeId->Type) );
06104 ObjectInformationLength +=
sizeof(TargetVolumeId->Type);
06105
06106
06107 RtlCopyMemory( &TargetVolumeId->VolumeId[0],
06108 &TrackingInformation->ObjectInformation[ ObjectInformationLength ],
06109
sizeof(TargetVolumeId->VolumeId) );
06110 ObjectInformationLength +=
sizeof(TargetVolumeId->VolumeId);
06111
06112 RtlCopyMemory( TargetObjectId,
06113 &TrackingInformation->ObjectInformation[ ObjectInformationLength ],
06114
sizeof(*TargetObjectId) );
06115 ObjectInformationLength +=
sizeof(*TargetObjectId);
06116
06117
if( TrackingInformation->ObjectInformationLength > ObjectInformationLength ) {
06118 RtlCopyMemory( TargetMachineId,
06119 &TrackingInformation->ObjectInformation[ ObjectInformationLength ],
06120
min(
sizeof(*TargetMachineId), TrackingInformation->ObjectInformationLength - ObjectInformationLength) );
06121
06122 }
06123 }
06124
06125
06126
NTSTATUS
06127 IopSendMessageToTrackService(
06128 IN PFILE_VOLUMEID_WITH_TYPE SourceVolumeId,
06129 IN PFILE_OBJECTID_BUFFER SourceObjectId,
06130 IN PFILE_TRACKING_INFORMATION TargetObjectInformation
06131 )
06132
06133
06134
06135
06136
06137
06138
06139
06140
06141
06142
06143
06144
06145
06146
06147
06148
06149
06150
06151
06152
06153
06154
06155
06156 {
06157
typedef struct _LINK_TRACKING_MESSAGE {
06158
NTSTATUS Status;
06159 ULONG
Request;
06160
FILE_VOLUMEID_WITH_TYPE SourceVolumeId;
06161 FILE_OBJECTID_BUFFER SourceObjectId;
06162
FILE_VOLUMEID_WITH_TYPE TargetVolumeId;
06163 GUID TargetObjectId;
06164 GUID TargetMachineId;
06165 } LINK_TRACKING_MESSAGE, *PLINK_TRACKING_MESSAGE;
06166
06167
typedef struct _LINK_TRACKING_RESPONSE {
06168
NTSTATUS Status;
06169 } LINK_TRACKING_RESPONSE, *PLINK_TRACKING_RESPONSE;
06170
06171 PPORT_MESSAGE portMessage;
06172 PPORT_MESSAGE portReplyMessage;
06173
CHAR portReply[ 256 ];
06174 PLINK_TRACKING_MESSAGE requestMessage;
06175 PLINK_TRACKING_RESPONSE replyMessage;
06176
LINK_TRACKING_PACKET ltp;
06177
NTSTATUS status;
06178 ULONG loopCount = 0;
06179
06180
PAGED_CODE();
06181
06182
06183
06184
06185
06186
06187 retry:
06188
06189
if (!
IopLinkTrackingServiceObject) {
06190
06191
06192
06193
06194
06195
06196
06197
if (!
KeReadStateEvent(
IopLinkTrackingServiceEvent )) {
06198
return STATUS_NO_TRACKING_SERVICE;
06199 }
06200
06201
for (;; ) {
06202 status =
KeWaitForSingleObject(&
IopLinkTrackingPortObject,
06203
Executive,
06204 KeGetPreviousMode(),
06205
FALSE,
06206 (PLARGE_INTEGER)
NULL );
06207
06208
if ((status == STATUS_USER_APC) || (status == STATUS_ALERTED)) {
06209
return status;
06210 }
06211
06212
06213
06214
06215
06216
if (!
IopLinkTrackingServiceObject) {
06217
ExInitializeWorkItem(
06218 &
IopLinkTrackingPacket.
WorkQueueItem,
06219
IopConnectLinkTrackingPort,
06220 &
IopLinkTrackingPacket);
06221 (
VOID)
KeResetEvent(&
IopLinkTrackingPacket.
Event);
06222
ExQueueWorkItem( &
IopLinkTrackingPacket.
WorkQueueItem,
06223
DelayedWorkQueue );
06224 status =
KeWaitForSingleObject(
06225 &
IopLinkTrackingPacket.
Event,
06226
Executive,
06227 KeGetPreviousMode(),
06228
FALSE,
06229 (PLARGE_INTEGER)
NULL );
06230
06231
if ((status == STATUS_USER_APC) || (status == STATUS_ALERTED)) {
06232 NOTHING;
06233 }
else if (!
NT_SUCCESS(
IopLinkTrackingPacket.
FinalStatus )) {
06234 status =
IopLinkTrackingPacket.
FinalStatus;
06235 }
06236
06237
KeSetEvent(&
IopLinkTrackingPortObject,
06238 0,
06239
FALSE);
06240
if (status == STATUS_SUCCESS) {
06241
break;
06242 }
else {
06243
return status;
06244 }
06245
06246 }
else {
06247
06248
06249
06250
06251
KeSetEvent(&
IopLinkTrackingPortObject,
06252 0,
06253
FALSE);
06254
break;
06255 }
06256 }
06257 }
06258
06259
06260
06261
06262
06263 portMessage =
ExAllocatePool(
PagedPool,
06264
sizeof( LINK_TRACKING_MESSAGE ) +
06265
sizeof( PORT_MESSAGE ) );
06266
if (!portMessage) {
06267
return STATUS_INSUFFICIENT_RESOURCES;
06268 }
06269
06270 requestMessage = (PLINK_TRACKING_MESSAGE) (portMessage + 1);
06271 RtlZeroMemory( requestMessage,
sizeof(*requestMessage) );
06272
06273 requestMessage->Status = STATUS_SUCCESS;
06274 requestMessage->Request = 0;
06275
06276 RtlCopyMemory( &requestMessage->SourceVolumeId,
06277 SourceVolumeId,
06278
sizeof(
FILE_VOLUMEID_WITH_TYPE ) );
06279
06280 RtlCopyMemory( &requestMessage->SourceObjectId,
06281 SourceObjectId,
06282
sizeof( FILE_OBJECTID_BUFFER ) );
06283
06284
IopUnMarshalIds( TargetObjectInformation,
06285 &requestMessage->TargetVolumeId,
06286 &requestMessage->TargetObjectId,
06287 &requestMessage->TargetMachineId);
06288
06289 portMessage->u1.s1.TotalLength = (
USHORT) (
sizeof( PORT_MESSAGE ) +
06290
sizeof( LINK_TRACKING_MESSAGE ));
06291 portMessage->u1.s1.DataLength = (
USHORT)
sizeof( LINK_TRACKING_MESSAGE );
06292 portMessage->u2.ZeroInit = 0;
06293
06294 status =
LpcRequestWaitReplyPort(
IopLinkTrackingServiceObject,
06295 portMessage,
06296 (PPORT_MESSAGE) &portReply[0] );
06297
if (!
NT_SUCCESS( status )) {
06298
if (status == STATUS_PORT_DISCONNECTED) {
06299 status =
KeWaitForSingleObject(&
IopLinkTrackingPortObject,
06300
Executive,
06301 KeGetPreviousMode(),
06302
FALSE,
06303 (PLARGE_INTEGER)
NULL );
06304
ObDereferenceObject(
IopLinkTrackingServiceObject );
06305
IopLinkTrackingServiceObject =
NULL;
06306
KeSetEvent(&
IopLinkTrackingPortObject,
06307 0,
06308
FALSE);
06309
if (!loopCount) {
06310 loopCount += 1;
06311
goto retry;
06312 }
06313 }
06314 }
06315
06316
if (
NT_SUCCESS( status )) {
06317 portReplyMessage = (PPORT_MESSAGE) &portReply[0];
06318 replyMessage = (PLINK_TRACKING_RESPONSE) (portReplyMessage + 1);
06319 status = replyMessage->Status;
06320 }
06321
06322
return status;
06323 }
06324
06325
NTSTATUS
06326 IopSetEaOrQuotaInformationFile(
06327 IN HANDLE FileHandle,
06328 OUT PIO_STATUS_BLOCK IoStatusBlock,
06329 IN PVOID Buffer,
06330 IN ULONG Length,
06331 IN BOOLEAN SetEa
06332 )
06333
06334
06335
06336
06337
06338
06339
06340
06341
06342
06343
06344
06345
06346
06347
06348
06349
06350
06351
06352
06353
06354
06355
06356
06357
06358
06359
06360
06361
06362 {
06363
PIRP irp;
06364
NTSTATUS status;
06365
PFILE_OBJECT fileObject;
06366
PDEVICE_OBJECT deviceObject;
06367
PKEVENT event = (
PKEVENT)
NULL;
06368
KPROCESSOR_MODE requestorMode;
06369
PIO_STACK_LOCATION irpSp;
06370 IO_STATUS_BLOCK localIoStatus;
06371 BOOLEAN synchronousIo;
06372
06373
PAGED_CODE();
06374
06375
06376
06377
06378
06379 requestorMode = KeGetPreviousMode();
06380
06381
if (requestorMode !=
KernelMode) {
06382
06383
06384
06385
06386
06387
06388
06389
06390
06391
try {
06392
06393
06394
06395
06396
06397
ProbeForWriteIoStatus( IoStatusBlock);
06398
06399
06400
06401
06402
06403
ProbeForRead(
Buffer, Length,
sizeof( ULONG ) );
06404
06405 } except(
EXCEPTION_EXECUTE_HANDLER) {
06406
06407
06408
06409
06410
06411
06412
return GetExceptionCode();
06413 }
06414 }
06415
06416
06417
06418
06419
06420
06421
06422
06423 status =
ObReferenceObjectByHandle( FileHandle,
06424 SetEa ? FILE_WRITE_EA : FILE_WRITE_DATA,
06425
IoFileObjectType,
06426 requestorMode,
06427 (PVOID *) &fileObject,
06428
NULL );
06429
if (!
NT_SUCCESS( status )) {
06430
return status;
06431 }
06432
06433
06434
06435
06436
06437
06438
06439
06440
if (fileObject->Flags &
FO_SYNCHRONOUS_IO) {
06441
06442 BOOLEAN interrupted;
06443
06444
if (!
IopAcquireFastLock( fileObject )) {
06445 status =
IopAcquireFileObjectLock( fileObject,
06446 requestorMode,
06447 (BOOLEAN) ((fileObject->Flags &
FO_ALERTABLE_IO) != 0),
06448 &interrupted );
06449
if (interrupted) {
06450
ObDereferenceObject( fileObject );
06451
return status;
06452 }
06453 }
06454 synchronousIo =
TRUE;
06455 }
else {
06456
06457
06458
06459
06460
06461
06462
06463
06464 event =
ExAllocatePool(
NonPagedPool,
sizeof(
KEVENT ) );
06465
if (!event) {
06466
ObDereferenceObject( fileObject );
06467
return STATUS_INSUFFICIENT_RESOURCES;
06468 }
06469
KeInitializeEvent( event, SynchronizationEvent,
FALSE );
06470 synchronousIo =
FALSE;
06471 }
06472
06473
06474
06475
06476
06477
KeClearEvent( &fileObject->Event );
06478
06479
06480
06481
06482
06483 deviceObject =
IoGetRelatedDeviceObject( fileObject );
06484
06485
06486
06487
06488
06489
06490 irp =
IoAllocateIrp( deviceObject->
StackSize,
TRUE );
06491
if (!irp) {
06492
06493
06494
06495
06496
06497
06498
if (!(fileObject->Flags &
FO_SYNCHRONOUS_IO)) {
06499
ExFreePool( event );
06500 }
06501
06502
IopAllocateIrpCleanup( fileObject, (
PKEVENT)
NULL );
06503
06504
return STATUS_INSUFFICIENT_RESOURCES;
06505 }
06506 irp->
Tail.Overlay.OriginalFileObject = fileObject;
06507 irp->
Tail.Overlay.Thread =
PsGetCurrentThread();
06508 irp->
RequestorMode = requestorMode;
06509
06510
06511
06512
06513
06514
if (synchronousIo) {
06515 irp->
UserEvent = (
PKEVENT)
NULL;
06516 irp->
UserIosb = IoStatusBlock;
06517 }
else {
06518 irp->
UserEvent = event;
06519 irp->
UserIosb = &localIoStatus;
06520 irp->
Flags =
IRP_SYNCHRONOUS_API;
06521 }
06522 irp->
Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE)
NULL;
06523
06524
06525
06526
06527
06528
06529 irpSp =
IoGetNextIrpStackLocation( irp );
06530 irpSp->
MajorFunction = SetEa ?
IRP_MJ_SET_EA :
IRP_MJ_SET_QUOTA;
06531 irpSp->
FileObject = fileObject;
06532
06533
06534
06535
06536
06537
06538
06539
06540
06541
06542
06543
06544
06545
if (deviceObject->
Flags &
DO_BUFFERED_IO) {
06546
06547 PVOID systemBuffer;
06548 ULONG errorOffset;
06549
06550
06551
06552
06553
06554
06555
06556
06557
06558
06559
try {
06560
06561
06562
06563
06564
06565
06566
06567 systemBuffer =
ExAllocatePoolWithQuota(
NonPagedPool, Length );
06568
06569 irp->
AssociatedIrp.SystemBuffer = systemBuffer;
06570
06571 RtlCopyMemory( systemBuffer,
Buffer, Length );
06572
06573
if (SetEa) {
06574 status =
IoCheckEaBufferValidity( systemBuffer,
06575 Length,
06576 &errorOffset );
06577 }
else {
06578 status =
IoCheckQuotaBufferValidity( systemBuffer,
06579 Length,
06580 &errorOffset );
06581 }
06582
06583
if (!
NT_SUCCESS( status )) {
06584 IoStatusBlock->Status = status;
06585 IoStatusBlock->Information = errorOffset;
06586
ExRaiseStatus( status );
06587 }
06588
06589 } except(
EXCEPTION_EXECUTE_HANDLER) {
06590
06591
06592
06593
06594
06595
06596
06597
06598
IopExceptionCleanup( fileObject,
06599 irp,
06600 (
PKEVENT)
NULL,
06601 event );
06602
06603
return GetExceptionCode();
06604
06605 }
06606
06607
06608
06609
06610
06611
06612 irp->
Flags |=
IRP_BUFFERED_IO |
IRP_DEALLOCATE_BUFFER;
06613
06614 }
else if (deviceObject->
Flags &
DO_DIRECT_IO) {
06615
06616
PMDL mdl;
06617
06618
06619
06620
06621
06622
06623
06624
06625 mdl = (
PMDL)
NULL;
06626
06627
try {
06628
06629
06630
06631
06632
06633
06634
06635
06636 mdl =
IoAllocateMdl(
Buffer, Length,
FALSE,
TRUE, irp );
06637
if (!mdl) {
06638
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
06639 }
06640
MmProbeAndLockPages( mdl, requestorMode,
IoReadAccess );
06641
06642 } except(
EXCEPTION_EXECUTE_HANDLER) {
06643
06644
06645
06646
06647
06648
06649
06650
IopExceptionCleanup( fileObject,
06651 irp,
06652 (
PKEVENT)
NULL,
06653 event );
06654
06655
return GetExceptionCode();
06656
06657 }
06658
06659 }
else {
06660
06661
06662
06663
06664
06665
06666 irp->
UserBuffer =
Buffer;
06667
06668 }
06669
06670
06671
06672
06673
06674
06675
if (SetEa) {
06676 irpSp->
Parameters.SetEa.Length = Length;
06677 }
else {
06678 irpSp->
Parameters.SetQuota.Length = Length;
06679 }
06680
06681
06682
06683
06684
06685
06686 status =
IopSynchronousServiceTail( deviceObject,
06687 irp,
06688 fileObject,
06689
FALSE,
06690 requestorMode,
06691 synchronousIo,
06692
OtherTransfer );
06693
06694
06695
06696
06697
06698
06699
06700
06701
06702
if (!synchronousIo) {
06703
06704 status =
IopSynchronousApiServiceTail( status,
06705 event,
06706 irp,
06707 requestorMode,
06708 &localIoStatus,
06709 IoStatusBlock );
06710 }
06711
06712
return status;
06713 }
06714
06715
NTSTATUS
06716 IopSetRemoteLink(
06717 IN
PFILE_OBJECT FileObject,
06718 IN
PFILE_OBJECT DestinationFileObject OPTIONAL,
06719 IN PFILE_TRACKING_INFORMATION FileInformation OPTIONAL
06720 )
06721
06722
06723
06724
06725
06726
06727
06728
06729
06730
06731
06732
06733
06734
06735
06736
06737
06738
06739
06740
06741
06742
06743
06744
06745
06746 {
06747
REMOTE_LINK_BUFFER remoteBuffer;
06748 IO_STATUS_BLOCK ioStatus;
06749
NTSTATUS status;
06750
PIRP irp;
06751
KEVENT event;
06752
PIO_STACK_LOCATION irpSp;
06753
PDEVICE_OBJECT deviceObject;
06754 ULONG length = 0;
06755
06756
PAGED_CODE();
06757
06758
06759
06760
06761
06762
06763
KeInitializeEvent( &event,
06764 NotificationEvent,
06765
FALSE );
06766
06767
06768
06769
06770
06771
06772 deviceObject =
IoGetRelatedDeviceObject( FileObject );
06773
06774 irp =
IoBuildDeviceIoControlRequest( FSCTL_LMR_SET_LINK_TRACKING_INFORMATION,
06775 deviceObject,
06776
NULL,
06777 0,
06778
NULL,
06779 0,
06780
FALSE,
06781 &event,
06782 &ioStatus );
06783
if (!irp) {
06784
return STATUS_INSUFFICIENT_RESOURCES;
06785 }
06786
06787
06788
06789
06790
06791
if (DestinationFileObject) {
06792
06793
06794 remoteBuffer.
TrackingInformation.TargetFileObject = DestinationFileObject;
06795
06796
if (FileInformation) {
06797
06798
06799
06800
06801 remoteBuffer.
TrackingInformation.TargetLinkTrackingInformationLength
06802 = length = FileInformation->ObjectInformationLength;
06803 RtlCopyMemory( &remoteBuffer.
TrackingInformation.TargetLinkTrackingInformationBuffer,
06804 FileInformation->ObjectInformation,
06805 length );
06806 }
else {
06807
06808 remoteBuffer.
TrackingInformation.TargetLinkTrackingInformationLength = 0;
06809 }
06810
06811
06812
06813 length +=
sizeof(
PFILE_OBJECT ) +
sizeof( ULONG );
06814
06815 }
else {
06816
06817
06818 length = FileInformation->ObjectInformationLength +
sizeof( HANDLE ) +
sizeof( ULONG );
06819 RtlCopyMemory( &remoteBuffer.
TrackingInformation,
06820 FileInformation,
06821 length );
06822 remoteBuffer.
TrackingInformation.TargetFileObject =
NULL;
06823 }
06824
06825
06826
06827
06828
06829
06830 irp->
Flags |=
IRP_SYNCHRONOUS_API;
06831 irp->
AssociatedIrp.SystemBuffer = &remoteBuffer;
06832 irp->
Tail.Overlay.OriginalFileObject = FileObject;
06833
06834 irpSp =
IoGetNextIrpStackLocation( irp );
06835 irpSp->
FileObject = FileObject;
06836 irpSp->
MajorFunction =
IRP_MJ_FILE_SYSTEM_CONTROL;
06837 irpSp->
MinorFunction =
IRP_MN_KERNEL_CALL;
06838 irpSp->
Parameters.FileSystemControl.InputBufferLength = length;
06839
06840
06841
06842
06843
06844
06845
ObReferenceObject( FileObject );
06846
06847
06848
06849
06850
06851 status =
IoCallDriver( deviceObject, irp );
06852
06853
06854
06855
06856
06857
if (status == STATUS_PENDING) {
06858 status =
KeWaitForSingleObject( &event,
06859
Executive,
06860
KernelMode,
06861
FALSE,
06862 (PLARGE_INTEGER)
NULL );
06863 status = ioStatus.Status;
06864 }
06865
06866
return status;
06867 }
06868
06869
VOID
06870 IopStartApcHardError(
06871 IN PVOID StartContext
06872 )
06873
06874
06875
06876
06877
06878
06879
06880
06881
06882
06883
06884
06885
06886
06887
06888
06889
06890
06891
06892 {
06893 HANDLE thread;
06894
NTSTATUS status;
06895
06896
06897
06898
06899
06900
06901 status =
PsCreateSystemThread( &thread,
06902 0,
06903 (POBJECT_ATTRIBUTES)
NULL,
06904 (HANDLE)0,
06905 (PCLIENT_ID)
NULL,
06906
IopApcHardError,
06907 StartContext );
06908
06909
if ( !
NT_SUCCESS( status ) ) {
06910
06911
06912
IoCompleteRequest( ((
PIOP_APC_HARD_ERROR_PACKET)StartContext)->
Irp,
06913
IO_DISK_INCREMENT );
06914
ExFreePool( StartContext );
06915
return;
06916 }
06917
06918
06919
06920
06921
06922 ZwClose(thread);
06923 }
06924
06925
NTSTATUS
06926 IopSynchronousApiServiceTail(
06927 IN NTSTATUS ReturnedStatus,
06928 IN
PKEVENT Event,
06929 IN
PIRP Irp,
06930 IN KPROCESSOR_MODE RequestorMode,
06931 IN PIO_STATUS_BLOCK LocalIoStatus,
06932 OUT PIO_STATUS_BLOCK IoStatusBlock
06933 )
06934
06935
06936
06937
06938
06939
06940
06941
06942
06943
06944
06945
06946
06947
06948
06949
06950
06951
06952
06953
06954
06955
06956
06957
06958
06959
06960
06961
06962
06963
06964
06965
06966
06967
06968
06969 {
06970
NTSTATUS status;
06971
06972
PAGED_CODE();
06973
06974
06975
06976
06977
06978
06979
06980
06981 status = ReturnedStatus;
06982
06983
if (status == STATUS_PENDING) {
06984
06985 status =
KeWaitForSingleObject(
Event,
06986
Executive,
06987 RequestorMode,
06988
FALSE,
06989 (PLARGE_INTEGER)
NULL );
06990
06991
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
06992
06993
06994
06995
06996
06997
06998
06999
07000
07001
07002
IopCancelAlertedRequest(
Event,
Irp );
07003
07004 }
07005
07006 status = LocalIoStatus->Status;
07007 }
07008
07009
try {
07010
07011 *IoStatusBlock = *LocalIoStatus;
07012
07013 } except(
EXCEPTION_EXECUTE_HANDLER) {
07014
07015
07016
07017
07018
07019
07020
07021 status = GetExceptionCode();
07022 }
07023
07024
ExFreePool(
Event );
07025
07026
return status;
07027 }
07028
07029
NTSTATUS
07030 IopSynchronousServiceTail(
07031 IN
PDEVICE_OBJECT DeviceObject,
07032 IN
PIRP Irp,
07033 IN
PFILE_OBJECT FileObject,
07034 IN BOOLEAN DeferredIoCompletion,
07035 IN KPROCESSOR_MODE RequestorMode,
07036 IN BOOLEAN SynchronousIo,
07037 IN
TRANSFER_TYPE TransferType
07038 )
07039
07040
07041
07042
07043
07044
07045
07046
07047
07048
07049
07050
07051
07052
07053
07054
07055
07056
07057
07058
07059
07060
07061
07062
07063
07064
07065
07066
07067
07068
07069
07070 {
07071
NTSTATUS status;
07072
07073
PAGED_CODE();
07074
07075
07076
07077
07078
07079
IopQueueThreadIrp(
Irp );
07080
07081
07082
07083
07084
07085
switch( TransferType ) {
07086
07087
case ReadTransfer:
07088
IopUpdateReadOperationCount();
07089
break;
07090
07091
case WriteTransfer:
07092
IopUpdateWriteOperationCount();
07093
break;
07094
07095
case OtherTransfer:
07096
IopUpdateOtherOperationCount();
07097
break;
07098 }
07099
07100
07101
07102
07103
07104 status =
IoCallDriver( DeviceObject,
Irp );
07105
07106
07107
07108
07109
07110
07111
07112
if (DeferredIoCompletion) {
07113
07114
if (status != STATUS_PENDING) {
07115
07116
07117
07118
07119
07120
07121
07122
PKNORMAL_ROUTINE normalRoutine;
07123 PVOID normalContext;
07124 KIRQL irql;
07125
07126
ASSERT( !
Irp->
PendingReturned );
07127
07128
KeRaiseIrql(
APC_LEVEL, &irql );
07129
IopCompleteRequest( &
Irp->
Tail.Apc,
07130 &normalRoutine,
07131 &normalContext,
07132 (PVOID *) &FileObject,
07133 &normalContext );
07134
KeLowerIrql( irql );
07135 }
07136 }
07137
07138
07139
07140
07141
07142
07143
07144
07145
if (
SynchronousIo) {
07146
07147
if (status == STATUS_PENDING) {
07148
07149 status =
KeWaitForSingleObject( &FileObject->Event,
07150
Executive,
07151 RequestorMode,
07152 (BOOLEAN) ((FileObject->Flags &
FO_ALERTABLE_IO) != 0),
07153 (PLARGE_INTEGER)
NULL );
07154
07155
if (status == STATUS_ALERTED || status == STATUS_USER_APC) {
07156
07157
07158
07159
07160
07161
07162
07163
07164
07165
07166
IopCancelAlertedRequest( &FileObject->Event,
Irp );
07167
07168 }
07169
07170 status = FileObject->FinalStatus;
07171
07172 }
07173
07174
IopReleaseFileObjectLock( FileObject );
07175
07176 }
07177
07178
return status;
07179 }
07180
07181
VOID
07182 IopTimerDispatch(
07183 IN
PKDPC Dpc,
07184 IN PVOID DeferredContext,
07185 IN PVOID SystemArgument1,
07186 IN PVOID SystemArgument2
07187 )
07188
07189
07190
07191
07192
07193
07194
07195
07196
07197
07198
07199
07200
07201
07202
07203
07204
07205
07206
07207
07208
07209
07210
07211
07212 {
07213 PLIST_ENTRY timerEntry;
07214
PIO_TIMER timer;
07215 LARGE_INTEGER deltaTime;
07216 KIRQL irql;
07217 ULONG i;
07218
07219 UNREFERENCED_PARAMETER( Dpc );
07220 UNREFERENCED_PARAMETER( DeferredContext );
07221 UNREFERENCED_PARAMETER( SystemArgument1 );
07222 UNREFERENCED_PARAMETER( SystemArgument2 );
07223
07224
07225
07226
07227
07228
07229
07230
07231
07232
07233
07234
if (
IopTimerCount) {
07235
07236
07237
07238
07239
07240
07241 ExAcquireSpinLock( &
IopTimerLock, &irql );
07242 i =
IopTimerCount;
07243 timerEntry =
IopTimerQueueHead.Flink;
07244
07245
07246
07247
07248
07249
07250
07251
07252
for (timerEntry =
IopTimerQueueHead.Flink;
07253 (timerEntry != &
IopTimerQueueHead) && i;
07254 timerEntry = timerEntry->Flink ) {
07255
07256 timer = CONTAINING_RECORD( timerEntry,
IO_TIMER, TimerList );
07257
07258
if (timer->
TimerFlag) {
07259 timer->
TimerRoutine( timer->
DeviceObject, timer->
Context );
07260 i--;
07261 }
07262 }
07263 ExReleaseSpinLock( &
IopTimerLock, irql );
07264 }
07265 }
07266
07267
07268
07269
07270
07271
NTSTATUS
07272 IopTrackLink(
07273 IN
PFILE_OBJECT FileObject,
07274 IN OUT PIO_STATUS_BLOCK IoStatusBlock,
07275 IN PFILE_TRACKING_INFORMATION FileInformation,
07276 IN ULONG Length,
07277 IN
PKEVENT Event,
07278 IN KPROCESSOR_MODE RequestorMode
07279 )
07280
07281
07282
07283
07284
07285
07286
07287
07288
07289
07290
07291
07292
07293
07294
07295
07296
07297
07298
07299
07300
07301
07302
07303
07304
07305
07306
07307
07308
07309
07310
07311
07312
07313
07314
07315 {
07316 PFILE_TRACKING_INFORMATION trackingInfo =
NULL;
07317
PFILE_OBJECT dstFileObject =
NULL;
07318
FILE_VOLUMEID_WITH_TYPE SourceVolumeId;
07319 FILE_OBJECTID_BUFFER SourceObjectId;
07320 FILE_OBJECTID_BUFFER NormalizedObjectId;
07321 FILE_OBJECTID_BUFFER CrossVolumeObjectId;
07322
FILE_VOLUMEID_WITH_TYPE TargetVolumeId;
07323 FILE_OBJECTID_BUFFER TargetObjectId;
07324
TRACKING_BUFFER trackingBuffer;
07325
NTSTATUS status;
07326
07327
PAGED_CODE();
07328
07329
07330
07331
07332
07333
if (RequestorMode !=
KernelMode) {
07334
07335
try {
07336 trackingInfo =
ExAllocatePoolWithQuota(
PagedPool,
07337 Length );
07338 RtlCopyMemory( trackingInfo, FileInformation, Length );
07339
07340
if (!trackingInfo->DestinationFile ||
07341 ((Length - FIELD_OFFSET( FILE_TRACKING_INFORMATION, ObjectInformation ))
07342 < trackingInfo->ObjectInformationLength)) {
07343
ExFreePool( trackingInfo );
07344
return STATUS_INVALID_PARAMETER;
07345 }
07346
07347 } except(
EXCEPTION_EXECUTE_HANDLER) {
07348
07349
07350
07351
07352
07353
07354
07355
if (trackingInfo) {
07356
ExFreePool( trackingInfo );
07357 }
07358
07359
return GetExceptionCode();
07360 }
07361 }
else {
07362 trackingInfo = FileInformation;
07363 }
07364
07365
07366
07367
07368
07369
07370
if (trackingInfo->DestinationFile) {
07371 status =
ObReferenceObjectByHandle( trackingInfo->DestinationFile,
07372 FILE_WRITE_DATA,
07373
IoFileObjectType,
07374 RequestorMode,
07375 (PVOID *) &dstFileObject,
07376
NULL );
07377
if (!
NT_SUCCESS( status )) {
07378
if (RequestorMode !=
KernelMode) {
07379
ExFreePool( trackingInfo );
07380 }
07381
return status;
07382 }
07383 }
07384
07385
try {
07386
07387
07388
07389
07390
07391
07392
if (
IsFileLocal( FileObject )) {
07393
07394
07395
07396
07397
07398
07399
07400
if (trackingInfo->DestinationFile) {
07401
07402
if (
IsFileLocal( dstFileObject )) {
07403
07404 BOOLEAN IdSetOnTarget =
FALSE;
07405
07406
07407
07408
07409
07410
07411
07412
07413
07414 status =
IopGetSetObjectId( FileObject,
07415 &SourceObjectId,
07416
sizeof( SourceObjectId ),
07417 FSCTL_GET_OBJECT_ID );
07418
07419
if (status == STATUS_OBJECT_NAME_NOT_FOUND) {
07420
return(STATUS_SUCCESS);
07421 }
07422
07423
if (!
NT_SUCCESS( status )) {
07424
return status;
07425 }
07426
07427
07428
07429
07430
07431
if (
RtlCompareMemoryUlong(SourceObjectId.BirthObjectId,
07432
sizeof(SourceObjectId.BirthObjectId),
07433 0) ==
sizeof(SourceObjectId.BirthObjectId)) {
07434
return (STATUS_SUCCESS);
07435 }
07436
07437
07438
07439
07440
07441
07442 status =
IopGetVolumeId( dstFileObject,
07443 &TargetVolumeId,
07444
sizeof( TargetVolumeId ) );
07445
if (!
NT_SUCCESS( status )) {
07446
return status;
07447 }
07448
07449 status =
IopGetVolumeId( FileObject,
07450 &SourceVolumeId,
07451
sizeof( SourceVolumeId ) );
07452
if (!
NT_SUCCESS( status )) {
07453
return status;
07454 }
07455
07456
07457
07458
07459
07460
07461
07462 status =
IopGetSetObjectId( FileObject,
07463
NULL,
07464 0,
07465 FSCTL_DELETE_OBJECT_ID );
07466
if (!
NT_SUCCESS( status )) {
07467
return status;
07468 }
07469
07470
07471
07472
07473
07474
07475
07476 CrossVolumeObjectId = TargetObjectId = SourceObjectId;
07477
if( !RtlEqualMemory( &TargetVolumeId.VolumeId[0],
07478 &SourceVolumeId.VolumeId[0],
07479
sizeof(SourceVolumeId.VolumeId) )) {
07480 CrossVolumeObjectId.BirthVolumeId[0] |= 1;
07481 }
07482
07483 status =
IopGetSetObjectId( dstFileObject,
07484 &CrossVolumeObjectId,
07485
sizeof( CrossVolumeObjectId ),
07486 FSCTL_SET_OBJECT_ID );
07487
07488
if( status == STATUS_DUPLICATE_NAME ||
07489 status == STATUS_OBJECT_NAME_COLLISION ) {
07490
07491
07492
07493
07494
07495 status =
IopGetSetObjectId( dstFileObject,
07496 &TargetObjectId,
07497
sizeof(TargetObjectId),
07498 FSCTL_CREATE_OR_GET_OBJECT_ID );
07499
if(
NT_SUCCESS(status) ) {
07500
07501
07502
07503 status =
IopGetSetObjectId( dstFileObject,
07504 &CrossVolumeObjectId.ExtendedInfo[0],
07505
sizeof( CrossVolumeObjectId.ExtendedInfo ),
07506 FSCTL_SET_OBJECT_ID_EXTENDED );
07507 }
07508 }
07509
07510
if(
NT_SUCCESS(status) ) {
07511
07512 IdSetOnTarget =
TRUE;
07513
07514
07515
07516
if( !RtlEqualMemory( &TargetVolumeId.VolumeId[0],
07517 &SourceVolumeId.VolumeId[0],
07518
sizeof(SourceVolumeId.VolumeId) )) {
07519
07520
IopMarshalIds( &trackingBuffer, &TargetVolumeId, &TargetObjectId, trackingInfo );
07521
07522
07523 NormalizedObjectId = SourceObjectId;
07524 NormalizedObjectId.BirthVolumeId[0] &= 0xfe;
07525
07526 status =
IopSendMessageToTrackService( &SourceVolumeId,
07527 &NormalizedObjectId,
07528 &trackingBuffer.
TrackingInformation );
07529 }
07530 }
07531
07532
07533
07534
07535
07536
07537
if( !
NT_SUCCESS(status) ) {
07538
NTSTATUS statusT = STATUS_SUCCESS;
07539
07540
if( IdSetOnTarget ) {
07541
07542
if( RtlEqualMemory( &TargetObjectId.ObjectId,
07543 &SourceObjectId.ObjectId,
07544
sizeof(TargetObjectId.ObjectId) )) {
07545
07546
07547 statusT =
IopGetSetObjectId( dstFileObject,
07548
NULL,
07549 0,
07550 FSCTL_DELETE_OBJECT_ID );
07551
07552 }
else {
07553
07554
07555
07556 statusT =
IopGetSetObjectId( dstFileObject,
07557 &TargetObjectId.ExtendedInfo[0],
07558
sizeof(TargetObjectId.ExtendedInfo),
07559 FSCTL_SET_OBJECT_ID_EXTENDED );
07560 }
07561 }
07562
07563
if(
NT_SUCCESS( statusT )) {
07564
07565
IopGetSetObjectId( FileObject,
07566 &SourceObjectId,
07567
sizeof(SourceObjectId),
07568 FSCTL_SET_OBJECT_ID );
07569 }
07570
07571
return status;
07572 }
07573
07574
07575 }
else {
07576
07577
07578
07579
07580
07581
07582
07583
07584
07585
07586
07587
07588
07589
07590 status =
IopGetSetObjectId( FileObject,
07591 &SourceObjectId,
07592
sizeof( SourceObjectId ),
07593 FSCTL_GET_OBJECT_ID );
07594
if (!
NT_SUCCESS( status )) {
07595
return STATUS_SUCCESS;
07596 }
07597
07598
07599
07600
07601
07602
07603
if (
RtlCompareMemoryUlong(&SourceObjectId.BirthObjectId,
07604
sizeof(SourceObjectId.BirthObjectId),
07605 0) ==
sizeof(SourceObjectId.BirthObjectId)) {
07606
return (STATUS_SUCCESS);
07607 }
07608
07609
07610
07611
07612
07613 status =
IopGetSetObjectId( dstFileObject,
07614 &TargetVolumeId,
07615
sizeof(
FILE_VOLUMEID_WITH_TYPE ),
07616 FSCTL_LMR_GET_LINK_TRACKING_INFORMATION );
07617
if (!
NT_SUCCESS( status )) {
07618
return status;
07619 }
07620
07621
07622
07623
07624
07625 status =
IopGetSetObjectId( dstFileObject,
07626 &TargetObjectId,
07627
sizeof( TargetObjectId ),
07628 FSCTL_CREATE_OR_GET_OBJECT_ID );
07629
if (!
NT_SUCCESS( status )) {
07630
return status;
07631 }
07632
07633
07634
07635
07636
07637
IopMarshalIds( &trackingBuffer, &TargetVolumeId, &TargetObjectId, trackingInfo );
07638 status =
IopTrackLink( FileObject,
07639 IoStatusBlock,
07640 &trackingBuffer.
TrackingInformation,
07641 FIELD_OFFSET( FILE_TRACKING_INFORMATION,
07642 ObjectInformation ) +
07643 trackingBuffer.
TrackingInformation.ObjectInformationLength,
07644
Event,
07645
KernelMode );
07646
if (!
NT_SUCCESS( status )) {
07647
return status;
07648 }
07649
07650
07651
07652
07653
07654 status =
IopGetSetObjectId( FileObject,
07655
NULL,
07656 0,
07657 FSCTL_DELETE_OBJECT_ID );
07658
if( !
NT_SUCCESS( status )) {
07659
return status;
07660 }
07661
07662
07663
07664
07665
07666
07667
07668 CrossVolumeObjectId = SourceObjectId;
07669 CrossVolumeObjectId.BirthVolumeId[0] |= 1;
07670
07671 status =
IopGetSetObjectId( dstFileObject,
07672 &CrossVolumeObjectId.ExtendedInfo[0],
07673
sizeof( CrossVolumeObjectId.ExtendedInfo ),
07674 FSCTL_SET_OBJECT_ID_EXTENDED );
07675
if (!
NT_SUCCESS( status )) {
07676
07677
07678
IopGetSetObjectId( FileObject,
07679 &SourceObjectId,
07680
sizeof(SourceObjectId),
07681 FSCTL_SET_OBJECT_ID );
07682
return status;
07683 }
07684
07685
07686 }
07687
07688 }
else {
07689
07690
07691
07692
07693
07694
07695
07696
07697
07698 status =
IopGetVolumeId( FileObject,
07699 &SourceVolumeId,
07700
sizeof( SourceVolumeId ) );
07701
if (!
NT_SUCCESS( status )) {
07702
return status;
07703 }
07704
07705 status =
IopGetSetObjectId( FileObject,
07706 &SourceObjectId,
07707
sizeof( SourceObjectId ),
07708 FSCTL_GET_OBJECT_ID );
07709
if (!
NT_SUCCESS( status )) {
07710
return status;
07711 }
07712
07713
07714
07715
07716
07717
if (
RtlCompareMemoryUlong(SourceObjectId.BirthObjectId,
07718
sizeof(SourceObjectId.BirthObjectId),
07719 0) ==
sizeof(SourceObjectId.BirthObjectId)) {
07720
return (STATUS_SUCCESS);
07721 }
07722
07723
07724
07725
07726
07727 NormalizedObjectId = SourceObjectId;
07728 NormalizedObjectId.BirthVolumeId[0] &= 0xfe;
07729
07730 status =
IopSendMessageToTrackService( &SourceVolumeId,
07731 &NormalizedObjectId,
07732 FileInformation );
07733
if (!
NT_SUCCESS( status )) {
07734
return status;
07735 }
07736
07737 }
07738
07739 }
else {
07740
07741
07742
07743
07744
07745
07746
07747
07748 status =
IopGetSetObjectId( FileObject,
07749 &SourceObjectId,
07750
sizeof( SourceObjectId ),
07751 FSCTL_GET_OBJECT_ID );
07752
07753
if (status == STATUS_OBJECT_NAME_NOT_FOUND)
07754 {
07755
return STATUS_SUCCESS;
07756 }
07757
07758
if (!
NT_SUCCESS( status )) {
07759
return status;
07760 }
07761
07762
07763
07764
07765
07766
if (
RtlCompareMemoryUlong(SourceObjectId.BirthObjectId,
07767
sizeof(SourceObjectId.BirthObjectId),
07768 0) ==
sizeof(SourceObjectId.BirthObjectId)) {
07769
return (STATUS_SUCCESS);
07770 }
07771
if (trackingInfo->DestinationFile) {
07772
07773
07774
07775
07776
07777
07778
07779
07780
07781
07782
07783
07784
if (
IsFileLocal( dstFileObject )) {
07785
07786
07787
07788
07789
07790
07791
07792 status =
IopGetVolumeId( dstFileObject,
07793 &TargetVolumeId,
07794
sizeof( TargetVolumeId ) );
07795
if (!
NT_SUCCESS( status )) {
07796
return status;
07797 }
07798
07799 status =
IopGetSetObjectId( dstFileObject,
07800 &TargetObjectId,
07801
sizeof( TargetObjectId ),
07802 FSCTL_CREATE_OR_GET_OBJECT_ID );
07803
if (!
NT_SUCCESS( status )) {
07804
return status;
07805 }
07806
07807
07808
07809
07810
07811
07812
IopMarshalIds( &trackingBuffer, &TargetVolumeId, &TargetObjectId, trackingInfo );
07813
07814 status =
IopTrackLink( FileObject,
07815 IoStatusBlock,
07816 &trackingBuffer.
TrackingInformation,
07817 FIELD_OFFSET( FILE_TRACKING_INFORMATION,
07818 ObjectInformation ) +
07819 trackingBuffer.
TrackingInformation.ObjectInformationLength,
07820
Event,
07821
KernelMode );
07822
if( !
NT_SUCCESS(status) ) {
07823
return status;
07824 }
07825
07826
07827
07828
07829
07830 status =
IopGetSetObjectId( FileObject,
07831
NULL,
07832 0,
07833 FSCTL_DELETE_OBJECT_ID );
07834
if( !
NT_SUCCESS( status )) {
07835
return status;
07836 }
07837
07838
07839
07840
07841
07842
07843 CrossVolumeObjectId = SourceObjectId;
07844 CrossVolumeObjectId.BirthVolumeId[0] |= 1;
07845
07846 status =
IopGetSetObjectId( dstFileObject,
07847 &CrossVolumeObjectId.ExtendedInfo[0],
07848
sizeof( CrossVolumeObjectId.ExtendedInfo ),
07849 FSCTL_SET_OBJECT_ID_EXTENDED );
07850
07851
if( !
NT_SUCCESS( status )) {
07852
07853
IopGetSetObjectId( FileObject,
07854 &SourceObjectId,
07855
sizeof(SourceObjectId),
07856 FSCTL_SET_OBJECT_ID );
07857
return status;
07858 }
07859
07860 }
07861
07862
else if (!
IopIsSameMachine( FileObject, trackingInfo->DestinationFile)) {
07863
07864
07865
07866
07867
07868
07869
07870
07871
07872
07873
07874 status =
IopGetSetObjectId( dstFileObject,
07875 &TargetVolumeId,
07876
sizeof(
FILE_VOLUMEID_WITH_TYPE ),
07877 FSCTL_LMR_GET_LINK_TRACKING_INFORMATION );
07878
07879
if (!
NT_SUCCESS( status )) {
07880
return status;
07881 }
07882
07883
07884
07885
07886
07887 status =
IopGetSetObjectId( dstFileObject,
07888 &TargetObjectId,
07889
sizeof( TargetObjectId ),
07890 FSCTL_CREATE_OR_GET_OBJECT_ID );
07891
if( !
NT_SUCCESS( status )) {
07892
return status;
07893 }
07894
07895
07896
07897
07898
07899
IopMarshalIds( &trackingBuffer, &TargetVolumeId, &TargetObjectId, trackingInfo );
07900
07901 status =
IopTrackLink( FileObject,
07902 IoStatusBlock,
07903 &trackingBuffer.
TrackingInformation,
07904 FIELD_OFFSET( FILE_TRACKING_INFORMATION,
07905 ObjectInformation ) +
07906 trackingBuffer.
TrackingInformation.ObjectInformationLength,
07907
Event,
07908
KernelMode );
07909
if( !
NT_SUCCESS( status )) {
07910
return status;
07911 }
07912
07913
07914
07915
07916
07917
07918 CrossVolumeObjectId = SourceObjectId;
07919 CrossVolumeObjectId.BirthVolumeId[0] |= 1;
07920
07921 status =
IopGetSetObjectId( dstFileObject,
07922 &CrossVolumeObjectId.ExtendedInfo[0],
07923
sizeof( CrossVolumeObjectId.ExtendedInfo ),
07924 FSCTL_SET_OBJECT_ID_EXTENDED );
07925
07926
if( !
NT_SUCCESS( status )) {
07927
IopGetSetObjectId( FileObject,
07928 &SourceObjectId,
07929
sizeof(SourceObjectId),
07930 FSCTL_SET_OBJECT_ID );
07931
return status;
07932 }
07933
07934 }
else {
07935
07936
07937
07938
07939
07940
07941
07942 status =
IopSetRemoteLink( FileObject, dstFileObject, trackingInfo );
07943
07944 }
07945
07946 }
else {
07947
07948
07949
07950
07951
07952
07953
07954
07955 status =
IopSetRemoteLink( FileObject,
NULL, FileInformation );
07956
07957 }
07958 }
07959
07960 } finally {
07961
07962
07963
07964
07965
07966
if (RequestorMode !=
KernelMode && trackingInfo) {
07967
ExFreePool( trackingInfo );
07968 }
07969
07970
if (dstFileObject ) {
07971
ObDereferenceObject( dstFileObject );
07972 }
07973
07974
KeSetEvent(
Event, 0,
FALSE );
07975 }
07976
07977
return status;
07978 }
07979
07980
VOID
07981 IopUserCompletion(
07982 IN
PKAPC Apc,
07983 IN PKNORMAL_ROUTINE *NormalRoutine,
07984 IN PVOID *NormalContext,
07985 IN PVOID *SystemArgument1,
07986 IN PVOID *SystemArgument2
07987 )
07988
07989
07990
07991
07992
07993
07994
07995
07996
07997
07998
07999
08000
08001
08002
08003
08004
08005
08006
08007
08008
08009
08010
08011
08012
08013
08014
08015
08016
08017
08018
08019
08020
08021
08022
08023
08024
08025
08026
08027
08028
08029
08030
08031
08032
08033 {
08034 UNREFERENCED_PARAMETER( NormalRoutine );
08035 UNREFERENCED_PARAMETER( NormalContext );
08036 UNREFERENCED_PARAMETER( SystemArgument1 );
08037 UNREFERENCED_PARAMETER( SystemArgument2 );
08038
08039
PAGED_CODE();
08040
08041
08042
08043
08044
08045
IoFreeIrp( CONTAINING_RECORD( Apc,
IRP, Tail.Apc ) );
08046 }
08047
08048
08049
08050
VOID
08051 IopUserRundown(
08052 IN
PKAPC Apc
08053 )
08054
08055
08056
08057
08058
08059
08060
08061
08062
08063
08064
08065
08066
08067
08068
08069
08070
08071
08072
08073 {
08074
PAGED_CODE();
08075
08076
08077
08078
08079
08080
IoFreeIrp( CONTAINING_RECORD( Apc,
IRP, Tail.Apc ) );
08081 }
08082
08083
NTSTATUS
08084 IopXxxControlFile(
08085 IN HANDLE FileHandle,
08086 IN HANDLE Event OPTIONAL,
08087 IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
08088 IN PVOID ApcContext OPTIONAL,
08089 OUT PIO_STATUS_BLOCK IoStatusBlock,
08090 IN ULONG IoControlCode,
08091 IN PVOID InputBuffer OPTIONAL,
08092 IN ULONG InputBufferLength,
08093 OUT PVOID OutputBuffer OPTIONAL,
08094 IN ULONG OutputBufferLength,
08095 IN BOOLEAN DeviceIoControl
08096 )
08097
08098
08099
08100
08101
08102
08103
08104
08105
08106
08107
08108
08109
08110
08111
08112
08113
08114
08115
08116
08117
08118
08119
08120
08121
08122
08123
08124
08125
08126
08127
08128
08129
08130
08131
08132
08133
08134
08135
08136
08137
08138
08139
08140
08141
08142
08143
08144
08145
08146
08147
08148
08149
08150 {
08151
PIRP irp;
08152
NTSTATUS status;
08153
PFILE_OBJECT fileObject;
08154
PDEVICE_OBJECT deviceObject;
08155
PKEVENT eventObject = (
PKEVENT)
NULL;
08156
PIO_STACK_LOCATION irpSp;
08157 ULONG method;
08158
OBJECT_HANDLE_INFORMATION handleInformation;
08159 BOOLEAN synchronousIo;
08160 IO_STATUS_BLOCK localIoStatus;
08161
PFAST_IO_DISPATCH fastIoDispatch;
08162
POOL_TYPE poolType;
08163 PULONG majorFunction;
08164
KPROCESSOR_MODE requestorMode;
08165
08166
PAGED_CODE();
08167
08168
08169
08170
08171
08172 method = IoControlCode & 3;
08173
08174
08175
08176
08177
08178 requestorMode = KeGetPreviousMode();
08179
08180
if (requestorMode !=
KernelMode) {
08181
08182
08183
08184
08185
08186
08187
08188
08189
08190
try {
08191
08192
08193
08194
08195
08196
ProbeForWriteIoStatusEx( IoStatusBlock , ApcRoutine);
08197
08198
08199
08200
08201
08202
08203
08204
08205
08206
08207
08208
08209
08210
08211
08212
08213
08214
08215
if (method == 0) {
08216
if (ARGUMENT_PRESENT( OutputBuffer )) {
08217
ProbeForWrite( OutputBuffer,
08218 OutputBufferLength,
08219
sizeof( UCHAR ) );
08220 }
else {
08221 OutputBufferLength = 0;
08222 }
08223 }
08224
08225
if (method != 3) {
08226
if (ARGUMENT_PRESENT( InputBuffer )) {
08227
ProbeForRead( InputBuffer,
08228 InputBufferLength,
08229
sizeof( UCHAR ) );
08230 }
else {
08231 InputBufferLength = 0;
08232 }
08233 }
08234
08235 } except(
EXCEPTION_EXECUTE_HANDLER) {
08236
08237
08238
08239
08240
08241
08242
08243
return GetExceptionCode();
08244
08245 }
08246 }
08247
08248
08249
08250
08251
08252
08253
08254
08255 status =
ObReferenceObjectByHandle( FileHandle,
08256 0
L,
08257
IoFileObjectType,
08258 requestorMode,
08259 (PVOID *) &fileObject,
08260 &handleInformation );
08261
if (!
NT_SUCCESS( status )) {
08262
return status;
08263 }
08264
08265
08266
08267
08268
08269
08270
08271
if (fileObject->CompletionContext &&
IopApcRoutinePresent( ApcRoutine )) {
08272
ObDereferenceObject( fileObject );
08273
return STATUS_INVALID_PARAMETER;
08274 }
08275
08276
08277
08278
08279
08280
08281
08282
if (requestorMode !=
KernelMode) {
08283
08284 ULONG accessMode = (IoControlCode >> 14) & 3;
08285
08286
if (accessMode != FILE_ANY_ACCESS) {
08287
08288
08289
08290
08291
08292
08293
08294
if (
SeComputeGrantedAccesses( handleInformation.
GrantedAccess, accessMode ) != accessMode ) {
08295
ObDereferenceObject( fileObject );
08296
return STATUS_ACCESS_DENIED;
08297 }
08298 }
08299 }
08300
08301
08302
08303
08304
08305
08306
08307
08308
if (ARGUMENT_PRESENT(
Event )) {
08309 status =
ObReferenceObjectByHandle(
Event,
08310 EVENT_MODIFY_STATE,
08311
ExEventObjectType,
08312 requestorMode,
08313 (PVOID *) &eventObject,
08314
NULL );
08315
if (!
NT_SUCCESS( status )) {
08316
ObDereferenceObject( fileObject );
08317
return status;
08318 }
else {
08319
KeClearEvent( eventObject );
08320 }
08321 }
08322
08323
08324
08325
08326
08327
08328
08329
if (fileObject->Flags &
FO_SYNCHRONOUS_IO) {
08330 BOOLEAN interrupted;
08331
08332
if (!
IopAcquireFastLock( fileObject )) {
08333 status =
IopAcquireFileObjectLock( fileObject,
08334 requestorMode,
08335 (BOOLEAN) ((fileObject->Flags &
FO_ALERTABLE_IO) != 0),
08336 &interrupted );
08337
if (interrupted) {
08338
if (eventObject) {
08339
ObDereferenceObject( eventObject );
08340 }
08341
ObDereferenceObject( fileObject );
08342
return status;
08343 }
08344 }
08345 synchronousIo =
TRUE;
08346 }
else {
08347 synchronousIo =
FALSE;
08348 }
08349
08350
08351
08352
08353
08354
08355
08356
if (!(fileObject->Flags &
FO_DIRECT_DEVICE_OPEN)) {
08357 deviceObject =
IoGetRelatedDeviceObject( fileObject );
08358 }
else {
08359 deviceObject =
IoGetAttachedDevice( fileObject->DeviceObject );
08360 }
08361
08362
if (DeviceIoControl) {
08363
08364
08365
08366
08367
08368 fastIoDispatch = deviceObject->
DriverObject->
FastIoDispatch;
08369
08370
08371
08372
08373
08374
08375
08376
08377
08378
if (fastIoDispatch && fastIoDispatch->
FastIoDeviceControl) {
08379
08380
08381
08382
08383
08384
08385
if (requestorMode !=
KernelMode && ARGUMENT_PRESENT(OutputBuffer)) {
08386
08387
try {
08388
08389
if (method == 1) {
08390
ProbeForRead( OutputBuffer,
08391 OutputBufferLength,
08392
sizeof( UCHAR ) );
08393 }
else if (method == 2) {
08394
ProbeForWrite( OutputBuffer,
08395 OutputBufferLength,
08396
sizeof( UCHAR ) );
08397 }
08398
08399 } except(
EXCEPTION_EXECUTE_HANDLER) {
08400
08401
08402
08403
08404
08405
08406
08407
if (synchronousIo) {
08408
IopReleaseFileObjectLock( fileObject );
08409 }
08410
08411
if (eventObject) {
08412
ObDereferenceObject( eventObject );
08413 }
08414
08415
ObDereferenceObject( fileObject );
08416
08417
return GetExceptionCode();
08418 }
08419 }
08420
08421
08422
08423
08424
08425
if (fastIoDispatch->
FastIoDeviceControl( fileObject,
08426
TRUE,
08427 InputBuffer,
08428 InputBufferLength,
08429 OutputBuffer,
08430 OutputBufferLength,
08431 IoControlCode,
08432 &localIoStatus,
08433 deviceObject )) {
08434
08435
08436
08437
08438
08439
08440
08441
try {
08442 *IoStatusBlock = localIoStatus;
08443 } except(
EXCEPTION_EXECUTE_HANDLER ) {
08444 localIoStatus.Status = GetExceptionCode();
08445 localIoStatus.Information = 0;
08446 }
08447
08448
08449
08450
08451
08452
if (ARGUMENT_PRESENT(
Event )) {
08453
KeSetEvent( eventObject, 0,
FALSE );
08454
ObDereferenceObject( eventObject );
08455 }
08456
08457
08458
08459
08460
08461
08462
08463
if (synchronousIo) {
08464
IopReleaseFileObjectLock( fileObject );
08465 }
08466
08467
08468
08469
08470
08471
08472
08473
if (fileObject->CompletionContext && ARGUMENT_PRESENT( ApcContext )) {
08474
if (!
NT_SUCCESS(
IoSetIoCompletion( fileObject->CompletionContext->Port,
08475 fileObject->CompletionContext->Key,
08476 ApcContext,
08477 localIoStatus.Status,
08478 localIoStatus.Information,
08479
TRUE ))) {
08480 localIoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
08481 }
08482 }
08483
08484
08485
08486
08487
08488
ObDereferenceObject( fileObject );
08489
return localIoStatus.Status;
08490 }
08491 }
08492
08493 }
08494
08495
08496
08497
08498
08499
KeClearEvent( &fileObject->Event );
08500
08501
08502
08503
08504 irp =
IopAllocateIrp( deviceObject->
StackSize,
TRUE );
08505
08506
if (!irp) {
08507
08508
08509
08510
08511
08512
08513
IopAllocateIrpCleanup( fileObject, eventObject );
08514
08515
return STATUS_INSUFFICIENT_RESOURCES;
08516 }
08517 irp->
Tail.Overlay.OriginalFileObject = fileObject;
08518 irp->
Tail.Overlay.Thread =
PsGetCurrentThread();
08519 irp->
Tail.Overlay.AuxiliaryBuffer = (PVOID)
NULL;
08520 irp->
RequestorMode = requestorMode;
08521 irp->
PendingReturned =
FALSE;
08522 irp->
Cancel =
FALSE;
08523 irp->
CancelRoutine = (
PDRIVER_CANCEL)
NULL;
08524
08525
08526
08527
08528
08529 irp->
UserEvent = eventObject;
08530 irp->
UserIosb = IoStatusBlock;
08531 irp->
Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
08532 irp->
Overlay.AsynchronousParameters.UserApcContext = ApcContext;
08533
08534
08535
08536
08537
08538
08539
08540
08541
08542
08543
08544 irpSp =
IoGetNextIrpStackLocation( irp );
08545 majorFunction = (PULONG) (&irpSp->
MajorFunction);
08546 *majorFunction = DeviceIoControl ?
IRP_MJ_DEVICE_CONTROL :
IRP_MJ_FILE_SYSTEM_CONTROL;
08547 irpSp->
FileObject = fileObject;
08548
08549
08550
08551
08552
08553
08554 irpSp->
Parameters.DeviceIoControl.OutputBufferLength = OutputBufferLength;
08555 irpSp->
Parameters.DeviceIoControl.InputBufferLength = InputBufferLength;
08556 irpSp->
Parameters.DeviceIoControl.IoControlCode = IoControlCode;
08557
08558
08559
08560
08561
08562 poolType = DeviceIoControl ?
NonPagedPoolCacheAligned :
NonPagedPool;
08563
08564
08565
08566
08567
08568
08569
08570 irp->
MdlAddress = (
PMDL)
NULL;
08571 irp->
AssociatedIrp.SystemBuffer = (PVOID)
NULL;
08572
08573
switch ( method ) {
08574
08575
case 0:
08576
08577
08578
08579
08580
08581
08582
08583 irpSp->
Parameters.DeviceIoControl.Type3InputBuffer = (PVOID)
NULL;
08584
08585
try {
08586
08587
if (InputBufferLength || OutputBufferLength) {
08588 irp->
AssociatedIrp.SystemBuffer =
08589
ExAllocatePoolWithQuota( poolType,
08590 (InputBufferLength > OutputBufferLength) ? InputBufferLength : OutputBufferLength );
08591
08592
if (ARGUMENT_PRESENT( InputBuffer )) {
08593 RtlCopyMemory( irp->
AssociatedIrp.SystemBuffer,
08594 InputBuffer,
08595 InputBufferLength );
08596 }
08597 irp->
Flags =
IRP_BUFFERED_IO |
IRP_DEALLOCATE_BUFFER;
08598 irp->
UserBuffer = OutputBuffer;
08599
if (ARGUMENT_PRESENT( OutputBuffer )) {
08600 irp->
Flags |=
IRP_INPUT_OPERATION;
08601 }
08602 }
else {
08603 irp->
Flags = 0;
08604 irp->
UserBuffer = (PVOID)
NULL;
08605 }
08606
08607 } except(
EXCEPTION_EXECUTE_HANDLER) {
08608
08609
08610
08611
08612
08613
08614
08615
08616
IopExceptionCleanup( fileObject,
08617 irp,
08618 eventObject,
08619 (
PKEVENT)
NULL );
08620
08621
return GetExceptionCode();
08622 }
08623
08624
break;
08625
08626
case 1:
08627
case 2:
08628
08629
08630
08631
08632
08633
08634
08635
08636
08637
08638
08639
08640
08641
08642
08643 irp->
Flags = 0;
08644 irpSp->
Parameters.DeviceIoControl.Type3InputBuffer = (PVOID)
NULL;
08645
08646
try {
08647
08648
if (InputBufferLength && ARGUMENT_PRESENT( InputBuffer )) {
08649 irp->
AssociatedIrp.SystemBuffer =
08650
ExAllocatePoolWithQuota( poolType,
08651 InputBufferLength );
08652 RtlCopyMemory( irp->
AssociatedIrp.SystemBuffer,
08653 InputBuffer,
08654 InputBufferLength );
08655 irp->
Flags =
IRP_BUFFERED_IO |
IRP_DEALLOCATE_BUFFER;
08656 }
08657
08658
if (OutputBufferLength != 0) {
08659 irp->
MdlAddress =
IoAllocateMdl( OutputBuffer,
08660 OutputBufferLength,
08661
FALSE,
08662
TRUE,
08663 irp );
08664
if (irp->
MdlAddress ==
NULL) {
08665
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
08666 }
08667
MmProbeAndLockPages( irp->
MdlAddress,
08668 requestorMode,
08669 (
LOCK_OPERATION) ((method == 1) ?
IoReadAccess :
IoWriteAccess) );
08670 }
08671
08672 } except(
EXCEPTION_EXECUTE_HANDLER) {
08673
08674
08675
08676
08677
08678
08679
08680
08681
08682
IopExceptionCleanup( fileObject,
08683 irp,
08684 eventObject,
08685 (
PKEVENT)
NULL );
08686
08687
return GetExceptionCode();
08688 }
08689
08690
break;
08691
08692
case 3:
08693
08694
08695
08696
08697
08698
08699
08700 irp->
Flags = 0;
08701 irp->
UserBuffer = OutputBuffer;
08702 irpSp->
Parameters.DeviceIoControl.Type3InputBuffer = InputBuffer;
08703 }
08704
08705
08706
08707
08708
08709
08710
if (!DeviceIoControl) {
08711 irp->
Flags |=
IRP_DEFER_IO_COMPLETION;
08712 }
08713
08714
08715
08716
08717
08718
08719
return IopSynchronousServiceTail( deviceObject,
08720 irp,
08721 fileObject,
08722 (BOOLEAN)!DeviceIoControl,
08723 requestorMode,
08724 synchronousIo,
08725
OtherTransfer );
08726 }
08727
08728
NTSTATUS
08729 IopLookupBusStringFromID (
08730 IN HANDLE KeyHandle,
08731 IN INTERFACE_TYPE InterfaceType,
08732 OUT PWCHAR Buffer,
08733 IN ULONG Length,
08734 OUT PULONG BusFlags OPTIONAL
08735 )
08736
08737
08738
08739
08740
08741
08742
08743
08744
08745
08746
08747
08748
08749
08750
08751
08752
08753
08754
08755
08756
08757
08758
08759
08760
08761
08762
08763
08764
08765
08766 {
08767
NTSTATUS status;
08768 ULONG
Index, junk, i, j;
08769 PULONG pl;
08770 PKEY_VALUE_FULL_INFORMATION KeyInformation;
08771 WCHAR
c;
08772
08773
PAGED_CODE();
08774
08775
Index = 0;
08776 KeyInformation = (PKEY_VALUE_FULL_INFORMATION)
Buffer;
08777
08778
for (; ;) {
08779 status = ZwEnumerateValueKey (
08780 KeyHandle,
08781
Index++,
08782 KeyValueFullInformation,
08783
Buffer,
08784 Length,
08785 &junk
08786 );
08787
08788
if (!
NT_SUCCESS (status)) {
08789
return status;
08790 }
08791
08792
if (KeyInformation->Type != REG_BINARY) {
08793
continue;
08794 }
08795
08796 pl = (PULONG) ((PUCHAR) KeyInformation + KeyInformation->DataOffset);
08797
if ((ULONG)
InterfaceType != pl[0]) {
08798
continue;
08799 }
08800
08801
08802
08803
08804
08805
if(ARGUMENT_PRESENT(BusFlags)) {
08806 *BusFlags = pl[1];
08807 }
08808
08809 j = KeyInformation->NameLength /
sizeof (WCHAR);
08810
for (i=0; i < j; i++) {
08811
c = KeyInformation->Name[i];
08812
Buffer[i] =
c;
08813 }
08814
08815
Buffer[i] = 0;
08816
return STATUS_SUCCESS;
08817 }
08818 }
08819
08820
08821 BOOLEAN
08822 IopSafebootDriverLoad(
08823 PUNICODE_STRING DriverId
08824 )
08825
08826
08827
08828
08829
08830
08831
08832
08833
08834
08835
08836
08837
08838
08839
08840
08841
08842
08843
08844 {
08845
NTSTATUS status;
08846 HANDLE hSafeBoot,hGuid;
08847 UNICODE_STRING safeBootKey;
08848 UNICODE_STRING SafeBootTypeString;
08849
08850
08851
08852
08853
08854
08855
08856
switch (
InitSafeBootMode) {
08857
case SAFEBOOT_MINIMAL:
08858
RtlInitUnicodeString(&SafeBootTypeString,SAFEBOOT_MINIMAL_STR_W);
08859
break;
08860
08861
case SAFEBOOT_NETWORK:
08862
RtlInitUnicodeString(&SafeBootTypeString,SAFEBOOT_NETWORK_STR_W);
08863
break;
08864
08865
case SAFEBOOT_DSREPAIR:
08866
return TRUE;
08867
08868
default:
08869 KdPrint((
"SAFEBOOT: invalid safeboot option = %d\n",
InitSafeBootMode));
08870
return FALSE;
08871 }
08872
08873 safeBootKey.Length = 0;
08874 safeBootKey.MaximumLength = DriverId->Length + SafeBootTypeString.Length + (4*
sizeof(WCHAR));
08875 safeBootKey.Buffer = (PWCHAR)
ExAllocatePool(
PagedPool,safeBootKey.MaximumLength);
08876
if (!safeBootKey.Buffer) {
08877 KdPrint((
"SAFEBOOT: could not allocate pool\n"));
08878
return FALSE;
08879 }
08880
08881
RtlCopyUnicodeString(&safeBootKey,&SafeBootTypeString);
08882 status =
RtlAppendUnicodeToString(&safeBootKey,
L"\\");
08883
if (!
NT_SUCCESS(status)) {
08884
ExFreePool (safeBootKey.Buffer);
08885 KdPrint((
"SAFEBOOT: could not create registry key string = %x\n",status));
08886
return FALSE;
08887 }
08888 status =
RtlAppendUnicodeStringToString(&safeBootKey,DriverId);
08889
if (!
NT_SUCCESS(status)) {
08890
ExFreePool (safeBootKey.Buffer);
08891 KdPrint((
"SAFEBOOT: could not create registry key string = %x\n",status));
08892
return FALSE;
08893 }
08894
08895 status =
IopOpenRegistryKey (
08896 &hSafeBoot,
08897
NULL,
08898 &
CmRegistryMachineSystemCurrentControlSetControlSafeBoot,
08899 KEY_ALL_ACCESS,
08900
FALSE
08901 );
08902
if (
NT_SUCCESS(status)) {
08903 status =
IopOpenRegistryKey (
08904 &hGuid,
08905 hSafeBoot,
08906 &safeBootKey,
08907 KEY_ALL_ACCESS,
08908
FALSE
08909 );
08910
NtClose(hSafeBoot);
08911
if (
NT_SUCCESS(status)) {
08912
NtClose(hGuid);
08913
ExFreePool(safeBootKey.Buffer);
08914
return TRUE;
08915 }
08916 }
08917
08918
ExFreePool(safeBootKey.Buffer);
08919
08920
return FALSE;
08921 }
08922
08923
08924
08925 static PBOOT_LOG_RECORD BootLogRecord;
08926
08927
VOID
08928 IopInitializeBootLogging(
08929
PLOADER_PARAMETER_BLOCK LoaderBlock,
08930 PCHAR HeaderString
08931 )
08932
08933
08934
08935
08936
08937
08938
08939
08940
08941
08942
08943
08944
08945
08946
08947 {
08948 PLDR_DATA_TABLE_ENTRY DataTableEntry;
08949 PMESSAGE_RESOURCE_ENTRY MessageEntry;
08950 ULONG MsgId = 0;
08951 ANSI_STRING AnsiString;
08952
NTSTATUS Status;
08953 PLIST_ENTRY nextEntry;
08954 PLDR_DATA_TABLE_ENTRY driverEntry;
08955
08956
08957
PAGED_CODE();
08958
08959
if (
BootLogRecord !=
NULL) {
08960
return;
08961 }
08962
08963
BootLogRecord = (
PBOOT_LOG_RECORD)
ExAllocatePool(
NonPagedPool,
sizeof(
BOOT_LOG_RECORD));
08964
08965
if (
BootLogRecord ==
NULL) {
08966
return;
08967 }
08968
08969 RtlZeroMemory(
BootLogRecord,
sizeof(
BOOT_LOG_RECORD));
08970
08971
ExInitializeResource(&
BootLogRecord->
Resource);
08972
08973
ExAcquireResourceExclusive(&
BootLogRecord->
Resource,
TRUE);
08974
08975 DataTableEntry = CONTAINING_RECORD(LoaderBlock->
LoadOrderListHead.Flink,
08976 LDR_DATA_TABLE_ENTRY,
08977 InLoadOrderLinks);
08978
08979
Status =
RtlFindMessage (DataTableEntry->DllBase, 11, 0, BOOTLOG_LOADED, &MessageEntry);
08980
08981
if (
NT_SUCCESS(
Status )) {
08982 AnsiString.Buffer = MessageEntry->Text;
08983 AnsiString.Length =
strlen(MessageEntry->Text);
08984 AnsiString.MaximumLength = AnsiString.Length + 1;
08985
08986
RtlAnsiStringToUnicodeString(&
BootLogRecord->
LoadedString, &AnsiString,
TRUE);
08987
08988
08989
08990
if (
BootLogRecord->
LoadedString.Length > 2 *
sizeof(WCHAR)) {
08991
BootLogRecord->
LoadedString.Length -= 2 *
sizeof(WCHAR);
08992
BootLogRecord->
LoadedString.Buffer[
BootLogRecord->
LoadedString.Length /
sizeof(WCHAR)] = UNICODE_NULL;
08993 }
08994 }
08995
08996
Status =
RtlFindMessage (DataTableEntry->DllBase, 11, 0, BOOTLOG_NOT_LOADED, &MessageEntry);
08997
08998
if (
NT_SUCCESS(
Status )) {
08999 AnsiString.Buffer = MessageEntry->Text;
09000 AnsiString.Length =
strlen(MessageEntry->Text);
09001 AnsiString.MaximumLength = AnsiString.Length + 1;
09002
09003
RtlAnsiStringToUnicodeString(&
BootLogRecord->
NotLoadedString, &AnsiString,
TRUE);
09004
09005
09006
09007
if (
BootLogRecord->
NotLoadedString.Length > 2 *
sizeof(WCHAR)) {
09008
BootLogRecord->
NotLoadedString.Length -= 2 *
sizeof(WCHAR);
09009
BootLogRecord->
NotLoadedString.Buffer[
BootLogRecord->
NotLoadedString.Length /
sizeof(WCHAR)] = UNICODE_NULL;
09010 }
09011 }
09012
09013
09014
09015 HeaderString++;
09016
09017
RtlCreateUnicodeStringFromAsciiz(&
BootLogRecord->
HeaderString, HeaderString);
09018
09019
09020
09021
ExAcquireResourceShared( &
PsLoadedModuleResource,
TRUE );
09022 nextEntry =
PsLoadedModuleList.Flink;
09023
while (nextEntry != &
PsLoadedModuleList) {
09024
09025
09026
09027
09028
09029 driverEntry = CONTAINING_RECORD( nextEntry,
09030 LDR_DATA_TABLE_ENTRY,
09031 InLoadOrderLinks );
09032
09033
if (driverEntry->Flags & LDRP_ENTRY_PROCESSED){
09034
IopBootLog(&driverEntry->FullDllName,
TRUE);
09035 }
09036
09037 nextEntry = nextEntry->Flink;
09038 }
09039
09040
ExReleaseResource( &
PsLoadedModuleResource );
09041
09042
ExReleaseResource(&
BootLogRecord->
Resource);
09043 }
09044
09045
VOID
09046 IopBootLog(
09047 PUNICODE_STRING LogEntry,
09048 BOOLEAN Loaded
09049 )
09050
09051
09052
09053
09054
09055
09056
09057
09058
09059
09060
09061
09062
09063
09064
09065
09066
09067
09068
09069
09070 {
09071 WCHAR NameBuffer[BOOTLOG_STRSIZE];
09072 UNICODE_STRING
KeyName;
09073 UNICODE_STRING
ValueName;
09074 UNICODE_STRING CrLf;
09075 UNICODE_STRING
Space;
09076
NTSTATUS Status;
09077
09078 WCHAR MessageBuffer[BOOTLOG_STRSIZE];
09079 UNICODE_STRING MessageString = {
09080 0,
09081 BOOTLOG_STRSIZE,
09082 &MessageBuffer[0]
09083 };
09084
09085
PAGED_CODE();
09086
09087
if (
BootLogRecord ==
NULL) {
09088
return;
09089 }
09090
09091
ExAcquireResourceExclusive(&
BootLogRecord->
Resource,
TRUE);
09092
09093
if (Loaded) {
09094
RtlCopyUnicodeString(&MessageString, &
BootLogRecord->
LoadedString);
09095 }
else {
09096
RtlCopyUnicodeString(&MessageString, &
BootLogRecord->
NotLoadedString);
09097 }
09098
09099
09100
09101
RtlInitUnicodeString(&
Space,
L" ");
09102
09103
RtlAppendUnicodeStringToString(&MessageString, &
Space);
09104
09105
RtlAppendUnicodeStringToString(&MessageString, LogEntry);
09106
09107
09108
09109
RtlInitUnicodeString(&CrLf,
L"\r\n");
09110
RtlAppendUnicodeStringToString(&MessageString, &CrLf);
09111
09112 swprintf(NameBuffer,
L"%d",
BootLogRecord->
NextKey++);
09113
09114
RtlCreateUnicodeString(&
KeyName, NameBuffer);
09115
RtlInitUnicodeString(&
ValueName,
L"");
09116
09117
if (!
BootLogRecord->
FileLogging) {
09118 HANDLE hLogKey, hBootKey;
09119
09120
Status =
IopOpenRegistryKey (
09121 &hBootKey,
09122
NULL,
09123 &
CmRegistryMachineSystemCurrentControlSetControlBootLog,
09124 KEY_ALL_ACCESS,
09125
TRUE
09126 );
09127
09128
if (
NT_SUCCESS(
Status)) {
09129
Status =
IopOpenRegistryKey (
09130 &hLogKey,
09131 hBootKey,
09132 &
KeyName,
09133 KEY_ALL_ACCESS,
09134
TRUE
09135 );
09136
if (
NT_SUCCESS(
Status)) {
09137
Status =
IopSetRegistryStringValue(
09138 hLogKey,
09139 &
ValueName,
09140 &MessageString
09141 );
09142 ZwClose(hLogKey);
09143 }
09144 ZwClose(hBootKey);
09145 }
09146
09147 }
else {
09148
IopBootLogToFile( &MessageString );
09149 }
09150
09151
RtlFreeUnicodeString(&
KeyName);
09152
09153
ExReleaseResource(&
BootLogRecord->
Resource);
09154 }
09155
09156
VOID
09157 IopCopyBootLogRegistryToFile(
09158 VOID
09159 )
09160
09161
09162
09163
09164
09165
09166
09167
09168
09169
09170
09171
09172
09173
09174
09175
09176
09177 {
09178 UNICODE_STRING
KeyName;
09179 WCHAR NameBuffer[BOOTLOG_STRSIZE];
09180
NTSTATUS Status;
09181 HANDLE hLogKey, hBootKey;
09182 ULONG
Index;
09183 PKEY_VALUE_FULL_INFORMATION Information;
09184 IO_STATUS_BLOCK IoStatus;
09185 LARGE_INTEGER LocalTime;
09186 TIME_FIELDS
TimeFields;
09187
CHAR AnsiTimeBuffer[256];
09188 ANSI_STRING AnsiTimeString;
09189 UNICODE_STRING UnicodeTimeString;
09190 UNICODE_STRING LogString;
09191
09192
PAGED_CODE();
09193
09194
if (
BootLogRecord ==
NULL) {
09195
return;
09196 }
09197
09198
ExAcquireResourceExclusive(&
BootLogRecord->
Resource,
TRUE);
09199
09200
IopBootLogToFile(&
BootLogRecord->
HeaderString);
09201
09202
ExSystemTimeToLocalTime(&
KeBootTime, &LocalTime);
09203
09204
RtlTimeToTimeFields(&LocalTime, &
TimeFields);
09205
09206
sprintf(
09207 AnsiTimeBuffer,
09208
"%2d %2d %4d %02d:%02d:%02d.%03d\r\n",
09209
TimeFields.Month,
09210
TimeFields.Day,
09211
TimeFields.Year,
09212
TimeFields.Hour,
09213
TimeFields.Minute,
09214
TimeFields.Second,
09215
TimeFields.Milliseconds
09216 );
09217
09218
RtlInitAnsiString(&AnsiTimeString, AnsiTimeBuffer);
09219
09220
RtlAnsiStringToUnicodeString(&UnicodeTimeString, &AnsiTimeString,
TRUE);
09221
09222
IopBootLogToFile(&UnicodeTimeString);
09223
09224
RtlFreeUnicodeString(&UnicodeTimeString);
09225
09226
09227
09228
09229
09230
09231
Status =
IopOpenRegistryKey (
09232 &hBootKey,
09233
NULL,
09234 &
CmRegistryMachineSystemCurrentControlSetControlBootLog,
09235 KEY_ALL_ACCESS,
09236
FALSE
09237 );
09238
09239
if (
NT_SUCCESS(
Status)) {
09240
for (
Index = 0;
Index <
BootLogRecord->
NextKey;
Index++) {
09241 swprintf(NameBuffer,
L"%d",
Index);
09242
09243
RtlCreateUnicodeString(&
KeyName, NameBuffer);
09244
09245
Status =
IopOpenRegistryKey (
09246 &hLogKey,
09247 hBootKey,
09248 &
KeyName,
09249 KEY_ALL_ACCESS,
09250
FALSE
09251 );
09252
09253
if (
NT_SUCCESS(
Status)) {
09254
Status =
IopGetRegistryValue(
09255 hLogKey,
09256
L"",
09257 &Information
09258 );
09259
09260
if (
NT_SUCCESS(
Status)){
09261
RtlInitUnicodeString(&LogString, (PWSTR) ((PUCHAR)Information + Information->DataOffset));
09262
IopBootLogToFile(&LogString);
09263 }
09264
ExFreePool(Information);
09265 ZwDeleteKey(hLogKey);
09266 ZwClose(hLogKey);
09267 }
09268 }
09269 ZwDeleteKey(hBootKey);
09270 ZwClose(hBootKey);
09271
09272
09273
09274
09275
09276
BootLogRecord->
FileLogging =
TRUE;
09277 }
09278
09279
ExReleaseResource(&
BootLogRecord->
Resource);
09280 }
09281
09282
09283
NTSTATUS
09284 IopBootLogToFile(
09285 PUNICODE_STRING String
09286 )
09287
09288
09289
09290
09291
09292
09293
09294
09295
09296
09297
09298
09299
09300
09301
09302
09303
09304 {
09305 OBJECT_ATTRIBUTES ObjA;
09306
NTSTATUS Status;
09307 IO_STATUS_BLOCK IoStatusBlock;
09308 HANDLE FileHandle;
09309 WCHAR UnicodeHeader = 0xfeff;
09310
09311
09312
PAGED_CODE();
09313
09314
if (
BootLogRecord ==
NULL) {
09315
return STATUS_SUCCESS;
09316 }
09317
09318
ExAcquireResourceExclusive(&
BootLogRecord->
Resource,
TRUE);
09319
09320
if (
BootLogRecord->
LogFileName.Buffer ==
NULL) {
09321
RtlInitUnicodeString(&
BootLogRecord->
LogFileName,
L"\\SystemRoot\\ntbtlog.txt");
09322 }
09323
09324 InitializeObjectAttributes(&ObjA, &
BootLogRecord->
LogFileName, OBJ_CASE_INSENSITIVE,
NULL,
NULL);
09325
09326
Status =
ZwCreateFile(&FileHandle,
09327 GENERIC_WRITE,
09328 &ObjA,
09329 &IoStatusBlock,
09330
NULL,
09331 FILE_ATTRIBUTE_NORMAL,
09332 FILE_SHARE_READ,
09333 FILE_OPEN_IF,
09334 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE | FILE_SEQUENTIAL_ONLY,
09335
NULL,
09336 0
09337 );
09338
09339
if (
NT_SUCCESS(
Status) && IoStatusBlock.Information == FILE_CREATED) {
09340
09341
Status = ZwWriteFile(
09342 FileHandle,
09343
NULL,
09344
NULL,
09345
NULL,
09346 &IoStatusBlock,
09347 (PVOID) &UnicodeHeader,
09348
sizeof(WCHAR),
09349
NULL,
09350
NULL
09351 );
09352
09353 }
09354
09355
if (
NT_SUCCESS(
Status)) {
09356
09357 LARGE_INTEGER EndOfFile;
09358
09359 EndOfFile.HighPart = 0xffffffff;
09360 EndOfFile.LowPart = FILE_WRITE_TO_END_OF_FILE;
09361
09362
Status = ZwWriteFile(
09363 FileHandle,
09364
NULL,
09365
NULL,
09366
NULL,
09367 &IoStatusBlock,
09368 (PVOID)
String->Buffer,
09369
String->Length,
09370 &EndOfFile,
09371
NULL
09372 );
09373
09374 ZwClose(FileHandle);
09375 }
09376
09377
ExReleaseResource(&
BootLogRecord->
Resource);
09378
09379
return Status;
09380 }