--*/
-#define CLASS_INIT_GUID 1
#include "classp.h"
-#include "debug.h"
+
+#include <stddef.h>
+
+#include <initguid.h>
+#include <mountdev.h>
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
return STATUS_SUCCESS;
}
-\f
-
-
/*++////////////////////////////////////////////////////////////////////////////
ClassInitialize()
--*/
ULONG
+NTAPI
ClassInitialize(
IN PVOID Argument1,
IN PVOID Argument2,
status = IoAllocateDriverObjectExtension(DriverObject,
CLASS_DRIVER_EXTENSION_KEY,
sizeof(CLASS_DRIVER_EXTENSION),
- &driverExtension);
+ (PVOID *)&driverExtension);
if(NT_SUCCESS(status)) {
status = STATUS_SUCCESS;
return status;
} // end ClassInitialize()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassInitializeEx()
--*/
ULONG
+NTAPI
ClassInitializeEx(
IN PDRIVER_OBJECT DriverObject,
IN LPGUID Guid,
return(status);
} // end ClassInitializeEx()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassUnload()
--*/
VOID
+NTAPI
ClassUnload(
IN PDRIVER_OBJECT DriverObject
)
{
PCLASS_DRIVER_EXTENSION driverExtension;
- NTSTATUS status;
+ //NTSTATUS status;
PAGED_CODE();
return;
} // end ClassUnload()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassAddDevice()
--*/
NTSTATUS
+NTAPI
ClassAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject
PhysicalDeviceObject);
return status;
} // end ClassAddDevice()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassDispatchPnp()
--*/
NTSTATUS
+NTAPI
ClassDispatchPnp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
PCLASS_DEV_INFO devInfo;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
- PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
NTSTATUS status = Irp->IoStatus.Status;
BOOLEAN completeRequest = TRUE;
BOOLEAN lockReleased = FALSE;
- ULONG isRemoved;
-
PAGED_CODE();
//
devInfo = &(initData->PdoData);
}
- isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
+ ClassAcquireRemoveLock(DeviceObject, Irp);
DebugPrint((2, "ClassDispatchPnp (%p,%p): minor code %#x for %s %p\n",
DeviceObject, Irp,
case IRP_MN_REMOVE_DEVICE:
case IRP_MN_SURPRISE_REMOVAL: {
- PDEVICE_OBJECT lowerDeviceObject = commonExtension->LowerDeviceObject;
UCHAR removeType = irpStack->MinorFunction;
if (commonExtension->PagingPathCount != 0) {
if (NT_SUCCESS(status)) {
IoAdjustPagingPathCount(
- &commonExtension->PagingPathCount,
+ (PLONG)&commonExtension->PagingPathCount,
irpStack->Parameters.UsageNotification.InPath);
if (irpStack->Parameters.UsageNotification.InPath) {
case DeviceUsageTypeHibernation: {
IoAdjustPagingPathCount(
- &commonExtension->HibernationPathCount,
+ (PLONG)&commonExtension->HibernationPathCount,
irpStack->Parameters.UsageNotification.InPath
);
status = ClassForwardIrpSynchronous(commonExtension, Irp);
if (!NT_SUCCESS(status)) {
IoAdjustPagingPathCount(
- &commonExtension->HibernationPathCount,
+ (PLONG)&commonExtension->HibernationPathCount,
!irpStack->Parameters.UsageNotification.InPath
);
}
case DeviceUsageTypeDumpFile: {
IoAdjustPagingPathCount(
- &commonExtension->DumpPathCount,
+ (PLONG)&commonExtension->DumpPathCount,
irpStack->Parameters.UsageNotification.InPath
);
status = ClassForwardIrpSynchronous(commonExtension, Irp);
if (!NT_SUCCESS(status)) {
IoAdjustPagingPathCount(
- &commonExtension->DumpPathCount,
+ (PLONG)&commonExtension->DumpPathCount,
!irpStack->Parameters.UsageNotification.InPath
);
}
return status;
} // end ClassDispatchPnp()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassPnpStartDevice()
none
--*/
-NTSTATUS ClassPnpStartDevice(IN PDEVICE_OBJECT DeviceObject)
+NTSTATUS NTAPI ClassPnpStartDevice(IN PDEVICE_OBJECT DeviceObject)
{
PCLASS_DRIVER_EXTENSION driverExtension;
PCLASS_INIT_DATA initData;
BOOLEAN isFdo = commonExtension->IsFdo;
BOOLEAN isMountedDevice = TRUE;
- UNICODE_STRING interfaceName;
+ //UNICODE_STRING interfaceName;
BOOLEAN timerStarted;
status = ClassGetDescriptor(
commonExtension->LowerDeviceObject,
&propertyId,
- &fdoExtension->AdapterDescriptor);
+ (PSTORAGE_DESCRIPTOR_HEADER *)&fdoExtension->AdapterDescriptor);
if(!NT_SUCCESS(status)) {
status = ClassGetDescriptor(
commonExtension->LowerDeviceObject,
&propertyId,
- &fdoExtension->DeviceDescriptor);
+ (PSTORAGE_DESCRIPTOR_HEADER *)&fdoExtension->DeviceDescriptor);
if(!NT_SUCCESS(status)) {
NT Status
--*/
-NTSTATUS ClassReadWrite(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
+NTSTATUS NTAPI ClassReadWrite(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
PDEVICE_OBJECT lowerDeviceObject = commonExtension->LowerDeviceObject;
PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
- LARGE_INTEGER startingOffset = currentIrpStack->Parameters.Read.ByteOffset;
+ //LARGE_INTEGER startingOffset = currentIrpStack->Parameters.Read.ByteOffset;
ULONG transferByteCount = currentIrpStack->Parameters.Read.Length;
ULONG isRemoved;
NTSTATUS status;
Status is returned.
--*/
-NTSTATUS ClassReadDriveCapacity(IN PDEVICE_OBJECT Fdo)
+NTSTATUS NTAPI ClassReadDriveCapacity(IN PDEVICE_OBJECT Fdo)
{
READ_CAPACITY_DATA readCapacityBuffer = {0};
NTSTATUS status;
if (pkt){
PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
KEVENT event;
- NTSTATUS pktStatus;
+ //NTSTATUS pktStatus;
IRP pseudoIrp = {0};
/*
--*/
VOID
+NTAPI
ClassSendStartUnit(
IN PDEVICE_OBJECT Fdo
)
ClassAcquireRemoveLock(Fdo, irp);
IoSetCompletionRoutine(irp,
- (PIO_COMPLETION_ROUTINE)ClassAsynchronousCompletion,
+ ClassAsynchronousCompletion,
context,
TRUE,
TRUE,
return;
} // end StartUnit()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassAsynchronousCompletion() ISSUE-2000/02/18-henrygab - why public?!
--*/
NTSTATUS
+NTAPI
ClassAsynchronousCompletion(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
return STATUS_MORE_PROCESSING_REQUIRED;
} // end ClassAsynchronousCompletion()
-\f
-
-VOID ServiceTransferRequest(PDEVICE_OBJECT Fdo, PIRP Irp)
+VOID NTAPI ServiceTransferRequest(PDEVICE_OBJECT Fdo, PIRP Irp)
{
- PCOMMON_DEVICE_EXTENSION commonExt = Fdo->DeviceExtension;
+ //PCOMMON_DEVICE_EXTENSION commonExt = Fdo->DeviceExtension;
PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
- PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExt->PartitionZeroExtension->AdapterDescriptor;
+ //PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExt->PartitionZeroExtension->AdapterDescriptor;
PIO_STACK_LOCATION currentSp = IoGetCurrentIrpStackLocation(Irp);
ULONG entireXferLen = currentSp->Parameters.Read.Length;
PUCHAR bufPtr = MmGetMdlVirtualAddress(Irp->MdlAddress);
SINGLE_LIST_ENTRY pktList;
PSINGLE_LIST_ENTRY slistEntry;
ULONG numPackets;
- KIRQL oldIrql;
+ //KIRQL oldIrql;
ULONG i;
/*
}
-
/*++////////////////////////////////////////////////////////////////////////////
ClassIoComplete()
--*/
NTSTATUS
+NTAPI
ClassIoComplete(
IN PDEVICE_OBJECT Fdo,
IN PIRP Irp,
} // end ClassIoComplete()
-
/*++////////////////////////////////////////////////////////////////////////////
ClassSendSrbSynchronous()
--*/
NTSTATUS
+NTAPI
ClassSendSrbSynchronous(
PDEVICE_OBJECT Fdo,
PSCSI_REQUEST_BLOCK Srb,
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
IO_STATUS_BLOCK ioStatus;
- ULONG controlType;
+ //ULONG controlType;
PIRP irp;
PIO_STACK_LOCATION irpStack;
KEVENT event;
DebugPrint((1, "ClassSendSrbSynchronous: Exception %lx "
"locking buffer\n", status));
- return status;
+ _SEH2_YIELD(return status);
} _SEH2_END;
}
return status;
}
-\f
/*++////////////////////////////////////////////////////////////////////////////
ClassInterpretSenseInfo()
--*/
BOOLEAN
+NTAPI
ClassInterpretSenseInfo(
IN PDEVICE_OBJECT Fdo,
IN PSCSI_REQUEST_BLOCK Srb,
)
{
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
- PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
case SCSI_SENSE_UNIT_ATTENTION: {
- PVPB vpb;
+ //PVPB vpb;
ULONG count;
//
// count for the physical device
//
- count = InterlockedIncrement(&fdoExtension->MediaChangeCount);
+ count = InterlockedIncrement((PLONG)&fdoExtension->MediaChangeCount);
DebugPrint((ClassDebugSenseInfo, "ClassInterpretSenseInfo: "
"Media change count for device %d incremented to %#lx\n",
fdoExtension->DeviceNumber, count));
ULONG totalSize;
ULONG senseBufferSize = 0;
IO_ERROR_LOG_PACKET staticErrLogEntry = {0};
- CLASS_ERROR_LOG_DATA staticErrLogData = {0};
+ CLASS_ERROR_LOG_DATA staticErrLogData = { { { 0 } } };
//
// Calculate the total size of the error log entry.
} // end ClassInterpretSenseInfo()
-
-\f
/*++////////////////////////////////////////////////////////////////////////////
ClassModeSense()
Length of the transferred data is returned.
--*/
-ULONG ClassModeSense( IN PDEVICE_OBJECT Fdo,
+ULONG NTAPI ClassModeSense( IN PDEVICE_OBJECT Fdo,
IN PCHAR ModeSenseBuffer,
IN ULONG Length,
IN UCHAR PageMode)
TRANSFER_PACKET *pkt = DequeueFreeTransferPacket(Fdo, TRUE);
if (pkt){
KEVENT event;
- NTSTATUS pktStatus;
+ //NTSTATUS pktStatus;
IRP pseudoIrp = {0};
/*
return lengthTransferred;
}
-
/*++////////////////////////////////////////////////////////////////////////////
ClassFindModePage()
--*/
PVOID
+NTAPI
ClassFindModePage(
IN PCHAR ModeSenseBuffer,
IN ULONG Length,
IN BOOLEAN Use6Byte
)
{
- PUCHAR limit;
+ PCHAR limit;
ULONG parameterHeaderLength;
PVOID result = NULL;
return result;
} // end ClassFindModePage()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassSendSrbAsynchronous()
--*/
NTSTATUS
+NTAPI
ClassSendSrbAsynchronous(
PDEVICE_OBJECT Fdo,
PSCSI_REQUEST_BLOCK Srb,
return STATUS_PENDING;
} // end ClassSendSrbAsynchronous()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassDeviceControlDispatch()
--*/
NTSTATUS
+NTAPI
ClassDeviceControlDispatch(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
return commonExtension->DevInfo->ClassDeviceControl(DeviceObject,Irp);
} // end ClassDeviceControlDispatch()
-\f
/*++////////////////////////////////////////////////////////////////////////////
ClassDeviceControl()
--*/
NTSTATUS
+NTAPI
ClassDeviceControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
if ((controlCode == IOCTL_SCSI_PASS_THROUGH) ||
(controlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT)) {
- PSCSI_PASS_THROUGH scsiPass;
+ //PSCSI_PASS_THROUGH scsiPass;
//
// Validiate the user buffer.
return status;
} // end ClassDeviceControl()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassShutdownFlush()
--*/
NTSTATUS
+NTAPI
ClassShutdownFlush(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
ULONG isRemoved;
- NTSTATUS status;
+ //NTSTATUS status;
isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
return STATUS_INVALID_DEVICE_REQUEST;
} // end ClassShutdownFlush()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassCreateDeviceObject()
--*/
NTSTATUS
+NTAPI
ClassCreateDeviceObject(
IN PDRIVER_OBJECT DriverObject,
IN PCCHAR ObjectNameBuffer,
BOOLEAN isPartitionable;
STRING ntNameString;
UNICODE_STRING ntUnicodeString;
- NTSTATUS status, status2;
+ NTSTATUS status;
PDEVICE_OBJECT deviceObject = NULL;
ULONG characteristics;
return status;
} // end ClassCreateDeviceObject()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassClaimDevice()
--*/
NTSTATUS
+NTAPI
ClassClaimDevice(
IN PDEVICE_OBJECT LowerDeviceObject,
IN BOOLEAN Release
return status;
} // end ClassClaimDevice()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassInternalIoControl()
--*/
NTSTATUS
+NTAPI
ClassInternalIoControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
return IoCallDriver(commonExtension->LowerDeviceObject, Irp);
} // end ClassInternalIoControl()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassQueryTimeOutRegistryValue()
--*/
ULONG
+NTAPI
ClassQueryTimeOutRegistryValue(
IN PDEVICE_OBJECT DeviceObject
)
return timeOut;
} // end ClassQueryTimeOutRegistryValue()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassCheckVerifyComplete() ISSUE-2000/02/18-henrygab - why public?!
--*/
NTSTATUS
+NTAPI
ClassCheckVerifyComplete(
IN PDEVICE_OBJECT Fdo,
IN PIRP Irp,
return STATUS_MORE_PROCESSING_REQUIRED;
} // end ClassCheckVerifyComplete()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassGetDescriptor()
--*/
NTSTATUS
+NTAPI
ClassGetDescriptor(
IN PDEVICE_OBJECT DeviceObject,
IN PSTORAGE_PROPERTY_ID PropertyId,
PSTORAGE_DESCRIPTOR_HEADER descriptor = NULL;
ULONG length;
- UCHAR pass = 0;
+ //UCHAR pass = 0;
PAGED_CODE();
*Descriptor = descriptor;
return ioStatus.Status;
} // end ClassGetDescriptor()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassSignalCompletion()
--*/
NTSTATUS
+NTAPI
ClassSignalCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
- IN PKEVENT Event
+ IN PVOID Context
)
{
+ PKEVENT Event = Context;
+
KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
return STATUS_MORE_PROCESSING_REQUIRED;
} // end ClassSignalCompletion()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassPnpQueryFdoRelations()
--*/
NTSTATUS
+NTAPI
ClassPnpQueryFdoRelations(
IN PDEVICE_OBJECT Fdo,
IN PIRP Irp
PCLASS_DRIVER_EXTENSION
driverExtension = IoGetDriverObjectExtension(Fdo->DriverObject,
CLASS_DRIVER_EXTENSION_KEY);
- NTSTATUS status;
PAGED_CODE();
// one.
//
- if(InterlockedIncrement(&(fdoExtension->EnumerationInterlock)) == 1) {
- status = driverExtension->InitData.ClassEnumerateDevice(Fdo);
+ if(InterlockedIncrement((PLONG)&fdoExtension->EnumerationInterlock) == 1) {
+ driverExtension->InitData.ClassEnumerateDevice(Fdo);
}
Irp->IoStatus.Information = (ULONG_PTR) NULL;
Fdo,
BusRelations,
(PDEVICE_RELATIONS*)&Irp->IoStatus.Information);
- InterlockedDecrement(&(fdoExtension->EnumerationInterlock));
+ InterlockedDecrement((PLONG)&fdoExtension->EnumerationInterlock);
return Irp->IoStatus.Status;
} // end ClassPnpQueryFdoRelations()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassMarkChildrenMissing()
--*/
VOID
+NTAPI
ClassMarkChildrenMissing(
IN PFUNCTIONAL_DEVICE_EXTENSION Fdo
)
ClassReleaseChildLock(Fdo);
return;
} // end ClassMarkChildrenMissing()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassMarkChildMissing()
--*/
BOOLEAN
+NTAPI
ClassMarkChildMissing(
IN PPHYSICAL_DEVICE_EXTENSION Child,
IN BOOLEAN AcquireChildLock
return returnValue;
} // end ClassMarkChildMissing()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassRetrieveDeviceRelations()
--*/
NTSTATUS
+NTAPI
ClassRetrieveDeviceRelations(
IN PDEVICE_OBJECT Fdo,
IN DEVICE_RELATION_TYPE RelationType,
ClassReleaseChildLock(fdoExtension);
return STATUS_SUCCESS;
} // end ClassRetrieveDeviceRelations()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassGetPdoId()
--*/
NTSTATUS
+NTAPI
ClassGetPdoId(
IN PDEVICE_OBJECT Pdo,
IN BUS_QUERY_ID_TYPE IdType,
return driverExtension->InitData.ClassQueryId( Pdo, IdType, IdString);
} // end ClassGetPdoId()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassQueryPnpCapabilities()
--*/
NTSTATUS
+NTAPI
ClassQueryPnpCapabilities(
IN PDEVICE_OBJECT DeviceObject,
IN PDEVICE_CAPABILITIES Capabilities
return STATUS_NOT_IMPLEMENTED;
}
} // end ClassQueryPnpCapabilities()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassInvalidateBusRelations()
--*/
VOID
+NTAPI
ClassInvalidateBusRelations(
IN PDEVICE_OBJECT Fdo
)
ASSERT_FDO(Fdo);
ASSERT(driverExtension->InitData.ClassEnumerateDevice != NULL);
- if(InterlockedIncrement(&(fdoExtension->EnumerationInterlock)) == 1) {
+ if(InterlockedIncrement((PLONG)&fdoExtension->EnumerationInterlock) == 1) {
status = driverExtension->InitData.ClassEnumerateDevice(Fdo);
}
- InterlockedDecrement(&(fdoExtension->EnumerationInterlock));
+ InterlockedDecrement((PLONG)&fdoExtension->EnumerationInterlock);
if(!NT_SUCCESS(status)) {
return;
} // end ClassInvalidateBusRelations()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassRemoveDevice() ISSUE-2000/02/18-henrygab - why public?!
--*/
NTSTATUS
+NTAPI
ClassRemoveDevice(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR RemoveType
status = STATUS_SUCCESS;
if (commonExtension->IsFdo){
- PDEVICE_OBJECT pdo;
+ //PDEVICE_OBJECT pdo;
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
ClasspDisableTimer(fdoExtension->DeviceObject);
* to delete it ourselves.
*/
ClassAcquireChildLock(fdoExtension);
- while (child = ClassRemoveChild(fdoExtension, NULL, FALSE)){
+ while ((child = ClassRemoveChild(fdoExtension, NULL, FALSE))){
//
// Yank the pdo. This routine will unlink the device from the
return STATUS_SUCCESS;
} // end ClassRemoveDevice()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassGetDriverExtension()
--*/
PCLASS_DRIVER_EXTENSION
+NTAPI
ClassGetDriverExtension(
IN PDRIVER_OBJECT DriverObject
)
{
return IoGetDriverObjectExtension(DriverObject, CLASS_DRIVER_EXTENSION_KEY);
} // end ClassGetDriverExtension()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClasspStartIo()
--*/
VOID
+NTAPI
ClasspStartIo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
return;
} // ClasspStartIo()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassUpdateInformationInRegistry()
--*/
VOID
+NTAPI
ClassUpdateInformationInRegistry(
IN PDEVICE_OBJECT Fdo,
IN PCHAR DeviceName,
IN ULONG InquiryDataLength
)
{
- PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
NTSTATUS status;
SCSI_ADDRESS scsiAddress;
OBJECT_ATTRIBUTES objectAttributes;
- PUCHAR buffer;
+ PSTR buffer;
STRING string;
UNICODE_STRING unicodeName;
UNICODE_STRING unicodeRegistryPath;
PAGED_CODE();
ASSERT(DeviceName);
- fdoExtension = Fdo->DeviceExtension;
buffer = NULL;
targetKey = NULL;
RtlZeroMemory(&unicodeName, sizeof(UNICODE_STRING));
RtlInitUnicodeString(&unicodeName, L"DeviceName");
- sprintf(buffer, "%s%d", DeviceName, DeviceNumber);
+ sprintf(buffer, "%s%lu", DeviceName, DeviceNumber);
RtlInitString(&string, buffer);
status = RtlAnsiStringToUnicodeString(&unicodeData,
&string,
}
} // end ClassUpdateInformationInRegistry()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClasspSendSynchronousCompletion()
--*/
NTSTATUS
+NTAPI
ClasspSendSynchronousCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
return STATUS_MORE_PROCESSING_REQUIRED;
} // end ClasspSendSynchronousCompletion()
-\f
+
/*++
ISSUE-2000/02/20-henrygab Not documented ClasspRegisterMountedDeviceInterface
--*/
VOID
+NTAPI
ClasspRegisterMountedDeviceInterface(
IN PDEVICE_OBJECT DeviceObject
)
}
return;
} // end ClasspRegisterMountedDeviceInterface()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassSendDeviceIoControlSynchronous()
--*/
VOID
+NTAPI
ClassSendDeviceIoControlSynchronous(
IN ULONG IoControlCode,
IN PDEVICE_OBJECT TargetDeviceObject,
return;
} // end ClassSendDeviceIoControlSynchronous()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassForwardIrpSynchronous()
--*/
NTSTATUS
+NTAPI
ClassForwardIrpSynchronous(
IN PCOMMON_DEVICE_EXTENSION CommonExtension,
IN PIRP Irp
IoCopyCurrentIrpStackLocationToNext(Irp);
return ClassSendIrpSynchronous(CommonExtension->LowerDeviceObject, Irp);
} // end ClassForwardIrpSynchronous()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassSendIrpSynchronous()
--*/
NTSTATUS
+NTAPI
ClassSendIrpSynchronous(
IN PDEVICE_OBJECT TargetDeviceObject,
IN PIRP Irp
return status;
} // end ClassSendIrpSynchronous()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassGetVpb()
--*/
PVPB
+NTAPI
ClassGetVpb(
IN PDEVICE_OBJECT DeviceObject
)
{
return DeviceObject->Vpb;
} // end ClassGetVpb()
-\f
+
/*++
ISSUE-2000/02/20-henrygab Not documented ClasspAllocateReleaseRequest
--*/
NTSTATUS
+NTAPI
ClasspAllocateReleaseRequest(
IN PDEVICE_OBJECT Fdo
)
{
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
- PIO_STACK_LOCATION irpStack;
+ //PIO_STACK_LOCATION irpStack;
KeInitializeSpinLock(&(fdoExtension->ReleaseQueueSpinLock));
return STATUS_SUCCESS;
} // end ClasspAllocateReleaseRequest()
-\f
+
/*++
ISSUE-2000/02/20-henrygab Not documented ClasspFreeReleaseRequest
--*/
VOID
+NTAPI
ClasspFreeReleaseRequest(
IN PDEVICE_OBJECT Fdo
)
return;
} // end ClasspFreeReleaseRequest()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassReleaseQueue()
--*/
VOID
+NTAPI
ClassReleaseQueue(
IN PDEVICE_OBJECT Fdo
)
ClasspReleaseQueue(Fdo, NULL);
return;
} // end ClassReleaseQueue()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClasspAllocateReleaseQueueIrp()
--*/
NTSTATUS
+NTAPI
ClasspAllocateReleaseQueueIrp(
PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
)
{
- KIRQL oldIrql;
+ //KIRQL oldIrql;
UCHAR lowerStackSize;
//
return STATUS_SUCCESS;
}
-
/*++////////////////////////////////////////////////////////////////////////////
ClasspReleaseQueue()
--*/
VOID
+NTAPI
ClasspReleaseQueue(
IN PDEVICE_OBJECT Fdo,
IN PIRP ReleaseQueueIrp OPTIONAL
return;
} // end ClassReleaseQueue()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassReleaseQueueCompletion()
--*/
NTSTATUS
+NTAPI
ClassReleaseQueueCompletion(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
return STATUS_MORE_PROCESSING_REQUIRED;
} // ClassAsynchronousCompletion()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassAcquireChildLock()
--*/
VOID
+NTAPI
ClassAcquireChildLock(
IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
)
FdoExtension->ChildLockAcquisitionCount++;
return;
}
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassReleaseChildLock() ISSUE-2000/02/18-henrygab - not documented
--*/
VOID
+NTAPI
ClassReleaseChildLock(
IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
)
return;
} // end ClassReleaseChildLock(
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassAddChild()
--*/
VOID
+NTAPI
ClassAddChild(
IN PFUNCTIONAL_DEVICE_EXTENSION Parent,
IN PPHYSICAL_DEVICE_EXTENSION Child,
}
return;
} // end ClassAddChild()
-\f
+
/*++////////////////////////////////////////////////////////////////////////////
ClassRemoveChild()
--*/
PPHYSICAL_DEVICE_EXTENSION
+NTAPI
ClassRemoveChild(
IN PFUNCTIONAL_DEVICE_EXTENSION Parent,
IN PPHYSICAL_DEVICE_EXTENSION Child,
return Child;
} // end ClassRemoveChild()
-\f
/*++
ISSUE-2000/02/20-henrygab Not documented ClasspRetryRequestDpc
--*/
VOID
+NTAPI
ClasspRetryRequestDpc(
IN PKDPC Dpc,
- IN PDEVICE_OBJECT DeviceObject,
+ IN PVOID Context,
IN PVOID Arg1,
IN PVOID Arg2
)
{
+ PDEVICE_OBJECT deviceObject = Context;
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
PCOMMON_DEVICE_EXTENSION commonExtension;
PCLASS_PRIVATE_FDO_DATA fdoData;
KIRQL irql;
- commonExtension = DeviceObject->DeviceExtension;
+ commonExtension = deviceObject->DeviceExtension;
ASSERT(commonExtension->IsFdo);
- fdoExtension = DeviceObject->DeviceExtension;
+ fdoExtension = deviceObject->DeviceExtension;
fdoData = fdoExtension->PrivateFdoData;
return;
} // end ClasspRetryRequestDpc()
-\f
+
/*++
ISSUE-2000/02/20-henrygab Not documented ClassRetryRequest
--*/
VOID
+NTAPI
ClassRetryRequest(
IN PDEVICE_OBJECT SelfDeviceObject,
IN PIRP Irp,
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
PCLASS_PRIVATE_FDO_DATA fdoData;
PCLASS_RETRY_INFO retryInfo;
- PCLASS_RETRY_INFO *previousNext;
+ //PCLASS_RETRY_INFO *previousNext;
LARGE_INTEGER delta;
KIRQL irql;
} // end ClassRetryRequest()
-\f
+
/*++
ISSUE-2000/02/20-henrygab Not documented ClasspRetryDpcTimer
--*/
VOID
+NTAPI
ClasspRetryDpcTimer(
IN PCLASS_PRIVATE_FDO_DATA FdoData
)
return;
} // end ClasspRetryDpcTimer()
-\f
+
NTSTATUS
+NTAPI
ClasspInitializeHotplugInfo(
IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
)
return STATUS_SUCCESS;
}
-\f
+
VOID
+NTAPI
ClasspScanForClassHacks(
IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension,
IN ULONG_PTR Data
SET_FLAG(FdoExtension->PrivateFdoData->HackFlags, Data);
return;
}
-\f
+
VOID
+NTAPI
ClasspScanForSpecialInRegistry(
IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension
)
return;
}
-
-
-
-
projects / reactos.git / blobdiff