StartIO/CancelIO

     驱动程序中的StartIO，CancelIO比较复杂，也很可能出错。翻了一下WDK，删除了一些无关紧要的code，贴在这里方便以后查阅：

1. BOOLEAN
2. IoCancelIrp(
3.     IN PIRP Irp
4.     )
5. {
6.     PDRIVER_CANCEL cancelRoutine;
7.     KIRQL irql;
8.     BOOLEAN returnValue;
11.     ASSERT( Irp->Type == IO_TYPE_IRP );
14.     //
15.     // Acquire the cancel spin lock.
16.     //
18.     IoAcquireCancelSpinLock( &irql );
20.     //
21.     // Set the cancel flag in the IRP.
22.     //
24.     Irp->Cancel = TRUE;
26.     //
27.     // Obtain the address of the cancel routine, and if one was specified,
28.     // invoke it.
29.     //
31.     cancelRoutine = (PDRIVER_CANCEL) (ULONG_PTR) InterlockedExchangePointer( (PVOID *) &Irp->CancelRoutine, NULL );
33.     if (cancelRoutine) {
34.         Irp->CancelIrql = irql;
36.         cancelRoutine( Irp->Tail.Overlay.CurrentStackLocation->DeviceObject,
37.                        Irp );
38.         //
39.         // The cancel spinlock should have been released by the cancel routine.
40.         //
42.         return(TRUE);
44.     } else {
46.         //
47.         // There was no cancel routine, so release the cancel spinlock and
48.         // return indicating the Irp was not currently cancelable.
49.         //
51.         IoReleaseCancelSpinLock( irql );
53.         return(FALSE);
54.     }
55. }

1. VOID
2. IoStartPacket(
3.     IN PDEVICE_OBJECT DeviceObject,
4.     IN PIRP Irp,
5.     IN PULONG Key OPTIONAL,
6.     IN PDRIVER_CANCEL CancelFunction OPTIONAL
7.     )
9. /*++
11. Routine Description:
13.     This routine attempts to start the specified packet request (IRP) on the
14.     specified device.  If the device is already busy, then the packet is
15.     simply queued to the device queue. If a non-NULL CancelFunction is
16.     supplied, it will be put in the IRP.  If the IRP has been canceled, the
17.     CancelFunction will be called after the IRP has been inserted into the
18.     queue or made the current packet.
20. Arguments:
22.     DeviceObject - Pointer to device object itself.
24.     Irp - I/O Request Packet which should be started on the device.
26.     Key - Key to be used in inserting packet into device queue;  optional
27.         (if not specified, then packet is inserted at the tail).
29.     CancelFunction - Pointer to an optional cancel routine.
31. Return Value:
33.     None.
35. --*/
37. {
38.     KIRQL oldIrql;
39.     KIRQL cancelIrql = PASSIVE_LEVEL;
40.     BOOLEAN i;
42.     //
43.     // Raise the IRQL of the processor to dispatch level for synchronization.
44.     //
46.     KeRaiseIrql( DISPATCH_LEVEL, &oldIrql );
48.     //
49.     // If the driver has indicated that packets are cancelable, then acquire
50.     // the cancel spinlock and set the address of the cancel function to
51.     // indicate that the packet is not only cancelable, but indicates what
52.     // routine to invoke should it be cancelled.
53.     //
55.     if (CancelFunction) {
56.         IoAcquireCancelSpinLock( &cancelIrql );
57.         Irp->CancelRoutine = CancelFunction;
58.     }
60.     i = KeInsertDeviceQueue( &DeviceObject->DeviceQueue,
61.                              &Irp->Tail.Overlay.DeviceQueueEntry );
63.     //
64.     // If the packet was not inserted into the queue, then this request is
65.     // now the current packet for this device.  Indicate so by storing its
66.     // address in the current IRP field, and begin processing the request.
67.     //
69.     if (!i) {
71.         DeviceObject->CurrentIrp = Irp;
73.         if (CancelFunction) {
75.             IoReleaseCancelSpinLock( cancelIrql );
76.         }
78.         //
79.         // Invoke the driver's start I/O routine to get the request going on the device.
80.         // The StartIo routine should handle the cancellation.
81.         //
83.         DeviceObject->DriverObject->DriverStartIo( DeviceObject, Irp );
85.     } else {
87.         //
88.         // The packet was successfully inserted into the device's work queue.
89.         // Make one last check to determine whether or not the packet has
90.         // already been marked cancelled.  If it has, then invoke the
91.         // driver's cancel routine now.  Note that because the cancel
92.         // spinlock is currently being held, an attempt to cancel the request
93.         // from another processor at this point will simply wait until this
94.         // routine is finished, and then get it cancelled.
95.         //
97.         if (CancelFunction) {
98.             if (Irp->Cancel) {
99.                 Irp->CancelIrql = cancelIrql;
100.                 Irp->CancelRoutine = (PDRIVER_CANCEL) NULL;
101.                 CancelFunction( DeviceObject, Irp );
102.             } else {
103.                 IoReleaseCancelSpinLock( cancelIrql );
104.             }
105.         }
106.     }
108.     //
109.     // Restore the IRQL back to its value upon entry to this function before
110.     // returning to the caller.
111.     //
113.     KeLowerIrql( oldIrql );
114. }

