mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1791 lines
41 KiB
1791 lines
41 KiB
/*++
|
|
|
|
Copyright (c) 1991, 1992, 1993 - 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
utils.c
|
|
|
|
Abstract:
|
|
|
|
This module contains code that perform queueing and completion
|
|
manipulation on requests. Also module generic functions such
|
|
as error logging.
|
|
|
|
Author:
|
|
|
|
Anthony V. Ercolano 26-Sep-1991
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
|
|
VOID
|
|
SerialRundownIrpRefs(
|
|
IN PIRP *CurrentOpIrp,
|
|
IN PKTIMER IntervalTimer,
|
|
IN PKTIMER TotalTimer,
|
|
IN PSERIAL_DEVICE_EXTENSION PDevExt
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGESER,SerialGetNextIrp)
|
|
#pragma alloc_text(PAGESER, SerialGetNextIrpLocked)
|
|
#pragma alloc_text(PAGESER,SerialTryToCompleteCurrent)
|
|
#pragma alloc_text(PAGESER,SerialStartOrQueue)
|
|
#pragma alloc_text(PAGESER,SerialCancelQueued)
|
|
#pragma alloc_text(PAGESER,SerialCompleteIfError)
|
|
#pragma alloc_text(PAGESER,SerialRundownIrpRefs)
|
|
|
|
#pragma alloc_text(PAGESRP0, SerialLogError)
|
|
#pragma alloc_text(PAGESRP0, SerialMarkHardwareBroken)
|
|
#endif
|
|
|
|
static const PHYSICAL_ADDRESS SerialPhysicalZero = {0};
|
|
|
|
|
|
VOID
|
|
SerialKillAllReadsOrWrites(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PLIST_ENTRY QueueToClean,
|
|
IN PIRP *CurrentOpIrp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is used to cancel all queued and the current irps
|
|
for reads or for writes.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - A pointer to the serial device object.
|
|
|
|
QueueToClean - A pointer to the queue which we're going to clean out.
|
|
|
|
CurrentOpIrp - Pointer to a pointer to the current irp.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
KIRQL cancelIrql;
|
|
PDRIVER_CANCEL cancelRoutine;
|
|
|
|
//
|
|
// We acquire the cancel spin lock. This will prevent the
|
|
// irps from moving around.
|
|
//
|
|
|
|
IoAcquireCancelSpinLock(&cancelIrql);
|
|
|
|
//
|
|
// Clean the list from back to front.
|
|
//
|
|
|
|
while (!IsListEmpty(QueueToClean)) {
|
|
|
|
PIRP currentLastIrp = CONTAINING_RECORD(
|
|
QueueToClean->Blink,
|
|
IRP,
|
|
Tail.Overlay.ListEntry
|
|
);
|
|
|
|
RemoveEntryList(QueueToClean->Blink);
|
|
|
|
cancelRoutine = currentLastIrp->CancelRoutine;
|
|
currentLastIrp->CancelIrql = cancelIrql;
|
|
currentLastIrp->CancelRoutine = NULL;
|
|
currentLastIrp->Cancel = TRUE;
|
|
|
|
cancelRoutine(
|
|
DeviceObject,
|
|
currentLastIrp
|
|
);
|
|
|
|
IoAcquireCancelSpinLock(&cancelIrql);
|
|
|
|
}
|
|
|
|
//
|
|
// The queue is clean. Now go after the current if
|
|
// it's there.
|
|
//
|
|
|
|
if (*CurrentOpIrp) {
|
|
|
|
|
|
cancelRoutine = (*CurrentOpIrp)->CancelRoutine;
|
|
(*CurrentOpIrp)->Cancel = TRUE;
|
|
|
|
//
|
|
// If the current irp is not in a cancelable state
|
|
// then it *will* try to enter one and the above
|
|
// assignment will kill it. If it already is in
|
|
// a cancelable state then the following will kill it.
|
|
//
|
|
|
|
if (cancelRoutine) {
|
|
|
|
(*CurrentOpIrp)->CancelRoutine = NULL;
|
|
(*CurrentOpIrp)->CancelIrql = cancelIrql;
|
|
|
|
//
|
|
// This irp is already in a cancelable state. We simply
|
|
// mark it as canceled and call the cancel routine for
|
|
// it.
|
|
//
|
|
|
|
cancelRoutine(
|
|
DeviceObject,
|
|
*CurrentOpIrp
|
|
);
|
|
|
|
} else {
|
|
|
|
IoReleaseCancelSpinLock(cancelIrql);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
IoReleaseCancelSpinLock(cancelIrql);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
SerialGetNextIrp(
|
|
IN PIRP *CurrentOpIrp,
|
|
IN PLIST_ENTRY QueueToProcess,
|
|
OUT PIRP *NextIrp,
|
|
IN BOOLEAN CompleteCurrent,
|
|
IN PSERIAL_DEVICE_EXTENSION extension
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is used to make the head of the particular
|
|
queue the current irp. It also completes the what
|
|
was the old current irp if desired.
|
|
|
|
Arguments:
|
|
|
|
CurrentOpIrp - Pointer to a pointer to the currently active
|
|
irp for the particular work list. Note that
|
|
this item is not actually part of the list.
|
|
|
|
QueueToProcess - The list to pull the new item off of.
|
|
|
|
NextIrp - The next Irp to process. Note that CurrentOpIrp
|
|
will be set to this value under protection of the
|
|
cancel spin lock. However, if *NextIrp is NULL when
|
|
this routine returns, it is not necessaryly true the
|
|
what is pointed to by CurrentOpIrp will also be NULL.
|
|
The reason for this is that if the queue is empty
|
|
when we hold the cancel spin lock, a new irp may come
|
|
in immediately after we release the lock.
|
|
|
|
CompleteCurrent - If TRUE then this routine will complete the
|
|
irp pointed to by the pointer argument
|
|
CurrentOpIrp.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
KIRQL oldIrql;
|
|
SERIAL_LOCKED_PAGED_CODE();
|
|
|
|
|
|
IoAcquireCancelSpinLock(&oldIrql);
|
|
SerialGetNextIrpLocked(CurrentOpIrp, QueueToProcess, NextIrp,
|
|
CompleteCurrent, extension, oldIrql);
|
|
}
|
|
|
|
VOID
|
|
SerialGetNextIrpLocked(
|
|
IN PIRP *CurrentOpIrp,
|
|
IN PLIST_ENTRY QueueToProcess,
|
|
OUT PIRP *NextIrp,
|
|
IN BOOLEAN CompleteCurrent,
|
|
IN PSERIAL_DEVICE_EXTENSION extension,
|
|
IN KIRQL OldIrql
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is used to make the head of the particular
|
|
queue the current irp. It also completes the what
|
|
was the old current irp if desired. The difference between
|
|
this and SerialGetNextIrp() is that for this we assume the caller
|
|
holds the cancel spinlock and we should release it when we're done.
|
|
|
|
Arguments:
|
|
|
|
CurrentOpIrp - Pointer to a pointer to the currently active
|
|
irp for the particular work list. Note that
|
|
this item is not actually part of the list.
|
|
|
|
QueueToProcess - The list to pull the new item off of.
|
|
|
|
NextIrp - The next Irp to process. Note that CurrentOpIrp
|
|
will be set to this value under protection of the
|
|
cancel spin lock. However, if *NextIrp is NULL when
|
|
this routine returns, it is not necessaryly true the
|
|
what is pointed to by CurrentOpIrp will also be NULL.
|
|
The reason for this is that if the queue is empty
|
|
when we hold the cancel spin lock, a new irp may come
|
|
in immediately after we release the lock.
|
|
|
|
CompleteCurrent - If TRUE then this routine will complete the
|
|
irp pointed to by the pointer argument
|
|
CurrentOpIrp.
|
|
|
|
OldIrql - IRQL which the cancel spinlock was acquired at and what we
|
|
should restore it to.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PIRP oldIrp;
|
|
|
|
SERIAL_LOCKED_PAGED_CODE();
|
|
|
|
|
|
oldIrp = *CurrentOpIrp;
|
|
|
|
#if DBG
|
|
if (oldIrp) {
|
|
|
|
if (CompleteCurrent) {
|
|
|
|
ASSERT(!oldIrp->CancelRoutine);
|
|
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Check to see if there is a new irp to start up.
|
|
//
|
|
|
|
if (!IsListEmpty(QueueToProcess)) {
|
|
|
|
PLIST_ENTRY headOfList;
|
|
|
|
headOfList = RemoveHeadList(QueueToProcess);
|
|
|
|
*CurrentOpIrp = CONTAINING_RECORD(
|
|
headOfList,
|
|
IRP,
|
|
Tail.Overlay.ListEntry
|
|
);
|
|
|
|
IoSetCancelRoutine(
|
|
*CurrentOpIrp,
|
|
NULL
|
|
);
|
|
|
|
} else {
|
|
|
|
*CurrentOpIrp = NULL;
|
|
|
|
}
|
|
|
|
*NextIrp = *CurrentOpIrp;
|
|
IoReleaseCancelSpinLock(OldIrql);
|
|
|
|
if (CompleteCurrent) {
|
|
|
|
if (oldIrp) {
|
|
|
|
SerialDump(
|
|
SERIRPPATH,
|
|
("SERIAL: Complete Irp: %x\n",oldIrp)
|
|
);
|
|
|
|
SerialCompleteRequest(extension, oldIrp, IO_SERIAL_INCREMENT);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
SerialTryToCompleteCurrent(
|
|
IN PSERIAL_DEVICE_EXTENSION Extension,
|
|
IN PKSYNCHRONIZE_ROUTINE SynchRoutine OPTIONAL,
|
|
IN KIRQL IrqlForRelease,
|
|
IN NTSTATUS StatusToUse,
|
|
IN PIRP *CurrentOpIrp,
|
|
IN PLIST_ENTRY QueueToProcess OPTIONAL,
|
|
IN PKTIMER IntervalTimer OPTIONAL,
|
|
IN PKTIMER TotalTimer OPTIONAL,
|
|
IN PSERIAL_START_ROUTINE Starter OPTIONAL,
|
|
IN PSERIAL_GET_NEXT_ROUTINE GetNextIrp OPTIONAL,
|
|
IN LONG RefType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine attempts to kill all of the reasons there are
|
|
references on the current read/write. If everything can be killed
|
|
it will complete this read/write and try to start another.
|
|
|
|
NOTE: This routine assumes that it is called with the cancel
|
|
spinlock held.
|
|
|
|
Arguments:
|
|
|
|
Extension - Simply a pointer to the device extension.
|
|
|
|
SynchRoutine - A routine that will synchronize with the isr
|
|
and attempt to remove the knowledge of the
|
|
current irp from the isr. NOTE: This pointer
|
|
can be null.
|
|
|
|
IrqlForRelease - This routine is called with the cancel spinlock held.
|
|
This is the irql that was current when the cancel
|
|
spinlock was acquired.
|
|
|
|
StatusToUse - The irp's status field will be set to this value, if
|
|
this routine can complete the irp.
|
|
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
SERIAL_LOCKED_PAGED_CODE();
|
|
|
|
//
|
|
// We can decrement the reference to "remove" the fact
|
|
// that the caller no longer will be accessing this irp.
|
|
//
|
|
|
|
SERIAL_CLEAR_REFERENCE(
|
|
*CurrentOpIrp,
|
|
RefType
|
|
);
|
|
|
|
if (SynchRoutine) {
|
|
|
|
KeSynchronizeExecution(
|
|
Extension->Interrupt,
|
|
SynchRoutine,
|
|
Extension
|
|
);
|
|
|
|
}
|
|
|
|
//
|
|
// Try to run down all other references to this irp.
|
|
//
|
|
|
|
SerialRundownIrpRefs(
|
|
CurrentOpIrp,
|
|
IntervalTimer,
|
|
TotalTimer,
|
|
Extension
|
|
);
|
|
|
|
//
|
|
// See if the ref count is zero after trying to kill everybody else.
|
|
//
|
|
|
|
if (!SERIAL_REFERENCE_COUNT(*CurrentOpIrp)) {
|
|
|
|
PIRP newIrp;
|
|
|
|
|
|
//
|
|
// The ref count was zero so we should complete this
|
|
// request.
|
|
//
|
|
// The following call will also cause the current irp to be
|
|
// completed.
|
|
//
|
|
|
|
(*CurrentOpIrp)->IoStatus.Status = StatusToUse;
|
|
|
|
if (StatusToUse == STATUS_CANCELLED) {
|
|
|
|
(*CurrentOpIrp)->IoStatus.Information = 0;
|
|
|
|
}
|
|
|
|
if (GetNextIrp) {
|
|
|
|
IoReleaseCancelSpinLock(IrqlForRelease);
|
|
GetNextIrp(
|
|
CurrentOpIrp,
|
|
QueueToProcess,
|
|
&newIrp,
|
|
TRUE,
|
|
Extension
|
|
);
|
|
|
|
if (newIrp) {
|
|
|
|
Starter(Extension);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
PIRP oldIrp = *CurrentOpIrp;
|
|
|
|
//
|
|
// There was no get next routine. We will simply complete
|
|
// the irp. We should make sure that we null out the
|
|
// pointer to the pointer to this irp.
|
|
//
|
|
|
|
*CurrentOpIrp = NULL;
|
|
|
|
IoReleaseCancelSpinLock(IrqlForRelease);
|
|
SerialDump(
|
|
SERIRPPATH,
|
|
("SERIAL: Complete Irp: %x\n",oldIrp)
|
|
);
|
|
SerialCompleteRequest(Extension, oldIrp, IO_SERIAL_INCREMENT);
|
|
}
|
|
|
|
} else {
|
|
|
|
IoReleaseCancelSpinLock(IrqlForRelease);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
SerialRundownIrpRefs(IN PIRP *CurrentOpIrp, IN PKTIMER IntervalTimer OPTIONAL,
|
|
IN PKTIMER TotalTimer OPTIONAL,
|
|
IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine runs through the various items that *could*
|
|
have a reference to the current read/write. It try's to kill
|
|
the reason. If it does succeed in killing the reason it
|
|
will decrement the reference count on the irp.
|
|
|
|
NOTE: This routine assumes that it is called with the cancel
|
|
spin lock held.
|
|
|
|
Arguments:
|
|
|
|
CurrentOpIrp - Pointer to a pointer to current irp for the
|
|
particular operation.
|
|
|
|
IntervalTimer - Pointer to the interval timer for the operation.
|
|
NOTE: This could be null.
|
|
|
|
TotalTimer - Pointer to the total timer for the operation.
|
|
NOTE: This could be null.
|
|
|
|
PDevExt - Pointer to device extension
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
SERIAL_LOCKED_PAGED_CODE();
|
|
|
|
//
|
|
// This routine is called with the cancel spin lock held
|
|
// so we know only one thread of execution can be in here
|
|
// at one time.
|
|
//
|
|
|
|
//
|
|
// First we see if there is still a cancel routine. If
|
|
// so then we can decrement the count by one.
|
|
//
|
|
|
|
if ((*CurrentOpIrp)->CancelRoutine) {
|
|
|
|
SERIAL_CLEAR_REFERENCE(
|
|
*CurrentOpIrp,
|
|
SERIAL_REF_CANCEL
|
|
);
|
|
|
|
IoSetCancelRoutine(
|
|
*CurrentOpIrp,
|
|
NULL
|
|
);
|
|
|
|
}
|
|
|
|
if (IntervalTimer) {
|
|
|
|
//
|
|
// Try to cancel the operations interval timer. If the operation
|
|
// returns true then the timer did have a reference to the
|
|
// irp. Since we've canceled this timer that reference is
|
|
// no longer valid and we can decrement the reference count.
|
|
//
|
|
// If the cancel returns false then this means either of two things:
|
|
//
|
|
// a) The timer has already fired.
|
|
//
|
|
// b) There never was an interval timer.
|
|
//
|
|
// In the case of "b" there is no need to decrement the reference
|
|
// count since the "timer" never had a reference to it.
|
|
//
|
|
// In the case of "a", then the timer itself will be coming
|
|
// along and decrement it's reference. Note that the caller
|
|
// of this routine might actually be the this timer, but it
|
|
// has already decremented the reference.
|
|
//
|
|
|
|
if (SerialCancelTimer(IntervalTimer, PDevExt)) {
|
|
|
|
SERIAL_CLEAR_REFERENCE(
|
|
*CurrentOpIrp,
|
|
SERIAL_REF_INT_TIMER
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (TotalTimer) {
|
|
|
|
//
|
|
// Try to cancel the operations total timer. If the operation
|
|
// returns true then the timer did have a reference to the
|
|
// irp. Since we've canceled this timer that reference is
|
|
// no longer valid and we can decrement the reference count.
|
|
//
|
|
// If the cancel returns false then this means either of two things:
|
|
//
|
|
// a) The timer has already fired.
|
|
//
|
|
// b) There never was an total timer.
|
|
//
|
|
// In the case of "b" there is no need to decrement the reference
|
|
// count since the "timer" never had a reference to it.
|
|
//
|
|
// In the case of "a", then the timer itself will be coming
|
|
// along and decrement it's reference. Note that the caller
|
|
// of this routine might actually be the this timer, but it
|
|
// has already decremented the reference.
|
|
//
|
|
|
|
if (SerialCancelTimer(TotalTimer, PDevExt)) {
|
|
|
|
SERIAL_CLEAR_REFERENCE(
|
|
*CurrentOpIrp,
|
|
SERIAL_REF_TOTAL_TIMER
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
SerialStartOrQueue(
|
|
IN PSERIAL_DEVICE_EXTENSION Extension,
|
|
IN PIRP Irp,
|
|
IN PLIST_ENTRY QueueToExamine,
|
|
IN PIRP *CurrentOpIrp,
|
|
IN PSERIAL_START_ROUTINE Starter
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to either start or queue any requst
|
|
that can be queued in the driver.
|
|
|
|
Arguments:
|
|
|
|
Extension - Points to the serial device extension.
|
|
|
|
Irp - The irp to either queue or start. In either
|
|
case the irp will be marked pending.
|
|
|
|
QueueToExamine - The queue the irp will be place on if there
|
|
is already an operation in progress.
|
|
|
|
CurrentOpIrp - Pointer to a pointer to the irp the is current
|
|
for the queue. The pointer pointed to will be
|
|
set with to Irp if what CurrentOpIrp points to
|
|
is NULL.
|
|
|
|
Starter - The routine to call if the queue is empty.
|
|
|
|
Return Value:
|
|
|
|
This routine will return STATUS_PENDING if the queue is
|
|
not empty. Otherwise, it will return the status returned
|
|
from the starter routine (or cancel, if the cancel bit is
|
|
on in the irp).
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
KIRQL oldIrql;
|
|
|
|
SERIAL_LOCKED_PAGED_CODE();
|
|
|
|
IoAcquireCancelSpinLock(&oldIrql);
|
|
|
|
//
|
|
// If this is a write irp then take the amount of characters
|
|
// to write and add it to the count of characters to write.
|
|
//
|
|
|
|
if (IoGetCurrentIrpStackLocation(Irp)->MajorFunction
|
|
== IRP_MJ_WRITE) {
|
|
|
|
Extension->TotalCharsQueued +=
|
|
IoGetCurrentIrpStackLocation(Irp)
|
|
->Parameters.Write.Length;
|
|
|
|
} else if ((IoGetCurrentIrpStackLocation(Irp)->MajorFunction
|
|
== IRP_MJ_DEVICE_CONTROL) &&
|
|
((IoGetCurrentIrpStackLocation(Irp)
|
|
->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_SERIAL_IMMEDIATE_CHAR) ||
|
|
(IoGetCurrentIrpStackLocation(Irp)
|
|
->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_SERIAL_XOFF_COUNTER))) {
|
|
|
|
Extension->TotalCharsQueued++;
|
|
|
|
}
|
|
|
|
if ((IsListEmpty(QueueToExamine)) &&
|
|
!(*CurrentOpIrp)) {
|
|
|
|
//
|
|
// There were no current operation. Mark this one as
|
|
// current and start it up.
|
|
//
|
|
|
|
*CurrentOpIrp = Irp;
|
|
|
|
IoReleaseCancelSpinLock(oldIrql);
|
|
|
|
return Starter(Extension);
|
|
|
|
} else {
|
|
|
|
//
|
|
// We don't know how long the irp will be in the
|
|
// queue. So we need to handle cancel.
|
|
//
|
|
|
|
if (Irp->Cancel) {
|
|
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
IoReleaseCancelSpinLock(oldIrql);
|
|
|
|
if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_SERIAL_SET_QUEUE_SIZE) {
|
|
//
|
|
// We shoved the pointer to the memory into the
|
|
// the type 3 buffer pointer which we KNOW we
|
|
// never use.
|
|
//
|
|
|
|
ASSERT(irpSp->Parameters.DeviceIoControl.Type3InputBuffer);
|
|
|
|
ExFreePool(irpSp->Parameters.DeviceIoControl.Type3InputBuffer);
|
|
|
|
irpSp->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
|
|
}
|
|
|
|
Irp->IoStatus.Status = STATUS_CANCELLED;
|
|
|
|
SerialDump(
|
|
SERIRPPATH,
|
|
("SERIAL: Complete Irp: %x\n",Irp)
|
|
);
|
|
SerialCompleteRequest(Extension, Irp, 0);
|
|
|
|
return STATUS_CANCELLED;
|
|
|
|
} else {
|
|
|
|
|
|
Irp->IoStatus.Status = STATUS_PENDING;
|
|
IoMarkIrpPending(Irp);
|
|
|
|
InsertTailList(
|
|
QueueToExamine,
|
|
&Irp->Tail.Overlay.ListEntry
|
|
);
|
|
|
|
IoSetCancelRoutine(
|
|
Irp,
|
|
SerialCancelQueued
|
|
);
|
|
|
|
IoReleaseCancelSpinLock(oldIrql);
|
|
|
|
return STATUS_PENDING;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
SerialCancelQueued(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to cancel Irps that currently reside on
|
|
a queue.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for this device
|
|
|
|
Irp - Pointer to the IRP to be canceled.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PSERIAL_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
|
|
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
SERIAL_LOCKED_PAGED_CODE();
|
|
|
|
Irp->IoStatus.Status = STATUS_CANCELLED;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
|
|
|
|
//
|
|
// If this is a write irp then take the amount of characters
|
|
// to write and subtract it from the count of characters to write.
|
|
//
|
|
|
|
if (irpSp->MajorFunction == IRP_MJ_WRITE) {
|
|
|
|
extension->TotalCharsQueued -= irpSp->Parameters.Write.Length;
|
|
|
|
} else if (irpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL) {
|
|
|
|
//
|
|
// If it's an immediate then we need to decrement the
|
|
// count of chars queued. If it's a resize then we
|
|
// need to deallocate the pool that we're passing on
|
|
// to the "resizing" routine.
|
|
//
|
|
|
|
if ((irpSp->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_SERIAL_IMMEDIATE_CHAR) ||
|
|
(irpSp->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_SERIAL_XOFF_COUNTER)) {
|
|
|
|
extension->TotalCharsQueued--;
|
|
|
|
} else if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_SERIAL_SET_QUEUE_SIZE) {
|
|
|
|
//
|
|
// We shoved the pointer to the memory into the
|
|
// the type 3 buffer pointer which we KNOW we
|
|
// never use.
|
|
//
|
|
|
|
ASSERT(irpSp->Parameters.DeviceIoControl.Type3InputBuffer);
|
|
|
|
ExFreePool(irpSp->Parameters.DeviceIoControl.Type3InputBuffer);
|
|
|
|
irpSp->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
IoReleaseCancelSpinLock(Irp->CancelIrql);
|
|
|
|
SerialDump(
|
|
SERIRPPATH,
|
|
("SERIAL: Complete Irp: %x\n",Irp)
|
|
);
|
|
SerialCompleteRequest(extension, Irp, IO_SERIAL_INCREMENT);
|
|
}
|
|
|
|
NTSTATUS
|
|
SerialCompleteIfError(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
If the current irp is not an IOCTL_SERIAL_GET_COMMSTATUS request and
|
|
there is an error and the application requested abort on errors,
|
|
then cancel the irp.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for this device
|
|
|
|
Irp - Pointer to the IRP to test.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS or STATUS_CANCELLED.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PSERIAL_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
|
|
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
SERIAL_LOCKED_PAGED_CODE();
|
|
|
|
if ((extension->HandFlow.ControlHandShake &
|
|
SERIAL_ERROR_ABORT) && extension->ErrorWord) {
|
|
|
|
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
//
|
|
// There is a current error in the driver. No requests should
|
|
// come through except for the GET_COMMSTATUS.
|
|
//
|
|
|
|
if ((irpSp->MajorFunction != IRP_MJ_DEVICE_CONTROL) ||
|
|
(irpSp->Parameters.DeviceIoControl.IoControlCode !=
|
|
IOCTL_SERIAL_GET_COMMSTATUS)) {
|
|
|
|
status = STATUS_CANCELLED;
|
|
Irp->IoStatus.Status = STATUS_CANCELLED;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
SerialDump(
|
|
SERIRPPATH,
|
|
("SERIAL: Complete Irp: %x\n",Irp)
|
|
);
|
|
SerialCompleteRequest(extension, Irp, 0);
|
|
}
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
VOID
|
|
SerialFilterCancelQueued(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will be used cancel irps on the stalled queue.
|
|
|
|
Arguments:
|
|
|
|
PDevObj - Pointer to the device object.
|
|
|
|
PIrp - Pointer to the Irp to cancel
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PSERIAL_DEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
|
|
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(PIrp);
|
|
|
|
PIrp->IoStatus.Status = STATUS_CANCELLED;
|
|
PIrp->IoStatus.Information = 0;
|
|
|
|
RemoveEntryList(&PIrp->Tail.Overlay.ListEntry);
|
|
|
|
IoReleaseCancelSpinLock(PIrp->CancelIrql);
|
|
}
|
|
|
|
VOID
|
|
SerialKillAllStalled(IN PDEVICE_OBJECT PDevObj)
|
|
{
|
|
KIRQL cancelIrql;
|
|
PDRIVER_CANCEL cancelRoutine;
|
|
PSERIAL_DEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
|
|
|
|
IoAcquireCancelSpinLock(&cancelIrql);
|
|
|
|
while (!IsListEmpty(&pDevExt->StalledIrpQueue)) {
|
|
|
|
PIRP currentLastIrp = CONTAINING_RECORD(pDevExt->StalledIrpQueue.Blink,
|
|
IRP, Tail.Overlay.ListEntry);
|
|
|
|
RemoveEntryList(pDevExt->StalledIrpQueue.Blink);
|
|
|
|
cancelRoutine = currentLastIrp->CancelRoutine;
|
|
currentLastIrp->CancelIrql = cancelIrql;
|
|
currentLastIrp->CancelRoutine = NULL;
|
|
currentLastIrp->Cancel = TRUE;
|
|
|
|
cancelRoutine(PDevObj, currentLastIrp);
|
|
|
|
IoAcquireCancelSpinLock(&cancelIrql);
|
|
}
|
|
|
|
IoReleaseCancelSpinLock(cancelIrql);
|
|
}
|
|
|
|
NTSTATUS
|
|
SerialFilterIrps(IN PIRP PIrp, IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will be used to approve irps for processing.
|
|
If an irp is approved, success will be returned. If not,
|
|
the irp will be queued or rejected outright. The IoStatus struct
|
|
and return value will appropriately reflect the actions taken.
|
|
|
|
Arguments:
|
|
|
|
PIrp - Pointer to the Irp to cancel
|
|
|
|
PDevExt - Pointer to the device extension
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION pIrpStack;
|
|
KIRQL oldIrqlFlags;
|
|
|
|
pIrpStack = IoGetCurrentIrpStackLocation(PIrp);
|
|
|
|
KeAcquireSpinLock(&PDevExt->FlagsLock, &oldIrqlFlags);
|
|
|
|
if ((PDevExt->DevicePNPAccept == SERIAL_PNPACCEPT_OK)
|
|
&& ((PDevExt->Flags & SERIAL_FLAGS_BROKENHW) == 0)) {
|
|
KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
if ((PDevExt->DevicePNPAccept & SERIAL_PNPACCEPT_REMOVING)
|
|
|| (PDevExt->Flags & SERIAL_FLAGS_BROKENHW)
|
|
|| (PDevExt->DevicePNPAccept & SERIAL_PNPACCEPT_SURPRISE_REMOVING)) {
|
|
|
|
KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
|
|
|
|
//
|
|
// Accept all PNP IRP's -- we assume PNP can synchronize itself
|
|
//
|
|
|
|
if (pIrpStack->MajorFunction == IRP_MJ_PNP) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
PIrp->IoStatus.Status = STATUS_DELETE_PENDING;
|
|
return STATUS_DELETE_PENDING;
|
|
}
|
|
|
|
if (PDevExt->DevicePNPAccept & SERIAL_PNPACCEPT_STOPPING) {
|
|
KIRQL oldIrql;
|
|
|
|
KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
|
|
|
|
|
|
//
|
|
// Accept all PNP IRP's -- we assume PNP can synchronize itself
|
|
//
|
|
|
|
if (pIrpStack->MajorFunction == IRP_MJ_PNP) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
IoAcquireCancelSpinLock(&oldIrql);
|
|
|
|
if (PIrp->Cancel) {
|
|
IoReleaseCancelSpinLock(oldIrql);
|
|
PIrp->IoStatus.Status = STATUS_CANCELLED;
|
|
return STATUS_CANCELLED;
|
|
} else {
|
|
//
|
|
// Mark the Irp as pending
|
|
//
|
|
|
|
PIrp->IoStatus.Status = STATUS_PENDING;
|
|
IoMarkIrpPending(PIrp);
|
|
|
|
//
|
|
// Queue up the IRP
|
|
//
|
|
|
|
InsertTailList(&PDevExt->StalledIrpQueue,
|
|
&PIrp->Tail.Overlay.ListEntry);
|
|
|
|
IoSetCancelRoutine(PIrp, SerialFilterCancelQueued);
|
|
IoReleaseCancelSpinLock(oldIrql);
|
|
return STATUS_PENDING;
|
|
}
|
|
}
|
|
|
|
KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
VOID
|
|
SerialUnstallIrps(IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will be used to restart irps temporarily stalled on
|
|
the stall queue due to a stop or some such nonsense.
|
|
|
|
Arguments:
|
|
|
|
PDevExt - Pointer to the device extension
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY pIrpLink;
|
|
PIRP pIrp;
|
|
PIO_STACK_LOCATION pIrpStack;
|
|
PDEVICE_OBJECT pDevObj;
|
|
PDRIVER_OBJECT pDrvObj;
|
|
KIRQL oldIrql;
|
|
|
|
SerialDump(SERTRACECALLS, ("SERIAL: Entering SerialUnstallIrps\n"));
|
|
IoAcquireCancelSpinLock(&oldIrql);
|
|
|
|
pIrpLink = PDevExt->StalledIrpQueue.Flink;
|
|
|
|
while (pIrpLink != &PDevExt->StalledIrpQueue) {
|
|
pIrp = CONTAINING_RECORD(pIrpLink, IRP, Tail.Overlay.ListEntry);
|
|
RemoveEntryList(&pIrp->Tail.Overlay.ListEntry);
|
|
|
|
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
|
|
pDevObj = pIrpStack->DeviceObject;
|
|
pDrvObj = pDevObj->DriverObject;
|
|
IoSetCancelRoutine(pIrp, NULL);
|
|
IoReleaseCancelSpinLock(oldIrql);
|
|
|
|
SerialDump(SERPNPPOWER, ("SERIAL: Unstalling Irp 0x%x with 0x%x\n",
|
|
pIrp, pIrpStack->MajorFunction));
|
|
|
|
pDrvObj->MajorFunction[pIrpStack->MajorFunction](pDevObj, pIrp);
|
|
|
|
IoAcquireCancelSpinLock(&oldIrql);
|
|
pIrpLink = PDevExt->StalledIrpQueue.Flink;
|
|
}
|
|
|
|
IoReleaseCancelSpinLock(oldIrql);
|
|
|
|
SerialDump(SERTRACECALLS, ("SERIAL: Leaving SerialUnstallIrps\n"));
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
SerialIRPPrologue(IN PIRP PIrp, IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called at any IRP dispatch entry point. It,
|
|
with SerialIRPEpilogue(), keeps track of all pending IRP's for the given
|
|
PDevObj.
|
|
|
|
Arguments:
|
|
|
|
PDevObj - Pointer to the device object we are tracking pending IRP's for.
|
|
|
|
Return Value:
|
|
|
|
Tentative status of the Irp.
|
|
|
|
--*/
|
|
{
|
|
InterlockedIncrement(&PDevExt->PendingIRPCnt);
|
|
|
|
return SerialFilterIrps(PIrp, PDevExt);
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
SerialIRPEpilogue(IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called at any IRP dispatch entry point. It,
|
|
with SerialIRPPrologue(), keeps track of all pending IRP's for the given
|
|
PDevObj.
|
|
|
|
Arguments:
|
|
|
|
PDevObj - Pointer to the device object we are tracking pending IRP's for.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
LONG pendingCnt;
|
|
|
|
pendingCnt = InterlockedDecrement(&PDevExt->PendingIRPCnt);
|
|
|
|
ASSERT(pendingCnt >= 0);
|
|
|
|
if (pendingCnt == 0) {
|
|
KeSetEvent(&PDevExt->PendingIRPEvent, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SerialInsertQueueDpc(IN PRKDPC PDpc, IN PVOID Sarg1, IN PVOID Sarg2,
|
|
IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called to queue DPC's for the serial driver.
|
|
|
|
Arguments:
|
|
|
|
PDpc thru Sarg2 - Standard args to KeInsertQueueDpc()
|
|
|
|
PDevExt - Pointer to the device extension for the device that needs to
|
|
queue a DPC
|
|
|
|
Return Value:
|
|
|
|
Kicks up return value from KeInsertQueueDpc()
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN queued;
|
|
|
|
InterlockedIncrement(&PDevExt->DpcCount);
|
|
|
|
queued = KeInsertQueueDpc(PDpc, Sarg1, Sarg2);
|
|
|
|
if (!queued) {
|
|
ULONG pendingCnt;
|
|
|
|
pendingCnt = InterlockedDecrement(&PDevExt->DpcCount);
|
|
|
|
if (pendingCnt == 0) {
|
|
KeSetEvent(&PDevExt->PendingIRPEvent, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
}
|
|
|
|
#if 0 // DBG
|
|
if (queued) {
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_DPC_QUEUE; i++) {
|
|
if (PDevExt->DpcQueued[i].Dpc == PDpc) {
|
|
PDevExt->DpcQueued[i].QueuedCount++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT(i < MAX_DPC_QUEUE);
|
|
}
|
|
#endif
|
|
|
|
return queued;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SerialSetTimer(IN PKTIMER Timer, IN LARGE_INTEGER DueTime,
|
|
IN PKDPC Dpc OPTIONAL, IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called to set timers for the serial driver.
|
|
|
|
Arguments:
|
|
|
|
Timer - pointer to timer dispatcher object
|
|
|
|
DueTime - time at which the timer should expire
|
|
|
|
Dpc - option Dpc
|
|
|
|
PDevExt - Pointer to the device extension for the device that needs to
|
|
set a timer
|
|
|
|
Return Value:
|
|
|
|
Kicks up return value from KeSetTimer()
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN set;
|
|
|
|
InterlockedIncrement(&PDevExt->DpcCount);
|
|
|
|
set = KeSetTimer(Timer, DueTime, Dpc);
|
|
|
|
if (set) {
|
|
InterlockedDecrement(&PDevExt->DpcCount);
|
|
}
|
|
|
|
#if 0 // DBG
|
|
if (set) {
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_DPC_QUEUE; i++) {
|
|
if (PDevExt->DpcQueued[i].Dpc == Dpc) {
|
|
PDevExt->DpcQueued[i].QueuedCount++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT(i < MAX_DPC_QUEUE);
|
|
}
|
|
#endif
|
|
|
|
return set;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SerialCancelTimer(IN PKTIMER Timer, IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called to cancel timers for the serial driver.
|
|
|
|
Arguments:
|
|
|
|
Timer - pointer to timer dispatcher object
|
|
|
|
PDevExt - Pointer to the device extension for the device that needs to
|
|
set a timer
|
|
|
|
Return Value:
|
|
|
|
True if timer was cancelled
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN cancelled;
|
|
|
|
cancelled = KeCancelTimer(Timer);
|
|
|
|
if (cancelled) {
|
|
SerialDpcEpilogue(PDevExt, Timer->Dpc);
|
|
}
|
|
|
|
return cancelled;
|
|
}
|
|
|
|
|
|
VOID
|
|
SerialDpcEpilogue(IN PSERIAL_DEVICE_EXTENSION PDevExt, PKDPC PDpc)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called at the end of every dpc function.
|
|
|
|
Arguments:
|
|
|
|
PDevObj - Pointer to the device object we are tracking dpc's for.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
LONG pendingCnt;
|
|
#if 1 // !DBG
|
|
UNREFERENCED_PARAMETER(PDpc);
|
|
#endif
|
|
|
|
pendingCnt = InterlockedDecrement(&PDevExt->DpcCount);
|
|
|
|
ASSERT(pendingCnt >= 0);
|
|
|
|
#if 0 //DBG
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_DPC_QUEUE; i++) {
|
|
if (PDevExt->DpcQueued[i].Dpc == PDpc) {
|
|
PDevExt->DpcQueued[i].FlushCount++;
|
|
|
|
ASSERT(PDevExt->DpcQueued[i].QueuedCount >=
|
|
PDevExt->DpcQueued[i].FlushCount);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT(i < MAX_DPC_QUEUE);
|
|
}
|
|
#endif
|
|
|
|
if (pendingCnt == 0) {
|
|
KeSetEvent(&PDevExt->PendingDpcEvent, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
SerialUnlockPages(IN PKDPC PDpc, IN PVOID PDeferredContext,
|
|
IN PVOID PSysContext1, IN PVOID PSysContext2)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is a DPC routine queue from the ISR if he released the
|
|
last lock on pending DPC's.
|
|
|
|
Arguments:
|
|
|
|
PDpdc, PSysContext1, PSysContext2 -- not used
|
|
|
|
PDeferredContext -- Really the device extension
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PSERIAL_DEVICE_EXTENSION pDevExt
|
|
= (PSERIAL_DEVICE_EXTENSION)PDeferredContext;
|
|
|
|
UNREFERENCED_PARAMETER(PDpc);
|
|
UNREFERENCED_PARAMETER(PSysContext1);
|
|
UNREFERENCED_PARAMETER(PSysContext2);
|
|
|
|
KeSetEvent(&pDevExt->PendingDpcEvent, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
SerialIoCallDriver(PSERIAL_DEVICE_EXTENSION PDevExt, PDEVICE_OBJECT PDevObj,
|
|
PIRP PIrp)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called instead of IoCallDriver. It automatically
|
|
updates Irp tracking for PDevObj.
|
|
|
|
Arguments:
|
|
PDevExt - Device extension attached to PDevObj
|
|
|
|
PDevObj - Pointer to the device object we are tracking pending IRP's for.
|
|
|
|
PIrp - Pointer to the Irp we are passing to the next driver.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
|
|
status = IoCallDriver(PDevObj, PIrp);
|
|
SerialIRPEpilogue(PDevExt);
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
SerialPoCallDriver(PSERIAL_DEVICE_EXTENSION PDevExt, PDEVICE_OBJECT PDevObj,
|
|
PIRP PIrp)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function must be called instead of PoCallDriver. It automatically
|
|
updates Irp tracking for PDevObj.
|
|
|
|
Arguments:
|
|
PDevExt - Device extension attached to PDevObj
|
|
|
|
PDevObj - Pointer to the device object we are tracking pending IRP's for.
|
|
|
|
PIrp - Pointer to the Irp we are passing to the next driver.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
|
|
status = PoCallDriver(PDevObj, PIrp);
|
|
SerialIRPEpilogue(PDevExt);
|
|
return status;
|
|
}
|
|
|
|
|
|
VOID
|
|
SerialLogError(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
|
|
IN PHYSICAL_ADDRESS P1,
|
|
IN PHYSICAL_ADDRESS P2,
|
|
IN ULONG SequenceNumber,
|
|
IN UCHAR MajorFunctionCode,
|
|
IN UCHAR RetryCount,
|
|
IN ULONG UniqueErrorValue,
|
|
IN NTSTATUS FinalStatus,
|
|
IN NTSTATUS SpecificIOStatus,
|
|
IN ULONG LengthOfInsert1,
|
|
IN PWCHAR Insert1,
|
|
IN ULONG LengthOfInsert2,
|
|
IN PWCHAR Insert2
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allocates an error log entry, copies the supplied data
|
|
to it, and requests that it be written to the error log file.
|
|
|
|
Arguments:
|
|
|
|
DriverObject - A pointer to the driver object for the device.
|
|
|
|
DeviceObject - A pointer to the device object associated with the
|
|
device that had the error, early in initialization, one may not
|
|
yet exist.
|
|
|
|
P1,P2 - If phyical addresses for the controller ports involved
|
|
with the error are available, put them through as dump data.
|
|
|
|
SequenceNumber - A ulong value that is unique to an IRP over the
|
|
life of the irp in this driver - 0 generally means an error not
|
|
associated with an irp.
|
|
|
|
MajorFunctionCode - If there is an error associated with the irp,
|
|
this is the major function code of that irp.
|
|
|
|
RetryCount - The number of times a particular operation has been
|
|
retried.
|
|
|
|
UniqueErrorValue - A unique long word that identifies the particular
|
|
call to this function.
|
|
|
|
FinalStatus - The final status given to the irp that was associated
|
|
with this error. If this log entry is being made during one of
|
|
the retries this value will be STATUS_SUCCESS.
|
|
|
|
SpecificIOStatus - The IO status for a particular error.
|
|
|
|
LengthOfInsert1 - The length in bytes (including the terminating NULL)
|
|
of the first insertion string.
|
|
|
|
Insert1 - The first insertion string.
|
|
|
|
LengthOfInsert2 - The length in bytes (including the terminating NULL)
|
|
of the second insertion string. NOTE, there must
|
|
be a first insertion string for their to be
|
|
a second insertion string.
|
|
|
|
Insert2 - The second insertion string.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_ERROR_LOG_PACKET errorLogEntry;
|
|
|
|
PVOID objectToUse;
|
|
SHORT dumpToAllocate = 0;
|
|
PUCHAR ptrToFirstInsert;
|
|
PUCHAR ptrToSecondInsert;
|
|
|
|
PAGED_CODE();
|
|
|
|
if (Insert1 == NULL) {
|
|
LengthOfInsert1 = 0;
|
|
}
|
|
|
|
if (Insert2 == NULL) {
|
|
LengthOfInsert2 = 0;
|
|
}
|
|
|
|
|
|
if (ARGUMENT_PRESENT(DeviceObject)) {
|
|
|
|
objectToUse = DeviceObject;
|
|
|
|
} else {
|
|
|
|
objectToUse = DriverObject;
|
|
|
|
}
|
|
|
|
if (SerialMemCompare(
|
|
P1,
|
|
(ULONG)1,
|
|
SerialPhysicalZero,
|
|
(ULONG)1
|
|
) != AddressesAreEqual) {
|
|
|
|
dumpToAllocate = (SHORT)sizeof(PHYSICAL_ADDRESS);
|
|
|
|
}
|
|
|
|
if (SerialMemCompare(
|
|
P2,
|
|
(ULONG)1,
|
|
SerialPhysicalZero,
|
|
(ULONG)1
|
|
) != AddressesAreEqual) {
|
|
|
|
dumpToAllocate += (SHORT)sizeof(PHYSICAL_ADDRESS);
|
|
|
|
}
|
|
|
|
errorLogEntry = IoAllocateErrorLogEntry(
|
|
objectToUse,
|
|
(UCHAR)(sizeof(IO_ERROR_LOG_PACKET) +
|
|
dumpToAllocate
|
|
+ LengthOfInsert1 +
|
|
LengthOfInsert2)
|
|
);
|
|
|
|
if ( errorLogEntry != NULL ) {
|
|
|
|
errorLogEntry->ErrorCode = SpecificIOStatus;
|
|
errorLogEntry->SequenceNumber = SequenceNumber;
|
|
errorLogEntry->MajorFunctionCode = MajorFunctionCode;
|
|
errorLogEntry->RetryCount = RetryCount;
|
|
errorLogEntry->UniqueErrorValue = UniqueErrorValue;
|
|
errorLogEntry->FinalStatus = FinalStatus;
|
|
errorLogEntry->DumpDataSize = dumpToAllocate;
|
|
|
|
if (dumpToAllocate) {
|
|
|
|
RtlCopyMemory(
|
|
&errorLogEntry->DumpData[0],
|
|
&P1,
|
|
sizeof(PHYSICAL_ADDRESS)
|
|
);
|
|
|
|
if (dumpToAllocate > sizeof(PHYSICAL_ADDRESS)) {
|
|
|
|
RtlCopyMemory(
|
|
((PUCHAR)&errorLogEntry->DumpData[0])
|
|
+sizeof(PHYSICAL_ADDRESS),
|
|
&P2,
|
|
sizeof(PHYSICAL_ADDRESS)
|
|
);
|
|
|
|
ptrToFirstInsert =
|
|
((PUCHAR)&errorLogEntry->DumpData[0])+(2*sizeof(PHYSICAL_ADDRESS));
|
|
|
|
} else {
|
|
|
|
ptrToFirstInsert =
|
|
((PUCHAR)&errorLogEntry->DumpData[0])+sizeof(PHYSICAL_ADDRESS);
|
|
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ptrToFirstInsert = (PUCHAR)&errorLogEntry->DumpData[0];
|
|
|
|
}
|
|
|
|
ptrToSecondInsert = ptrToFirstInsert + LengthOfInsert1;
|
|
|
|
if (LengthOfInsert1) {
|
|
|
|
errorLogEntry->NumberOfStrings = 1;
|
|
errorLogEntry->StringOffset = (USHORT)(ptrToFirstInsert -
|
|
(PUCHAR)errorLogEntry);
|
|
RtlCopyMemory(
|
|
ptrToFirstInsert,
|
|
Insert1,
|
|
LengthOfInsert1
|
|
);
|
|
|
|
if (LengthOfInsert2) {
|
|
|
|
errorLogEntry->NumberOfStrings = 2;
|
|
RtlCopyMemory(
|
|
ptrToSecondInsert,
|
|
Insert2,
|
|
LengthOfInsert2
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
IoWriteErrorLogEntry(errorLogEntry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
SerialMarkHardwareBroken(IN PSERIAL_DEVICE_EXTENSION PDevExt)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Marks a UART as broken. This causes the driver stack to stop accepting
|
|
requests and eventually be removed.
|
|
|
|
Arguments:
|
|
PDevExt - Device extension attached to PDevObj
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Mark as damaged goods
|
|
//
|
|
|
|
SerialSetFlags(PDevExt, SERIAL_FLAGS_BROKENHW);
|
|
|
|
//
|
|
// Write a log entry
|
|
//
|
|
|
|
SerialLogError(PDevExt->DriverObject, NULL, SerialPhysicalZero,
|
|
SerialPhysicalZero, 0, 0, 0, 88, STATUS_SUCCESS,
|
|
SERIAL_HARDWARE_FAILURE, PDevExt->DeviceName.Length
|
|
+ sizeof(WCHAR), PDevExt->DeviceName.Buffer, 0, NULL);
|
|
|
|
//
|
|
// Invalidate the device
|
|
//
|
|
|
|
IoInvalidateDeviceState(PDevExt->Pdo);
|
|
}
|
|
|
|
VOID
|
|
SerialSetDeviceFlags(IN PSERIAL_DEVICE_EXTENSION PDevExt, OUT PULONG PFlags,
|
|
IN ULONG Value, IN BOOLEAN Set)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets flags in a value protected by the flags spinlock. This is used
|
|
to set values that would stop IRP's from being accepted.
|
|
|
|
Arguments:
|
|
PDevExt - Device extension attached to PDevObj
|
|
|
|
PFlags - Pointer to the flags variable that needs changing
|
|
|
|
Value - Value to modify flags variable with
|
|
|
|
Set - TRUE if |= , FALSE if &=
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
KIRQL oldIrql;
|
|
|
|
KeAcquireSpinLock(&PDevExt->FlagsLock, &oldIrql);
|
|
|
|
if (Set) {
|
|
*PFlags |= Value;
|
|
} else {
|
|
*PFlags &= ~Value;
|
|
}
|
|
|
|
KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrql);
|
|
}
|