- Move irp completion to CompleteRequest function for debugging of multiple irp completion bugs
- Remove bugs asserts in IKsDevice_PnpStartDevice
- Set device to started when the device does not need pnp notification
- Don't complete the irp in IKsDevice_Create, the driver has already done this
- Comment out UNIMPLEMENTED macro in KsFilterAttemptProcessing
- Fix check in FindMatchingCreateItem
- Don't set DO_DIRECT_IO flags on PDO devices
- Set DO_DEVICE_INITIALIZING flag on PDO device
- Construct device name with swprintf
- Add check if the device entry has already been constructed
- Zero device capabilities
- Implement bus watchdog routine. The routine checks if pdo has successfully been started, otherwise the pdo is marked invalid and the deleted and then constructed again. If the pdo has been started, all pending irp requests are completed with STATUS_REPARSE. (This is probably not supported by Ros kernel yet)
- Acquire device entry list lock when working with device entries
- Always store status code in irp for all Ks bus api routines
- Handle IRP_MN_REMOVE_DEVICE
- Start watchdog timer when IRP_MN_START_DEVICE is received
- Ros KS nos successfully initializes and all audio devices appear in VBOX+WinXP+SP3. Playback not yet working (Needs KsAttemptFilterProcessing for splitter and friends)
- TODO: enhance time out to make audio system initialize faster
svn path=/branches/audio-bringup/; revision=50079
/* complete and forget irps */
Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_IMPLEMENTED;
}
{
/* invalid request */
Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INVALID_DEVICE_REQUEST;
}
Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
Irp->IoStatus.Information = sizeof(KSSTREAMALLOCATOR_FUNCTIONTABLE);
/* complete and forget irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_BUFFER_TOO_SMALL;
}
if (!(Property->Flags & KSPROPERTY_TYPE_GET))
/* only support retrieving the property */
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
/* complete and forget irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = sizeof(KSSTREAMALLOCATOR_FUNCTIONTABLE);
/* complete request */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
else if (Property->Id == KSPROPERTY_STREAMALLOCATOR_STATUS)
Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
Irp->IoStatus.Information = sizeof(KSPROPERTY_STREAMALLOCATOR_STATUS);
/* complete and forget irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_BUFFER_TOO_SMALL;
}
if (!(Property->Flags & KSPROPERTY_TYPE_GET))
/* only support retrieving the property */
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
/* complete and forget irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
Irp->IoStatus.Information = sizeof(KSSTREAMALLOCATOR_STATUS);
/* complete request */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
}
/* unhandled request */
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_SUPPORTED;
}
/* complete request */
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
/* complete request */
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
/* complete request */
Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
IoStack->FileObject->FsContext2 = (PVOID)Header;
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
FreeItem(Header);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
if (IoStack->MajorFunction != IRP_MJ_CLOSE)
{
/* can be completed immediately */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return;
}
if (!NT_SUCCESS(Irp->IoStatus.Status))
{
/* closing failed, complete irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
UNIMPLEMENTED
Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
{
DPRINT1("NextDevice object failed to start with %x\n", Status);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
}
ASSERT(DeviceHeader->KsDevice.Descriptor);
- ASSERT(DeviceHeader->KsDevice.Descriptor->Dispatch);
- ASSERT(DeviceHeader->KsDevice.Descriptor->Dispatch->Start);
-
/* do we have a device descriptor */
if (DeviceHeader->KsDevice.Descriptor)
{
DPRINT1("Driver: failed to start %x\n", Status);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
Status = KspSetFilterFactoriesState(DeviceHeader, TRUE);
}
}
+ else
+ {
+ /* set state to run */
+ DeviceHeader->KsDevice.Started = TRUE;
+ }
}
/* store result */
Irp->IoStatus.Status = Status;
/* complete request */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
if (Ctx)
{
}
/* return result */
- DPRINT1("IKsDevice_PnpStartDevice Status %x PostStartRoutine %p\n", Status, Ctx);
+ DPRINT("IKsDevice_PnpStartDevice Status %x PostStartRoutine %p\n", Status, Ctx);
return Status;
}
{
DPRINT1("Driver: query stop failed %x\n", Status);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
DPRINT("Next Device: Status %x\n", Status);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
case IRP_MN_QUERY_INTERFACE:
/* driver supports a private interface */
DPRINT1("IRP_MN_QUERY_INTERFACE Device supports interface\n");
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
DPRINT1("IRP_MN_QUERY_INTERFACE Next Device: Status %x\n", Status);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
case IRP_MN_QUERY_DEVICE_RELATIONS:
DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS Next Device: Status %x\n", Status);
//Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS Next Device: Status %x\n", Status);
//Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS Next Device: Status %x\n", Status);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
default:
Status = KspForwardIrpSynchronous(DeviceObject, Irp);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
}
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
}
}
- /* acquire list lock */
+ /* release list lock */
IKsDevice_fnReleaseDevice((IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown);
- if (Status != STATUS_PENDING)
- {
- Irp->IoStatus.Information = 0;
- /* set return status */
- Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
- }
-
+ /* done */
return Status;
PKSIOBJECT_BAG Bag;
NTSTATUS Status = STATUS_SUCCESS;
- DPRINT("KsInitializeDevice Descriptor %p\n", Descriptor);
+ DPRINT1("KsInitializeDevice Descriptor %p\n", Descriptor);
/* get device extension */
DeviceExtension = (PDEVICE_EXTENSION)FunctionalDeviceObject->DeviceExtension;
/* point to allocated header */
Header = DeviceExtension->DeviceHeader;
- DPRINT("DeviceHeader %p\n", DeviceExtension->DeviceHeader);
+ DPRINT1("DeviceHeader %p\n", DeviceExtension->DeviceHeader);
if (Descriptor && Descriptor->Dispatch)
{
IKsDevice * Device;
PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
- DPRINT1("KsDereferenceSoftwareBusObject DeviceHeader %p\n", Header);
+ DPRINT("KsDereferenceSoftwareBusObject DeviceHeader %p\n", Header);
/* get device interface */
Device = (IKsDevice*)DeviceHeader->BasicHeader.OuterUnknown;
Irp->IoStatus.Status = Status;
/* complete and forget irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
return Status;
/* save the result */
Irp->IoStatus.Status = Status;
/* complete irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
/* remove our instance from the filter factory */
IKsFilter_RemoveFilterFromFilterFactory(This, This->Factory);
/* complete and forget */
Irp->IoStatus.Status = Status;
/* complete irp */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
}
/* done */
if (Status != STATUS_PENDING)
{
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
}
/* done */
{
/* complete request */
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
}
/* done */
{
UNIMPLEMENTED
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
IN PKSFILTER Filter,
IN BOOLEAN Asynchronous)
{
- UNIMPLEMENTED
+ //UNIMPLEMENTED
}
/*
{
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
}
return Status;
{
/* no create item */
Irp->IoStatus.Status = STATUS_NO_SECURITY_ON_OBJECT;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_SECURITY_ON_OBJECT;
}
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = Length;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
{
/* no create item */
Irp->IoStatus.Status = STATUS_NO_SECURITY_ON_OBJECT;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_SECURITY_ON_OBJECT;
}
/* store result */
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
IN PIRP Irp)
{
Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INVALID_DEVICE_REQUEST;
}
/* complete request */
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT("KsAddIrpToCancelableQueue QueueHead %p SpinLock %p Irp %p ListLocation %x DriverCancel %p\n", QueueHead, SpinLock, Irp, ListLocation, DriverCancel);
+ DPRINT1("KsAddIrpToCancelableQueue QueueHead %p SpinLock %p Irp %p ListLocation %x DriverCancel %p\n", QueueHead, SpinLock, Irp, ListLocation, DriverCancel);
// HACK for ms portcls
if (IoStack->MajorFunction == IRP_MJ_CREATE)
{
// complete the request
+DPRINT1("MS HACK\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return;
}
{
/* let's complete it */
Irp->IoStatus.Status = STATUS_CANCELLED;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
}
}
continue;
}
- ASSERT(CreateItemEntry->CreateItem->ObjectClass.Buffer);
-
DPRINT("CreateItem %S Length %u Request %wZ %u\n", CreateItemEntry->CreateItem->ObjectClass.Buffer,
CreateItemEntry->CreateItem->ObjectClass.Length,
&RefString,
- BufferSize);
+ RefString.Length);
- if (CreateItemEntry->CreateItem->ObjectClass.Length > BufferSize)
+ if (CreateItemEntry->CreateItem->ObjectClass.Length > RefString.Length)
{
/* create item doesnt match in length */
Entry = Entry->Flink;
Irp->IoStatus.Information = 0;
/* set return status */
Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
Irp->IoStatus.Information = 0;
/* set return status */
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
/* complete and forget */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
/* get device extension */
DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
+
/* get device header */
DeviceHeader = DeviceExtension->DeviceHeader;
#define TAG_KSDEVICE 'DESK'
#define TAG_KSOBJECT_TAG 'HOSK'
+VOID
+CompleteRequest(
+ PIRP Irp,
+ CCHAR PriorityBoost);
+
+
+
NTSTATUS
NTAPI
KspCreateObjectType(
typedef BOOLEAN (NTAPI *PKSEVENT_SYNCHRONIZED_ROUTINE)(PKSEVENT_CTX Context);
struct __BUS_ENUM_DEVICE_EXTENSION__;
-struct BUS_DEVICE_ENTRY;
+struct __BUS_DEVICE_ENTRY__;
typedef struct
{
};
union
{
- PVOID DeviceEntry;
+ struct __BUS_DEVICE_ENTRY__* DeviceEntry;
ULONG Dummy1;
};
struct __BUS_ENUM_DEVICE_EXTENSION__ *BusDeviceExtension;
}DEVICE_STATE;
-typedef struct
+typedef struct __BUS_DEVICE_ENTRY__
{
LIST_ENTRY Entry;
LIST_ENTRY DeviceInterfaceList;
#include "priv.h"
+VOID
+CompleteRequest(
+ PIRP Irp,
+ CCHAR PriorityBoost)
+{
+ DPRINT("Completing IRP %p Status %x\n", Irp, Irp->IoStatus.Status);
+
+ ASSERT(Irp->IoStatus.Status != STATUS_PENDING);
+
+
+ IoCompleteRequest(Irp, PriorityBoost);
+}
+
PVOID
AllocateItem(
IN POOL_TYPE PoolType,
DPRINT1("KsProbeStreamIrp failed with %x\n", Status);
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
{
DPRINT("NoHeader Canceling Irp %p\n", Irp);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
{
DPRINT("NoHeader->Data Canceling Irp %p\n", Irp);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
/* invalid device request */
DPRINT("Filter Centric Processing No Process Routine\n");
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
if (Status != STATUS_PENDING)
{
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
}
/* done */
{
/* abort closing */
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
if (Status != STATUS_PENDING)
{
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
}
UNIMPLEMENTED;
Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_IMPLEMENTED;
}
/* done */
Irp->IoStatus.Status = Status;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
UNIMPLEMENTED;
Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_IMPLEMENTED;
}
CurDeviceId = InterlockedIncrement(&KsDeviceCount);
/* generate new device id */
- swprintf(Buffer, L"\\Device\\KSENUM%08x\n", CurDeviceId);
+ swprintf(Buffer, L"\\Device\\KSENUM%08x", CurDeviceId);
/* initialize new device name */
RtlInitUnicodeString(&DeviceName, Buffer);
/* TODO: update last creation time in bus device extension */
/* setup flags */
- DeviceObject->Flags |= DO_DIRECT_IO | DO_POWER_PAGABLE;
-
+ DeviceObject->Flags |= DO_POWER_PAGABLE;
+ DeviceObject->Flags &= ~ DO_DEVICE_INITIALIZING;
/* TODO: fire time when expired */
*OutDeviceObject = DeviceObject;
BOOLEAN ItemExists = FALSE;
UNICODE_STRING String;
NTSTATUS Status;
+ KIRQL OldLevel;
/* first construct device name & reference guid */
Length = wcslen(DeviceCategory) + wcslen(ReferenceString);
}
/* construct device name */
- wcscpy(DeviceName, DeviceCategory);
- wcscat(DeviceName, L"&");
- wcscat(DeviceName, ReferenceString);
+ swprintf(DeviceName, L"%s&%s", DeviceCategory, ReferenceString);
/* scan list and check if it is already present */
Entry = BusDeviceExtension->Common.Entry.Flink;
return Status;
}
- /* successfully initialized entry */
- InsertTailList(&BusDeviceExtension->Common.Entry, &DeviceEntry->Entry);
+ if (!ItemExists)
+ {
+ /* acquire lock */
+ KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
+
+ /* successfully initialized entry */
+ InsertTailList(&BusDeviceExtension->Common.Entry, &DeviceEntry->Entry);
+
+ /* release lock */
+ KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
+ }
/* done */
return Status;
NTSTATUS
KspQueryBusDeviceInterface(
- IN PIRP Irp,
- IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension)
+ IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
+ IN PIRP Irp)
{
PBUS_INTERFACE_SWENUM Interface;
PIO_STACK_LOCATION IoStack;
{
/* get bus instance entry */
InstanceEntry = (PBUS_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BUS_INSTANCE_ENTRY, Entry);
+ DPRINT1("Enabling %u %wZ Irql %u\n", bEnable, &InstanceEntry->SymbolicLink, KeGetCurrentIrql());
/* set interface state */
Status = IoSetDeviceInterfaceState(&InstanceEntry->SymbolicLink, bEnable);
Length += 2;
/* allocate buffer */
- Buffer = AllocateItem(PagedPool, Length * sizeof(WCHAR));
+ Buffer = AllocateItem(NonPagedPool, Length * sizeof(WCHAR));
if (!Buffer)
{
/* no resources */
}
/* construct buffer */
- wcscpy(Buffer, DeviceEntry->PDODeviceName);
- wcscat(Buffer, L"\\");
- wcscat(Buffer, DeviceEntry->Instance);
+ swprintf(Buffer, L"%s\\%s", DeviceEntry->PDODeviceName, DeviceEntry->Instance);
- /* free old file name */
ExFreePool(IoStack->FileObject->FileName.Buffer);
/* store new file name */
NTSTATUS Status;
/* go through list */
-
while(!IsListEmpty(&DeviceEntry->IrpPendingList))
{
/* get first entry */
/* store result code */
Irp->IoStatus.Status = Status;
- DPRINT1("Completing IRP %p\n", Irp);
+ DPRINT1("Completing IRP %p Status %x\n", Irp, Status);
/* complete the request */
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ CompleteRequest(Irp, IO_NO_INCREMENT);
}
+
}
}
/* allocate device name buffer */
- Name = AllocateItem(PagedPool, ResultLength);
+ Name = AllocateItem(NonPagedPool, (ResultLength + 1) * sizeof(WCHAR));
if (!Name)
{
/* no memory */
/* mark device as started */
DeviceEntry->DeviceState = Started;
- DPRINT1("KspStartBusDevice Name %S Started\n", Name);
+ /* reference start time */
+ KeQuerySystemTime(&DeviceEntry->TimeCreated);
- /* now complete pending i/o */
- KspCompletePendingIrps(DeviceEntry, STATUS_REPARSE);
+ DPRINT1("KspStartBusDevice Name %S DeviceName %S Instance %S Started\n", Name, DeviceEntry->DeviceName, DeviceEntry->Instance);
+
+ /* enable device classes */
+ //KspEnableBusDeviceInterface(DeviceEntry, TRUE);
/* done */
return STATUS_SUCCESS;
/* get capabilities */
Capabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
+ RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES));
+
/* setup capabilities */
Capabilities->UniqueID = TRUE;
Capabilities->SilentInstall = TRUE;
}
/* construct id */
- wcscpy(Name, BusDeviceExtension->BusIdentifier);
- wcscat(Name, L"\\");
- wcscat(Name, DeviceEntry->BusId);
+ swprintf(Name, L"%s\\%s", BusDeviceExtension->BusIdentifier, DeviceEntry->BusId);
/* store result */
Irp->IoStatus.Information = (ULONG_PTR)Name;
else
{
/* other ids are not supported */
- DPRINT1("Not Supported ID Type %x\n", IoStack->Parameters.QueryId.IdType);
- return STATUS_NOT_SUPPORTED;
+ //DPRINT1("Not Supported ID Type %x\n", IoStack->Parameters.QueryId.IdType);
+ return Irp->IoStatus.Status;
}
}
KspBusWorkerRoutine(
IN PVOID Parameter)
{
- /* TODO: implement sweeping */
- UNIMPLEMENTED
+ PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
+ PBUS_DEVICE_ENTRY DeviceEntry;
+ PLIST_ENTRY Entry;
+ LARGE_INTEGER Time, Diff;
+ BOOLEAN DoInvalidate = FALSE;
+ KIRQL OldLevel;
+
+ /* acquire lock */
+ KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
+
+ /* get device extension */
+ BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)Parameter;
+
+ /* get current time */
+ KeQuerySystemTime(&Time);
+
+ /* enumerate all device entries */
+ Entry = BusDeviceExtension->Common.Entry.Flink;
+ while(Entry != &BusDeviceExtension->Common.Entry)
+ {
+ /* get offset to device entry */
+ DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
+
+ /* sanity check */
+ ASSERT(DeviceEntry);
+
+ //DPRINT1("DeviceEntry %p PDO %p State %x\n", DeviceEntry, DeviceEntry->PDO, DeviceEntry->DeviceState);
+
+ if (DeviceEntry->PDO)
+ {
+ if (DeviceEntry->DeviceState == NotStarted)
+ {
+ Diff.QuadPart = Time.QuadPart - DeviceEntry->TimeCreated.QuadPart;
+
+ if (Diff.QuadPart > Int32x32To64(15000, 10000))
+ {
+ DPRINT1("DeviceID %S Instance %S TimeCreated %I64u Now %I64u Diff %I64u hung\n", DeviceEntry->DeviceName, DeviceEntry->Instance, DeviceEntry->TimeCreated.QuadPart, Time.QuadPart, Diff.QuadPart);
+
+ /* release spin lock */
+ KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
+
+ /* deactivate interfaces */
+ //KspEnableBusDeviceInterface(DeviceEntry, FALSE);
+
+ /* re-acquire lock */
+ KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
+
+ /* pending remove device object */
+ DeviceEntry->DeviceState = StopPending;
+
+ /* perform invalidation */
+ DoInvalidate = TRUE;
+ }
+ }
+ else if (DeviceEntry->DeviceState == Started)
+ {
+ /* found pending irps */
+ KspCompletePendingIrps(DeviceEntry, STATUS_REPARSE);
+ }
+ }
+
+
+ /* move to next */
+ Entry = Entry->Flink;
+ }
+
+ /* release lock */
+ KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
+
+ if (DoInvalidate)
+ {
+ /* invalidate device relations */
+ IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
+ }
+
+ Time.QuadPart = Int32x32To64(5000, -10000);
+ KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
}
VOID
PLIST_ENTRY Entry;
PBUS_DEVICE_ENTRY DeviceEntry;
ULONG Count = 0, Length;
+ KIRQL OldLevel;
-
- /* FIXME locks */
+ /* acquire lock */
+ KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
/* first scan all device entries */
Entry = BusDeviceExtension->Common.Entry.Flink;
DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
/* is there a pdo yet */
- if (DeviceEntry->PDO)
+ if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
{
/* increment count */
Count++;
if (!DeviceRelations)
{
/* not enough memory */
+ KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
return STATUS_INSUFFICIENT_RESOURCES;
}
DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
/* is there a pdo yet */
- if (DeviceEntry->PDO)
+ if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
{
/* store pdo */
DeviceRelations->Objects[DeviceRelations->Count] = DeviceEntry->PDO;
Entry = Entry->Flink;
}
+ /* release lock */
+ KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
+
/* FIXME handle existing device relations */
ASSERT(Irp->IoStatus.Information == 0);
}
/* done */
+ Irp->IoStatus.Status = Status;
return Status;
}
FreeItem(BusDeviceExtension);
}
- DPRINT1("KsCreateBusEnumObject cp %x\n", Status);
+ DPRINT("KsCreateBusEnumObject Status %x\n", Status);
/* done */
return Status;
}
PCOMMON_DEVICE_EXTENSION CommonDeviceExtension;
PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
- DPRINT1("KsGetBusEnumPnpDeviceObject\n");
+ DPRINT("KsGetBusEnumPnpDeviceObject\n");
if (!DeviceObject->DeviceExtension)
{
PLIST_ENTRY Entry;
PBUS_DEVICE_ENTRY DeviceEntry = NULL; /* fix gcc */
PIO_STACK_LOCATION IoStack;
- BOOLEAN ItemExists;
+ BOOLEAN ItemExists = FALSE;
PDEV_EXTENSION DeviceExtension;
PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
//PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
NTSTATUS Status;
-
- DPRINT1("KsServiceBusEnumCreateRequest\n");
+ LARGE_INTEGER Time;
/* FIXME: locks */
ASSERT(IoStack->FileObject);
ASSERT(IoStack->FileObject->FileName.Buffer);
+ DPRINT1("KsServiceBusEnumCreateRequest IRP %p Name %wZ\n", Irp, &IoStack->FileObject->FileName);
+
/* scan list and check if it is already present */
Entry = BusDeviceExtension->Common.Entry.Flink;
if (DeviceEntry->DeviceState == Started)
{
/* issue reparse */
- return KspDoReparseForIrp(Irp, DeviceEntry);
+ Status = KspDoReparseForIrp(Irp, DeviceEntry);
+ DPRINT("REPARSE Irp %p '%wZ'\n", Irp, &IoStack->FileObject->FileName);
+
+ Irp->IoStatus.Status = Status;
+ return Status;
}
/* delay processing until pnp is finished with enumeration */
/* insert into irp pending list */
InsertTailList(&DeviceEntry->IrpPendingList, &Irp->Tail.Overlay.ListEntry);
- /* HACK */
- IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
+ Time.QuadPart = Int32x32To64(1500, -10000);
+ DbgPrint("PENDING Irp %p %wZ\n", Irp, &IoStack->FileObject->FileName);
+ /* query current time */
+ KeQuerySystemTime(&DeviceEntry->TimeCreated);
+
+ /* set timer */
+ KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
/* done for now */
return STATUS_PENDING;
DPRINT1("KsServiceBusEnumCreateRequest failed to create PDO with %x\n", Status);
return Status;
}
+ DPRINT1("PENDING CREATE Irp %p %wZ\n", Irp, &IoStack->FileObject->FileName);
/* delay processing until pnp is finished with enumeration */
IoMarkIrpPending(Irp);
{
PDEV_EXTENSION DeviceExtension;
PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
+ PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
PIO_STACK_LOCATION IoStack;
-
- DPRINT1("KsServiceBusEnumPnpRequest %p\n", DeviceObject);
+ NTSTATUS Status;
+ LARGE_INTEGER Time;
+ PDEVICE_RELATIONS DeviceRelation;
+ PBUS_DEVICE_ENTRY DeviceEntry;
/* get device extension */
DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
{
/* no op for bus driver */
- return STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
}
else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS)
{
/* handle bus device relations */
ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == BusRelations);
- return KspQueryBusRelations(BusDeviceExtension, Irp);
+ Status = KspQueryBusRelations(BusDeviceExtension, Irp);
+ }
+ else
+ {
+ /* get default status */
+ Status = Irp->IoStatus.Status;
}
- DPRINT1("KsServiceBusEnumPnpRequest BusObject MinorFunction %x\n", IoStack->MinorFunction);
- return STATUS_NOT_SUPPORTED;
}
else
{
+ /* get child device extension */
+ ChildDeviceExtension = DeviceExtension->Ext;
+
+ /* get bus device extension */
+ BusDeviceExtension = ChildDeviceExtension->BusDeviceExtension;
+
if (IoStack->MinorFunction == IRP_MN_QUERY_ID)
{
/* query id */
- return KspQueryId(&BusDeviceExtension->Common, Irp);
+ Status = KspQueryId(ChildDeviceExtension, Irp);
+ }
+ else if (IoStack->MinorFunction == IRP_MN_REMOVE_DEVICE)
+ {
+ ASSERT(ChildDeviceExtension->DeviceEntry->DeviceState != Started || ChildDeviceExtension->DeviceEntry->DeviceState == NotStarted);
+ ASSERT(ChildDeviceExtension->DeviceEntry->PDO == DeviceObject);
+
+ /* backup device entry */
+ DeviceEntry = ChildDeviceExtension->DeviceEntry;
+
+ /* free device extension */
+ FreeItem(ChildDeviceExtension);
+
+ /* clear PDO reference */
+ DeviceEntry->PDO = NULL;
+
+ /* delete the device */
+ IoDeleteDevice(DeviceObject);
+
+ if (DeviceEntry->PDODeviceName)
+ {
+ /* delete pdo device name */
+ FreeItem(DeviceEntry->PDODeviceName);
+
+ /* set to null */
+ DeviceEntry->PDODeviceName = NULL;
+ }
+
+ /* set state no notstarted */
+ DeviceEntry->DeviceState = NotStarted;
+
+ /* time to create PDO */
+ KspCreatePDO(BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
+
+ /* invalidate device relations */
+ IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
+
+ /* done */
+ Status = STATUS_SUCCESS;
}
else if (IoStack->MinorFunction == IRP_MN_QUERY_BUS_INFORMATION)
{
/* query bus information */
- return KspQueryBusInformation(&BusDeviceExtension->Common, Irp);
+ Status = KspQueryBusInformation(ChildDeviceExtension, Irp);
}
else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCES)
{
/* no op */
- return STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
}
else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCE_REQUIREMENTS)
{
/* no op */
- return STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
}
else if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
{
/* start bus */
- return KspStartBusDevice(DeviceObject, &BusDeviceExtension->Common, Irp);
+ Status = KspStartBusDevice(DeviceObject, ChildDeviceExtension, Irp);
+
+ /* set time out */
+ Time.QuadPart = Int32x32To64(1500, -10000);
+
+ /* sanity check */
+ ASSERT(BusDeviceExtension);
+
+ /* set timer */
+ KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
}
else if (IoStack->MinorFunction == IRP_MN_QUERY_CAPABILITIES)
{
/* query capabilities */
- return KspQueryBusDeviceCapabilities(&BusDeviceExtension->Common, Irp);
+ Status = KspQueryBusDeviceCapabilities(ChildDeviceExtension, Irp);
}
else if (IoStack->MinorFunction == IRP_MN_QUERY_PNP_DEVICE_STATE)
{
/* query pnp state */
- return KspQueryBusDevicePnpState(&BusDeviceExtension->Common, Irp);
+ Status = KspQueryBusDevicePnpState(ChildDeviceExtension, Irp);
}
else if (IoStack->MinorFunction == IRP_MN_QUERY_INTERFACE)
{
/* query interface */
- return KspQueryBusDeviceInterface(Irp, &BusDeviceExtension->Common);
+ Status = KspQueryBusDeviceInterface(ChildDeviceExtension, Irp);
}
+ else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS && IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
+ {
+ /* handle target device relations */
+ ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation);
+ ASSERT(Irp->IoStatus.Information == 0);
+
+ /* allocate device relation */
+ DeviceRelation = AllocateItem(PagedPool, sizeof(DEVICE_RELATIONS));
+ if (DeviceRelation)
+ {
+ DeviceRelation->Count = 1;
+ DeviceRelation->Objects[0] = DeviceObject;
+
+ /* reference self */
+ ObReferenceObject(DeviceObject);
- DPRINT1("KsServiceBusEnumPnpRequest BusObject MinorFunction %x\n", IoStack->MinorFunction);
- return STATUS_NOT_SUPPORTED;
+ /* store result */
+ Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
+
+ /* done */
+ Status = STATUS_SUCCESS;
+ }
+ else
+ {
+ /* no memory */
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ }
+ }
+ else
+ {
+ /* get default status */
+ Status = Irp->IoStatus.Status;
+ }
}
+
+ DPRINT("KsServiceBusEnumPnpRequest %p Bus %u Function %x Status %x\n", DeviceObject, BusDeviceExtension->Common.IsBus, IoStack->MinorFunction, Status);
+ Irp->IoStatus.Status = Status;
+ return Status;
}
/*
projects / reactos.git / commitdiff