1. VOID
2. IopStartNextPacket(
3.     IN PDEVICE_OBJECT DeviceObject,
4.     IN LOGICAL Cancelable
5.     )
7. /*++
9. Routine Description:
11.     This routine is invoked to dequeue the next packet (IRP) from the
12.     specified device work queue and invoke the device driver's start I/O
13.     routine for it.  If the Cancelable parameter is TRUE, then the update of
14.     current IRP is synchronized using the cancel spinlock.
16. Arguments:
18.     DeviceObject - Pointer to device object itself.
20.     Cancelable - Indicates that IRPs in the device queue may be cancelable.
22. Return Value:
24.     None.
26. --*/
28. {
29.     KIRQL cancelIrql = PASSIVE_LEVEL;
30.     PIRP irp;
31.     PKDEVICE_QUEUE_ENTRY packet;
33.     //
34.     // Begin by checking to see whether or not this driver's requests are
35.     // to be considered cancelable.  If so, then acquire the cancel spinlock.
36.     //
38.     if (Cancelable) {
39.         IoAcquireCancelSpinLock( &cancelIrql );
40.     }
42.     //
43.     // Clear the current IRP field before starting another request.
44.     //
46.     DeviceObject->CurrentIrp = (PIRP) NULL;
48.     //
49.     // Remove the next packet from the head of the queue.  If a packet was
50.     // found, then process it.
51.     //
53.     packet = KeRemoveDeviceQueue( &DeviceObject->DeviceQueue );
55.     if (packet) {
56.         irp = CONTAINING_RECORD( packet, IRP, Tail.Overlay.DeviceQueueEntry );
58.         //
59.         // A packet was located so make it the current packet for this
60.         // device.
61.         //
63.         DeviceObject->CurrentIrp = irp;
64.         if (Cancelable) {
65.            
66.            IoReleaseCancelSpinLock( cancelIrql );
67.         }
69.         //
70.         // Invoke the driver's start I/O routine for this packet.
71.         //
73.         DeviceObject->DriverObject->DriverStartIo( DeviceObject, irp );
74.     } else {
76.         //
77.         // No packet was found, so simply release the cancel spinlock if
78.         // it was acquired.
79.         //
81.         if (Cancelable) {
82.            IoReleaseCancelSpinLock( cancelIrql );
83.         }
84.     }
85. }

1. #define IoSetCancelRoutine( Irp, NewCancelRoutine ) (  /
2.     (PDRIVER_CANCEL) (ULONG_PTR) InterlockedExchangePointer( (PVOID *) &(Irp)->CancelRoutine, (PVOID) (ULONG_PTR)(NewCancelRoutine) ) )