Ros-diffs October 2020

ros-diffs@reactos.org

22 participants
156 discussions

[reactos] 01/01: [SETUPLIB] Fix some copy-pasta comments, no code changes

by Stanislav Motylkov

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9be9750dc8464d53e8cc9… commit 9be9750dc8464d53e8cc9469daed030a9168fb0a Author: Stanislav Motylkov <x86corez(a)gmail.com> AuthorDate: Sat Oct 17 00:48:30 2020 +0300 Commit: Stanislav Motylkov <x86corez(a)gmail.com> CommitDate: Sat Oct 17 00:48:30 2020 +0300 [SETUPLIB] Fix some copy-pasta comments, no code changes --- base/setup/lib/utils/bldrsup.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/base/setup/lib/utils/bldrsup.c b/base/setup/lib/utils/bldrsup.c index 2e127924368..0040d77180c 100644 --- a/base/setup/lib/utils/bldrsup.c +++ b/base/setup/lib/utils/bldrsup.c @@ -295,23 +295,23 @@ CreateCommonFreeLdrSections( IniCacheInsertKey(IniSection, NULL, INSERT_LAST, L"SelectedColor", L"Gray"); - /* SelectedColor=Gray */ + /* ShowTime=Yes */ IniCacheInsertKey(IniSection, NULL, INSERT_LAST, L"ShowTime", L"No"); - /* SelectedColor=Gray */ + /* MenuBox=Yes */ IniCacheInsertKey(IniSection, NULL, INSERT_LAST, L"MenuBox", L"No"); - /* SelectedColor=Gray */ + /* CenterMenu=Yes */ IniCacheInsertKey(IniSection, NULL, INSERT_LAST, L"CenterMenu", L"No"); - /* SelectedColor=Gray */ + /* MinimalUI=No */ IniCacheInsertKey(IniSection, NULL, INSERT_LAST, L"MinimalUI", L"Yes"); - /* SelectedColor=Gray */ + /* TimeText=Your text goes here... */ IniCacheInsertKey(IniSection, NULL, INSERT_LAST, L"TimeText", L"Seconds until highlighted choice will be started automatically: ");

3 years, 11 months

[reactos] 01/01: [FASTFAT] Ensure that deferred write IRP contexts are not touched. CORE-17328

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=320abafdc3ce9c89d561b… commit 320abafdc3ce9c89d561bb41e4d5bd6a34f1442e Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Sun Oct 11 15:02:26 2020 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Fri Oct 16 16:18:56 2020 +0200 [FASTFAT] Ensure that deferred write IRP contexts are not touched. CORE-17328 Cc may decide to process deferred writes any time, so the context might already be freed by the time we return from CcDeferWrite. Also mark the IRP as pending, since we're going to return STATUS_PENDING. --- drivers/filesystems/fastfat/misc.c | 47 ++++++++++++++++++++------------------ drivers/filesystems/fastfat/rw.c | 11 +++++---- drivers/filesystems/fastfat/vfat.h | 2 +- 3 files changed, 33 insertions(+), 27 deletions(-) diff --git a/drivers/filesystems/fastfat/misc.c b/drivers/filesystems/fastfat/misc.c index 4f7bf5b7d4b..443ad290817 100644 --- a/drivers/filesystems/fastfat/misc.c +++ b/drivers/filesystems/fastfat/misc.c @@ -130,7 +130,7 @@ VfatDispatchRequest( break; case IRP_MJ_WRITE: - Status = VfatWrite(IrpContext); + Status = VfatWrite(&IrpContext); break; case IRP_MJ_FILE_SYSTEM_CONTROL: @@ -182,30 +182,33 @@ VfatDispatchRequest( Status = STATUS_DRIVER_INTERNAL_ERROR; } - QueueIrp = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_QUEUE); - CompleteIrp = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_COMPLETE); + if (IrpContext != NULL) + { + QueueIrp = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_QUEUE); + CompleteIrp = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_COMPLETE); - ASSERT((!CompleteIrp && !QueueIrp) || - (CompleteIrp && !QueueIrp) || - (!CompleteIrp && QueueIrp)); + ASSERT((!CompleteIrp && !QueueIrp) || + (CompleteIrp && !QueueIrp) || + (!CompleteIrp && QueueIrp)); - if (CompleteIrp) - { - IrpContext->Irp->IoStatus.Status = Status; - IoCompleteRequest(IrpContext->Irp, IrpContext->PriorityBoost); - } + if (CompleteIrp) + { + IrpContext->Irp->IoStatus.Status = Status; + IoCompleteRequest(IrpContext->Irp, IrpContext->PriorityBoost); + } - if (QueueIrp) - { - /* Reset our status flags before queueing the IRP */ - IrpContext->Flags |= IRPCONTEXT_COMPLETE; - IrpContext->Flags &= ~IRPCONTEXT_QUEUE; - Status = VfatQueueRequest(IrpContext); - } - else - { - /* Unless the IRP was queued, always free the IRP context */ - VfatFreeIrpContext(IrpContext); + if (QueueIrp) + { + /* Reset our status flags before queueing the IRP */ + IrpContext->Flags |= IRPCONTEXT_COMPLETE; + IrpContext->Flags &= ~IRPCONTEXT_QUEUE; + Status = VfatQueueRequest(IrpContext); + } + else + { + /* Unless the IRP was queued, always free the IRP context */ + VfatFreeIrpContext(IrpContext); + } } FsRtlExitFileSystem(); diff --git a/drivers/filesystems/fastfat/rw.c b/drivers/filesystems/fastfat/rw.c index 60713e104c4..0afebafe893 100644 --- a/drivers/filesystems/fastfat/rw.c +++ b/drivers/filesystems/fastfat/rw.c @@ -873,8 +873,9 @@ ByeBye: NTSTATUS VfatWrite( - PVFAT_IRP_CONTEXT IrpContext) + PVFAT_IRP_CONTEXT *pIrpContext) { + PVFAT_IRP_CONTEXT IrpContext = *pIrpContext; PVFATFCB Fcb; PERESOURCE Resource = NULL; LARGE_INTEGER ByteOffset; @@ -999,13 +1000,15 @@ VfatWrite( Retrying = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_DEFERRED_WRITE); SetFlag(IrpContext->Flags, IRPCONTEXT_DEFERRED_WRITE); + IoMarkIrpPending(IrpContext->Irp); Status = STATUS_PENDING; + + DPRINT1("Deferring write for Irp %p, context %p!\n", IrpContext->Irp, IrpContext); CcDeferWrite(IrpContext->FileObject, VfatHandleDeferredWrite, IrpContext, NULL, Length, Retrying); + *pIrpContext = NULL; - DPRINT1("Dererring write!\n"); - - goto ByeBye; + return Status; } if (IsVolume) diff --git a/drivers/filesystems/fastfat/vfat.h b/drivers/filesystems/fastfat/vfat.h index 593ceb7c2da..fcb3a25cca7 100644 --- a/drivers/filesystems/fastfat/vfat.h +++ b/drivers/filesystems/fastfat/vfat.h @@ -1189,7 +1189,7 @@ VfatRead( NTSTATUS VfatWrite( - PVFAT_IRP_CONTEXT IrpContext); + PVFAT_IRP_CONTEXT *pIrpContext); NTSTATUS NextCluster(

3 years, 11 months

[reactos] 01/01: [NTOS] Consistently use MUTANT_INCREMENT.

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6b3f309a08f14ab68b538… commit 6b3f309a08f14ab68b538f85bf6a61f568871aeb Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Fri Oct 16 16:09:08 2020 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Fri Oct 16 16:09:54 2020 +0200 [NTOS] Consistently use MUTANT_INCREMENT. Spotted by Hermès. --- ntoskrnl/ke/mutex.c | 2 +- ntoskrnl/mm/ARM3/drvmgmt.c | 2 +- ntoskrnl/mm/ARM3/sysldr.c | 8 ++++---- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/ntoskrnl/ke/mutex.c b/ntoskrnl/ke/mutex.c index ef82931445f..7854b5fda66 100644 --- a/ntoskrnl/ke/mutex.c +++ b/ntoskrnl/ke/mutex.c @@ -192,7 +192,7 @@ KeReleaseMutex(IN PKMUTEX Mutex, ASSERT_MUTANT(Mutex); /* There's no difference at this level between the two */ - return KeReleaseMutant(Mutex, 1, FALSE, Wait); + return KeReleaseMutant(Mutex, MUTANT_INCREMENT, FALSE, Wait); } /* EOF */ diff --git a/ntoskrnl/mm/ARM3/drvmgmt.c b/ntoskrnl/mm/ARM3/drvmgmt.c index 0d4a5b1aa82..ce06e3247d8 100644 --- a/ntoskrnl/mm/ARM3/drvmgmt.c +++ b/ntoskrnl/mm/ARM3/drvmgmt.c @@ -194,7 +194,7 @@ Cleanup: // // Release the lock // - KeReleaseMutant(&MmSystemLoadLock, 1, FALSE, FALSE); + KeReleaseMutant(&MmSystemLoadLock, MUTANT_INCREMENT, FALSE, FALSE); KeLeaveCriticalRegion(); // diff --git a/ntoskrnl/mm/ARM3/sysldr.c b/ntoskrnl/mm/ARM3/sysldr.c index 9d51898ec64..d414b1f6b43 100644 --- a/ntoskrnl/mm/ARM3/sysldr.c +++ b/ntoskrnl/mm/ARM3/sysldr.c @@ -991,7 +991,7 @@ MmUnloadSystemImage(IN PVOID ImageHandle) /* Release the system lock and return */ Done: - KeReleaseMutant(&MmSystemLoadLock, 1, FALSE, FALSE); + KeReleaseMutant(&MmSystemLoadLock, MUTANT_INCREMENT, FALSE, FALSE); KeLeaveCriticalRegion(); return STATUS_SUCCESS; } @@ -1623,7 +1623,7 @@ MiFindInitializationCode(OUT PVOID *StartVa, /* Release the locks and return */ ExReleaseResourceLite(&PsLoadedModuleResource); - KeReleaseMutant(&MmSystemLoadLock, 1, FALSE, FALSE); + KeReleaseMutant(&MmSystemLoadLock, MUTANT_INCREMENT, FALSE, FALSE); KeLeaveCriticalRegion(); } @@ -2972,7 +2972,7 @@ LoaderScan: else if (!Section) { /* It wasn't loaded, and we didn't have a previous attempt */ - KeReleaseMutant(&MmSystemLoadLock, 1, FALSE, FALSE); + KeReleaseMutant(&MmSystemLoadLock, MUTANT_INCREMENT, FALSE, FALSE); KeLeaveCriticalRegion(); LockOwned = FALSE; @@ -3324,7 +3324,7 @@ Quickie: if (LockOwned) { /* Release the lock */ - KeReleaseMutant(&MmSystemLoadLock, 1, FALSE, FALSE); + KeReleaseMutant(&MmSystemLoadLock, MUTANT_INCREMENT, FALSE, FALSE); KeLeaveCriticalRegion(); LockOwned = FALSE; }

3 years, 11 months

[reactos] 01/01: [CDROM_NEW] Import Microsoft CDROM class driver from GitHub

by Victor Perevertkin

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=83b85e2124dcfc01a2351… commit 83b85e2124dcfc01a23516d1c07b84f520507e88 Author: Victor Perevertkin <victor.perevertkin(a)reactos.org> AuthorDate: Fri Oct 16 04:37:10 2020 +0300 Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org> CommitDate: Fri Oct 16 04:37:10 2020 +0300 [CDROM_NEW] Import Microsoft CDROM class driver from GitHub The source code is licensed under MS-PL license, taken from Windows Driver Samples repository (microsoft/Windows-driver-samples@master/storage/class/cdrom/) Synched with commit 96eb96dfb613e4c745db6bd1f53a92fe7e2290fc The driver is written for Windows 10 and uses KMDF so we compile it with ntoskrnl_vista and wdf01000 statically linked (for wdf01000 this will likely be changed in future) CORE-17129 --- drivers/storage/class/cdrom_new/CMakeLists.txt | 41 + drivers/storage/class/cdrom_new/aacs.c | 1481 ++++ drivers/storage/class/cdrom_new/autorun.c | 3080 ++++++++ drivers/storage/class/cdrom_new/cdrom.c | 4242 +++++++++++ drivers/storage/class/cdrom_new/cdrom.h | 1624 +++++ drivers/storage/class/cdrom_new/cdrom.inf | 159 + drivers/storage/class/cdrom_new/cdrom.rc | 23 + drivers/storage/class/cdrom_new/cdromp.h | 383 + drivers/storage/class/cdrom_new/common.c | 3878 ++++++++++ drivers/storage/class/cdrom_new/data.c | 283 + drivers/storage/class/cdrom_new/guid.c | 16 + drivers/storage/class/cdrom_new/init.c | 2742 +++++++ drivers/storage/class/cdrom_new/ioctl.c | 9134 ++++++++++++++++++++++++ drivers/storage/class/cdrom_new/ioctl.h | 847 +++ drivers/storage/class/cdrom_new/license.txt | 23 + drivers/storage/class/cdrom_new/localwpp.ini | 17 + drivers/storage/class/cdrom_new/mmc.c | 1629 +++++ drivers/storage/class/cdrom_new/mmc.h | 122 + drivers/storage/class/cdrom_new/pnppower.c | 689 ++ drivers/storage/class/cdrom_new/scratch.c | 1467 ++++ drivers/storage/class/cdrom_new/scratch.h | 187 + drivers/storage/class/cdrom_new/sense.c | 2600 +++++++ drivers/storage/class/cdrom_new/zpodd.c | 832 +++ 23 files changed, 35499 insertions(+) diff --git a/drivers/storage/class/cdrom_new/CMakeLists.txt b/drivers/storage/class/cdrom_new/CMakeLists.txt new file mode 100644 index 00000000000..7def3bc655d --- /dev/null +++ b/drivers/storage/class/cdrom_new/CMakeLists.txt @@ -0,0 +1,41 @@ + +remove_definitions(-D_WIN32_WINNT=0x502) + +list(APPEND SOURCE + aacs.c + autorun.c + cdrom.c + common.c + data.c + guid.c + init.c + ioctl.c + mmc.c + pnppower.c + scratch.c + sense.c + zpodd.c + cdrom.h) + +add_library(cdrom MODULE ${SOURCE}) +set_module_type(cdrom kernelmodedriver) + +if(GCC OR CLANG) + target_compile_options(cdrom PRIVATE -Wno-format -Wno-unused-variable -Wno-pointer-sign) +endif() + +if(GCC) + target_compile_options(cdrom PRIVATE -Wno-unknown-pragmas -Wno-incompatible-pointer-types -Wno-switch) +endif() + +if(CLANG) + target_compile_options(cdrom PRIVATE -Wno-enum-conversion -Wno-tautological-constant-compare) +endif() + +target_compile_definitions(cdrom PRIVATE DEBUG_USE_KDPRINT) + +target_link_libraries(cdrom wdf01000 ntoskrnl_vista libcntpr ${PSEH_LIB}) +add_importlibs(cdrom ntoskrnl hal) +# add_pch(cdrom cdrom.h SOURCE) +add_cd_file(TARGET cdrom DESTINATION reactos/system32/drivers NO_CAB FOR all) +add_driver_inf(cdrom cdrom.inf) diff --git a/drivers/storage/class/cdrom_new/aacs.c b/drivers/storage/class/cdrom_new/aacs.c new file mode 100644 index 00000000000..f81eacb372c --- /dev/null +++ b/drivers/storage/class/cdrom_new/aacs.c @@ -0,0 +1,1481 @@ +/*-- + +Copyright (C) Microsoft Corporation. All rights reserved. + +Module Name: + + aacs.c + +Abstract: + + The CDROM class driver implementation of handling AACS IOCTLs. + +Environment: + + kernel mode only + +Notes: + + +Revision History: + +--*/ + +#include "stddef.h" +#include "string.h" + +#include "ntddk.h" +#include "ntddstor.h" +#include "cdrom.h" +#include "ioctl.h" +#include "scratch.h" + +#ifdef DEBUG_USE_WPP +#include "aacs.tmh" +#endif + +#ifdef ALLOC_PRAGMA + +#pragma alloc_text(PAGE, DeviceHandleAacsReadMediaKeyBlock) +#pragma alloc_text(PAGE, DeviceHandleAacsStartSession) +#pragma alloc_text(PAGE, DeviceHandleAacsEndSession) +#pragma alloc_text(PAGE, DeviceHandleAacsSendCertificate) +#pragma alloc_text(PAGE, DeviceHandleAacsGetCertificate) +#pragma alloc_text(PAGE, DeviceHandleAacsGetChallengeKey) +#pragma alloc_text(PAGE, DeviceHandleAacsReadSerialNumber) +#pragma alloc_text(PAGE, DeviceHandleAacsReadMediaId) +#pragma alloc_text(PAGE, DeviceHandleAacsReadBindingNonce) +#pragma alloc_text(PAGE, DeviceHandleAacsGenerateBindingNonce) +#pragma alloc_text(PAGE, DeviceHandleReadVolumeId) +#pragma alloc_text(PAGE, DeviceHandleSendChallengeKey) + +#endif + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsReadMediaKeyBlock( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTLs: + IOCTL_AACS_READ_MEDIA_KEY_BLOCK_SIZE + IOCTL_AACS_READ_MEDIA_KEY_BLOCK +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + NTSTATUS status = STATUS_SUCCESS; + PAACS_LAYER_NUMBER layerNumber = NULL; + PVOID outputBuffer = NULL; + ULONG transferSize = sizeof(READ_DVD_STRUCTURES_HEADER); + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&layerNumber, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + if (RequestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_AACS_READ_MEDIA_KEY_BLOCK) + { + // maximum size for this transfer is one pack + header + transferSize += AACS_MKB_PACK_SIZE; + } + + if (transferSize > DeviceExtension->ScratchContext.ScratchBufferSize) + { + // rare case. normally the size of scratch buffer is 64k. + status = STATUS_INTERNAL_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + UCHAR rmdBlockNumber = 0; + BOOLEAN sendChangedCommand = TRUE; + BOOLEAN shouldRetry = TRUE; + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.READ_DVD_STRUCTURE.OperationCode = SCSIOP_READ_DVD_STRUCTURE; + // cdb->AsByte[1] = 0x01; // AACS sub-command not required for this + + cdb.READ_DVD_STRUCTURE.LayerNumber = (UCHAR)(*layerNumber); + cdb.READ_DVD_STRUCTURE.Format = 0x83; // MKB + cdb.READ_DVD_STRUCTURE.AllocationLength[0] = (UCHAR)(transferSize >> (8*1)); + cdb.READ_DVD_STRUCTURE.AllocationLength[1] = (UCHAR)(transferSize >> (8*0)); + + while (sendChangedCommand) + { + // RMDBlockNumber is set to zero.... + // RMDBlockNumber[3] maybe changed for other blocks. + cdb.READ_DVD_STRUCTURE.RMDBlockNumber[3] = rmdBlockNumber; + + if (shouldRetry) + { + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, transferSize, TRUE, &cdb, 12); + } + + #ifdef ENABLE_AACS_TESTING + if (RequestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_AACS_READ_MEDIA_KEY_BLOCK_SIZE) + { + static const UCHAR results[] = { 0x80, 0x02, 0x00, 0x02 }; + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; + } + else if (RequestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_AACS_READ_MEDIA_KEY_BLOCK) + { + static const UCHAR results[] = { 0x80, 0x02, 0x00, 0x02 }; + static const UCHAR defaultFill = 0x30; // '0' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x8004, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; + } + #endif //ENABLE_AACS_TESTING + + if (NT_SUCCESS(status)) + { + // command succeeded, process data... + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + UCHAR thisPackNumber = cdb.READ_DVD_STRUCTURE.RMDBlockNumber[3]; + UCHAR otherPacks = header->Reserved[1]; + + // validate and zero-base the otherPacks + if (otherPacks == 0) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, + "AACS: Device is reporting zero total packs (invalid)\n")); + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + else + { + otherPacks--; + + if (RequestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_AACS_READ_MEDIA_KEY_BLOCK_SIZE) + { + // if not already requested last pack, do so now + if (otherPacks != thisPackNumber) + { + // re-send the command for the other pack number. + // this is safe here because NT_SUCCESS() is TRUE, + // and all the rest of this routine does is SetHardError() + // and release of resources we're still about to use. + + // re-zero the output buffer + RtlZeroMemory(DeviceExtension->ScratchContext.ScratchBuffer, sizeof(READ_DVD_STRUCTURES_HEADER)); + + // modify the CDB to get the very last pack of the MKB + rmdBlockNumber = otherPacks; + + transferSize = sizeof(READ_DVD_STRUCTURES_HEADER); + + // keep items clean + ScratchBuffer_ResetItems(DeviceExtension, TRUE); + + // make sure the loop will be executed for modified command. + sendChangedCommand = TRUE; + shouldRetry = TRUE; + } + else + { + // this request already got the last pack + // so just interpret the data + REVERSE_SHORT(&header->Length); + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + else + { + ULONG totalSize = header->Length; + // subtract out any remaining bytes in the header + // to get the number of usable bytes in this pack + totalSize -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + totalSize += otherPacks * AACS_MKB_PACK_SIZE; + + // save the result and complete the request + *((PULONG)outputBuffer) = totalSize; + *DataLength = sizeof(ULONG); + status = STATUS_SUCCESS; + } + // This will exit the loop of sendChangedCommand + sendChangedCommand = FALSE; + shouldRetry = FALSE; + } + } + else if (RequestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_AACS_READ_MEDIA_KEY_BLOCK) + { + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + else + { + // success, how many bytes to copy for this pack? + ULONG totalSize = header->Length; + size_t originalBufferSize; + + // subtract out any remaining bytes in the header + // to get the number of usable bytes in this pack + totalSize -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // if not the final pack, this should be a full transfer per spec + NT_ASSERT( (totalSize == AACS_MKB_PACK_SIZE) || (thisPackNumber == otherPacks) ); + + // validate the user's buffer is large enough to accept the full data + originalBufferSize = RequestParameters.Parameters.DeviceIoControl.OutputBufferLength; + + if (originalBufferSize < (totalSize + (AACS_MKB_PACK_SIZE*thisPackNumber))) + { + // just return a slightly bigger-than-normal size + *DataLength = (otherPacks + 1)*AACS_MKB_PACK_SIZE; + status = STATUS_BUFFER_TOO_SMALL; + } + else + { + PUCHAR whereToCopy; + // determine where to copy to the user's memory + whereToCopy = outputBuffer; + whereToCopy += AACS_MKB_PACK_SIZE * thisPackNumber; + + RtlCopyMemory(whereToCopy, header->Data, totalSize); + + // update the Information field here because we already + // have calculated the size of the block + *DataLength = totalSize + (AACS_MKB_PACK_SIZE * thisPackNumber); + status = STATUS_SUCCESS; + + // if there are more packs to get from the device, send it again.... + if (thisPackNumber != otherPacks) + { + // re-send the command for the next pack number. + // this is safe here because NT_SUCCESS() is TRUE, + // and all the rest of this routine does is SetHardError() + // and release of resources we're still about to use. + + // re-zero the output buffer + RtlZeroMemory(DeviceExtension->ScratchContext.ScratchBuffer, sizeof(READ_DVD_STRUCTURES_HEADER)); + + // modify the CDB to get the next pack of the MKB + rmdBlockNumber = cdb.READ_DVD_STRUCTURE.RMDBlockNumber[3]++; + + // modify the SRB to be resent + // + transferSize = AACS_MKB_PACK_SIZE + sizeof(READ_DVD_STRUCTURES_HEADER); + + // keep items clean + ScratchBuffer_ResetItems(DeviceExtension, FALSE); + + // make sure the loop will be executed for modified command. + sendChangedCommand = TRUE; + shouldRetry = TRUE; + } + else + { + // else, that was the end of the transfer, so just complete the request + sendChangedCommand = FALSE; + } + } + } + + } // end of IOCTL_AACS_READ_MEDIA_KEY_BLOCK + } + } // end of NT_SUCCESS(status) + + if (!NT_SUCCESS(status)) + { + // command failed. + sendChangedCommand = FALSE; + } + } //end of while (sendChangedCommand) + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsStartSession( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_START_SESSION +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsGetAgid + + NTSTATUS status = STATUS_SUCCESS; + PDVD_SESSION_ID sessionId = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&sessionId, + NULL); + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(CDVD_REPORT_AGID_DATA); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.REPORT_KEY.OperationCode = SCSIOP_REPORT_KEY; + cdb.AsByte[7] = 0x02; // AACS key class + cdb.REPORT_KEY.AllocationLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.REPORT_KEY.AllocationLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.REPORT_KEY.KeyFormat = 0x00; // DVD_REPORT_AGID? + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0 }; + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PCDVD_KEY_HEADER keyHeader = DeviceExtension->ScratchContext.ScratchBuffer; + PCDVD_REPORT_AGID_DATA keyData = (PCDVD_REPORT_AGID_DATA)keyHeader->Data; + + *sessionId = (DVD_SESSION_ID)(keyData->AGID); + *DataLength = sizeof(DVD_SESSION_ID); + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsEndSession( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_END_SESSION +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsReleaseAgid + + NTSTATUS status = STATUS_SUCCESS; + PDVD_SESSION_ID sessionId = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&sessionId, + NULL); + + if (NT_SUCCESS(status)) + { + ULONG transferSize = 0; + CDB cdb; + DVD_SESSION_ID currentSession = 0; + DVD_SESSION_ID limitSession = 0; + + if(*sessionId == DVD_END_ALL_SESSIONS) + { + currentSession = 0; + limitSession = MAX_COPY_PROTECT_AGID - 1; + } + else + { + currentSession = *sessionId; + limitSession = *sessionId; + } + + ScratchBuffer_BeginUse(DeviceExtension); + + do + { + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.SEND_KEY.OperationCode = SCSIOP_SEND_KEY; + cdb.AsByte[7] = 0x02; // AACS key class + cdb.SEND_KEY.AGID = (UCHAR)(currentSession); + cdb.SEND_KEY.KeyFormat = DVD_INVALIDATE_AGID; + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, transferSize, FALSE, &cdb, 12); + + currentSession++; + } while ((currentSession <= limitSession) && NT_SUCCESS(status)); + +#ifdef ENABLE_AACS_TESTING + status = STATUS_SUCCESS; +#endif + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsSendCertificate( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_SEND_CERTIFICATE +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsSendHostCertificate + + NTSTATUS status = STATUS_SUCCESS; + PAACS_SEND_CERTIFICATE input = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_CERTIFICATE); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + // copy the input buffer to the data buffer for the transfer + { + PCDVD_KEY_HEADER header = (PCDVD_KEY_HEADER)DeviceExtension->ScratchContext.ScratchBuffer; + ULONG tmp = dataTransferLength; + + tmp -= RTL_SIZEOF_THROUGH_FIELD(CDVD_KEY_HEADER, DataLength); + + header->DataLength[0] = (UCHAR)(tmp >> (8*1)); + header->DataLength[1] = (UCHAR)(tmp >> (8*0)); + RtlCopyMemory(header->Data, &(input->Certificate), sizeof(AACS_CERTIFICATE)); + } + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.SEND_KEY.OperationCode = SCSIOP_SEND_KEY; + cdb.AsByte[7] = 0x02; // AACS key class + cdb.SEND_KEY.ParameterListLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.SEND_KEY.ParameterListLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.SEND_KEY.AGID = (UCHAR)( input->SessionId ); + cdb.SEND_KEY.KeyFormat = 0x01; // Send Host Challenge Certificate + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, FALSE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + *DataLength = 0; + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsGetCertificate( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_GET_CERTIFICATE +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsGetDriveCertificate + + NTSTATUS status = STATUS_SUCCESS; + PDVD_SESSION_ID input = NULL; + PVOID outputBuffer = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_CERTIFICATE); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.REPORT_KEY.OperationCode = SCSIOP_REPORT_KEY; + cdb.AsByte[7] = 0x02; // AACS key class + cdb.REPORT_KEY.AllocationLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.REPORT_KEY.AllocationLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.REPORT_KEY.AGID = (UCHAR)(*input); + cdb.REPORT_KEY.KeyFormat = 0x01; // Return a drive certificate challenge + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x72, 0x00, 0x00 }; + static const UCHAR defaultFill = 0x31; // '1' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x0074, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG dataLengthToCopy = sizeof(AACS_CERTIFICATE); + + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < (sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length))) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + + if (NT_SUCCESS(status)) + { + // adjust data length to reflect only the addition data + header->Length -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // exit if the drive is returning an unexpected data size + if (header->Length != dataLengthToCopy) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // else copy the data to the user's buffer + RtlCopyMemory(outputBuffer, header->Data, dataLengthToCopy); + *DataLength = dataLengthToCopy; + } + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsGetChallengeKey( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_GET_CHALLENGE_KEY +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsGetChallengeKey + + NTSTATUS status = STATUS_SUCCESS; + PDVD_SESSION_ID input = NULL; + PVOID outputBuffer = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_CHALLENGE_KEY); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.REPORT_KEY.OperationCode = SCSIOP_REPORT_KEY; + cdb.AsByte[7] = 0x02; // AACS key class + cdb.REPORT_KEY.AllocationLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.REPORT_KEY.AllocationLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.REPORT_KEY.AGID = (UCHAR)(*input); + cdb.REPORT_KEY.KeyFormat = 0x02; // Return a drive certificate challenge + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x52, 0x00, 0x00 }; + static const UCHAR defaultFill = 0x32; // '2' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x0054, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG dataLengthToCopy = sizeof(AACS_CHALLENGE_KEY); + + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + + if (NT_SUCCESS(status)) + { + // adjust data length to reflect only the addition data + header->Length -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // exit if the drive is returning an unexpected data size + if (header->Length != dataLengthToCopy) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // else copy the data to the user's buffer + RtlCopyMemory(outputBuffer, header->Data, dataLengthToCopy); + *DataLength = dataLengthToCopy; + } + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleSendChallengeKey( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_SEND_CHALLENGE_KEY +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsSendChallengeKey + + NTSTATUS status = STATUS_SUCCESS; + PAACS_SEND_CHALLENGE_KEY input = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_CHALLENGE_KEY); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + // copy the input buffer to the data buffer for the transfer + { + PCDVD_KEY_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG tmp = dataTransferLength; + tmp -= RTL_SIZEOF_THROUGH_FIELD(CDVD_KEY_HEADER, DataLength); + + header->DataLength[0] = (UCHAR)(tmp >> (8*1)); + header->DataLength[1] = (UCHAR)(tmp >> (8*0)); + RtlCopyMemory(header->Data, &(input->ChallengeKey), sizeof(AACS_CHALLENGE_KEY)); + } + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.SEND_KEY.OperationCode = SCSIOP_SEND_KEY; + cdb.AsByte[7] = 0x02; // AACS key class + cdb.SEND_KEY.ParameterListLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.SEND_KEY.ParameterListLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.SEND_KEY.AGID = (UCHAR)( input->SessionId ); + cdb.SEND_KEY.KeyFormat = 0x02; // Send Host Challenge Certificate + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, FALSE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + *DataLength = 0; + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleReadVolumeId( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_READ_VOLUME_ID +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsReadVolumeID + + NTSTATUS status = STATUS_SUCCESS; + PDVD_SESSION_ID input = NULL; + PVOID outputBuffer = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_VOLUME_ID); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.READ_DVD_STRUCTURE.OperationCode = SCSIOP_READ_DVD_STRUCTURE; + cdb.READ_DVD_STRUCTURE.Format = 0x80; // Return the AACS volumeID + cdb.READ_DVD_STRUCTURE.AllocationLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.READ_DVD_STRUCTURE.AllocationLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.READ_DVD_STRUCTURE.AGID = (UCHAR)(*input); + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x22, 0x00, 0x00 }; + static const UCHAR defaultFill = 0x33; // '3' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x0024, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG dataLengthToCopy = sizeof(AACS_VOLUME_ID); + + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + + if (NT_SUCCESS(status)) + { + // adjust data length to reflect only the addition data + header->Length -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // exit if the drive is returning an unexpected data size + if (header->Length != dataLengthToCopy) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // else copy the data to the user's buffer + RtlCopyMemory(outputBuffer, header->Data, dataLengthToCopy); + *DataLength = dataLengthToCopy; + } + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsReadSerialNumber( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_READ_SERIAL_NUMBER +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsReadSerialNumber + + NTSTATUS status = STATUS_SUCCESS; + PDVD_SESSION_ID input = NULL; + PVOID outputBuffer = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_SERIAL_NUMBER); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.READ_DVD_STRUCTURE.OperationCode = SCSIOP_READ_DVD_STRUCTURE; + cdb.READ_DVD_STRUCTURE.Format = 0x81; // Return the AACS volumeID + cdb.READ_DVD_STRUCTURE.AllocationLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.READ_DVD_STRUCTURE.AllocationLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.READ_DVD_STRUCTURE.AGID = (UCHAR)(*input); + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x22, 0x00, 0x00 }; + static const UCHAR defaultFill = 0x34; // '4' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x0024, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG dataLengthToCopy = sizeof(AACS_SERIAL_NUMBER); + + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + + if (NT_SUCCESS(status)) + { + // adjust data length to reflect only the addition data + header->Length -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // exit if the drive is returning an unexpected data size + if (header->Length != dataLengthToCopy) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // else copy the data to the user's buffer + RtlCopyMemory(outputBuffer, header->Data, dataLengthToCopy); + *DataLength = dataLengthToCopy; + } + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsReadMediaId( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_READ_MEDIA_ID +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsReadMediaID + + NTSTATUS status = STATUS_SUCCESS; + PDVD_SESSION_ID input = NULL; + PVOID outputBuffer = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_MEDIA_ID); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.READ_DVD_STRUCTURE.OperationCode = SCSIOP_READ_DVD_STRUCTURE; + cdb.READ_DVD_STRUCTURE.Format = 0x82; // Return the AACS volumeID + cdb.READ_DVD_STRUCTURE.AllocationLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.READ_DVD_STRUCTURE.AllocationLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.READ_DVD_STRUCTURE.AGID = (UCHAR)(*input); + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x22, 0x00, 0x00 }; + static const UCHAR defaultFill = 0x35; // '5' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x0024, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG dataLengthToCopy = sizeof(AACS_MEDIA_ID); + + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + + if (NT_SUCCESS(status)) + { + // adjust data length to reflect only the addition data + header->Length -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // exit if the drive is returning an unexpected data size + if (header->Length != dataLengthToCopy) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // else copy the data to the user's buffer + RtlCopyMemory(outputBuffer, header->Data, dataLengthToCopy); + *DataLength = dataLengthToCopy; + } + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsReadBindingNonce( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_READ_BINDING_NONCE +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsReadBindingNonce + + NTSTATUS status = STATUS_SUCCESS; + PAACS_READ_BINDING_NONCE input = NULL; + PVOID outputBuffer = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_BINDING_NONCE); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + cdb.REPORT_KEY.OperationCode = SCSIOP_REPORT_KEY; + cdb.REPORT_KEY.LogicalBlockAddress[0] = (UCHAR)( input->StartLba >> (3*8) ); + cdb.REPORT_KEY.LogicalBlockAddress[1] = (UCHAR)( input->StartLba >> (2*8) ); + cdb.REPORT_KEY.LogicalBlockAddress[2] = (UCHAR)( input->StartLba >> (1*8) ); + cdb.REPORT_KEY.LogicalBlockAddress[3] = (UCHAR)( input->StartLba >> (0*8) ); + cdb.AsByte[6] = (UCHAR)( input->NumberOfSectors ); + cdb.AsByte[7] = 0x02; // AACS key class + cdb.REPORT_KEY.AllocationLength[0] = (UCHAR)(dataTransferLength >> (8*1)); + cdb.REPORT_KEY.AllocationLength[1] = (UCHAR)(dataTransferLength >> (8*0)); + cdb.REPORT_KEY.AGID = (UCHAR)( input->SessionId ); + cdb.REPORT_KEY.KeyFormat = 0x21; // Return an existing binding nonce + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x22, 0x00, 0x00 }; + static const UCHAR defaultFill = 0x36; // '6' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x0024, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG dataLengthToCopy = sizeof(AACS_BINDING_NONCE); + + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + + if (NT_SUCCESS(status)) + { + // adjust data length to reflect only the addition data + header->Length -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // exit if the drive is returning an unexpected data size + if (header->Length != dataLengthToCopy) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // else copy the data to the user's buffer + RtlCopyMemory(outputBuffer, header->Data, dataLengthToCopy); + *DataLength = dataLengthToCopy; + } + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceHandleAacsGenerateBindingNonce( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _In_ WDF_REQUEST_PARAMETERS RequestParameters, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + This routine is used to process IOCTL: + IOCTL_AACS_GENERATE_BINDING_NONCE +Arguments: + DeviceExtension - device context + + Request - the request that will be formatted + + RequestParameters - request parameter structur + + DataLength - data transferred length + +Return Value: + NTSTATUS + + --*/ +{ + //AacsGenerateBindingNonce + + NTSTATUS status = STATUS_SUCCESS; + PAACS_READ_BINDING_NONCE input = NULL; + PVOID outputBuffer = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.InputBufferLength, + (PVOID*)&input, + NULL); + + if (NT_SUCCESS(status)) + { + status = WdfRequestRetrieveOutputBuffer(Request, + RequestParameters.Parameters.DeviceIoControl.OutputBufferLength, + (PVOID*)&outputBuffer, + NULL); + } + + if (NT_SUCCESS(status)) + { + ULONG dataTransferLength = sizeof(CDVD_KEY_HEADER) + sizeof(AACS_BINDING_NONCE); + CDB cdb; + + ScratchBuffer_BeginUse(DeviceExtension); + + RtlZeroMemory(&cdb, sizeof(CDB)); + // Set up the CDB + + status = ScratchBuffer_ExecuteCdb(DeviceExtension, Request, dataTransferLength, TRUE, &cdb, 12); + +#ifdef ENABLE_AACS_TESTING + static const UCHAR results[] = { 0x00, 0x22, 0x00, 0x00 }; + static const UCHAR defaultFill = 0x37; // '7' + RtlFillMemory(DeviceExtension->ScratchContext.ScratchBuffer, 0x0024, defaultFill); + RtlCopyMemory(DeviceExtension->ScratchContext.ScratchBuffer, results, SIZEOF_ARRAY(results)); + status = STATUS_SUCCESS; +#endif + if (NT_SUCCESS(status)) + { + PDVD_DESCRIPTOR_HEADER header = DeviceExtension->ScratchContext.ScratchBuffer; + ULONG dataLengthToCopy = sizeof(AACS_BINDING_NONCE); + + // make length field native byte ordering + REVERSE_SHORT(&header->Length); + + // exit if getting invalid data from the drive + if (header->Length < sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length)) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + + if (NT_SUCCESS(status)) + { + // adjust data length to reflect only the addition data + header->Length -= sizeof(DVD_DESCRIPTOR_HEADER) - RTL_SIZEOF_THROUGH_FIELD(DVD_DESCRIPTOR_HEADER, Length); + + // exit if the drive is returning an unexpected data size + if (header->Length != dataLengthToCopy) + { + *DataLength = 0; + status = STATUS_IO_DEVICE_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // else copy the data to the user's buffer + RtlCopyMemory(outputBuffer, header->Data, dataLengthToCopy); + *DataLength = dataLengthToCopy; + } + } + + ScratchBuffer_EndUse(DeviceExtension); + } + + return status; +} + diff --git a/drivers/storage/class/cdrom_new/autorun.c b/drivers/storage/class/cdrom_new/autorun.c new file mode 100644 index 00000000000..e5c9b110021 --- /dev/null +++ b/drivers/storage/class/cdrom_new/autorun.c @@ -0,0 +1,3080 @@ +/*++ + +Copyright (C) Microsoft Corporation. All rights reserved. + +Module Name: + + autorun.c + +Abstract: + + Code for support of media change detection in the cd/dvd driver + +Environment: + + kernel mode only + +Notes: + + +Revision History: + +--*/ + +#include "stddef.h" +#include "string.h" + +#include "ntddk.h" +#include "ntddstor.h" +#include "cdrom.h" +#include "mmc.h" +#include "ioctl.h" + +#include "ntstrsafe.h" + +#ifdef DEBUG_USE_WPP +#include "autorun.tmh" +#endif + +#define GESN_TIMEOUT_VALUE (0x4) +#define GESN_BUFFER_SIZE (0x8) +#define GESN_DEVICE_BUSY_LOWER_THRESHOLD_100_MS (2) + +#define MAXIMUM_IMMEDIATE_MCN_RETRIES (0x20) +#define MCN_REG_SUBKEY_NAME (L"MediaChangeNotification") +#define MCN_REG_AUTORUN_DISABLE_INSTANCE_NAME (L"AlwaysDisableMCN") +#define MCN_REG_AUTORUN_ENABLE_INSTANCE_NAME (L"AlwaysEnableMCN") + +// +// Only send polling irp when device is fully powered up and a +// power down irp is not in progress. +// +// NOTE: This helps close a window in time where a polling irp could cause +// a drive to spin up right after it has powered down. The problem is +// that SCSIPORT, ATAPI and SBP2 will be in the process of powering +// down (which may take a few seconds), but won't know that. It would +// then get a polling irp which will be put into its queue since it +// the disk isn't powered down yet. Once the disk is powered down it +// will find the polling irp in the queue and then power up the +// device to do the poll. They do not want to check if the polling +// irp has the SRB_NO_KEEP_AWAKE flag here since it is in a critical +// path and would slow down all I/Os. A better way to fix this +// would be to serialize the polling and power down irps so that +// only one of them is sent to the device at a time. +// + +_IRQL_requires_max_(PASSIVE_LEVEL) +BOOLEAN +DeviceIsMediaChangeDisabledDueToHardwareLimitation( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ); + +_IRQL_requires_max_(PASSIVE_LEVEL) +BOOLEAN +DeviceIsMediaChangeDisabledForClass( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ); + +_IRQL_requires_max_(PASSIVE_LEVEL) +NTSTATUS +DeviceMediaChangeDeviceInstanceOverride( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _Out_ PBOOLEAN Enabled + ); + +_IRQL_requires_max_(PASSIVE_LEVEL) +NTSTATUS +DeviceInitializeMcn( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ BOOLEAN AllowDriveToSleep + ); + +_IRQL_requires_max_(PASSIVE_LEVEL) +NTSTATUS +DeviceInitializeGesn( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ); + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +GesnDataInterpret( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ PNOTIFICATION_EVENT_STATUS_HEADER Header, + _Out_ PBOOLEAN ResendImmediately + ); + +RTL_QUERY_REGISTRY_ROUTINE DeviceMediaChangeRegistryCallBack; + +EVT_WDF_WORKITEM DeviceDisableGesn; + +#if ALLOC_PRAGMA + +#pragma alloc_text(PAGE, DeviceInitializeMediaChangeDetection) +#pragma alloc_text(PAGE, DeviceEnableMediaChangeDetection) +#pragma alloc_text(PAGE, DeviceDisableMediaChangeDetection) +#pragma alloc_text(PAGE, DeviceSendDelayedMediaChangeNotifications) +#pragma alloc_text(PAGE, DeviceReleaseMcnResources) +#pragma alloc_text(PAGE, DeviceMediaChangeRegistryCallBack) +#pragma alloc_text(PAGE, DeviceInitializeMcn) +#pragma alloc_text(PAGE, DeviceDisableGesn) + +#pragma alloc_text(PAGE, DeviceIsMediaChangeDisabledDueToHardwareLimitation) +#pragma alloc_text(PAGE, DeviceMediaChangeDeviceInstanceOverride) +#pragma alloc_text(PAGE, DeviceIsMediaChangeDisabledForClass) + +#pragma alloc_text(PAGE, DeviceDisableMainTimer) + +#pragma alloc_text(PAGE, GesnDataInterpret) + +#pragma alloc_text(PAGE, RequestSetupMcnRequest) +#pragma alloc_text(PAGE, RequestPostWorkMcnRequest) +#pragma alloc_text(PAGE, RequestSendMcnRequest) + +// +// DeviceEnableMainTimer is called by EvtDeviceD0Entry which can't be made pageable +// so neither is DeviceEnableMainTimer +// +//#pragma alloc_text(PAGE, DeviceEnableMainTimer) + +#pragma alloc_text(PAGE, DeviceInitializeGesn) + +#pragma alloc_text(PAGE, RequestHandleMcnControl) + +#endif + +#pragma warning(push) +#pragma warning(disable:4152) // nonstandard extension, function/data pointer conversion in expression + + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +GesnDataInterpret( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ PNOTIFICATION_EVENT_STATUS_HEADER Header, + _Out_ PBOOLEAN ResendImmediately + ) +/*++ + +Routine Description: + + This routine will interpret the data returned for a GESN command, and + (if appropriate) set the media change event, and broadcast the + appropriate events to user mode for applications who care. + +Arguments: + + DeviceExtension - the device extension + + Header - the resulting data from a GESN event. + requires at least EIGHT valid bytes (header == 4, data == 4) + + ResendImmediately - whether or not to immediately resend the request. + this should be FALSE if there was no event, FALSE if the reported + event was of the DEVICE BUSY class, else true. + +Return Value: + + STATUS_SUCCESS if successful, an error code otherwise + +Notes: + + DataBuffer must be at least four bytes of valid data (header == 4 bytes), + and have at least eight bytes of allocated memory (all events == 4 bytes). + + The call to StartNextPacket may occur before this routine is completed. + the operational change notifications are informational in nature, and + while useful, are not neccessary to ensure proper operation. For example, + if the device morphs to no longer supporting WRITE commands, all further + write commands will fail. There exists a small timing window wherein + IOCTL_IS_DISK_WRITABLE may be called and get an incorrect response. If + a device supports software write protect, it is expected that the + application can handle such a case. + + NOTE: perhaps setting the updaterequired byte to one should be done here. + if so, it relies upon the setting of a 32-byte value to be an atomic + operation. unfortunately, there is no simple way to notify a class driver + which wants to know that the device behavior requires updating. + + Not ready events may be sent every second. For example, if we were + to minimize the number of asynchronous notifications, an application may + register just after a large busy time was reported. This would then + prevent the application from knowing the device was busy until some + arbitrarily chosen timeout has occurred. Also, the GESN request would + have to still occur, since it checks for non-busy events (such as user + keybutton presses and media change events) as well. The specification + states that the lower-numered events get reported first, so busy events, + while repeating, will only be reported when all other events have been + cleared from the device. + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + LONG dataLength = 0; + LONG requiredLength = 0; + BOOLEAN inHomePosition = FALSE; + + PAGED_CODE(); + + // note: don't allocate anything in this routine so that we can + // always just 'return'. + *ResendImmediately = FALSE; + + if (Header->NEA) + { + return status; + } + if (Header->NotificationClass == NOTIFICATION_NO_CLASS_EVENTS) + { + return status; + } + + // HACKHACK - REF #0001 + // This loop is only taken initially, due to the inability to reliably + // auto-detect drives that report events correctly at boot. When we + // detect this behavior during the normal course of running, we will + // disable the hack, allowing more efficient use of the system. This + // should occur "nearly" instantly, as the drive should have multiple + // events queue'd (ie. power, morphing, media). + if (info->Gesn.HackEventMask) + { + // all events use the low four bytes of zero to indicate + // that there was no change in status. + UCHAR thisEvent = Header->ClassEventData[0] & 0xf; + UCHAR lowestSetBit; + UCHAR thisEventBit = (1 << Header->NotificationClass); + + if (!TEST_FLAG(info->Gesn.EventMask, thisEventBit)) + { + // The drive is reporting an event that wasn't requested + return STATUS_DEVICE_PROTOCOL_ERROR; + } + + // some bit magic here... this results in the lowest set bit only + lowestSetBit = info->Gesn.EventMask; + lowestSetBit &= (info->Gesn.EventMask - 1); + lowestSetBit ^= (info->Gesn.EventMask); + + if (thisEventBit != lowestSetBit) + { + // HACKHACK - REF #0001 + // the first time we ever see an event set that is not the lowest + // set bit in the request (iow, highest priority), we know that the + // hack is no longer required, as the device is ignoring "no change" + // events when a real event is waiting in the other requested queues. + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN::NONE: Compliant drive found, " + "removing GESN hack (%x, %x)\n", + thisEventBit, info->Gesn.EventMask)); + + info->Gesn.HackEventMask = FALSE; + } + else if (thisEvent == 0) // NOTIFICATION_*_EVENT_NO_CHANGE + { + // HACKHACK - REF #0001 + // note: this hack prevents poorly implemented firmware from constantly + // returning "No Event". we do this by cycling through the + // supported list of events here. + SET_FLAG(info->Gesn.NoChangeEventMask, thisEventBit); + CLEAR_FLAG(info->Gesn.EventMask, thisEventBit); + + // if we have cycled through all supported event types, then + // we need to reset the events we are asking about. else we + // want to resend this request immediately in case there was + // another event pending. + if (info->Gesn.EventMask == 0) + { + info->Gesn.EventMask = info->Gesn.NoChangeEventMask; + info->Gesn.NoChangeEventMask = 0; + } + else + { + *ResendImmediately = TRUE; + } + return status; + } + + } // end if (info->Gesn.HackEventMask) + + dataLength = (Header->EventDataLength[0] << 8) | + (Header->EventDataLength[1] & 0xff); + dataLength -= 2; + requiredLength = 4; // all events are four bytes + + if (dataLength < requiredLength) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "error - GESN returned only %x bytes data for fdo %p\n", + dataLength, DeviceExtension->DeviceObject)); + + return STATUS_DEVICE_PROTOCOL_ERROR; + } + + if (dataLength > requiredLength) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "error - GESN returned too many (%x) bytes data for fdo %p\n", + dataLength, DeviceExtension->DeviceObject)); + } + + if ((Header->ClassEventData[0] & 0xf) == 0) + { + // a zero event is a "no change event, so do not retry + return status; + } + + // because a event other than "no change" occurred, + // we should immediately resend this request. + *ResendImmediately = TRUE; + + switch (Header->NotificationClass) + { + + case NOTIFICATION_OPERATIONAL_CHANGE_CLASS_EVENTS: // 0x01 + { + PNOTIFICATION_OPERATIONAL_STATUS opChangeInfo = + (PNOTIFICATION_OPERATIONAL_STATUS)(Header->ClassEventData); + ULONG event; + + if (opChangeInfo->OperationalEvent == NOTIFICATION_OPERATIONAL_EVENT_CHANGE_REQUESTED) + { + break; + } + + event = (opChangeInfo->Operation[0] << 8) | + (opChangeInfo->Operation[1] ) ; + + // Workaround some hardware that is buggy but prevalent in the market + // This hardware has the property that it will report OpChange events repeatedly, + // causing us to retry immediately so quickly that we will eventually disable + // GESN to prevent an infinite loop. + // (only one valid OpChange event type now, only two ever defined) + if (info->MediaChangeRetryCount >= 4) + { + // + // HACKHACK - REF #0002 + // Some drives incorrectly report OpChange/Change (001b/0001h) events + // continuously when the tray has been ejected. This causes this routine + // to set ResendImmediately to "TRUE", and that results in our cycling + // 32 times immediately resending. At that point, we give up detecting + // the infinite retry loop, and disable GESN on these drives. This + // prevents Media Eject Request (from eject button) from being reported. + // Thus, instead we should attempt to workaround this issue by detecting + // this behavior. + // + + static UCHAR const OpChangeMask = 0x02; + + // At least one device reports "temporarily busy" (which is useless) on eject + // At least one device reports "OpChange" repeatedly when re-inserting media + // All seem to work well using this workaround + + TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_MCN, + "GESN OpChange events are broken. Working around this problem in software (for WDFDEVICE %p)\n", + DeviceExtension->Device)); + + // OpChange is not the only bit set -- Media class is required.... + NT_ASSERT(CountOfSetBitsUChar(info->Gesn.EventMask) != 1); + + // Force the use of the hackhack (ref #0001) to workaround the + // issue noted this hackhack (ref #0002). + SET_FLAG(info->Gesn.NoChangeEventMask, OpChangeMask); + CLEAR_FLAG(info->Gesn.EventMask, OpChangeMask); + info->Gesn.HackEventMask = TRUE; + + // don't request the opChange event again. use the method + // defined by hackhack (ref #0001) as the workaround. + if (info->Gesn.EventMask == 0) + { + info->Gesn.EventMask = info->Gesn.NoChangeEventMask; + info->Gesn.NoChangeEventMask = 0; + *ResendImmediately = FALSE; + } + else + { + *ResendImmediately = TRUE; + } + + break; + } + + + if ((event == NOTIFICATION_OPERATIONAL_OPCODE_FEATURE_ADDED) | + (event == NOTIFICATION_OPERATIONAL_OPCODE_FEATURE_CHANGE)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN says features added/changed for WDFDEVICE %p\n", + DeviceExtension->Device)); + + // don't notify that new media arrived, just set the + // DO_VERIFY to force a FS reload. + + if (IsVolumeMounted(DeviceExtension->DeviceObject)) + { + SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME); + } + + // Call error handler with + // a "fake" media change error in case it needs to update + // internal structures as though a media change occurred. + { + SCSI_REQUEST_BLOCK srb = {0}; + SENSE_DATA sense = {0}; + NTSTATUS tempStatus; + BOOLEAN retry; + + tempStatus = STATUS_MEDIA_CHANGED; + retry = FALSE; + + srb.CdbLength = 6; + srb.Length = sizeof(SCSI_REQUEST_BLOCK); + srb.SrbStatus = SRB_STATUS_AUTOSENSE_VALID | SRB_STATUS_ERROR; + srb.SenseInfoBuffer = &sense; + srb.SenseInfoBufferLength = sizeof(SENSE_DATA); + + sense.AdditionalSenseLength = sizeof(SENSE_DATA) - + RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseLength); + + sense.SenseKey = SCSI_SENSE_UNIT_ATTENTION; + sense.AdditionalSenseCode = SCSI_ADSENSE_MEDIUM_CHANGED; + + if (DeviceExtension->DeviceAdditionalData.ErrorHandler) + { + DeviceExtension->DeviceAdditionalData.ErrorHandler(DeviceExtension, + &srb, + &tempStatus, + &retry); + } + } // end error handler + + } + break; + } + + case NOTIFICATION_EXTERNAL_REQUEST_CLASS_EVENTS: // 0x3 + { + PNOTIFICATION_EXTERNAL_STATUS externalInfo = + (PNOTIFICATION_EXTERNAL_STATUS)(Header->ClassEventData); + DEVICE_EVENT_EXTERNAL_REQUEST externalData = {0}; + + // unfortunately, due to time constraints, we will only notify + // about keys being pressed, and not released. this makes keys + // single-function, but simplifies the code significantly. + if (externalInfo->ExternalEvent != NOTIFICATION_EXTERNAL_EVENT_BUTTON_DOWN) + { + break; + } + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN::EXTERNAL: Event: %x Status %x Req %x\n", + externalInfo->ExternalEvent, externalInfo->ExternalStatus, + (externalInfo->Request[0] << 8) | externalInfo->Request[1] + )); + + externalData.Version = 1; + externalData.DeviceClass = 0; + externalData.ButtonStatus = externalInfo->ExternalEvent; + externalData.Request = (externalInfo->Request[0] << 8) | + (externalInfo->Request[1] & 0xff); + KeQuerySystemTime(&(externalData.SystemTime)); + externalData.SystemTime.QuadPart *= (LONGLONG)KeQueryTimeIncrement(); + + DeviceSendNotification(DeviceExtension, + &GUID_IO_DEVICE_EXTERNAL_REQUEST, + sizeof(DEVICE_EVENT_EXTERNAL_REQUEST), + &externalData); + + return status; + } + + case NOTIFICATION_MEDIA_STATUS_CLASS_EVENTS: // 0x4 + { + PNOTIFICATION_MEDIA_STATUS mediaInfo = + (PNOTIFICATION_MEDIA_STATUS)(Header->ClassEventData); + + if ((mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_NEW_MEDIA) || + (mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_MEDIA_CHANGE)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN::MEDIA ARRIVAL, Status %x\n", + mediaInfo->MediaStatus)); + + if (IsVolumeMounted(DeviceExtension->DeviceObject)) + { + SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME); + } + DeviceSetMediaChangeStateEx(DeviceExtension, + MediaPresent, + NULL); + + // If media is inserted into slot loading type, mark the device active + // to not power off. + if ((DeviceExtension->ZeroPowerODDInfo != NULL) && + (DeviceExtension->ZeroPowerODDInfo->LoadingMechanism == LOADING_MECHANISM_CADDY) && + (DeviceExtension->ZeroPowerODDInfo->Load == 0)) // Slot + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER, + "GesnDataInterpret: MediaArrival event detected, device marked as active\n")); + + DeviceMarkActive(DeviceExtension, TRUE, FALSE); + } + } + else if (mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_MEDIA_REMOVAL) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN::MEDIA REMOVAL, Status %x\n", + mediaInfo->MediaStatus)); + + DeviceSetMediaChangeStateEx(DeviceExtension, + MediaNotPresent, + NULL); + + // If media is removed from slot loading type, start powering off the device + // if it is ZPODD capable. + if ((DeviceExtension->ZeroPowerODDInfo != NULL) && + (DeviceExtension->ZeroPowerODDInfo->LoadingMechanism == LOADING_MECHANISM_CADDY) && + (DeviceExtension->ZeroPowerODDInfo->Load == 0)) // Slot + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER, + "GesnDataInterpret: MediaRemoval event detected, device marked as idle\n")); + + DeviceMarkActive(DeviceExtension, FALSE, FALSE); + } + } + else if (mediaInfo->MediaEvent == NOTIFICATION_MEDIA_EVENT_EJECT_REQUEST) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN::MEDIA EJECTION, Status %x\n", + mediaInfo->MediaStatus)); + + DeviceSendNotification(DeviceExtension, + &GUID_IO_MEDIA_EJECT_REQUEST, + 0, + NULL); + } + + break; + } + + case NOTIFICATION_DEVICE_BUSY_CLASS_EVENTS: // lowest priority events... + { + PNOTIFICATION_BUSY_STATUS busyInfo = + (PNOTIFICATION_BUSY_STATUS)(Header->ClassEventData); + DEVICE_EVENT_BECOMING_READY busyData = {0}; + + // else we want to report the approximated time till it's ready. + busyData.Version = 1; + busyData.Reason = busyInfo->DeviceBusyStatus; + busyData.Estimated100msToReady = (busyInfo->Time[0] << 8) | + (busyInfo->Time[1] & 0xff); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN::BUSY: Event: %x Status %x Time %x\n", + busyInfo->DeviceBusyEvent, busyInfo->DeviceBusyStatus, + busyData.Estimated100msToReady + )); + + // Ignore the notification if the time is small + if (busyData.Estimated100msToReady >= GESN_DEVICE_BUSY_LOWER_THRESHOLD_100_MS) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GesnDataInterpret: media BECOMING_READY\n")); + + DeviceSendNotification(DeviceExtension, + &GUID_IO_DEVICE_BECOMING_READY, + sizeof(DEVICE_EVENT_BECOMING_READY), + &busyData); + } + + // If manual loading operation is observed for slot loading type, start powering off the device + // if it is ZPODD capable. + if ((DeviceExtension->ZeroPowerODDInfo != NULL) && + (DeviceExtension->ZeroPowerODDInfo->LoadingMechanism == LOADING_MECHANISM_TRAY) && + (DeviceExtension->ZeroPowerODDInfo->Load == 0) && // Drawer + (busyInfo->DeviceBusyEvent == NOTIFICATION_BUSY_EVENT_LO_CHANGE) && + (busyInfo->DeviceBusyStatus == NOTIFICATION_BUSY_STATUS_NO_EVENT)) + { + inHomePosition = DeviceZPODDIsInHomePosition(DeviceExtension); + + if (inHomePosition == FALSE) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER, + "GesnDataInterpret: LoChange event detected, device marked as active\n")); + + DeviceMarkActive(DeviceExtension, TRUE, FALSE); + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER, + "GesnDataInterpret: LoChange event detected, device marked as idle\n")); + + DeviceMarkActive(DeviceExtension, FALSE, FALSE); + } + } + + break; + } + + default: + { + break; + } + + } // end switch on notification class + + return status; +} + + +VOID +DeviceInternalSetMediaChangeState( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ MEDIA_CHANGE_DETECTION_STATE NewState, + _Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE OldState + ) +/*++ + +Routine Description: + + This routine will (if appropriate) set the media change event for the + device. The event will be set if the media state is changed and + media change events are enabled. Otherwise the media state will be + tracked but the event will not be set. + + This routine will lock out the other media change routines if possible + but if not a media change notification may be lost after the enable has + been completed. + +Arguments: + + DeviceExtension - the device extension + + NewState - new state for setting + + OldState - optional storage for the old state + +Return Value: + + none + +--*/ +{ +#if DBG + LPCSTR states[] = {"Unknown", "Present", "Not Present", "Unavailable"}; +#endif + MEDIA_CHANGE_DETECTION_STATE oldMediaState; + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + CLASS_MEDIA_CHANGE_CONTEXT mcnContext; + + if (!((NewState >= MediaUnknown) && (NewState <= MediaUnavailable))) + { + return; + } + + if (info == NULL) + { + return; + } + + oldMediaState = info->LastKnownMediaDetectionState; + if (OldState) + { + *OldState = oldMediaState; + } + + info->LastKnownMediaDetectionState = NewState; + + // Increment MediaChangeCount on transition to MediaPresent + if (NewState == MediaPresent && oldMediaState != NewState) + { + InterlockedIncrement((PLONG)&DeviceExtension->MediaChangeCount); + } + + if (info->MediaChangeDetectionDisableCount != 0) + { +#if DBG + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInternalSetMediaChangeState: MCN not enabled, state " + "changed from %s to %s\n", + states[oldMediaState], states[NewState])); +#endif + return; + } +#if DBG + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInternalSetMediaChangeState: State change from %s to %s\n", + states[oldMediaState], states[NewState])); +#endif + + if (info->LastReportedMediaDetectionState == info->LastKnownMediaDetectionState) + { + // Media is in the same state as we reported last time, no need to report again. + return; + } + + // make the data useful -- it used to always be zero. + mcnContext.MediaChangeCount = DeviceExtension->MediaChangeCount; + mcnContext.NewState = NewState; + + if (NewState == MediaPresent) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInternalSetMediaChangeState: Reporting media ARRIVAL\n")); + + DeviceSendNotification(DeviceExtension, + &GUID_IO_MEDIA_ARRIVAL, + sizeof(CLASS_MEDIA_CHANGE_CONTEXT), + &mcnContext); + } + else if ((NewState == MediaNotPresent) || (NewState == MediaUnavailable)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInternalSetMediaChangeState: Reporting media REMOVAL\n")); + DeviceSendNotification(DeviceExtension, + &GUID_IO_MEDIA_REMOVAL, + sizeof(CLASS_MEDIA_CHANGE_CONTEXT), + &mcnContext); + } + else + { + // Don't notify of changed going to unknown. + return; + } + + info->LastReportedMediaDetectionState = info->LastKnownMediaDetectionState; + + return; +} // end DeviceInternalSetMediaChangeState() + + +VOID +DeviceSetMediaChangeStateEx( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ MEDIA_CHANGE_DETECTION_STATE NewState, + _Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE OldState + ) +/*++ + +Routine Description: + + This routine will (if appropriate) set the media change event for the + device. The event will be set if the media state is changed and + media change events are enabled. Otherwise the media state will be + tracked but the event will not be set. + +Arguments: + + DeviceExtension - the device extension + + NewState - new state for setting + + OldState - optional storage for the old state + +Return Value: + + none + +--*/ +{ + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + LARGE_INTEGER zero; + NTSTATUS status; + + // timeout value must be 0, as this function can be called at DISPATCH_LEVEL. + zero.QuadPart = 0; + + if (info == NULL) + { + return; + } + + status = KeWaitForMutexObject(&info->MediaChangeMutex, + Executive, + KernelMode, + FALSE, + &zero); + + if (status == STATUS_TIMEOUT) + { + // Someone else is in the process of setting the media state. + return; + } + + // Change the media present state and signal an event, if applicable + DeviceInternalSetMediaChangeState(DeviceExtension, NewState, OldState); + + KeReleaseMutex(&info->MediaChangeMutex, FALSE); + + return; +} // end DeviceSetMediaChangeStateEx() + + +_IRQL_requires_max_(APC_LEVEL) +VOID +DeviceSendDelayedMediaChangeNotifications( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + This routine sends the so-called delayed media change notifications. + These notifications get accumulated while the MCN mechanism is disabled + and need to be sent to the application on MCN enabling, if MCN enabling + happens as a part of exclusive access unlock and the application has not + requested us explicitly to not send the delayed notifications. + +Arguments: + + DeviceExtension - the device extension + +Return Value: + + none + +--*/ +{ + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + LARGE_INTEGER zero; + NTSTATUS status; + + PAGED_CODE(); + + zero.QuadPart = 0; + + if (info == NULL) + { + return; + } + + status = KeWaitForMutexObject(&info->MediaChangeMutex, + Executive, + KernelMode, + FALSE, + &zero); + + if (status == STATUS_TIMEOUT) + { + // Someone else is in the process of setting the media state. + // That's totally okay, we'll send delayed notifications later. + return; + } + + // If the last reported state and the last known state are different and + // MCN is enabled, generate a notification based on the last known state. + if ((info->LastKnownMediaDetectionState != info->LastReportedMediaDetectionState) && + (info->MediaChangeDetectionDisableCount == 0)) + { + DeviceInternalSetMediaChangeState(DeviceExtension, info->LastKnownMediaDetectionState, NULL); + } + + KeReleaseMutex(&info->MediaChangeMutex, FALSE); + + return; +} + + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +RequestSetupMcnRequest( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ BOOLEAN UseGesn +) +/*++ + +Routine Description: + + This routine sets up the fields of the request for MCN + +Arguments: + DeviceExtension - device context + + UseGesn - If TRUE, the device supports GESN and it's currently the mechanism for MCN + +Return Value: + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + PSCSI_REQUEST_BLOCK srb; + PIRP irp; + PIO_STACK_LOCATION nextIrpStack; + PCDB cdb; + PVOID buffer; + WDF_REQUEST_REUSE_PARAMS params; + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + + PAGED_CODE(); + + irp = WdfRequestWdmGetIrp(info->MediaChangeRequest); + NT_ASSERT(irp != NULL); + + // deassign the MdlAddress, this is the value we assign explicitly. + // this is to prevent WdfRequestReuse to release the Mdl unexpectly. + if (irp->MdlAddress) + { + irp->MdlAddress = NULL; + } + + if (NT_SUCCESS(status)) + { + // Setup the IRP to perform a test unit ready. + WDF_REQUEST_REUSE_PARAMS_INIT(&params, + WDF_REQUEST_REUSE_NO_FLAGS, + STATUS_NOT_SUPPORTED); + + status = WdfRequestReuse(info->MediaChangeRequest, &params); + } + + if (NT_SUCCESS(status)) + { + // Format the request. + status = WdfIoTargetFormatRequestForInternalIoctlOthers(DeviceExtension->IoTarget, + info->MediaChangeRequest, + IOCTL_SCSI_EXECUTE_IN, + NULL, NULL, + NULL, NULL, + NULL, NULL); + + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, + "RequestSetupMcnRequest: WdfIoTargetFormatRequestForInternalIoctlOthers failed, %!STATUS!\n", + status)); + } + } + + if (NT_SUCCESS(status)) + { + RequestClearSendTime(info->MediaChangeRequest); + + nextIrpStack = IoGetNextIrpStackLocation(irp); + + nextIrpStack->Flags = SL_OVERRIDE_VERIFY_VOLUME; + nextIrpStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; + nextIrpStack->Parameters.Scsi.Srb = &(info->MediaChangeSrb); + + // Prepare the SRB for execution. + srb = nextIrpStack->Parameters.Scsi.Srb; + buffer = info->SenseBuffer; + RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK)); + RtlZeroMemory(buffer, SENSE_BUFFER_SIZE); + + srb->QueueTag = SP_UNTAGGED; + srb->QueueAction = SRB_SIMPLE_TAG_REQUEST; + srb->Length = sizeof(SCSI_REQUEST_BLOCK); + srb->Function = SRB_FUNCTION_EXECUTE_SCSI; + srb->SenseInfoBuffer = buffer; + srb->SrbStatus = 0; + srb->ScsiStatus = 0; + srb->OriginalRequest = irp; + srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE; + + srb->SrbFlags = DeviceExtension->SrbFlags; + SET_FLAG(srb->SrbFlags, info->SrbFlags); + + if (!UseGesn) + { + srb->TimeOutValue = CDROM_TEST_UNIT_READY_TIMEOUT; + srb->CdbLength = 6; + srb->DataTransferLength = 0; + SET_FLAG(srb->SrbFlags, SRB_FLAGS_NO_DATA_TRANSFER); + nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_NONE; + srb->DataBuffer = NULL; + srb->DataTransferLength = 0; + irp->MdlAddress = NULL; + + cdb = (PCDB) &srb->Cdb[0]; + cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY; + } + else + { + NT_ASSERT(info->Gesn.Buffer); + + srb->TimeOutValue = GESN_TIMEOUT_VALUE; // much shorter timeout for GESN + + srb->CdbLength = 10; + SET_FLAG(srb->SrbFlags, SRB_FLAGS_DATA_IN); + nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_IN; + srb->DataBuffer = info->Gesn.Buffer; + srb->DataTransferLength = info->Gesn.BufferSize; + irp->MdlAddress = info->Gesn.Mdl; + + cdb = (PCDB) &srb->Cdb[0]; + cdb->GET_EVENT_STATUS_NOTIFICATION.OperationCode = SCSIOP_GET_EVENT_STATUS; + cdb->GET_EVENT_STATUS_NOTIFICATION.Immediate = 1; + cdb->GET_EVENT_STATUS_NOTIFICATION.EventListLength[0] = (UCHAR)((info->Gesn.BufferSize) >> 8); + cdb->GET_EVENT_STATUS_NOTIFICATION.EventListLength[1] = (UCHAR)((info->Gesn.BufferSize) & 0xff); + cdb->GET_EVENT_STATUS_NOTIFICATION.NotificationClassRequest = info->Gesn.EventMask; + } + } + + return status; +} + + +VOID +NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ +DeviceDisableGesn( + _In_ WDFWORKITEM WorkItem + ) +/*++ + +Routine Description: + + Work item routine to set the hack flag in the registry to disable GESN + This routine is invoked when the device reports TOO many events that affects system + +Arguments: + WorkItem - the work item be perfromed. + +Return Value: + None + +--*/ +{ + WDFDEVICE device = WdfWorkItemGetParentObject(WorkItem); + PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device); + + PAGED_CODE(); + + // + // Set the hack flag in the registry + // + DeviceSetParameter(deviceExtension, + CLASSP_REG_SUBKEY_NAME, + CLASSP_REG_MMC_DETECTION_VALUE_NAME, + CdromDetectionUnsupported); + + WdfObjectDelete(WorkItem); + + return; +} + +_IRQL_requires_max_(APC_LEVEL) +BOOLEAN +RequestPostWorkMcnRequest( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + This routine handles the completion of the test unit ready irps used to + determine if the media has changed. If the media has changed, this code + signals the named event to wake up other system services that react to + media change (aka AutoPlay). + +Arguments: + + DeviceExtension - the device context + +Return Value: + + BOOLEAN - TRUE (needs retry); FALSE (shoule not retry) + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + PIRP irp; + BOOLEAN retryImmediately = FALSE; + + PAGED_CODE(); + + NT_ASSERT(info->MediaChangeRequest != NULL); + irp = WdfRequestWdmGetIrp(info->MediaChangeRequest); + + NT_ASSERT(!TEST_FLAG(info->MediaChangeSrb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)); + + // use InterpretSenseInfo routine to check for media state, and also + // to call ClassError() with correct parameters. + if (SRB_STATUS(info->MediaChangeSrb.SrbStatus) != SRB_STATUS_SUCCESS) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, "MCN request - failed - srb status=%x, sense=%x/%x/%x.\n", + info->MediaChangeSrb.SrbStatus, + ((PSENSE_DATA)(info->MediaChangeSrb.SenseInfoBuffer))->SenseKey, + ((PSENSE_DATA)(info->MediaChangeSrb.SenseInfoBuffer))->AdditionalSenseCode, + ((PSENSE_DATA)(info->MediaChangeSrb.SenseInfoBuffer))->AdditionalSenseCodeQualifier)); + + if (SRB_STATUS(info->MediaChangeSrb.SrbStatus) != SRB_STATUS_NOT_POWERED) + { + // Release the queue if it is frozen. + if (info->MediaChangeSrb.SrbStatus & SRB_STATUS_QUEUE_FROZEN) + { + DeviceReleaseQueue(DeviceExtension->Device); + } + + RequestSenseInfoInterpret(DeviceExtension, + info->MediaChangeRequest, + &info->MediaChangeSrb, + 0, + &status, + NULL); + } + } + else + { + DeviceExtension->PrivateFdoData->LoggedTURFailureSinceLastIO = FALSE; + + if (!info->Gesn.Supported) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "MCN request - succeeded (GESN NOT supported, setting MediaPresent).\n")); + + // success != media for GESN case + DeviceSetMediaChangeStateEx(DeviceExtension, + MediaPresent, + NULL); + } + else + { + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, + "MCN request - succeeded (GESN supported).\n")); + } + } + + if (info->Gesn.Supported) + { + if (status == STATUS_DATA_OVERRUN) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN Request - Data Overrun\n")); + status = STATUS_SUCCESS; + } + + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN Request: GESN failed with status %x\n", status)); + } + else + { + // for GESN, need to interpret the results of the data. + // this may also require an immediate retry + if (irp->IoStatus.Information == 8 ) + { + GesnDataInterpret(DeviceExtension, + (PVOID)info->Gesn.Buffer, + &retryImmediately); + } + + } // end of NT_SUCCESS(status) + + } // end of Info->Gesn.Supported + + // free port-allocated sense buffer, if any. + if (PORT_ALLOCATED_SENSE(DeviceExtension, &info->MediaChangeSrb)) + { + FREE_PORT_ALLOCATED_SENSE_BUFFER(DeviceExtension, &info->MediaChangeSrb); + } + + // Remember the IRP and SRB for use the next time. + NT_ASSERT(IoGetNextIrpStackLocation(irp)); + IoGetNextIrpStackLocation(irp)->Parameters.Scsi.Srb = &info->MediaChangeSrb; + + // run a sanity check to make sure we're not recursing continuously + if (retryImmediately) + { + info->MediaChangeRetryCount++; + + if (info->MediaChangeRetryCount > MAXIMUM_IMMEDIATE_MCN_RETRIES) + { + // Disable GESN on this device. + // Create a work item to set the value in the registry + WDF_OBJECT_ATTRIBUTES attributes; + WDF_WORKITEM_CONFIG workitemConfig; + WDFWORKITEM workItem; + + WDF_OBJECT_ATTRIBUTES_INIT(&attributes); + attributes.ParentObject = DeviceExtension->Device; + + WDF_WORKITEM_CONFIG_INIT(&workitemConfig, DeviceDisableGesn); + workitemConfig.AutomaticSerialization = FALSE; + + status = WdfWorkItemCreate(&workitemConfig, + &attributes, + &workItem); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN Request: Disabling GESN for WDFDEVICE %p\n", DeviceExtension->Device)); + + if (NT_SUCCESS(status)) + { + WdfWorkItemEnqueue(workItem); + } + + info->Gesn.Supported = FALSE; + info->Gesn.EventMask = 0; + info->Gesn.BufferSize = 0; + info->MediaChangeRetryCount = 0; + retryImmediately = FALSE; + // should we log an error in event log? + } + } + else + { + info->MediaChangeRetryCount = 0; + } + + return retryImmediately; +} + + +_IRQL_requires_max_(APC_LEVEL) +BOOLEAN +RequestSendMcnRequest( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + This routine sends the formatted MCN request sychronizely to lower driver. + +Arguments: + + DeviceExtension - the device context + +Return Value: + BOOLEAN - TRUE (requst successfully sent); FALSE (request failed to send) + +--*/ +{ + BOOLEAN requestSent = FALSE; + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + + PAGED_CODE(); + + RequestSend(DeviceExtension, + info->MediaChangeRequest, + DeviceExtension->IoTarget, + WDF_REQUEST_SEND_OPTION_SYNCHRONOUS, + &requestSent); + + return requestSent; +} // end RequestSendMcnRequest() + + + +_IRQL_requires_max_(PASSIVE_LEVEL) +NTSTATUS +DeviceInitializeMcn( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ BOOLEAN AllowDriveToSleep + ) +/*++ + +Routine Description: + + This routine initialize the contents of MCN structure. + +Arguments: + + DeviceExtension - the device extension + + AllowDriveToSleep - for CDROM, this parameter should be always FALSE + +Return Value: + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + PMEDIA_CHANGE_DETECTION_INFO mediaChangeInfo = NULL; + PIRP irp = NULL; + PVOID senseBuffer = NULL; + WDF_OBJECT_ATTRIBUTES attributes; + + PAGED_CODE(); + + if (DeviceExtension->MediaChangeDetectionInfo != NULL) + { + //Already initialized. + return STATUS_SUCCESS; + } + + DeviceExtension->KernelModeMcnContext.FileObject = (PVOID)-1; + DeviceExtension->KernelModeMcnContext.DeviceObject = (PVOID)-1; + DeviceExtension->KernelModeMcnContext.LockCount = 0; + DeviceExtension->KernelModeMcnContext.McnDisableCount = 0; + + mediaChangeInfo = ExAllocatePoolWithTag(NonPagedPoolNx, + sizeof(MEDIA_CHANGE_DETECTION_INFO), + CDROM_TAG_MEDIA_CHANGE_DETECTION); + + if (mediaChangeInfo == NULL) + { + status = STATUS_INSUFFICIENT_RESOURCES; + } + else + { + RtlZeroMemory(mediaChangeInfo, sizeof(MEDIA_CHANGE_DETECTION_INFO)); + } + + if (NT_SUCCESS(status)) + { + if ((DeviceExtension->PowerDescriptor != NULL) && + (DeviceExtension->PowerDescriptor->AsynchronousNotificationSupported != FALSE) && + (!TEST_FLAG(DeviceExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_ASYNCHRONOUS_NOTIFICATION))) + { + mediaChangeInfo->AsynchronousNotificationSupported = TRUE; + } + } + + // Allocate an IRP to carry the IOCTL_MCN_SYNC_FAKE_IOCTL. + if (NT_SUCCESS(status)) + { + irp = IoAllocateIrp(DeviceExtension->DeviceObject->StackSize, FALSE); + + if (irp == NULL) + { + status = STATUS_INSUFFICIENT_RESOURCES; + } + } + + if (NT_SUCCESS(status)) + { + WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, + CDROM_REQUEST_CONTEXT); + attributes.ParentObject = DeviceExtension->Device; + status = WdfRequestCreate(&attributes, + DeviceExtension->IoTarget, + &mediaChangeInfo->MediaChangeRequest); + } + + if (NT_SUCCESS(status)) + { + // Preformat the media change request. With this being done, we never need to worry about + // WdfIoTargetFormatRequestForInternalIoctlOthers ever failing later. + status = WdfIoTargetFormatRequestForInternalIoctlOthers(DeviceExtension->IoTarget, + mediaChangeInfo->MediaChangeRequest, + IOCTL_SCSI_EXECUTE_IN, + NULL, NULL, + NULL, NULL, + NULL, NULL); + } + + if (NT_SUCCESS(status)) + { + senseBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, + SENSE_BUFFER_SIZE, + CDROM_TAG_MEDIA_CHANGE_DETECTION); + if (senseBuffer == NULL) + { + status = STATUS_INSUFFICIENT_RESOURCES; + } + } + + if (NT_SUCCESS(status)) + { + mediaChangeInfo->MediaChangeSyncIrp = irp; + mediaChangeInfo->SenseBuffer = senseBuffer; + + // Set default values for the media change notification + // configuration. + mediaChangeInfo->MediaChangeDetectionDisableCount = 0; + + // Assume that there is initially no media in the device + // only notify upper layers if there is something there + mediaChangeInfo->LastKnownMediaDetectionState = MediaUnknown; + mediaChangeInfo->LastReportedMediaDetectionState = MediaUnknown; + + // setup all extra flags we'll be setting for this irp + mediaChangeInfo->SrbFlags = 0; + + SET_FLAG(mediaChangeInfo->SrbFlags, SRB_CLASS_FLAGS_LOW_PRIORITY); + SET_FLAG(mediaChangeInfo->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE); + SET_FLAG(mediaChangeInfo->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER); + + if (AllowDriveToSleep) //FALSE for CD/DVD devices + { + SET_FLAG(mediaChangeInfo->SrbFlags, SRB_FLAGS_NO_KEEP_AWAKE); + } + + KeInitializeMutex(&mediaChangeInfo->MediaChangeMutex, 0x100); + + // It is ok to support media change events on this device. + DeviceExtension->MediaChangeDetectionInfo = mediaChangeInfo; + + // check the device supports GESN or not, initialize GESN structure if it supports. + { + // This is only valid for type5 devices. + NTSTATUS tempStatus = STATUS_SUCCESS; + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMcn: Testing for GESN\n")); + tempStatus = DeviceInitializeGesn(DeviceExtension); + + if (NT_SUCCESS(tempStatus)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMcn: GESN available for %p\n", + DeviceExtension->DeviceObject)); + NT_ASSERT(mediaChangeInfo->Gesn.Supported ); + NT_ASSERT(mediaChangeInfo->Gesn.Buffer != NULL); + NT_ASSERT(mediaChangeInfo->Gesn.BufferSize != 0); + NT_ASSERT(mediaChangeInfo->Gesn.EventMask != 0); + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMcn: GESN *NOT* available for %p\n", + DeviceExtension->DeviceObject)); + NT_ASSERT(!mediaChangeInfo->Gesn.Supported); + NT_ASSERT(mediaChangeInfo->Gesn.Buffer == NULL); + NT_ASSERT(mediaChangeInfo->Gesn.BufferSize == 0); + NT_ASSERT(mediaChangeInfo->Gesn.EventMask == 0); + mediaChangeInfo->Gesn.Supported = FALSE; // just in case.... + } + } + } + + if (NT_SUCCESS(status)) + { + // Register for display state change on AOAC capable systems so we can put the + // device to low power state when not required. + if (mediaChangeInfo->DisplayStateCallbackHandle == NULL) + { + POWER_PLATFORM_INFORMATION PlatformInfo = {0}; + + status = ZwPowerInformation(PlatformInformation, + NULL, + 0, + &PlatformInfo, + sizeof(PlatformInfo)); + + if (NT_SUCCESS(status) && PlatformInfo.AoAc) + { + PoRegisterPowerSettingCallback(DeviceExtension->DeviceObject, + &GUID_CONSOLE_DISPLAY_STATE, + &DevicePowerSettingCallback, + DeviceExtension, + &mediaChangeInfo->DisplayStateCallbackHandle); + } + + // Ignore any failures above. + status = STATUS_SUCCESS; + } + } + + if (!NT_SUCCESS(status)) + { + if (irp != NULL) + { + IoFreeIrp(irp); + } + FREE_POOL(senseBuffer); + FREE_POOL(mediaChangeInfo); + } + + return status; + +} // end DeviceInitializeMcn() + + +_IRQL_requires_max_(PASSIVE_LEVEL) +NTSTATUS +DeviceInitializeGesn( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + This routine initialize the contents of GESN structure. + +Arguments: + + DeviceExtension - the device extension + +Return Value: + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + PNOTIFICATION_EVENT_STATUS_HEADER header = NULL; + CDROM_DETECTION_STATE detectionState = CdromDetectionUnknown; + PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor = DeviceExtension->DeviceDescriptor; + BOOLEAN retryImmediately = TRUE; + ULONG i = 0; + ULONG atapiResets = 0; + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + + PAGED_CODE(); + + NT_ASSERT(info != NULL); + + // read if we already know the abilities of the device + DeviceGetParameter(DeviceExtension, + CLASSP_REG_SUBKEY_NAME, + CLASSP_REG_MMC_DETECTION_VALUE_NAME, + (PULONG)&detectionState); + + if (detectionState == CdromDetectionUnsupported) + { + status = STATUS_NOT_SUPPORTED; + } + + // check if the device has a hack flag saying never to try this. + if (NT_SUCCESS(status) && + (TEST_FLAG(DeviceExtension->PrivateFdoData->HackFlags, FDO_HACK_GESN_IS_BAD)) ) + { + DeviceSetParameter(DeviceExtension, + CLASSP_REG_SUBKEY_NAME, + CLASSP_REG_MMC_DETECTION_VALUE_NAME, + CdromDetectionUnsupported); + status = STATUS_NOT_SUPPORTED; + } + + // else go through the process since we allocate buffers and + // get all sorts of device settings. + if (NT_SUCCESS(status)) + { + if (info->Gesn.Buffer == NULL) + { + info->Gesn.Buffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, + GESN_BUFFER_SIZE, + CDROM_TAG_GESN); + } + + if (info->Gesn.Buffer == NULL) + { + status = STATUS_INSUFFICIENT_RESOURCES; + } + } + + if (NT_SUCCESS(status)) + { + if (info->Gesn.Mdl != NULL) + { + IoFreeMdl(info->Gesn.Mdl); + } + + info->Gesn.Mdl = IoAllocateMdl(info->Gesn.Buffer, + GESN_BUFFER_SIZE, + FALSE, + FALSE, + NULL); + if (info->Gesn.Mdl == NULL) + { + status = STATUS_INSUFFICIENT_RESOURCES; + } + } + + if (NT_SUCCESS(status)) + { + MmBuildMdlForNonPagedPool(info->Gesn.Mdl); + info->Gesn.BufferSize = GESN_BUFFER_SIZE; + info->Gesn.EventMask = 0; + + // all items are prepared to use GESN (except the event mask, so don't + // optimize this part out!). + // + // now see if it really works. we have to loop through this because + // many SAMSUNG (and one COMPAQ) drives timeout when requesting + // NOT_READY events, even when the IMMEDIATE bit is set. :( + // + // using a drive list is cumbersome, so this might fix the problem. + for (i = 0; (i < 16) && retryImmediately; i++) + { + status = RequestSetupMcnRequest(DeviceExtension, TRUE); + + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "Setup Mcn request failed %x for WDFDEVICE %p\n", + status, DeviceExtension->Device)); + break; + } + + NT_ASSERT(TEST_FLAG(info->MediaChangeSrb.SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE)); + + status = DeviceSendRequestSynchronously(DeviceExtension->Device, info->MediaChangeRequest, TRUE); + + if (SRB_STATUS(info->MediaChangeSrb.SrbStatus) != SRB_STATUS_SUCCESS) + { + // Release the queue if it is frozen. + if (info->MediaChangeSrb.SrbStatus & SRB_STATUS_QUEUE_FROZEN) + { + DeviceReleaseQueue(DeviceExtension->Device); + } + + RequestSenseInfoInterpret(DeviceExtension, + info->MediaChangeRequest, + &(info->MediaChangeSrb), + 0, + &status, + NULL); + } + + if ((deviceDescriptor->BusType == BusTypeAtapi) && + (info->MediaChangeSrb.SrbStatus == SRB_STATUS_BUS_RESET)) + { + // + // ATAPI unfortunately returns SRB_STATUS_BUS_RESET instead + // of SRB_STATUS_TIMEOUT, so we cannot differentiate between + // the two. if we get this status four time consecutively, + // stop trying this command. it is too late to change ATAPI + // at this point, so special-case this here. (07/10/2001) + // NOTE: any value more than 4 may cause the device to be + // marked missing. + // + atapiResets++; + if (atapiResets >= 4) + { + status = STATUS_IO_DEVICE_ERROR; + break; + } + } + + if (status == STATUS_DATA_OVERRUN) + { + status = STATUS_SUCCESS; + } + + if ((status == STATUS_INVALID_DEVICE_REQUEST) || + (status == STATUS_TIMEOUT) || + (status == STATUS_IO_DEVICE_ERROR) || + (status == STATUS_IO_TIMEOUT)) + { + // with these error codes, we don't ever want to try this command + // again on this device, since it reacts poorly. + DeviceSetParameter( DeviceExtension, + CLASSP_REG_SUBKEY_NAME, + CLASSP_REG_MMC_DETECTION_VALUE_NAME, + CdromDetectionUnsupported); + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "GESN test failed %x for WDFDEVICE %p\n", + status, DeviceExtension->Device)); + break; + } + + if (!NT_SUCCESS(status)) + { + // this may be other errors that should not disable GESN + // for all future start_device calls. + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "GESN test failed %x for WDFDEVICE %p\n", + status, DeviceExtension->Device)); + break; + } + else if (i == 0) + { + // the first time, the request was just retrieving a mask of + // available bits. use this to mask future requests. + header = (PNOTIFICATION_EVENT_STATUS_HEADER)(info->Gesn.Buffer); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "WDFDEVICE %p supports event mask %x\n", + DeviceExtension->Device, header->SupportedEventClasses)); + + if (TEST_FLAG(header->SupportedEventClasses, + NOTIFICATION_MEDIA_STATUS_CLASS_MASK)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN supports MCN\n")); + } + if (TEST_FLAG(header->SupportedEventClasses, + NOTIFICATION_DEVICE_BUSY_CLASS_MASK)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN supports DeviceBusy\n")); + } + if (TEST_FLAG(header->SupportedEventClasses, + NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK)) + { + if (TEST_FLAG(DeviceExtension->PrivateFdoData->HackFlags, + FDO_HACK_GESN_IGNORE_OPCHANGE)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN supports OpChange, but must ignore these events for compatibility\n")); + CLEAR_FLAG(header->SupportedEventClasses, + NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK); + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN supports OpChange\n")); + } + } + info->Gesn.EventMask = header->SupportedEventClasses; + + // + // realistically, we are only considering the following events: + // EXTERNAL REQUEST - this is being tested for play/stop/etc. + // MEDIA STATUS - autorun and ejection requests. + // DEVICE BUSY - to allow us to predict when media will be ready. + // therefore, we should not bother querying for the other, + // unknown events. clear all but the above flags. + // + info->Gesn.EventMask &= NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK | + NOTIFICATION_EXTERNAL_REQUEST_CLASS_MASK | + NOTIFICATION_MEDIA_STATUS_CLASS_MASK | + NOTIFICATION_DEVICE_BUSY_CLASS_MASK ; + + + // + // HACKHACK - REF #0001 + // Some devices will *never* report an event if we've also requested + // that it report lower-priority events. this is due to a + // misunderstanding in the specification wherein a "No Change" is + // interpreted to be a real event. what should occur is that the + // device should ignore "No Change" events when multiple event types + // are requested unless there are no other events waiting. this + // greatly reduces the number of requests that the host must send + // to determine if an event has occurred. Since we must work on all + // drives, default to enabling the hack until we find evidence of + // proper firmware. + // + if (info->Gesn.EventMask == 0) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN supported, but not mask we care about (%x) for FDO %p\n", + header->SupportedEventClasses, + DeviceExtension->DeviceObject)); + // NOTE: the status is still status_sucess. + break; + } + else if (CountOfSetBitsUChar(info->Gesn.EventMask) == 1) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN hack not required for FDO %p\n", + DeviceExtension->DeviceObject)); + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN hack enabled for FDO %p\n", + DeviceExtension->DeviceObject)); + info->Gesn.HackEventMask = 1; + } + } + else + { + // i > 0; not the first time looping through, so interpret the results. + status = GesnDataInterpret(DeviceExtension, + (PVOID)info->Gesn.Buffer, + &retryImmediately); + + if (!NT_SUCCESS(status)) + { + // This drive does not support GESN correctly + DeviceSetParameter( DeviceExtension, + CLASSP_REG_SUBKEY_NAME, + CLASSP_REG_MMC_DETECTION_VALUE_NAME, + CdromDetectionUnsupported); + break; + } + } + } // end 'for' loop of GESN requests.... + } + + if (NT_SUCCESS(status)) + { + // + // we can only use this if it can be relied upon for media changes, + // since we are (by definition) no longer going to be polling via + // a TEST_UNIT_READY irp, and drives will not report UNIT ATTENTION + // for this command (although a filter driver, such as one for burning + // cd's, might still fake those errors). + // + // since we also rely upon NOT_READY events to change the cursor + // into a "wait" cursor; GESN is still more reliable than other + // methods, and includes eject button requests, so we'll use it + // without DEVICE_BUSY in Windows Vista. + // + + if (TEST_FLAG(info->Gesn.EventMask, NOTIFICATION_MEDIA_STATUS_CLASS_MASK)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "Enabling GESN support for WDFDEVICE %p\n", + DeviceExtension->Device)); + info->Gesn.Supported = TRUE; + + DeviceSetParameter( DeviceExtension, + CLASSP_REG_SUBKEY_NAME, + CLASSP_REG_MMC_DETECTION_VALUE_NAME, + CdromDetectionSupported); + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "GESN available but not enabled for WDFDEVICE %p\n", + DeviceExtension->Device)); + status = STATUS_NOT_SUPPORTED; + } + } + + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "GESN support detection failed for WDFDEVICE %p with status %08x\n", + DeviceExtension->Device, status)); + + if (info->Gesn.Mdl) + { + PIRP irp = WdfRequestWdmGetIrp(info->MediaChangeRequest); + + IoFreeMdl(info->Gesn.Mdl); + info->Gesn.Mdl = NULL; + irp->MdlAddress = NULL; + } + + FREE_POOL(info->Gesn.Buffer); + info->Gesn.Supported = FALSE; + info->Gesn.EventMask = 0; + info->Gesn.BufferSize = 0; + } + + return status; +} + + +_IRQL_requires_max_(PASSIVE_LEVEL) +NTSTATUS +DeviceInitializeMediaChangeDetection( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + This routine checks to see if it is safe to initialize MCN (the back end + to autorun) for a given device. It will then check the device-type wide + key "Autorun" in the service key (for legacy reasons), and then look in + the device-specific key to potentially override that setting. + + If MCN is to be enabled, all neccessary structures and memory are + allocated and initialized. + + This routine MUST be called only from the DeviceInit...() . + +Arguments: + + DeviceExtension - the device to initialize MCN for, if appropriate + +Return Value: + + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + + BOOLEAN disabled = FALSE; + BOOLEAN instanceOverride; + + PAGED_CODE(); + + // NOTE: This assumes that DeviceInitializeMediaChangeDetection is always + // called in the context of the DeviceInitDevicePhase2. If called + // after then this check will have already been made and the + // once a second timer will not have been enabled. + + disabled = DeviceIsMediaChangeDisabledDueToHardwareLimitation(DeviceExtension); + + if (disabled) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMediaChangeDetection: Disabled due to hardware" + "limitations for this device\n")); + } + else + { + // autorun should now be enabled by default for all media types. + disabled = DeviceIsMediaChangeDisabledForClass(DeviceExtension); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMediaChangeDetection: MCN is %s\n", + (disabled ? "disabled" : "enabled"))); + + status = DeviceMediaChangeDeviceInstanceOverride(DeviceExtension, + &instanceOverride); // default value + + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMediaChangeDetection: Instance using default\n")); + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMediaChangeDetection: Instance override: %s MCN\n", + (instanceOverride ? "Enabling" : "Disabling"))); + disabled = !instanceOverride; + } + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceInitializeMediaChangeDetection: Instance MCN is %s\n", + (disabled ? "disabled" : "enabled"))); + } + + if (!disabled) + { + // if the drive is not a CDROM, allow the drive to sleep + status = DeviceInitializeMcn(DeviceExtension, FALSE); + } + + return status; +} // end DeviceInitializeMediaChangeDetection() + + +_IRQL_requires_max_(PASSIVE_LEVEL) +NTSTATUS +DeviceMediaChangeDeviceInstanceOverride( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _Out_ PBOOLEAN Enabled + ) +/*++ + +Routine Description: + + The user can override the global setting to enable or disable Autorun on a + specific cdrom device via the control panel. This routine checks and/or + sets this value. + +Arguments: + + DeviceExtension - the device to set/get the value for + + Enabled - TRUE (Autorun is enabled) + FALSE (Autorun is disabled) +Return Value: + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_UNSUCCESSFUL; + WDFKEY deviceKey = NULL; + WDFKEY subKey = NULL; + + UNICODE_STRING subkeyName; + UNICODE_STRING enableMcnValueName; + UNICODE_STRING disableMcnValueName; + ULONG alwaysEnable = 0; + ULONG alwaysDisable = 0; + + PAGED_CODE(); + + status = WdfDeviceOpenRegistryKey(DeviceExtension->Device, + PLUGPLAY_REGKEY_DEVICE, + KEY_ALL_ACCESS, + WDF_NO_OBJECT_ATTRIBUTES, + &deviceKey); + if (!NT_SUCCESS(status)) + { + // this can occur when a new device is added to the system + // this is due to cdrom.sys being an 'essential' driver + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceMediaChangeDeviceInstanceOverride: " + "Could not open device registry key [%lx]\n", status)); + } + else + { + RtlInitUnicodeString(&subkeyName, MCN_REG_SUBKEY_NAME); + + status = WdfRegistryOpenKey(deviceKey, + &subkeyName, + KEY_READ, + WDF_NO_OBJECT_ATTRIBUTES, + &subKey); + } + + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceMediaChangeDeviceInstanceOverride: " + "subkey could not be created. %lx\n", status)); + } + else + { + // Default to not changing autorun behavior, based upon setting + // registryValue to zero. + RtlInitUnicodeString(&enableMcnValueName, MCN_REG_AUTORUN_ENABLE_INSTANCE_NAME); + RtlInitUnicodeString(&disableMcnValueName, MCN_REG_AUTORUN_DISABLE_INSTANCE_NAME); + + // Ignore failures on reading of subkeys + (VOID) WdfRegistryQueryULong(subKey, + &enableMcnValueName, + &alwaysEnable); + (VOID) WdfRegistryQueryULong(subKey, + &disableMcnValueName, + &alwaysDisable); + } + + // set return value and cleanup + + if (subKey != NULL) + { + WdfRegistryClose(subKey); + } + + if (deviceKey != NULL) + { + WdfRegistryClose(deviceKey); + } + + if (alwaysEnable && alwaysDisable) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceMediaChangeDeviceInstanceOverride: %s selected\n", + "Both Enable and Disable set -- DISABLE")); + NT_ASSERT(NT_SUCCESS(status)); + status = STATUS_SUCCESS; + *Enabled = FALSE; + } + else if (alwaysDisable) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceMediaChangeDeviceInstanceOverride: %s selected\n", + "DISABLE")); + NT_ASSERT(NT_SUCCESS(status)); + status = STATUS_SUCCESS; + *Enabled = FALSE; + } + else if (alwaysEnable) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceMediaChangeDeviceInstanceOverride: %s selected\n", + "ENABLE")); + NT_ASSERT(NT_SUCCESS(status)); + status = STATUS_SUCCESS; + *Enabled = TRUE; + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceMediaChangeDeviceInstanceOverride: %s selected\n", + "DEFAULT")); + status = STATUS_UNSUCCESSFUL; + } + + return status; +} // end DeviceMediaChangeDeviceInstanceOverride() + + +NTSTATUS +NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ +DeviceMediaChangeRegistryCallBack( + _In_z_ PWSTR ValueName, + _In_ ULONG ValueType, + _In_reads_bytes_opt_(ValueLength) PVOID ValueData, + _In_ ULONG ValueLength, + _In_opt_ PVOID Context, + _In_opt_ PVOID EntryContext + ) +/*++ + +Routine Description: + + This callback for a registry SZ or MULTI_SZ is called once for each + SZ in the value. It will attempt to match the data with the + UNICODE_STRING passed in as Context, and modify EntryContext if a + match is found. Written for ClasspCheckRegistryForMediaChangeCompletion + +Arguments: + + ValueName - name of the key that was opened + ValueType - type of data stored in the value (REG_SZ for this routine) + ValueData - data in the registry, in this case a wide string + ValueLength - length of the data including the terminating null + Context - unicode string to compare against ValueData + EntryContext - should be initialized to 0, will be set to 1 if match found + +Return Value: + + STATUS_SUCCESS + EntryContext will be 1 if found + +--*/ +{ + PULONG valueFound; + PUNICODE_STRING deviceString; + PWSTR keyValue; + + PAGED_CODE(); + + UNREFERENCED_PARAMETER(ValueName); + + if ((Context == NULL) || (EntryContext == NULL)) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "DeviceMediaChangeRegistryCallBack: NULL context should never be passed to registry call-back!\n")); + + return STATUS_SUCCESS; + } + + // if we have already set the value to true, exit + valueFound = EntryContext; + if ((*valueFound) != 0) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceMediaChangeRegistryCallBack: already set to true\n")); + return STATUS_SUCCESS; + } + + if (ValueLength == sizeof(WCHAR)) + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "DeviceMediaChangeRegistryCallBack: NULL string should never be passed to registry call-back!\n")); + return STATUS_SUCCESS; + } + + // if the data is not a terminated string, exit + if (ValueType != REG_SZ) + { + return STATUS_SUCCESS; + } + + deviceString = Context; + keyValue = ValueData; + ValueLength -= sizeof(WCHAR); // ignore the null character + + // do not compare more memory than is in deviceString + if (ValueLength > deviceString->Length) + { + ValueLength = deviceString->Length; + } + + if (keyValue == NULL) + { + return STATUS_SUCCESS; + } + + // if the strings match, disable autorun + if (RtlCompareMemory(deviceString->Buffer, keyValue, ValueLength) == ValueLength) + { + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, "DeviceMediaChangeRegistryCallBack: Match found\n")); + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, "DeviceMediaChangeRegistryCallBack: DeviceString at %p\n", + deviceString->Buffer)); + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, + "DeviceMediaChangeRegistryCallBack: KeyValue at %p\n", + keyValue)); + (*valueFound) = TRUE; + } + + return STATUS_SUCCESS; +} // end DeviceMediaChangeRegistryCallBack() + + +_IRQL_requires_max_(PASSIVE_LEVEL) +BOOLEAN +DeviceIsMediaChangeDisabledDueToHardwareLimitation( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + The key AutoRunAlwaysDisable contains a MULTI_SZ of hardware IDs for + which to never enable MediaChangeNotification. + + The user can override the global setting to enable or disable Autorun on a + specific cdrom device via the control panel. + + NOTE: It's intended that not use WdfRegistryQueryMultiString in this funciton, + as it's much more complicated.(needs WDFCOLLECTION, WDFSTRING other than + UNICODE_STRING) + +Arguments: + + FdoExtension - + RegistryPath - pointer to the unicode string inside + ...\CurrentControlSet\Services\Cdrom + +Return Value: + + TRUE - no autorun. + FALSE - Autorun may be enabled + +--*/ +{ + NTSTATUS status; + + PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor = DeviceExtension->DeviceDescriptor; + WDFKEY wdfKey; + HANDLE serviceKey = NULL; + RTL_QUERY_REGISTRY_TABLE parameters[2] = {0}; + + UNICODE_STRING deviceUnicodeString = {0}; + ANSI_STRING deviceString = {0}; + ULONG mediaChangeNotificationDisabled = 0; + + PAGED_CODE(); + + // open the service key. + status = WdfDriverOpenParametersRegistryKey(WdfGetDriver(), + KEY_ALL_ACCESS, + WDF_NO_OBJECT_ATTRIBUTES, + &wdfKey); + + if(!NT_SUCCESS(status)) + { + // NT_ASSERT(FALSE); __REACTOS__ : allow to fail (for 1st stage setup) + + // always take the safe path. if we can't open the service key, disable autorun + return TRUE; + } + + if(NT_SUCCESS(status)) + { + // Determine if drive is in a list of those requiring + // autorun to be disabled. this is stored in a REG_MULTI_SZ + // named AutoRunAlwaysDisable. this is required as some autochangers + // must load the disc to reply to ChkVerify request, causing them + // to cycle discs continuously. + + PWSTR nullMultiSz; + PUCHAR vendorId = NULL; + PUCHAR productId = NULL; + PUCHAR revisionId = NULL; + size_t length; + size_t offset; + + deviceString.Buffer = NULL; + deviceUnicodeString.Buffer = NULL; + + serviceKey = WdfRegistryWdmGetHandle(wdfKey); + + // there may be nothing to check against + if ((deviceDescriptor->VendorIdOffset == 0) && + (deviceDescriptor->ProductIdOffset == 0)) + { + // no valid data in device extension. + status = STATUS_INTERNAL_ERROR; + } + + // build deviceString using VendorId, Model and Revision. + // this string will be used to checked if it's one of devices in registry disable list. + if (NT_SUCCESS(status)) + { + length = 0; + + if (deviceDescriptor->VendorIdOffset == 0) + { + vendorId = NULL; + } + else + { + vendorId = (PUCHAR) deviceDescriptor + deviceDescriptor->VendorIdOffset; + length = strlen((LPCSTR)vendorId); + } + + if ( deviceDescriptor->ProductIdOffset == 0 ) + { + productId = NULL; + } + else + { + productId = (PUCHAR) deviceDescriptor + deviceDescriptor->ProductIdOffset; + length += strlen((LPCSTR)productId); + } + + if ( deviceDescriptor->ProductRevisionOffset == 0 ) + { + revisionId = NULL; + } + else + { + revisionId = (PUCHAR) deviceDescriptor + deviceDescriptor->ProductRevisionOffset; + length += strlen((LPCSTR)revisionId); + } + + // allocate a buffer for the string + deviceString.Length = (USHORT)( length ); + deviceString.MaximumLength = deviceString.Length + 1; + deviceString.Buffer = (PCHAR)ExAllocatePoolWithTag( NonPagedPoolNx, + deviceString.MaximumLength, + CDROM_TAG_AUTORUN_DISABLE + ); + if (deviceString.Buffer == NULL) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceIsMediaChangeDisabledDueToHardwareLimitation: Unable to alloc string buffer\n" )); + status = STATUS_INTERNAL_ERROR; + } + } + + if (NT_SUCCESS(status)) + { + // copy strings to the buffer + offset = 0; + + if (vendorId != NULL) + { + RtlCopyMemory(deviceString.Buffer + offset, + vendorId, + strlen((LPCSTR)vendorId)); + offset += strlen((LPCSTR)vendorId); + } + + if ( productId != NULL ) + { + RtlCopyMemory(deviceString.Buffer + offset, + productId, + strlen((LPCSTR)productId)); + offset += strlen((LPCSTR)productId); + } + if ( revisionId != NULL ) + { + RtlCopyMemory(deviceString.Buffer + offset, + revisionId, + strlen((LPCSTR)revisionId)); + offset += strlen((LPCSTR)revisionId); + } + + NT_ASSERT(offset == deviceString.Length); + + #pragma warning(suppress:6386) // Not an issue as deviceString.Buffer is of size deviceString.MaximumLength, which is equal to (deviceString.Length + 1) + deviceString.Buffer[deviceString.Length] = '\0'; // Null-terminated + + // convert to unicode as registry deals with unicode strings + status = RtlAnsiStringToUnicodeString( &deviceUnicodeString, + &deviceString, + TRUE + ); + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceIsMediaChangeDisabledDueToHardwareLimitation: cannot convert " + "to unicode %lx\n", status)); + } + } + + if (NT_SUCCESS(status)) + { + // query the value, setting valueFound to true if found + nullMultiSz = L"\0"; + parameters[0].QueryRoutine = DeviceMediaChangeRegistryCallBack; + parameters[0].Flags = RTL_QUERY_REGISTRY_REQUIRED; + parameters[0].Name = L"AutoRunAlwaysDisable"; + parameters[0].EntryContext = &mediaChangeNotificationDisabled; + parameters[0].DefaultType = REG_MULTI_SZ; + parameters[0].DefaultData = nullMultiSz; + parameters[0].DefaultLength = 0; + + status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, + serviceKey, + parameters, + &deviceUnicodeString, + NULL); + UNREFERENCED_PARAMETER(status); //defensive coding, avoid PREFAST warning. + } + } + + // Cleanup + { + + FREE_POOL( deviceString.Buffer ); + if (deviceUnicodeString.Buffer != NULL) + { + RtlFreeUnicodeString( &deviceUnicodeString ); + } + + // handle serviceKey will be closed by framework while it closes registry key. + WdfRegistryClose(wdfKey); + } + + if (mediaChangeNotificationDisabled > 0) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceIsMediaChangeDisabledDueToHardwareLimitation: Device is on MCN disable list\n")); + } + + return (mediaChangeNotificationDisabled > 0); + +} // end DeviceIsMediaChangeDisabledDueToHardwareLimitation() + + +_IRQL_requires_max_(PASSIVE_LEVEL) +BOOLEAN +DeviceIsMediaChangeDisabledForClass( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + The user must specify that AutoPlay is to run on the platform + by setting the registry value HKEY_LOCAL_MACHINE\System\CurrentControlSet\ + Services\<SERVICE>\Autorun:REG_DWORD:1. + + The user can override the global setting to enable or disable Autorun on a + specific cdrom device via the control panel. + +Arguments: + + DeviceExtension - device extension + +Return Value: + + TRUE - Autorun is disabled for this class + FALSE - Autorun is enabled for this class + +--*/ +{ + NTSTATUS status; + WDFKEY serviceKey = NULL; + WDFKEY parametersKey = NULL; + + UNICODE_STRING parameterKeyName; + UNICODE_STRING valueName; + + // Default to ENABLING MediaChangeNotification (!) + ULONG mcnRegistryValue = 1; + + PAGED_CODE(); + + // open the service key. + status = WdfDriverOpenParametersRegistryKey(WdfGetDriver(), + KEY_ALL_ACCESS, + WDF_NO_OBJECT_ATTRIBUTES, + &serviceKey); + if(!NT_SUCCESS(status)) + { + // return the default value, which is the inverse of the registry setting default + // since this routine asks if it's disabled + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceIsMediaChangeDisabledForClass: Defaulting to %s\n", + (mcnRegistryValue ? "Enabled" : "Disabled"))); + return (BOOLEAN)(mcnRegistryValue == 0); + } + else + { + // Open the parameters key (if any) beneath the services key. + RtlInitUnicodeString(&parameterKeyName, L"Parameters"); + + status = WdfRegistryOpenKey(serviceKey, + &parameterKeyName, + KEY_READ, + WDF_NO_OBJECT_ATTRIBUTES, + &parametersKey); + } + + if (!NT_SUCCESS(status)) + { + parametersKey = NULL; + } + + RtlInitUnicodeString(&valueName, L"Autorun"); + // ignore failures + status = WdfRegistryQueryULong(serviceKey, + &valueName, + &mcnRegistryValue); + + if (NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, + "DeviceIsMediaChangeDisabledForClass: <Service>/Autorun flag = %d\n", + mcnRegistryValue)); + } + + if (parametersKey != NULL) + { + status = WdfRegistryQueryULong(parametersKey, + &valueName, + &mcnRegistryValue); + + if (NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, + "DeviceIsMediaChangeDisabledForClass: <Service>/Parameters/Autorun flag = %d\n", + mcnRegistryValue)); + } + + WdfRegistryClose(parametersKey); + } + + WdfRegistryClose(serviceKey); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceIsMediaChangeDisabledForClass: Autoplay for device %p is %s\n", + DeviceExtension->DeviceObject, + (mcnRegistryValue ? "on" : "off") + )); + + // return if it is _disabled_, which is the + // inverse of the registry setting + + return (BOOLEAN)(!mcnRegistryValue); +} // end DeviceIsMediaChangeDisabledForClass() + + +_IRQL_requires_max_(APC_LEVEL) +VOID +DeviceEnableMediaChangeDetection( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _Inout_ PFILE_OBJECT_CONTEXT FileObjectContext, + _In_ BOOLEAN IgnorePreviousMediaChanges + ) +/*++ + +Routine Description: + + When the disable count decrease to 0, enable the MCN + +Arguments: + + DeviceExtension - the device context + + FileObjectContext - the file object context + + IgnorePreviousMediaChanges - ignore all previous media changes + +Return Value: + None. + +--*/ +{ + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + LONG oldCount; + + PAGED_CODE(); + + if (FileObjectContext) + { + InterlockedDecrement((PLONG)&(FileObjectContext->McnDisableCount)); + } + + if (info == NULL) + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceEnableMediaChangeDetection: not initialized\n")); + return; + } + + (VOID) KeWaitForMutexObject(&info->MediaChangeMutex, + UserRequest, + KernelMode, + FALSE, + NULL); + + oldCount = --info->MediaChangeDetectionDisableCount; + + NT_ASSERT(oldCount >= 0); + + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, + "DeviceEnableMediaChangeDetection: Disable count reduced to %d - \n", + info->MediaChangeDetectionDisableCount)); + + if (oldCount == 0) + { + if (IgnorePreviousMediaChanges) + { + info->LastReportedMediaDetectionState = info->LastKnownMediaDetectionState; + } + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "MCN is enabled\n")); + } + else + { + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, "MCD still disabled\n")); + } + + // Let something else run. + KeReleaseMutex(&info->MediaChangeMutex, FALSE); + + return; +} // end DeviceEnableMediaChangeDetection() + + +_IRQL_requires_max_(APC_LEVEL) +VOID +DeviceDisableMediaChangeDetection( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _Inout_ PFILE_OBJECT_CONTEXT FileObjectContext + ) +/*++ + +Routine Description: + + Increase the disable count. + +Arguments: + + DeviceExtension - the device context + + FileObjectContext - the file object context + +Return Value: + None. + +--*/ +{ + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + + PAGED_CODE(); + + if (FileObjectContext) + { + InterlockedIncrement((PLONG)&(FileObjectContext->McnDisableCount)); + } + + if (info == NULL) + { + return; + } + + (VOID) KeWaitForMutexObject(&info->MediaChangeMutex, + UserRequest, + KernelMode, + FALSE, + NULL); + + info->MediaChangeDetectionDisableCount++; + + TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_MCN, + "DisableMediaChangeDetection: disable count is %d\n", + info->MediaChangeDetectionDisableCount)); + + KeReleaseMutex(&info->MediaChangeMutex, FALSE); + + return; +} // end DeviceDisableMediaChangeDetection() + + +_IRQL_requires_max_(APC_LEVEL) +VOID +DeviceReleaseMcnResources( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + This routine will cleanup any resources allocated for MCN. It is called + by classpnp during remove device, and therefore is not typically required + by external drivers. + +Arguments: + + DeviceExtension - the device context + +Return Value: + None. + +--*/ +{ + PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo; + + PAGED_CODE() + + if(info == NULL) + { + return; + } + + if (info->Gesn.Mdl) + { + PIRP irp = WdfRequestWdmGetIrp(info->MediaChangeRequest); + IoFreeMdl(info->Gesn.Mdl); + irp->MdlAddress = NULL; + } + IoFreeIrp(info->MediaChangeSyncIrp); + FREE_POOL(info->Gesn.Buffer); + FREE_POOL(info->SenseBuffer); + + if (info->DisplayStateCallbackHandle) + { + PoUnregisterPowerSettingCallback(info->DisplayStateCallbackHandle); + info->DisplayStateCallbackHandle = NULL; + } + + FREE_POOL(info); + + DeviceExtension->MediaChangeDetectionInfo = NULL; + + return; +} // end DeviceReleaseMcnResources() + + +IO_COMPLETION_ROUTINE RequestMcnSyncIrpCompletion; + +NTSTATUS +NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ +RequestMcnSyncIrpCompletion( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp, + _In_reads_opt_(_Inexpressible_("varies")) PVOID Context + ) +/*++ + +Routine Description: + + The MCN work finishes, reset the fields to allow another MCN request + be scheduled. + +Arguments: + + DeviceObject - device that the completion routine fires on. + + Irp - The irp to be completed. + + Context - IRP context + +Return Value: + NTSTATUS + +--*/ +{ + PCDROM_DEVICE_EXTENSION DeviceExtension = NULL; + PMEDIA_CHANGE_DETECTION_INFO info = NULL; + + if (Context == NULL) + { + // this will never happen, but code must be there to prevent OACR warnings. + return STATUS_MORE_PROCESSING_REQUIRED; + } + + DeviceExtension = (PCDROM_DEVICE_EXTENSION) Context; + info = DeviceExtension->MediaChangeDetectionInfo; + +#ifndef DEBUG + UNREFERENCED_PARAMETER(Irp); +#endif + UNREFERENCED_PARAMETER(DeviceObject); + + NT_ASSERT(Irp == info->MediaChangeSyncIrp); + + IoReuseIrp(info->MediaChangeSyncIrp, STATUS_NOT_SUPPORTED); + + // reset the value to let timer routine be able to send the next request. + InterlockedCompareExchange((PLONG)&(info->MediaChangeRequestInUse), 0, 1); + + return STATUS_MORE_PROCESSING_REQUIRED; +} + + +VOID +RequestSetupMcnSyncIrp( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + setup the MCN synchronization irp. + +Arguments: + + DeviceExtension - the device context + +Return Value: + None + +--*/ +{ + PIRP irp = NULL; + PIO_STACK_LOCATION irpStack = NULL; + PIO_STACK_LOCATION nextIrpStack = NULL; + + irp = DeviceExtension->MediaChangeDetectionInfo->MediaChangeSyncIrp; + NT_ASSERT(irp != NULL); + + // + // For the driver that creates an IRP, there is no 'current' stack location. + // Step down one IRP stack location so that the extra top one + // becomes our 'current' one. + // + IoSetNextIrpStackLocation(irp); + + /* + * Cache our device object in the extra top IRP stack location + * so we have it in our completion routine. + */ + irpStack = IoGetCurrentIrpStackLocation(irp); + irpStack->DeviceObject = DeviceExtension->DeviceObject; + + // + // If the irp is sent down when the volume needs to be + // verified, CdRomUpdateGeometryCompletion won't complete + // it since it's not associated with a thread. Marking + // it to override the verify causes it always be sent + // to the port driver + // + nextIrpStack = IoGetNextIrpStackLocation(irp); + + SET_FLAG(nextIrpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME); + + nextIrpStack->MajorFunction = IRP_MJ_DEVICE_CONTROL; + // pick up this IOCTL code as it's not normaly seen for CD/DVD drive and does not require input. + // set other fields to make this IOCTL recognizable by CDROM.SYS + nextIrpStack->Parameters.Others.Argument1 = RequestSetupMcnSyncIrp; + nextIrpStack->Parameters.Others.Argument2 = RequestSetupMcnSyncIrp; + nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_MCN_SYNC_FAKE_IOCTL; //Argument3. + nextIrpStack->Parameters.Others.Argument4 = RequestSetupMcnSyncIrp; + + IoSetCompletionRoutine(irp, + RequestMcnSyncIrpCompletion, + DeviceExtension, + TRUE, + TRUE, + TRUE); + + return; +} + + +VOID +NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ +DeviceMainTimerTickHandler( + _In_ WDFTIMER Timer + ) +/*++ + +Routine Description: + + This routine setup a sync irp and send it to the serial queue. + Serial queue will process MCN when receive this sync irp. + +Arguments: + + Timer - the timer object that fires. + +Return Value: + None + +--*/ +{ + PCDROM_DEVICE_EXTENSION deviceExtension = NULL; + size_t dataLength = 0; + + deviceExtension = WdfObjectGetTypedContext(WdfTimerGetParentObject(Timer), CDROM_DEVICE_EXTENSION); + + (void) RequestHandleEventNotification(deviceExtension, NULL, NULL, &dataLength); + + return; +} // end DeviceMainTimerTickHandler() + + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +DeviceEnableMainTimer( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + This routine will allocate timer related resources on the first time call. + Start the timer. + +Arguments: + + DeviceExtension - the device context + +Return Value: + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + + if ((DeviceExtension->MediaChangeDetectionInfo == NULL) || + (DeviceExtension->MediaChangeDetectionInfo->AsynchronousNotificationSupported != FALSE)) + { + // Asynchronous Notification is enabled, timer not needed. + return status; + } + + if (DeviceExtension->MainTimer == NULL) + { + //create main timer object. + WDF_TIMER_CONFIG timerConfig; + WDF_OBJECT_ATTRIBUTES timerAttributes; + + WDF_TIMER_CONFIG_INIT(&timerConfig, DeviceMainTimerTickHandler); + + // Polling frequently on virtual optical devices created by Hyper-V will + // cause a significant perf / power hit. These devices need to be polled + // less frequently for device state changes. + if (TEST_FLAG(DeviceExtension->DeviceAdditionalData.HackFlags, CDROM_HACK_MSFT_VIRTUAL_ODD)) + { + timerConfig.Period = 2000; // 2 seconds, in milliseconds. + } + else + { + timerConfig.Period = 1000; // 1 second, in milliseconds. + } + + timerConfig.TolerableDelay = 500; // 0.5 seconds, in milliseconds + + //Set the autoSerialization to FALSE, as the parent device's + //execute level is WdfExecutionLevelPassive. + timerConfig.AutomaticSerialization = FALSE; + + WDF_OBJECT_ATTRIBUTES_INIT(&timerAttributes); + timerAttributes.ParentObject = DeviceExtension->Device; + timerAttributes.ExecutionLevel = WdfExecutionLevelInheritFromParent; + + status = WdfTimerCreate(&timerConfig, + &timerAttributes, + &DeviceExtension->MainTimer); + } + + if (NT_SUCCESS(status)) + { + WdfTimerStart(DeviceExtension->MainTimer,WDF_REL_TIMEOUT_IN_MS(100)); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceEnableMainTimer: Once a second timer enabled for WDFDEVICE %p\n", + DeviceExtension->Device)); + } + else + { + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceEnableMainTimer: WDFDEVICE %p, Status %lx initializing timer\n", + DeviceExtension->Device, status)); + } + + return status; +} // end DeviceEnableMainTimer() + + +_IRQL_requires_max_(PASSIVE_LEVEL) +VOID +DeviceDisableMainTimer( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension + ) +/*++ + +Routine Description: + + stop the timer. + +Arguments: + + DeviceExtension - device context + +Return Value: + None + +--*/ +{ + PAGED_CODE(); + + if ((DeviceExtension->MediaChangeDetectionInfo == NULL) || + (DeviceExtension->MediaChangeDetectionInfo->AsynchronousNotificationSupported != FALSE)) + { + // Asynchronous Notification is enabled, timer not needed. + return; + } + + if (DeviceExtension->MainTimer != NULL) + { + // + // we are only going to stop the actual timer in remove device routine. + // it is the responsibility of the code within the timer routine to + // check if the device is removed and not processing io for the final + // call. + // this keeps the code clean and prevents lots of bugs. + // + WdfTimerStop(DeviceExtension->MainTimer,TRUE); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, + "DeviceDisableMainTimer: Once a second timer disabled for device %p\n", + DeviceExtension->Device)); + } + else + { + TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN, + "DeviceDisableMainTimer: Timer never enabled\n")); + } + + return; +} // end DeviceDisableMainTimer() + + +_IRQL_requires_max_(APC_LEVEL) +NTSTATUS +RequestHandleMcnControl( + _In_ PCDROM_DEVICE_EXTENSION DeviceExtension, + _In_ WDFREQUEST Request, + _Out_ size_t * DataLength + ) +/*++ + +Routine Description: + + This routine handles the process of IOCTL_STORAGE_MCN_CONTROL + +Arguments: + + DeviceExtension - device context + + Request - request object + + RequestParameters - request parameters + + DataLength - data transferred + +Return Value: + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + WDFFILEOBJECT fileObject = NULL; + PFILE_OBJECT_CONTEXT fileObjectContext = NULL; + PPREVENT_MEDIA_REMOVAL mediaRemoval = NULL; + + PAGED_CODE(); + + *DataLength = 0; + + status = WdfRequestRetrieveInputBuffer(Request, + sizeof(PREVENT_MEDIA_REMOVAL), + &mediaRemoval, + NULL); + + if (NT_SUCCESS(status)) + { + fileObject = WdfRequestGetFileObject(Request); + + // Check to make sure we have a file object extension to keep track of this + // request. If not we'll fail it before synchronizing. + if (fileObject != NULL) + { + fileObjectContext = FileObjectGetContext(fileObject); + } + + if ((fileObjectContext == NULL) && + (WdfRequestGetRequestorMode(Request) == KernelMode)) + { + fileObjectContext = &DeviceExtension->KernelModeMcnContext; + } + + if (fileObjectContext == NULL) + { + // This handle isn't setup correctly. We can't let the + // operation go. + status = STATUS_INVALID_PARAMETER; + } + } + + if (NT_SUCCESS(status)) + { + if (mediaRemoval->PreventMediaRemoval) + { + // This is a lock command. Reissue the command in case bus or + // device was reset and the lock was cleared. + DeviceDisableMediaChangeDetection(DeviceExtension, fileObjectContext); + } + else + { + if (fileObjectContext->McnDisableCount == 0) + { + status = STATUS_INVALID_DEVICE_STATE; + } + else + { + DeviceEnableMediaChangeDetection(DeviceExtension, fileObjectContext, TRUE); + } + } + } + + return status; +} // end RequestHandleMcnControl() + +#pragma warning(pop) // un-sets any local warning changes + diff --git a/drivers/storage/class/cdrom_new/cdrom.c b/drivers/storage/class/cdrom_new/cdrom.c new file mode 100644 index 00000000000..ac0c9c63090 --- /dev/null +++ b/drivers/storage/class/cdrom_new/cdrom.c @@ -0,0 +1,4242 @@ +/*-- + +Copyright (C) Microsoft Corporation. All rights reserved. + +Module Name: + + cdrom.c + +Abstract: + + The CDROM class driver tranlates IRPs to SRBs with embedded CDBs + and sends them to its devices through the port driver. + +Environment: + + kernel mode only + +Notes: + + +Revision History: + +--*/ + +// this definition is used to link _StorDebugPrint() function. +#define DEBUG_MAIN_SOURCE 1 + + +#include "ntddk.h" +#include "ntstrsafe.h" + +#include "ntddstor.h" +#include "ntddtape.h" +#include "wdfcore.h" +#include "devpkey.h" + +#include "cdrom.h" +#include "ioctl.h" +#include "mmc.h" +#include "scratch.h" + + +#ifdef DEBUG_USE_WPP +#include "cdrom.tmh" +#endif + +BOOLEAN +BootEnvironmentIsWinPE( + VOID + ); + +#ifdef ALLOC_PRAGMA + +#pragma alloc_text(INIT, DriverEntry) +#pragma alloc_text(INIT, BootEnvironmentIsWinPE) + +#pragma alloc_text(PAGE, DriverEvtCleanup) +#pragma alloc_text(PAGE, DriverEvtDeviceAdd) +#pragma alloc_text(PAGE, DeviceEvtCleanup) +#pragma alloc_text(PAGE, DeviceEvtSelfManagedIoCleanup) +#pragma alloc_text(PAGE, DeviceEvtD0Exit) +#pragma alloc_text(PAGE, CreateQueueEvtIoDefault) +#pragma alloc_text(PAGE, DeviceEvtFileClose) +#pragma alloc_text(PAGE, DeviceCleanupProtectedLocks) +#pragma alloc_text(PAGE, DeviceCleanupDisableMcn) +#pragma alloc_text(PAGE, RequestProcessSerializedIoctl) +#pragma alloc_text(PAGE, ReadWriteWorkItemRoutine) +#pragma alloc_text(PAGE, IoctlWorkItemRoutine) +#pragma alloc_text(PAGE, DeviceEvtSurpriseRemoval) + +#endif + +NTSTATUS +NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ +DriverEntry( + _In_ PDRIVER_OBJECT DriverObject, + _In_ PUNICODE_STRING RegistryPath + ) +/*++ + +Routine Description: + + Installable driver initialization entry point. + This entry point is called directly by the I/O system. + +Arguments: + + DriverObject - pointer to the driver object + + RegistryPath - pointer to a unicode string representing the path, + to driver-specific key in the registry. + +Return Value: + + STATUS_SUCCESS if successful, + STATUS_UNSUCCESSFUL otherwise. + +--*/ +{ + NTSTATUS status; + WDF_DRIVER_CONFIG config; + WDF_OBJECT_ATTRIBUTES attributes; + WDFDRIVER driverObject = NULL; + + PAGED_CODE(); + + // Initialize WPP Tracing + WPP_INIT_TRACING(DriverObject, RegistryPath); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT, + "CDROM.SYS DriverObject %p loading\n", + DriverObject)); + + // Register DeviceAdd and DriverEvtCleanup callback. + // WPP_CLEANUP will be called in DriverEvtCleanup + WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CDROM_DRIVER_EXTENSION); + attributes.EvtCleanupCallback = DriverEvtCleanup; + + WDF_DRIVER_CONFIG_INIT(&config, DriverEvtDeviceAdd); + + status = WdfDriverCreate(DriverObject, + RegistryPath, + &attributes, + &config, + &driverObject); + + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_INIT, + "WdfDriverCreate failed. %x\n", + status)); + + // Cleanup tracing here because DriverUnload will not be called + // as we have failed to create WDFDRIVER object itself. + WPP_CLEANUP(DriverObject); + + } + else + { + PCDROM_DRIVER_EXTENSION driverExtension = DriverGetExtension(driverObject); + + // Copy the registry path into the driver extension so we can use it later + driverExtension->Version = 0x01; + driverExtension->DriverObject = DriverObject; + + if (BootEnvironmentIsWinPE()) { + + SET_FLAG(driverExtension->Flags, CDROM_FLAG_WINPE_MODE); + } + + } + + return status; +} + + +BOOLEAN +BootEnvironmentIsWinPE( + VOID + ) +/*++ + +Routine Description: + + This routine determines if the boot enviroment is WinPE + +Arguments: + + None + +Return Value: + + BOOLEAN - TRUE if the environment is WinPE; FALSE otherwise + +--*/ +{ + NTSTATUS status; + WDFKEY registryKey = NULL; + + DECLARE_CONST_UNICODE_STRING(registryKeyName, WINPE_REG_KEY_NAME); + + PAGED_CODE(); + + status = WdfRegistryOpenKey(NULL, + &registryKeyName, + KEY_READ, + WDF_NO_OBJECT_ATTRIBUTES, + &registryKey); + + if (!NT_SUCCESS(status)) + { + return FALSE; + } + + WdfRegistryClose(registryKey); + return TRUE; +} // end BootEnvironmentIsWinPE() + + +VOID +NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ +DriverEvtCleanup( + _In_ WDFOBJECT Driver + ) +/*++ +Routine Description: + + Free all the resources allocated in DriverEntry. + +Arguments: + + Driver - handle to a WDF Driver object. + +Return Value: + + VOID. + +--*/ +{ + WDFDRIVER driver = (WDFDRIVER)Driver; + + PAGED_CODE (); + + TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT, + "CDROM.SYS DriverObject %p cleanup. Will be unloaded soon\n", + driver)); + + // Stop WPP Tracing + WPP_CLEANUP( WdfDriverWdmGetDriverObject(driver) ); + + + return; +} + + +NTSTATUS +NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ +DriverEvtDeviceAdd( + _In_ WDFDRIVER Driver, + _Inout_ PWDFDEVICE_INIT DeviceInit + ) +/*++ + +Routine Description: + + EvtDeviceAdd is called by the framework in response to AddDevice + call from the PnP manager. + + +Arguments: + + Driver - Handle to a framework driver object created in DriverEntry + + DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure. + +Return Value: + + NTSTATUS + +--*/ +{ + NTSTATUS status = STATUS_SUCCESS; + PCDROM_DRIVER_EXTENSION driverExtension = NULL; + WDFDEVICE device = NULL; + PCDROM_DEVICE_EXTENSION deviceExtension = NULL; + BOOLEAN deviceClaimed = FALSE; + + WDF_OBJECT_ATTRIBUTES attributes; + WDF_FILEOBJECT_CONFIG fileObjectConfig; + WDF_IO_TARGET_OPEN_PARAMS ioTargetOpenParams; + WDF_IO_QUEUE_CONFIG queueConfig; + WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks; + WDF_REMOVE_LOCK_OPTIONS removeLockOptions; + PWCHAR wideDeviceName = NULL; + UNICODE_STRING unicodeDeviceName; + PDEVICE_OBJECT lowerPdo = NULL; + ULONG deviceNumber = 0; + ULONG devicePropertySessionId = INVALID_SESSION; + ULONG devicePropertySize = 0; + DEVPROPTYPE devicePropertyType = DEVPROP_TYPE_EMPTY; + + PAGED_CODE(); + + driverExtension = DriverGetExtension(Driver); + + // 0. Initialize the objects that we're going to use + RtlInitUnicodeString(&unicodeDeviceName, NULL); + + // 1. Register PnP&Power callbacks for any we are interested in. + // If a callback isn't set, Framework will take the default action by itself. + { + // Zero out the PnpPowerCallbacks structure. + WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks); + + // Use this callback to init resources that are used by the device and only needs to be called once. + pnpPowerCallbacks.EvtDeviceSelfManagedIoInit = DeviceEvtSelfManagedIoInit; + + // Use this callback to prepare device for coming back from a lower power mode to D0. + pnpPowerCallbacks.EvtDeviceD0Entry = DeviceEvtD0Entry; + + // Use this callback to prepare device for entering into a lower power mode. + pnpPowerCallbacks.EvtDeviceD0Exit = DeviceEvtD0Exit; + + // Use this callback to free any resources used by device and will be called when the device is + // powered down. + pnpPowerCallbacks.EvtDeviceSelfManagedIoCleanup = DeviceEvtSelfManagedIoCleanup; + + pnpPowerCallbacks.EvtDeviceSurpriseRemoval = DeviceEvtSurpriseRemoval; + + // Register the PnP and power callbacks. + WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks); + } + + // 2. Register the EvtIoInCallerContext to deal with IOCTLs that need to stay in original context. + WdfDeviceInitSetIoInCallerContextCallback(DeviceInit, + DeviceEvtIoInCallerContext); + + // 3. Register PreprocessCallback for IRP_MJ_POWER, IRP_MJ_FLUSH_BUFFERS and IRP_MJ_SHUTDOWN + { + UCHAR minorFunctions[1]; + + minorFunctions[0] = IRP_MN_SET_POWER; + + status = WdfDeviceInitAssignWdmIrpPreprocessCallback(DeviceInit, + RequestProcessSetPower, + IRP_MJ_POWER, + minorFunctions, + RTL_NUMBER_OF(minorFunctions)); + if (!NT_SUCCESS(status)) + { + TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP, + "DriverEvtDeviceAdd: Assign IrpPreprocessCallback for IRP_MJ_POWER failed, " + "status: 0x%X\n", status)); ... 30678 lines suppressed ...

3 years, 11 months

[reactos] 02/02: [ACPICA] Update to version 20200925. CORE-17170

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3499b966821e50384bb38… commit 3499b966821e50384bb38bfda4dfa0dfc0c6f18b Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Fri Oct 9 09:19:55 2020 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Fri Oct 16 01:21:52 2020 +0200 [ACPICA] Update to version 20200925. CORE-17170 --- drivers/bus/acpi/acpica/events/evrgnini.c | 11 ++-- drivers/bus/acpi/acpica/executer/exregion.c | 70 ++++++++++++++++------ drivers/bus/acpi/acpica/include/acconfig.h | 2 +- drivers/bus/acpi/acpica/include/acdebug.h | 6 ++ drivers/bus/acpi/acpica/include/acexcep.h | 4 +- drivers/bus/acpi/acpica/include/acpixf.h | 2 +- drivers/bus/acpi/acpica/include/acpredef.h | 23 ++++++- drivers/bus/acpi/acpica/include/actbl1.h | 16 ++--- drivers/bus/acpi/acpica/include/actypes.h | 16 +++-- drivers/bus/acpi/acpica/include/acuuid.h | 8 ++- drivers/bus/acpi/acpica/include/platform/aclinux.h | 3 +- drivers/bus/acpi/acpica/namespace/nsalloc.c | 2 +- drivers/bus/acpi/acpica/namespace/nsarguments.c | 4 +- drivers/bus/acpi/acpica/namespace/nsxfobj.c | 3 +- drivers/bus/acpi/acpica/parser/psparse.c | 4 +- drivers/bus/acpi/acpica/utilities/utpredef.c | 4 +- drivers/bus/acpi/acpica/utilities/utstrsuppt.c | 30 ++++++++-- media/doc/3rd Party Files.txt | 2 +- 18 files changed, 154 insertions(+), 56 deletions(-) diff --git a/drivers/bus/acpi/acpica/events/evrgnini.c b/drivers/bus/acpi/acpica/events/evrgnini.c index 144240e3c73..04b5fbe13ec 100644 --- a/drivers/bus/acpi/acpica/events/evrgnini.c +++ b/drivers/bus/acpi/acpica/events/evrgnini.c @@ -75,6 +75,7 @@ AcpiEvSystemMemoryRegionSetup ( { ACPI_OPERAND_OBJECT *RegionDesc = (ACPI_OPERAND_OBJECT *) Handle; ACPI_MEM_SPACE_CONTEXT *LocalRegionContext; + ACPI_MEM_MAPPING *Mm; ACPI_FUNCTION_TRACE (EvSystemMemoryRegionSetup); @@ -86,12 +87,14 @@ AcpiEvSystemMemoryRegionSetup ( { LocalRegionContext = (ACPI_MEM_SPACE_CONTEXT *) *RegionContext; - /* Delete a cached mapping if present */ + /* Delete memory mappings if present */ - if (LocalRegionContext->MappedLength) + while (LocalRegionContext->FirstMm) { - AcpiOsUnmapMemory (LocalRegionContext->MappedLogicalAddress, - LocalRegionContext->MappedLength); + Mm = LocalRegionContext->FirstMm; + LocalRegionContext->FirstMm = Mm->NextMm; + AcpiOsUnmapMemory(Mm->LogicalAddress, Mm->Length); + ACPI_FREE(Mm); } ACPI_FREE (LocalRegionContext); *RegionContext = NULL; diff --git a/drivers/bus/acpi/acpica/executer/exregion.c b/drivers/bus/acpi/acpica/executer/exregion.c index 5f3745d23cc..3a13c04a77e 100644 --- a/drivers/bus/acpi/acpica/executer/exregion.c +++ b/drivers/bus/acpi/acpica/executer/exregion.c @@ -80,6 +80,7 @@ AcpiExSystemMemorySpaceHandler ( ACPI_STATUS Status = AE_OK; void *LogicalAddrPtr = NULL; ACPI_MEM_SPACE_CONTEXT *MemInfo = RegionContext; + ACPI_MEM_MAPPING *Mm = MemInfo->CurMm; UINT32 Length; ACPI_SIZE MapLength; ACPI_SIZE PageBoundaryMapLength; @@ -139,21 +140,46 @@ AcpiExSystemMemorySpaceHandler ( * Is 1) Address below the current mapping? OR * 2) Address beyond the current mapping? */ - if ((Address < MemInfo->MappedPhysicalAddress) || - (((UINT64) Address + Length) > - ((UINT64) - MemInfo->MappedPhysicalAddress + MemInfo->MappedLength))) + if (!Mm || (Address < Mm->PhysicalAddress) || + ((UINT64) Address + Length > (UINT64) Mm->PhysicalAddress + Mm->Length)) { /* - * The request cannot be resolved by the current memory mapping; - * Delete the existing mapping and create a new one. + * The request cannot be resolved by the current memory mapping. + * + * Look for an existing saved mapping covering the address range + * at hand. If found, save it as the current one and carry out + * the access. */ - if (MemInfo->MappedLength) + for (Mm = MemInfo->FirstMm; Mm; Mm = Mm->NextMm) { - /* Valid mapping, delete it */ + if (Mm == MemInfo->CurMm) + { + continue; + } + + if (Address < Mm->PhysicalAddress) + { + continue; + } + + if ((UINT64) Address + Length > (UINT64) Mm->PhysicalAddress + Mm->Length) + { + continue; + } + + MemInfo->CurMm = Mm; + goto access; + } - AcpiOsUnmapMemory (MemInfo->MappedLogicalAddress, - MemInfo->MappedLength); + /* Create a new mappings list entry */ + + Mm = ACPI_ALLOCATE_ZEROED(sizeof(*Mm)); + if (!Mm) + { + ACPI_ERROR((AE_INFO, + "Unable to save memory mapping at 0x%8.8X%8.8X, size %u", + ACPI_FORMAT_UINT64(Address), Length)); + return_ACPI_STATUS(AE_NO_MEMORY); } /* @@ -189,28 +215,38 @@ AcpiExSystemMemorySpaceHandler ( /* Create a new mapping starting at the address given */ - MemInfo->MappedLogicalAddress = AcpiOsMapMemory (Address, MapLength); - if (!MemInfo->MappedLogicalAddress) + LogicalAddrPtr = AcpiOsMapMemory(Address, MapLength); + if (!LogicalAddrPtr) { ACPI_ERROR ((AE_INFO, "Could not map memory at 0x%8.8X%8.8X, size %u", ACPI_FORMAT_UINT64 (Address), (UINT32) MapLength)); - MemInfo->MappedLength = 0; + ACPI_FREE(Mm); return_ACPI_STATUS (AE_NO_MEMORY); } /* Save the physical address and mapping size */ - MemInfo->MappedPhysicalAddress = Address; - MemInfo->MappedLength = MapLength; + Mm->LogicalAddress = LogicalAddrPtr; + Mm->PhysicalAddress = Address; + Mm->Length = MapLength; + + /* + * Add the new entry to the mappigs list and save it as the + * current mapping. + */ + Mm->NextMm = MemInfo->FirstMm; + MemInfo->FirstMm = Mm; + MemInfo->CurMm = Mm; } +access: /* * Generate a logical pointer corresponding to the address we want to * access */ - LogicalAddrPtr = MemInfo->MappedLogicalAddress + - ((UINT64) Address - (UINT64) MemInfo->MappedPhysicalAddress); + LogicalAddrPtr = Mm->LogicalAddress + + ((UINT64) Address - (UINT64) Mm->PhysicalAddress); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "System-Memory (width %u) R/W %u Address=%8.8X%8.8X\n", diff --git a/drivers/bus/acpi/acpica/include/acconfig.h b/drivers/bus/acpi/acpica/include/acconfig.h index aa38a84eca5..c764770a479 100644 --- a/drivers/bus/acpi/acpica/include/acconfig.h +++ b/drivers/bus/acpi/acpica/include/acconfig.h @@ -158,7 +158,7 @@ * *****************************************************************************/ -/* Method info (in WALK_STATE), containing local variables and argumetns */ +/* Method info (in WALK_STATE), containing local variables and arguments */ #define ACPI_METHOD_NUM_LOCALS 8 #define ACPI_METHOD_MAX_LOCAL 7 diff --git a/drivers/bus/acpi/acpica/include/acdebug.h b/drivers/bus/acpi/acpica/include/acdebug.h index c32a94c89cf..1fa90043471 100644 --- a/drivers/bus/acpi/acpica/include/acdebug.h +++ b/drivers/bus/acpi/acpica/include/acdebug.h @@ -79,6 +79,7 @@ typedef struct acpi_db_execute_walk { UINT32 Count; UINT32 MaxCount; + char NameSeg[ACPI_NAMESEG_SIZE + 1]; } ACPI_DB_EXECUTE_WALK; @@ -87,6 +88,7 @@ typedef struct acpi_db_execute_walk #define EX_NO_SINGLE_STEP 1 #define EX_SINGLE_STEP 2 +#define EX_ALL 4 /* @@ -237,6 +239,10 @@ void AcpiDbEvaluatePredefinedNames ( void); +void +AcpiDbEvaluateAll ( + char *NameSeg); + /* * dbnames - namespace commands diff --git a/drivers/bus/acpi/acpica/include/acexcep.h b/drivers/bus/acpi/acpica/include/acexcep.h index 06b554b8a7f..194f3a82732 100644 --- a/drivers/bus/acpi/acpica/include/acexcep.h +++ b/drivers/bus/acpi/acpica/include/acexcep.h @@ -76,12 +76,12 @@ typedef struct acpi_exception_info { char *Name; -#ifdef ACPI_HELP_APP +#if defined (ACPI_HELP_APP) || defined (ACPI_ASL_COMPILER) char *Description; #endif } ACPI_EXCEPTION_INFO; -#ifdef ACPI_HELP_APP +#if defined (ACPI_HELP_APP) || defined (ACPI_ASL_COMPILER) #define EXCEP_TXT(Name,Description) {Name, Description} #else #define EXCEP_TXT(Name,Description) {Name} diff --git a/drivers/bus/acpi/acpica/include/acpixf.h b/drivers/bus/acpi/acpica/include/acpixf.h index c14c302d617..4003b45da0a 100644 --- a/drivers/bus/acpi/acpica/include/acpixf.h +++ b/drivers/bus/acpi/acpica/include/acpixf.h @@ -46,7 +46,7 @@ /* Current ACPICA subsystem version in YYYYMMDD format */ -#define ACPI_CA_VERSION 0x20200717 +#define ACPI_CA_VERSION 0x20200925 #include "acconfig.h" #include "actypes.h" diff --git a/drivers/bus/acpi/acpica/include/acpredef.h b/drivers/bus/acpi/acpica/include/acpredef.h index 2b6173d6c9f..188070bcde0 100644 --- a/drivers/bus/acpi/acpica/include/acpredef.h +++ b/drivers/bus/acpi/acpica/include/acpredef.h @@ -138,7 +138,7 @@ enum AcpiReturnPackageTypes /* Support macros for users of the predefined info table */ -#define METHOD_PREDEF_ARGS_MAX 4 +#define METHOD_PREDEF_ARGS_MAX 5 #define METHOD_ARG_BIT_WIDTH 3 #define METHOD_ARG_MASK 0x0007 #define ARG_COUNT_IS_MINIMUM 0x8000 @@ -154,6 +154,7 @@ enum AcpiReturnPackageTypes #define METHOD_2ARGS(a1,a2) (2 | (a1 << 3) | (a2 << 6)) #define METHOD_3ARGS(a1,a2,a3) (3 | (a1 << 3) | (a2 << 6) | (a3 << 9)) #define METHOD_4ARGS(a1,a2,a3,a4) (4 | (a1 << 3) | (a2 << 6) | (a3 << 9) | (a4 << 12)) +#define METHOD_5ARGS(a1,a2,a3,a4,a5) (5 | (a1 << 3) | (a2 << 6) | (a3 << 9) | (a4 << 12) | (a5 << 15)) #define METHOD_RETURNS(type) (type) #define METHOD_NO_RETURN_VALUE 0 @@ -915,9 +916,29 @@ const ACPI_PREDEFINED_INFO AcpiGbl_PredefinedMethods[] = {{"_S4W", METHOD_0ARGS, METHOD_RETURNS (ACPI_RTYPE_INTEGER)}}, + {{"_SBA", METHOD_0ARGS, + METHOD_RETURNS (ACPI_RTYPE_PACKAGE)}}, /* Fixed-length (4 Int) */ + PACKAGE_INFO (ACPI_PTYPE1_FIXED, ACPI_RTYPE_INTEGER, 4,0,0,0), + + {{"_SBI", METHOD_0ARGS, + METHOD_RETURNS (ACPI_RTYPE_PACKAGE)}}, /* Fixed-length (1 Int, 1 Buf) */ + PACKAGE_INFO (ACPI_PTYPE1_FIXED, ACPI_RTYPE_INTEGER, 1, ACPI_RTYPE_BUFFER,1,0), + + {{"_SBR", METHOD_3ARGS (ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER), + METHOD_RETURNS (ACPI_RTYPE_PACKAGE)}}, /* Fixed-length (2 Int) */ + PACKAGE_INFO (ACPI_PTYPE1_FIXED, ACPI_RTYPE_INTEGER, 2, ACPI_RTYPE_BUFFER | ACPI_RTYPE_INTEGER, 1,0), + {{"_SBS", METHOD_0ARGS, METHOD_RETURNS (ACPI_RTYPE_INTEGER)}}, + {{"_SBT", METHOD_4ARGS (ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER, ACPI_TYPE_ANY), + METHOD_RETURNS (ACPI_RTYPE_PACKAGE)}}, /* Fixed-length (2 Int, 1 Buf | Int) */ + PACKAGE_INFO (ACPI_PTYPE1_FIXED, ACPI_RTYPE_INTEGER, 2, ACPI_RTYPE_BUFFER | ACPI_RTYPE_INTEGER, 1,0), + + {{"_SBW", METHOD_5ARGS (ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER, ACPI_TYPE_INTEGER, ACPI_TYPE_ANY), + METHOD_RETURNS (ACPI_RTYPE_PACKAGE)}}, + PACKAGE_INFO (ACPI_PTYPE1_FIXED, ACPI_RTYPE_BUFFER | ACPI_RTYPE_INTEGER, 1, 0,0,0), + {{"_SCP", METHOD_1ARGS (ACPI_TYPE_INTEGER) | ARG_COUNT_IS_MINIMUM, METHOD_NO_RETURN_VALUE}}, /* Acpi 1.0 allowed 1 integer arg. Acpi 3.0 expanded to 3 args. Allow both. */ diff --git a/drivers/bus/acpi/acpica/include/actbl1.h b/drivers/bus/acpi/acpica/include/actbl1.h index 4c17bdbfd7f..b25b690a4c0 100644 --- a/drivers/bus/acpi/acpica/include/actbl1.h +++ b/drivers/bus/acpi/acpica/include/actbl1.h @@ -1659,8 +1659,7 @@ typedef struct acpi_hest_ia_deferred_check /******************************************************************************* * - * HMAT - Heterogeneous Memory Attributes Table (ACPI 6.2) - * Version 1 + * HMAT - Heterogeneous Memory Attributes Table (ACPI 6.3) * ******************************************************************************/ @@ -1702,7 +1701,7 @@ typedef struct acpi_hmat_proximity_domain ACPI_HMAT_STRUCTURE Header; UINT16 Flags; UINT16 Reserved1; - UINT32 ProcessorPD; /* Processor proximity domain */ + UINT32 InitiatorPD; /* Attached Initiator proximity domain */ UINT32 MemoryPD; /* Memory proximity domain */ UINT32 Reserved2; UINT64 Reserved3; @@ -1712,9 +1711,7 @@ typedef struct acpi_hmat_proximity_domain /* Masks for Flags field above */ -#define ACPI_HMAT_PROCESSOR_PD_VALID (1) /* 1: ProcessorPD field is valid */ -#define ACPI_HMAT_MEMORY_PD_VALID (1<<1) /* 1: MemoryPD field is valid */ -#define ACPI_HMAT_RESERVATION_HINT (1<<2) /* 1: Reservation hint */ +#define ACPI_HMAT_INITIATOR_PD_VALID (1) /* 1: InitiatorPD field is valid */ /* 1: System locality latency and bandwidth information */ @@ -1739,10 +1736,9 @@ typedef struct acpi_hmat_locality /* Values for Memory Hierarchy flag */ #define ACPI_HMAT_MEMORY 0 -#define ACPI_HMAT_LAST_LEVEL_CACHE 1 -#define ACPI_HMAT_1ST_LEVEL_CACHE 2 -#define ACPI_HMAT_2ND_LEVEL_CACHE 3 -#define ACPI_HMAT_3RD_LEVEL_CACHE 4 +#define ACPI_HMAT_1ST_LEVEL_CACHE 1 +#define ACPI_HMAT_2ND_LEVEL_CACHE 2 +#define ACPI_HMAT_3RD_LEVEL_CACHE 3 /* Values for DataType field above */ diff --git a/drivers/bus/acpi/acpica/include/actypes.h b/drivers/bus/acpi/acpica/include/actypes.h index 86064afe79d..46d934635db 100644 --- a/drivers/bus/acpi/acpica/include/actypes.h +++ b/drivers/bus/acpi/acpica/include/actypes.h @@ -869,7 +869,7 @@ typedef UINT8 ACPI_ADR_SPACE_TYPE; * * Note: A Data Table region is a special type of operation region * that has its own AML opcode. However, internally, the AML - * interpreter simply creates an operation region with an an address + * interpreter simply creates an operation region with an address * space type of ACPI_ADR_SPACE_DATA_TABLE. */ #define ACPI_ADR_SPACE_DATA_TABLE (ACPI_ADR_SPACE_TYPE) 0x7E /* Internal to ACPICA only */ @@ -1332,13 +1332,21 @@ typedef struct acpi_pci_id } ACPI_PCI_ID; +typedef struct acpi_mem_mapping +{ + ACPI_PHYSICAL_ADDRESS PhysicalAddress; + UINT8 *LogicalAddress; + ACPI_SIZE Length; + struct acpi_mem_mapping *NextMm; + +} ACPI_MEM_MAPPING; + typedef struct acpi_mem_space_context { UINT32 Length; ACPI_PHYSICAL_ADDRESS Address; - ACPI_PHYSICAL_ADDRESS MappedPhysicalAddress; - UINT8 *MappedLogicalAddress; - ACPI_SIZE MappedLength; + ACPI_MEM_MAPPING *CurMm; + ACPI_MEM_MAPPING *FirstMm; } ACPI_MEM_SPACE_CONTEXT; diff --git a/drivers/bus/acpi/acpica/include/acuuid.h b/drivers/bus/acpi/acpica/include/acuuid.h index 39e3d2d9231..f0929081877 100644 --- a/drivers/bus/acpi/acpica/include/acuuid.h +++ b/drivers/bus/acpi/acpica/include/acuuid.h @@ -61,6 +61,10 @@ #define UUID_PCI_HOST_BRIDGE "33db4d5b-1ff7-401c-9657-7441c03dd766" #define UUID_I2C_DEVICE "3cdff6f7-4267-4555-ad05-b30a3d8938de" #define UUID_POWER_BUTTON "dfbcf3c5-e7a5-44e6-9c1f-29c76f6e059c" +#define UUID_MEMORY_DEVICE "03b19910-f473-11dd-87af-0800200c9a66" +#define UUID_GENERIC_BUTTONS_DEVICE "fa6bd625-9ce8-470d-a2c7-b3ca36c4282e" +#define UUID_NVDIMM_ROOT_DEVICE "2f10e7a4-9e91-11e4-89d3-123b93f75cba" +#define UUID_CONTROL_METHOD_BATTERY "f18fc78b-0f15-4978-b793-53f833a1d35b" /* Interfaces */ @@ -90,6 +94,8 @@ #define UUID_BATTERY_THERMAL_LIMIT "4c2067e3-887d-475c-9720-4af1d3ed602e" #define UUID_THERMAL_EXTENSIONS "14d399cd-7a27-4b18-8fb4-7cb7b9f4e500" #define UUID_DEVICE_PROPERTIES "daffd814-6eba-4d8c-8a91-bc9bbf4aa301" - +#define UUID_DEVICE_GRAPHS "ab02a46b-74c7-45a2-bd68-f7d344ef2153" +#define UUID_HIERARCHICAL_DATA_EXTENSION "dbb8e3e6-5886-4ba6-8795-1319f52a966b" +#define UUID_CORESIGHT_GRAPH "3ecbc8b6-1d0e-4fb3-8107-e627f805c6cd" #endif /* __ACUUID_H__ */ diff --git a/drivers/bus/acpi/acpica/include/platform/aclinux.h b/drivers/bus/acpi/acpica/include/platform/aclinux.h index 2d7bd59594a..011347c80e5 100644 --- a/drivers/bus/acpi/acpica/include/platform/aclinux.h +++ b/drivers/bus/acpi/acpica/include/platform/aclinux.h @@ -216,7 +216,8 @@ #if defined(__ia64__) || (defined(__x86_64__) && !defined(__ILP32__)) ||\ defined(__aarch64__) || defined(__PPC64__) ||\ - defined(__s390x__) + defined(__s390x__) ||\ + (defined(__riscv) && (defined(__LP64__) || defined(_LP64))) #define ACPI_MACHINE_WIDTH 64 #define COMPILER_DEPENDENT_INT64 long #define COMPILER_DEPENDENT_UINT64 unsigned long diff --git a/drivers/bus/acpi/acpica/namespace/nsalloc.c b/drivers/bus/acpi/acpica/namespace/nsalloc.c index f9103e651f0..8d94a7f0694 100644 --- a/drivers/bus/acpi/acpica/namespace/nsalloc.c +++ b/drivers/bus/acpi/acpica/namespace/nsalloc.c @@ -373,7 +373,7 @@ AcpiNsDeleteChildren ( NodeToDelete = NextNode; NextNode = NextNode->Peer; AcpiNsDeleteNode (NodeToDelete); - }; + } /* Clear the parent's child pointer */ diff --git a/drivers/bus/acpi/acpica/namespace/nsarguments.c b/drivers/bus/acpi/acpica/namespace/nsarguments.c index f9f2dbcf831..892e5f31d30 100644 --- a/drivers/bus/acpi/acpica/namespace/nsarguments.c +++ b/drivers/bus/acpi/acpica/namespace/nsarguments.c @@ -97,7 +97,9 @@ AcpiNsCheckArgumentTypes ( ArgType = METHOD_GET_NEXT_TYPE (ArgTypeList); UserArgType = Info->Parameters[i]->Common.Type; - if (UserArgType != ArgType) + /* No typechecking for ACPI_TYPE_ANY */ + + if ((UserArgType != ArgType) && (ArgType != ACPI_TYPE_ANY)) { ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, ACPI_WARN_ALWAYS, "Argument #%u type mismatch - " diff --git a/drivers/bus/acpi/acpica/namespace/nsxfobj.c b/drivers/bus/acpi/acpica/namespace/nsxfobj.c index a1d9596abb3..5fe4f9bd2b6 100644 --- a/drivers/bus/acpi/acpica/namespace/nsxfobj.c +++ b/drivers/bus/acpi/acpica/namespace/nsxfobj.c @@ -61,7 +61,8 @@ * * RETURN: Status * - * DESCRIPTION: This routine returns the type associatd with a particular handle + * DESCRIPTION: This routine returns the type associated with a particular + * handle * ******************************************************************************/ diff --git a/drivers/bus/acpi/acpica/parser/psparse.c b/drivers/bus/acpi/acpica/parser/psparse.c index 0baad4d556c..97c7be4d49f 100644 --- a/drivers/bus/acpi/acpica/parser/psparse.c +++ b/drivers/bus/acpi/acpica/parser/psparse.c @@ -554,8 +554,8 @@ AcpiPsParseAml ( } /* - * If the transfer to the new method method call worked - *, a new walk state was created -- get it + * If the transfer to the new method method call worked, + * a new walk state was created -- get it */ WalkState = AcpiDsGetCurrentWalkState (Thread); continue; diff --git a/drivers/bus/acpi/acpica/utilities/utpredef.c b/drivers/bus/acpi/acpica/utilities/utpredef.c index 016cb0516b3..a5e57f01bc5 100644 --- a/drivers/bus/acpi/acpica/utilities/utpredef.c +++ b/drivers/bus/acpi/acpica/utilities/utpredef.c @@ -209,7 +209,7 @@ AcpiUtGetArgumentTypes ( static const char *UtExternalTypeNames[] = /* Indexed by ACPI_TYPE_* */ { - ", UNSUPPORTED-TYPE", + ", Type_ANY", ", Integer", ", String", ", Buffer", @@ -391,7 +391,7 @@ AcpiUtGetArgumentTypes ( { ThisArgumentType = METHOD_GET_NEXT_TYPE (ArgumentTypes); - if (!ThisArgumentType || (ThisArgumentType > METHOD_MAX_ARG_TYPE)) + if (ThisArgumentType > METHOD_MAX_ARG_TYPE) { printf ("**** Invalid argument type (%u) " "in predefined info structure\n", ThisArgumentType); diff --git a/drivers/bus/acpi/acpica/utilities/utstrsuppt.c b/drivers/bus/acpi/acpica/utilities/utstrsuppt.c index 878e6e91640..1a660c743b8 100644 --- a/drivers/bus/acpi/acpica/utilities/utstrsuppt.c +++ b/drivers/bus/acpi/acpica/utilities/utstrsuppt.c @@ -99,10 +99,16 @@ AcpiUtConvertOctalString ( while (*String) { - /* Character must be ASCII 0-7, otherwise terminate with no error */ - + /* + * Character must be ASCII 0-7, otherwise: + * 1) Runtime: terminate with no error, per the ACPI spec + * 2) Compiler: return an error + */ if (!(ACPI_IS_OCTAL_DIGIT (*String))) { +#ifdef ACPI_ASL_COMPILER + Status = AE_BAD_OCTAL_CONSTANT; +#endif break; } @@ -155,10 +161,16 @@ AcpiUtConvertDecimalString ( while (*String) { - /* Character must be ASCII 0-9, otherwise terminate with no error */ - + /* + * Character must be ASCII 0-9, otherwise: + * 1) Runtime: terminate with no error, per the ACPI spec + * 2) Compiler: return an error + */ if (!isdigit (*String)) { +#ifdef ACPI_ASL_COMPILER + Status = AE_BAD_DECIMAL_CONSTANT; +#endif break; } @@ -211,10 +223,16 @@ AcpiUtConvertHexString ( while (*String) { - /* Must be ASCII A-F, a-f, or 0-9, otherwise terminate with no error */ - + /* + * Character must be ASCII A-F, a-f, or 0-9, otherwise: + * 1) Runtime: terminate with no error, per the ACPI spec + * 2) Compiler: return an error + */ if (!isxdigit (*String)) { +#ifdef ACPI_ASL_COMPILER + Status = AE_BAD_HEX_CONSTANT; +#endif break; } diff --git a/media/doc/3rd Party Files.txt b/media/doc/3rd Party Files.txt index 7280aed5f64..5b2ff47e5b0 100644 --- a/media/doc/3rd Party Files.txt +++ b/media/doc/3rd Party Files.txt @@ -92,7 +92,7 @@ Used Version: 1.6.37 Website: http://libpng.sourceforge.net/ Title: ACPICA -Used Version: 20200717 +Used Version: 20200925 Website: https://acpica.org/ Title: Schily Tools, mkisofs

3 years, 11 months

[reactos] 01/02: [ACPICA] Update to version 20200717. CORE-17170

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8605f660f479a6c391066… commit 8605f660f479a6c391066817ff4308bb18ef179f Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Sun Sep 6 12:29:37 2020 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Fri Oct 16 01:21:47 2020 +0200 [ACPICA] Update to version 20200717. CORE-17170 --- drivers/bus/acpi/acpica/executer/exprep.c | 4 ---- drivers/bus/acpi/acpica/include/acpixf.h | 2 +- drivers/bus/acpi/acpica/include/actypes.h | 2 +- drivers/bus/acpi/acpica/include/platform/acmsvc.h | 3 +++ drivers/bus/acpi/acpica/utilities/utdelete.c | 6 +----- drivers/bus/acpi/acpica/utilities/utids.c | 2 +- media/doc/3rd Party Files.txt | 2 +- 7 files changed, 8 insertions(+), 13 deletions(-) diff --git a/drivers/bus/acpi/acpica/executer/exprep.c b/drivers/bus/acpi/acpica/executer/exprep.c index 720bd3488c8..b74f430bbd8 100644 --- a/drivers/bus/acpi/acpica/executer/exprep.c +++ b/drivers/bus/acpi/acpica/executer/exprep.c @@ -543,10 +543,6 @@ AcpiExPrepFieldValue ( } } - /* An additional reference for the container */ - - AcpiUtAddReference (ObjDesc->Field.RegionObj); - ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n", ObjDesc->Field.StartFieldBitOffset, diff --git a/drivers/bus/acpi/acpica/include/acpixf.h b/drivers/bus/acpi/acpica/include/acpixf.h index 1fa5770c7b4..c14c302d617 100644 --- a/drivers/bus/acpi/acpica/include/acpixf.h +++ b/drivers/bus/acpi/acpica/include/acpixf.h @@ -46,7 +46,7 @@ /* Current ACPICA subsystem version in YYYYMMDD format */ -#define ACPI_CA_VERSION 0x20200528 +#define ACPI_CA_VERSION 0x20200717 #include "acconfig.h" #include "actypes.h" diff --git a/drivers/bus/acpi/acpica/include/actypes.h b/drivers/bus/acpi/acpica/include/actypes.h index cb8d7cd4d2d..86064afe79d 100644 --- a/drivers/bus/acpi/acpica/include/actypes.h +++ b/drivers/bus/acpi/acpica/include/actypes.h @@ -1271,7 +1271,7 @@ typedef struct acpi_pnp_device_id_list { UINT32 Count; /* Number of IDs in Ids array */ UINT32 ListSize; /* Size of list, including ID strings */ - ACPI_PNP_DEVICE_ID Ids[1]; /* ID array */ + ACPI_PNP_DEVICE_ID Ids[]; /* ID array */ } ACPI_PNP_DEVICE_ID_LIST; diff --git a/drivers/bus/acpi/acpica/include/platform/acmsvc.h b/drivers/bus/acpi/acpica/include/platform/acmsvc.h index 48672f84ced..aa3492e087d 100644 --- a/drivers/bus/acpi/acpica/include/platform/acmsvc.h +++ b/drivers/bus/acpi/acpica/include/platform/acmsvc.h @@ -230,6 +230,9 @@ /* warn C4131: uses old-style declarator (iASL compiler only) */ #pragma warning(disable:4459) +/* warn c4200: allow flexible arrays (of zero length) */ +#pragma warning(disable:4200) + #if _MSC_VER > 1200 /* Versions above VC++ 6 */ #pragma warning( disable : 4295 ) /* needed for acpredef.h array */ #endif diff --git a/drivers/bus/acpi/acpica/utilities/utdelete.c b/drivers/bus/acpi/acpica/utilities/utdelete.c index c339dba4557..a816dc7ea42 100644 --- a/drivers/bus/acpi/acpica/utilities/utdelete.c +++ b/drivers/bus/acpi/acpica/utilities/utdelete.c @@ -641,11 +641,6 @@ AcpiUtUpdateObjectReference ( NextObject = Object->BufferField.BufferObj; break; - case ACPI_TYPE_LOCAL_REGION_FIELD: - - NextObject = Object->Field.RegionObj; - break; - case ACPI_TYPE_LOCAL_BANK_FIELD: NextObject = Object->BankField.BankObj; @@ -681,6 +676,7 @@ AcpiUtUpdateObjectReference ( } break; + case ACPI_TYPE_LOCAL_REGION_FIELD: case ACPI_TYPE_REGION: default: diff --git a/drivers/bus/acpi/acpica/utilities/utids.c b/drivers/bus/acpi/acpica/utilities/utids.c index 238d7eaf3bc..c857f040b74 100644 --- a/drivers/bus/acpi/acpica/utilities/utids.c +++ b/drivers/bus/acpi/acpica/utilities/utids.c @@ -327,7 +327,7 @@ AcpiUtExecute_CID ( * 3) Size of the actual CID strings */ CidListSize = sizeof (ACPI_PNP_DEVICE_ID_LIST) + - ((Count - 1) * sizeof (ACPI_PNP_DEVICE_ID)) + + (Count * sizeof (ACPI_PNP_DEVICE_ID)) + StringAreaSize; CidList = ACPI_ALLOCATE_ZEROED (CidListSize); diff --git a/media/doc/3rd Party Files.txt b/media/doc/3rd Party Files.txt index dbca0168fb5..7280aed5f64 100644 --- a/media/doc/3rd Party Files.txt +++ b/media/doc/3rd Party Files.txt @@ -92,7 +92,7 @@ Used Version: 1.6.37 Website: http://libpng.sourceforge.net/ Title: ACPICA -Used Version: 20200528 +Used Version: 20200717 Website: https://acpica.org/ Title: Schily Tools, mkisofs

3 years, 11 months

[reactos] 01/01: [RAPPS] Update Hebrew (he-IL) translation (#3297)

by Omer I.S

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c758d15d0aca62e20456f… commit c758d15d0aca62e20456f8066993eeff62dbb342 Author: Omer I.S <66558205+omeritzics(a)users.noreply.github.com> AuthorDate: Thu Oct 15 17:12:50 2020 +0300 Commit: GitHub <noreply(a)github.com> CommitDate: Thu Oct 15 17:12:50 2020 +0300 [RAPPS] Update Hebrew (he-IL) translation (#3297) --- base/applications/rapps/lang/he-IL.rc | 40 +++++++++++++++++------------------ 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/base/applications/rapps/lang/he-IL.rc b/base/applications/rapps/lang/he-IL.rc index b8054551e94..e1a059117d1 100644 --- a/base/applications/rapps/lang/he-IL.rc +++ b/base/applications/rapps/lang/he-IL.rc @@ -1,4 +1,4 @@ -/* Translated by Baruch Rutman, additional translations by Shy Zedaka */ +/* Translated by Baruch Rutman, additional translations by Shy Zedaka and Omer I.S. */ LANGUAGE LANG_HEBREW, SUBLANG_DEFAULT @@ -26,7 +26,7 @@ BEGIN POPUP "עזרה" BEGIN MENUITEM "עזרה\tF1", ID_HELP, GRAYED - MENUITEM "אודות", ID_ABOUT + MENUITEM "על אודות", ID_ABOUT END END @@ -147,7 +147,7 @@ BEGIN IDS_INFO_UNINSTALLSTR "\nמחרוזת הסרה: " IDS_INFO_MODIFYPATH "\nנתיב שינוי: " IDS_INFO_INSTALLDATE "\nתאריך התקנה: " - IDS_AINFO_PACKAGE_NAME "\nPackage Name: " + IDS_AINFO_PACKAGE_NAME "\nשם החבילה: " END STRINGTABLE @@ -186,13 +186,13 @@ STRINGTABLE BEGIN IDS_APPTITLE "מנהל היישומים של ReactOS" IDS_APP_AUTHORS "Copyright 2009 Dmitry Chapyshev" - IDS_SEARCH_TEXT "חפש…" + IDS_SEARCH_TEXT "חיפוש…" IDS_INSTALL "התקנה" IDS_UNINSTALL "הסרה" IDS_MODIFY "שינוי" IDS_APPS_COUNT "ספירת יישומים: %d; Selected: %d" IDS_WELCOME_TITLE "ברוכים הבאים למנהל היישומים של ReactOS!\n\n" - IDS_WELCOME_TEXT "Choose a category on the left, then choose an application to install or uninstall.\nReactOS Web Site: " + IDS_WELCOME_TEXT "בחר קטגוריה בצד שמאל, לאחר מכן בחר יישום להתקנה או להסרה.\nהאתר של ReactOS: " IDS_WELCOME_URL "https://reactos.org/" IDS_INSTALLED "מותקן" IDS_AVAILABLEFORINST "זמין להתקנה" @@ -212,8 +212,8 @@ BEGIN IDS_INTEG_CHECK_FAIL "The package did not pass the integrity check, it may have been corrupted or tampered with during downloading. Running the software is not recommended." IDS_INTERRUPTED_DOWNLOAD "The download was interrupted. Check connection to Internet." IDS_UNABLE_TO_WRITE "Unable to write to disk. Disk may be at capacity." - IDS_SELECT_ALL "Select/Deselect All" - IDS_INSTALL_SELECTED "Install Selected" + IDS_SELECT_ALL "בחר הכול/בטל בחירת הכול" + IDS_INSTALL_SELECTED "התקן נבחרים" IDS_SELECTEDFORINST "Selected for installation" IDS_MISMATCH_CERT_INFO "The certificate used is unknown:\nSubject: %s\nIssuer: %s\nDo you want to continue anyway?" IDS_UNABLE_PATH "Incorrect path format." @@ -237,35 +237,35 @@ END STRINGTABLE BEGIN IDS_LICENSE_OPENSOURCE "קוד פתוח" - IDS_LICENSE_FREEWARE "Freeware" - IDS_LICENSE_TRIAL "Trial/Demo" + IDS_LICENSE_FREEWARE "תוכנה חינמית" + IDS_LICENSE_TRIAL "גרסת ניסיון/דמו" END STRINGTABLE BEGIN - IDS_LANGUAGE_AVAILABLE_TRANSLATION "Supports your language" - IDS_LANGUAGE_NO_TRANSLATION "Supports other languages" - IDS_LANGUAGE_ENGLISH_TRANSLATION "Supports English" - IDS_LANGUAGE_SINGLE "Single language" - IDS_LANGUAGE_MORE_PLACEHOLDER " (+%d more)" - IDS_LANGUAGE_AVAILABLE_PLACEHOLDER " (+%d available)" + IDS_LANGUAGE_AVAILABLE_TRANSLATION "עם תמיכה בשפה שלך" + IDS_LANGUAGE_NO_TRANSLATION "עם תמיכה בשפות אחרות" + IDS_LANGUAGE_ENGLISH_TRANSLATION "עם תמיכה באנגלית" + IDS_LANGUAGE_SINGLE "שפה יחידה" + IDS_LANGUAGE_MORE_PLACEHOLDER " (עוד +%d)" + IDS_LANGUAGE_AVAILABLE_PLACEHOLDER " (+%d זמינה)" END STRINGTABLE BEGIN IDS_DL_DIALOG_DB_DISP "מסד נתונים של היישומים" IDS_DL_DIALOG_DB_DOWNLOAD_DISP "מעדכן את מסד הנתונים..." - IDS_DL_DIALOG_DB_UNOFFICIAL_DOWNLOAD_DISP "Updating Database… (Unofficial source)" + IDS_DL_DIALOG_DB_UNOFFICIAL_DOWNLOAD_DISP "מעדכן את מסד הנתונים… (מקור לא רשמי)" END STRINGTABLE BEGIN - IDS_CMD_USAGE "Usage: " + IDS_CMD_USAGE "שימוש: " IDS_CMD_NEED_PACKAGE_NAME "Error: option %1 expects one or more package name.\n" IDS_CMD_NEED_FILE_NAME "Error: option %1 expects a file name.\n" IDS_CMD_NEED_PARAMS "Error: option %1 expects one or more parameters.\n" IDS_CMD_INVALID_OPTION "Error: Unknown or invalid command line option specified.\n" IDS_CMD_FIND_RESULT_FOR "Find result for %1:\n" - IDS_CMD_PACKAGE_NOT_FOUND "Failed to find package %1.\n" - IDS_CMD_PACKAGE_INFO "Information about package %1:\n" -END + IDS_CMD_PACKAGE_NOT_FOUND "החבילה %1 לא נמצאה.\n" + IDS_CMD_PACKAGE_INFO "מידע על החבילה %1:\n" +END

3 years, 11 months

[reactos] 02/02: [NTOS:MM] Acquire PsLoadedModuleResource when walking PsLoadedModuleList. CORE-16449

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ba9bf73d4803eeac62adb… commit ba9bf73d4803eeac62adb2d13e92e0eb870bcf17 Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Thu Oct 15 13:42:13 2020 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Thu Oct 15 14:49:20 2020 +0200 [NTOS:MM] Acquire PsLoadedModuleResource when walking PsLoadedModuleList. CORE-16449 --- ntoskrnl/mm/ARM3/sysldr.c | 6 ++++-- ntoskrnl/mm/mminit.c | 4 +++- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/ntoskrnl/mm/ARM3/sysldr.c b/ntoskrnl/mm/ARM3/sysldr.c index 92a31896205..9d51898ec64 100644 --- a/ntoskrnl/mm/ARM3/sysldr.c +++ b/ntoskrnl/mm/ARM3/sysldr.c @@ -1466,13 +1466,14 @@ MiFindInitializationCode(OUT PVOID *StartVa, /* Assume failure */ *StartVa = NULL; - /* Acquire the necessary lock while we loop the list */ + /* Acquire the necessary locks while we loop the list */ KeEnterCriticalRegion(); KeWaitForSingleObject(&MmSystemLoadLock, WrVirtualMemory, KernelMode, FALSE, NULL); + ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE); /* Loop all loaded modules */ NextEntry = PsLoadedModuleList.Flink; @@ -1620,7 +1621,8 @@ MiFindInitializationCode(OUT PVOID *StartVa, NextEntry = NextEntry->Flink; } - /* Release the lock and return */ + /* Release the locks and return */ + ExReleaseResourceLite(&PsLoadedModuleResource); KeReleaseMutant(&MmSystemLoadLock, 1, FALSE, FALSE); KeLeaveCriticalRegion(); } diff --git a/ntoskrnl/mm/mminit.c b/ntoskrnl/mm/mminit.c index 7c0bbd4efd4..4005b34e0f9 100644 --- a/ntoskrnl/mm/mminit.c +++ b/ntoskrnl/mm/mminit.c @@ -273,7 +273,8 @@ MmInitSystem(IN ULONG Phase, /* Initialize the balance set manager */ MmInitBsmThread(); - /* Loop the boot loaded images */ + /* Loop the boot loaded images (under lock) */ + ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE); for (ListEntry = PsLoadedModuleList.Flink; ListEntry != &PsLoadedModuleList; ListEntry = ListEntry->Flink) @@ -284,6 +285,7 @@ MmInitSystem(IN ULONG Phase, /* Set up the image protection */ MiWriteProtectSystemImage(DataTableEntry->DllBase); } + ExReleaseResourceLite(&PsLoadedModuleResource); return TRUE; }

3 years, 11 months

[reactos] 01/02: [NTOS:MM] Acquire MmSystemLoadLock in MiFindInitializationCode. CORE-16449

by Thomas Faber

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a30edc324e5a3c265d01d… commit a30edc324e5a3c265d01d345bf33786faa6ae727 Author: Thomas Faber <thomas.faber(a)reactos.org> AuthorDate: Thu Oct 15 13:40:42 2020 +0200 Commit: Thomas Faber <thomas.faber(a)reactos.org> CommitDate: Thu Oct 15 14:49:11 2020 +0200 [NTOS:MM] Acquire MmSystemLoadLock in MiFindInitializationCode. CORE-16449 We might otherwise free the INIT section for an image that's in the process of being loaded by Mm. --- ntoskrnl/mm/ARM3/sysldr.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/ntoskrnl/mm/ARM3/sysldr.c b/ntoskrnl/mm/ARM3/sysldr.c index c66f06c4fe8..92a31896205 100644 --- a/ntoskrnl/mm/ARM3/sysldr.c +++ b/ntoskrnl/mm/ARM3/sysldr.c @@ -1466,8 +1466,13 @@ MiFindInitializationCode(OUT PVOID *StartVa, /* Assume failure */ *StartVa = NULL; - /* Enter a critical region while we loop the list */ + /* Acquire the necessary lock while we loop the list */ KeEnterCriticalRegion(); + KeWaitForSingleObject(&MmSystemLoadLock, + WrVirtualMemory, + KernelMode, + FALSE, + NULL); /* Loop all loaded modules */ NextEntry = PsLoadedModuleList.Flink; @@ -1615,7 +1620,8 @@ MiFindInitializationCode(OUT PVOID *StartVa, NextEntry = NextEntry->Flink; } - /* Leave the critical region and return */ + /* Release the lock and return */ + KeReleaseMutant(&MmSystemLoadLock, 1, FALSE, FALSE); KeLeaveCriticalRegion(); }

3 years, 11 months

[reactos] 01/01: [OLE32_WINETEST] Fix build with lower optimization level

by Jérôme Gardou

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a385a78cf0e0385071d67… commit a385a78cf0e0385071d67d9d8919250768538b80 Author: Jérôme Gardou <jerome.gardou(a)reactos.org> AuthorDate: Thu Oct 15 11:53:11 2020 +0200 Commit: Jérôme Gardou <jerome.gardou(a)reactos.org> CommitDate: Thu Oct 15 11:53:11 2020 +0200 [OLE32_WINETEST] Fix build with lower optimization level --- modules/rostests/winetests/ole32/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/modules/rostests/winetests/ole32/CMakeLists.txt b/modules/rostests/winetests/ole32/CMakeLists.txt index 0b54eae962e..dd2aa62975d 100644 --- a/modules/rostests/winetests/ole32/CMakeLists.txt +++ b/modules/rostests/winetests/ole32/CMakeLists.txt @@ -30,6 +30,8 @@ add_importlibs(ole32_winetest oleaut32 ole32 user32 gdi32 advapi32 msvcrt kernel if(MSVC) add_importlibs(ole32_winetest ntdll) +else() + target_compile_options(ole32_winetest PRIVATE -Wno-format-overflow) endif() add_pch(ole32_winetest precomp.h "${PCH_SKIP_SOURCE}")

3 years, 11 months

← Newer
1
...
7
8
9
10
11
12
13
...
16
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs October 2020