开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 文章/文档 > 通讯编程文档 > 查看源码
main.c
资源名称：虚拟串口驱动程序.rar　[点击查看]
上传用户：zanmei2
上传日期：2010-03-06
资源大小：775k
文件大小：19k
源码类别：

通讯编程文档

开发平台：

C/C++

main.c：源码内容
  1. /*++
  3. Copyright (c) 2005  Changzhi Zhou All Rights Reserved
  5. Module Name:
  7.     main.c
  9. Abstract:
  11.     This module is main module that deals with
  12. DriverEntry, AddDevice, Unload, handles to device name.
  13. SampleIoCrement and SampleIoDecrement.
  15. Environment:
  17.     Kernel mode
  19. Revision History:
  21. Changzhi Zhou Dec 20  2004
  23. --*/
  24. #include <wdm.h>
  25. #include <ntddk.h>
  26. #include <initguid.h>
  28. #include "main.h"
  29. #include "..incwdmioctl.h"
  30. #include <wmistr.h>
  31. #include <wmilib.h>
  34. #ifdef ALLOC_PRAGMA
  35. #pragma alloc_text (INIT, DriverEntry)
  36. #pragma alloc_text (PAGE, AddDevice)
  37. #pragma alloc_text (PAGE, SamplePnpDispatch)
  38. #pragma alloc_text (PAGE, Unload)
  39. #endif
  41. NTSTATUS
  42. DriverEntry(
  43.     IN PDRIVER_OBJECT  DriverObject,
  44.     IN PUNICODE_STRING RegistryPath
  45.     )
  46. /*++
  48. Routine Description:
  50.     Installable driver initialization entry point.
  51.     This entry point is called directly by the I/O system.
  53. Arguments:
  55.     DriverObject - pointer to the driver object
  57.     RegistryPath - pointer to a unicode string representing the path,
  58.                    to driver-specific key in the registry.
  60. Return Value:
  62.     STATUS_SUCCESS if successful,
  63.     STATUS_UNSUCCESSFUL otherwise.
  65. --*/
  66. {
  67. NTSTATUS            status;
  69.     UNREFERENCED_PARAMETER (RegistryPath);
  71.     DbgPrint("------  VirtualSerial Build on %s %s -------n", __DATE__, __TIME__ );
  73. status = STATUS_SUCCESS;
  75.     DriverObject->MajorFunction[IRP_MJ_PNP] = SamplePnpDispatch;
  76.     DriverObject->MajorFunction[IRP_MJ_POWER] = SamplePowerDispatch;
  77.     DriverObject->MajorFunction[IRP_MJ_CREATE] = SampleCreate;
  78.     DriverObject->MajorFunction[IRP_MJ_CLOSE] = SampleClose;
  79. DriverObject->MajorFunction[IRP_MJ_CLEANUP ] = SampleCleanup;
  80.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = SampleIoControl;
  82. DriverObject->MajorFunction[IRP_MJ_WRITE]           = SampleWrite;
  83. DriverObject->MajorFunction[IRP_MJ_READ]            = SampleRead;
  85.     DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = ToasterSystemControl;
  87.     DriverObject->DriverExtension->AddDevice = AddDevice;
  88.     DriverObject->DriverUnload = Unload;
  90.     return status;
  91. }
  95. NTSTATUS
  96. AddDevice(
  97.     IN PDRIVER_OBJECT DriverObject,
  98.     IN PDEVICE_OBJECT PhysicalDeviceObject
  99.     )
  100. /*++
  102. Routine Description:
  104.     The Plug & Play subsystem is handing us a brand new PDO, for which we
  105.     (by means of INF registration) have been asked to provide a driver.
  107.     We need to determine if we need to be in the driver stack for the device.
  108.     Create a function device object to attach to the stack
  109.     Initialize that device object
  110.     Return status success.
  112.     Remember: We can NOT actually send ANY non pnp IRPS to the given driver
  113.     stack, UNTIL we have received an IRP_MN_START_DEVICE.
  115. Arguments:
  117.     DeviceObject - pointer to a device object.
  119.     PhysicalDeviceObject -  pointer to a device object created by the
  120.                             underlying bus driver.
  122. Return Value:
  124.     NT status code.
  126. --*/
  127. {
  128.     NTSTATUS                status = STATUS_SUCCESS;
  129.     PDEVICE_OBJECT          deviceObject = NULL;
  130.     PDEVICE_EXTENSION       deviceExtension;
  133. UNICODE_STRING deviceObjName;
  135.     PAGED_CODE ();
  136. DbgPrint("------- AddDevice  build on %s %s ---------n", __DATE__, __TIME__);
  138. if( FALSE == InitializeSerialDevName( &deviceObjName ) )
  139. return STATUS_INSUFFICIENT_RESOURCES;
  140.     status = IoCreateDevice (DriverObject,
  141.                              sizeof (DEVICE_EXTENSION),
  142.                              &deviceObjName,
  143.                              FILE_DEVICE_SERIAL_PORT,
  144.                              FILE_DEVICE_SECURE_OPEN,
  145.                              FALSE,
  146.                              &deviceObject);
  147.     if (!NT_SUCCESS (status)) {
  148. DebugPrint(("IoCreateDevice failedn"));
  149. if ( deviceObjName.Buffer != NULL )
  150. ExFreePool ( deviceObjName.Buffer );
  151.         return status;
  152.     }
  154.     DebugPrint (("AddDevice PDO (0x%x) FDO (0x%x)n", PhysicalDeviceObject, deviceObject));
  156.     deviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
  157. deviceExtension->DeviceName.MaximumLength = deviceObjName.MaximumLength;
  158. deviceExtension->DeviceName.Length = deviceObjName.Length;
  159. deviceExtension->DeviceName.Buffer = deviceObjName.Buffer;
  160. deviceExtension->CreatedSerialCommEntry = FALSE;
  161. deviceExtension->CreatedSymbolicLink = FALSE;
  163. // for working thread
  164. KeInitializeSpinLock( &deviceExtension->ThreadSpinLock );
  166.     deviceExtension->NextLowerDriver = IoAttachDeviceToDeviceStack (
  167.                                        deviceObject,
  168.                                        PhysicalDeviceObject);
  169.     if(NULL == deviceExtension->NextLowerDriver) {
  171.         IoDeleteDevice(deviceObject);
  172.         return STATUS_UNSUCCESSFUL;
  173.     }
  174.     DebugPrint(("AddDevice: %x to %x->%x n", deviceObject, 
  175.                        deviceExtension->NextLowerDriver,
  176.                        PhysicalDeviceObject));
  177.     // Initialize the remove event to not-signaled.
  178.     //
  179.     KeInitializeEvent(&deviceExtension->RemoveEvent, 
  180.                       SynchronizationEvent, 
  181.                       FALSE);
  182.     //
  183.     // Initialize the stop event to signaled.
  184.     // This event is signaled when the OutstandingIO becomes 1
  185.     //
  186.     KeInitializeEvent(&deviceExtension->StopEvent, 
  187.                       SynchronizationEvent, 
  188.                       TRUE);
  190.     deviceExtension->OutStandingIO = 1;
  191. deviceExtension->bIsOpen = FALSE;
  192.     
  193. KeInitializeSpinLock( &deviceExtension->IOCountLock );
  194. if ( PhysicalDeviceObject->Flags & DO_POWER_PAGABLE) {
  195.         deviceObject->Flags |= DO_POWER_PAGABLE;
  196.     }
  198.     deviceObject->Flags |= DO_DIRECT_IO;
  199.     deviceExtension->Self = deviceObject;
  201. // Initialize serial-related parameters
  202. deviceExtension->WaitOnMaskIrp = NULL;
  203. deviceExtension->CurrentBaud = 0;
  204. deviceExtension->PendingReadIrp = NULL;
  205. KeInitializeTimer ( &deviceExtension->ReadTimer );
  206. KeInitializeDpc ( &deviceExtension->ReadDpc, ReadDpcRoutine, (PVOID)deviceExtension );
  208. RtlZeroMemory( &deviceExtension->SerialStatus, sizeof( SERIAL_STATUS ) );
  209. // initialize  members relevant to TDI.
  210. deviceExtension->RxBuffer = ExAllocatePoolWithTag( NonPagedPool, RINGBUFFER_SIZE, 'RBuf' );
  211. if ( deviceExtension->RxBuffer == NULL )
  212. goto Error_Exit;
  214. deviceExtension->lpRead = deviceExtension->RxBuffer;
  215. deviceExtension->lpRx = deviceExtension->RxBuffer;
  217. deviceExtension->hTransAddr = NULL;
  218. deviceExtension->lpTransAddrFileObject = NULL;
  219. deviceExtension->TDILowerDeviceObject = NULL;
  220. deviceExtension->RemoteAddress = 0x601a8c0; // 192.168.1.6
  221. deviceExtension->RemotePort = 0x7217; // 6002
  222. RtlZeroMemory( (PVOID)&deviceExtension->recvContext, sizeof( RECV_CONTEXT ) );
  224. deviceExtension->recvContext.RemainderBuffer = ExAllocatePoolWithTag ( NonPagedPool, RECVREMAINDER_BUFFER_SIZE, 'Rrem' );
  225. if ( deviceExtension->recvContext.RemainderBuffer == NULL )
  226. goto Error_Exit;
  227.     KeInitializeEvent(&deviceExtension->recvContext.Event, 
  228.                       SynchronizationEvent,
  229.                       FALSE);
  230. RtlZeroMemory ( (PVOID)&deviceExtension->recvContext.ReceiveDatagramInfo, sizeof ( TDI_CONNECTION_INFORMATION ) );
  231. RtlZeroMemory ( (PVOID)&deviceExtension->recvContext.ReturnInfo, sizeof ( TDI_CONNECTION_INFORMATION ) );
  233.     INITIALIZE_PNP_STATE(deviceExtension);
  234.  
  235. //++ Register device interface for win32app
  236. status = IoRegisterDeviceInterface( PhysicalDeviceObject,
  237. (LPGUID)&GUID_CLASS_COMPORT,
  238. NULL,
  239. &deviceExtension->InterfaceName );
  240. DebugPrint(("InterfaceName:  %wsn", deviceExtension->InterfaceName.Buffer ));
  241. if( !NT_SUCCESS ( status ) ){
  242. DebugPrint(( "AddDevice:  IoRegisterDeviceInterface failed (%x) n", status ));
  243. goto Error_Exit;
  244. }
  245. //--
  247.     deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
  249.     return STATUS_SUCCESS;
  250. Error_Exit:
  251. if( deviceExtension->RxBuffer  )
  252. {
  253. ExFreePool ( deviceExtension->RxBuffer );
  254. deviceExtension->RxBuffer = NULL;
  255. }
  256. if ( deviceExtension->recvContext.RemainderBuffer )
  257. {
  258. ExFreePool ( deviceExtension->recvContext.RemainderBuffer );
  259. deviceExtension->recvContext.RemainderBuffer = NULL;
  260. }
  262. IoDetachDevice( deviceExtension->NextLowerDriver );
  263. IoDeleteDevice( deviceObject );
  264. return status;
  266. }
  268. NTSTATUS
  269. SerialDoExternalNaming(
  270. IN PDEVICE_EXTENSION deviceExtension,
  271. IN LONG ComX
  272. )
  273. /*++
  275. Routine Description:
  277. Create external name, SymbolicLinkName and DOS name.
  279. Arguments:
  281.     deviceExtension - pointer to a device object extension.
  283.     ComX -  indicates the number of Serial Ports.
  285. Return Value:
  287.     NT status code.
  289. --*/
  290. {
  291. NTSTATUS status;
  292. ULONG bufLen;
  293. WCHAR ComXBuffer[ 4 ];
  294. UNICODE_STRING instanceStr;
  295. DebugPrint(("Enter SerialdoExternalNaming routine...n"));
  296. if( deviceExtension->CreatedSymbolicLink || deviceExtension->CreatedSerialCommEntry ){
  297. DebugPrint(("Already create symboliclink or serial commentryn"));
  298. return STATUS_UNSUCCESSFUL;
  299. }
  300. ASSERT( deviceExtension->SymbolicLinkName.Buffer == NULL );
  301. ASSERT( deviceExtension->DosName.Buffer == NULL );
  303. RtlInitUnicodeString(&instanceStr, NULL);
  304. instanceStr.MaximumLength = sizeof( ComXBuffer );
  305. instanceStr.Buffer = ComXBuffer; // 4 WCHAR
  306. RtlIntegerToUnicodeString( ComX, 10, &instanceStr );
  308. // 将SymbolicLinkName设置为 DosDevicesCOMn 的形式。其中n = ComX
  309. RtlZeroMemory( &deviceExtension->SymbolicLinkName, sizeof( UNICODE_STRING ) );
  310. deviceExtension->SymbolicLinkName.MaximumLength = DEVICE_OBJECT_NAME_LENGTH + sizeof( WCHAR );
  311. deviceExtension->SymbolicLinkName.Buffer = ExAllocatePoolWithTag( PagedPool, deviceExtension->SymbolicLinkName.MaximumLength, 'SymL' );
  312. if( deviceExtension->SymbolicLinkName.Buffer == NULL ){
  313. DebugPrint(("SERIAL: Couldn't allocate memory for symbolic link namen"));
  314. status = STATUS_INSUFFICIENT_RESOURCES;
  315. goto SerialDoExternalNamingError;
  316. }
  317. RtlZeroMemory( deviceExtension->SymbolicLinkName.Buffer, deviceExtension->SymbolicLinkName.MaximumLength );
  318. RtlAppendUnicodeToString( &deviceExtension->SymbolicLinkName, DOS_DEVICE_NAME ); //L"\DosDevices\COM"
  319. RtlAppendUnicodeStringToString( &deviceExtension->SymbolicLinkName, &instanceStr);
  320. DebugPrint(("SymbolicLinkName:   %wZn",  deviceExtension->SymbolicLinkName ));
  322. // 将DosName初始化 COMn 的形式， 其中 n = ComX
  323. deviceExtension->DosName.MaximumLength = 64 + sizeof(WCHAR);
  324. deviceExtension->DosName.Buffer = ExAllocatePoolWithTag( PagedPool, 64 + sizeof( WCHAR ), 'Name' );
  325. if( deviceExtension->DosName.Buffer == NULL ){
  326. DebugPrint(("SERIAL: Couldn't allocate memory for Dos namen"));
  327. status =  STATUS_INSUFFICIENT_RESOURCES;
  328. goto SerialDoExternalNamingError;
  329. }
  330. deviceExtension->DosName.Length = 0;
  331. RtlZeroMemory( deviceExtension->DosName.Buffer, deviceExtension->DosName.MaximumLength );
  332. RtlAppendUnicodeToString( &deviceExtension->DosName, L"COM" );
  333. RtlAppendUnicodeStringToString( &deviceExtension->DosName, &instanceStr);
  334. DebugPrint(("DosName:   %wZn", &deviceExtension->DosName ));
  335. DebugPrint(("DeviceName:    %wZn", &deviceExtension->DeviceName ));
  337. // 生成符号连接，至此本设备对win32应用表现的Dos设备名为 DosDevicesCOMn
  338. status = IoCreateSymbolicLink( &deviceExtension->SymbolicLinkName, &deviceExtension->DeviceName );
  339. if( !NT_SUCCESS( status )){
  340. DebugPrint(("SERIAL:  Couldn't create the symbolic link with error %dn", status));
  341. goto SerialDoExternalNamingError;
  342. }else{
  343. DebugPrint(("Create the symbolic link OKn"));
  344. deviceExtension->CreatedSymbolicLink = TRUE;
  345. }
  346. // 在注册表的 HKEY_LOCAL_MACHINEHARDWAREDEVICEMAPSERIALCOMM 中，添加ComX的键值
  347. // 若不进行这一步，则超级终端程序无法检测到本虚拟串口设备
  348. status = RtlWriteRegistryValue(RTL_REGISTRY_DEVICEMAP, SERIAL_DEVICE_MAP,
  349. deviceExtension->DeviceName.Buffer, REG_SZ,
  350. deviceExtension->DosName.Buffer,
  351. deviceExtension->DosName.Length + sizeof(WCHAR));
  352. if( !NT_SUCCESS( status )){
  353. DebugPrint(("SERIAL: Couldn't create the device map entryn------- for port %wZn", deviceExtension->DeviceName ));
  354. goto SerialDoExternalNamingError;
  355. }
  356. deviceExtension->ComX = ComX;
  357. deviceExtension->CreatedSerialCommEntry = TRUE;
  359. SerialDoExternalNamingError:
  361. if( !NT_SUCCESS( status )){
  362. if( deviceExtension->DosName.Buffer != NULL ){
  363. ExFreePool( deviceExtension->DosName.Buffer );
  364. deviceExtension->DosName.Buffer = NULL;
  365. deviceExtension->CreatedSerialCommEntry = FALSE;
  366. }
  367. if( deviceExtension->CreatedSymbolicLink ){
  368. IoDeleteSymbolicLink( &deviceExtension->SymbolicLinkName );
  369. deviceExtension->CreatedSymbolicLink = FALSE;
  370. }
  371. if( deviceExtension->SymbolicLinkName.Buffer != NULL ){
  372. ExFreePool( deviceExtension->SymbolicLinkName.Buffer );
  373. deviceExtension->SymbolicLinkName.Buffer = NULL;
  374. }
  375. }
  376. return status;
  377. }
  380. BOOLEAN InitializeSerialDevName( PUNICODE_STRING lpDeviceName )
  381. /*++
  383. Routine Description:
  385. Initialize serial device name. This name is available in Kernel Mode.
  387. Arguments:
  389.     PUNICODE_STRING lpDeviceName - the pointer to device name string.
  391. Return Value:
  393.     return TRUE if it is successful, otherwise return FALSE.
  395. --*/
  396. {
  398. WCHAR instanceNumberBuffer[ 4 ];
  399. UNICODE_STRING instanceStr;
  400. static ULONG currentInstance = 10;
  401. // 首先处理deviceObjName，这是一个核心态使用的设备名，形如"\Device\SiSerial0"
  402. // Zero out allocated memory pointers so we know if they must be freed
  403. RtlZeroMemory( lpDeviceName, sizeof(UNICODE_STRING) );
  404. lpDeviceName->MaximumLength = DEVICE_OBJECT_NAME_LENGTH * sizeof(WCHAR);
  405. lpDeviceName->Buffer = ExAllocatePool(PagedPool, lpDeviceName->MaximumLength + sizeof(WCHAR));
  406. if ( lpDeviceName->Buffer == NULL) {
  407. DebugPrint(("Couldn't allocate memory for device namen"));
  408. return FALSE;
  409. }
  410. RtlZeroMemory( lpDeviceName->Buffer, lpDeviceName->MaximumLength + sizeof(WCHAR));
  411. // now, the size of deviceObjName.Buffer is (128 + 1)(WCHAR)
  412. RtlAppendUnicodeToString( lpDeviceName, DEVICE_NAME); // L"\Device\VSer"
  414. // 处理 lpDeviceName 的后缀序号
  415. RtlInitUnicodeString(&instanceStr, NULL);
  416. instanceStr.MaximumLength = sizeof(instanceNumberBuffer);
  417. instanceStr.Buffer = instanceNumberBuffer; // 20 WCHAR
  418. currentInstance++;
  419. RtlIntegerToUnicodeString( currentInstance, 10, &instanceStr);
  420. RtlAppendUnicodeStringToString( lpDeviceName, &instanceStr);
  421. DebugPrint(("DeviceName:n"));
  422. DebugPrint(("----------- %wsn", lpDeviceName->Buffer ));
  423. return TRUE;
  424. }
  426. NTSTATUS
  427. SerialUndoExternalNaming(
  428. IN PDEVICE_EXTENSION deviceExtension
  429. )
  430. /*++
  432. Routine Description:
  434. Delete or unregister external name, SymbolicLinkName and DOS name.
  436. Arguments:
  438.     deviceExtension - pointer to a device object extension.
  440. Return Value:
  442.     NT status code.
  444. --*/
  445. {
  446. NTSTATUS status = STATUS_SUCCESS;
  447. if( deviceExtension->CreatedSymbolicLink ){
  448. IoDeleteSymbolicLink( &deviceExtension->SymbolicLinkName );
  449. ExFreePool( deviceExtension->SymbolicLinkName.Buffer );
  450. deviceExtension->SymbolicLinkName.Buffer = NULL;
  451. deviceExtension->CreatedSymbolicLink = FALSE;
  452. }else{
  453. ASSERT( deviceExtension->SymbolicLinkName.Buffer == NULL );
  454. }
  455. ASSERT( deviceExtension->DeviceName.Buffer != NULL );
  456. if( deviceExtension->CreatedSerialCommEntry ){
  457. status = RtlDeleteRegistryValue( RTL_REGISTRY_DEVICEMAP, SERIAL_DEVICE_MAP, deviceExtension->DeviceName.Buffer );
  458. if( !NT_SUCCESS( status ) ){
  459. DebugPrint(("RtlDeleteRegistryValue device map failedn"));
  460. }
  461. ExFreePool( deviceExtension->DosName.Buffer );
  462. deviceExtension->DosName.Buffer = NULL;
  463. deviceExtension->CreatedSerialCommEntry = FALSE;
  464. }else{
  465. ASSERT( deviceExtension->DosName.Buffer == NULL );
  466. }
  467. return status;
  468. }
  470. NTSTATUS
  471. SerialRemoveDevObj(IN PDEVICE_OBJECT PDevObj)
  472. /*++
  474. Routine Description:
  476.     Removes a serial device object from the system.
  478. Arguments:
  480.     PDevObj - A pointer to the Device Object we want removed.
  482. Return Value:
  484.     Always TRUE
  486. --*/
  487. {
  488. PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)PDevObj->DeviceExtension;
  489. PAGED_CODE();
  491. DebugPrint(("SERIAL: Enter SerialRemoveDevObjn"));
  494. //
  495. // Free memory allocated in the extension
  496. //
  498. if (pDevExt->DeviceName.Buffer != NULL) {
  499. ExFreePool(pDevExt->DeviceName.Buffer);
  500. }
  502. if (pDevExt->SymbolicLinkName.Buffer != NULL) {
  503. ExFreePool(pDevExt->SymbolicLinkName.Buffer);
  504. }
  506. if (pDevExt->DosName.Buffer != NULL) {
  507. ExFreePool(pDevExt->DosName.Buffer);
  508. }
  509. DebugPrint(("SERIAL: Leave SerialRemoveDevObjn"));
  511. return STATUS_SUCCESS;
  512. }
  514. NTSTATUS CompleteRequest(IN PIRP Irp, IN NTSTATUS status, IN ULONG info)
  515. {
  516.     Irp->IoStatus.Status = status;
  517.     Irp->IoStatus.Information = info;
  518.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  519.     return status;
  520. }
  521.     
  522. VOID
  523. Unload(
  524.     IN PDRIVER_OBJECT DriverObject
  525.     )
  526. /*++
  528. Routine Description:
  530.     Free all the allocated resources in DriverEntry, etc.
  532. Arguments:
  534.     DriverObject - pointer to a driver object.
  536. Return Value:
  538.     VOID.
  540. --*/
  541. {
  542.     PAGED_CODE ();
  544.     //
  545.     // The device object(s) should be NULL now
  546.     // (since we unload, all the devices objects associated with this
  547.     // driver must be deleted.
  548.     //
  549. DebugPrint( ("Is unloading......n") );
  550.     ASSERT(DriverObject->DeviceObject == NULL);
  551.     
  552.     //
  553.     // We should not be unloaded until all the devices we control 
  554.     // have been removed from our queue.  
  555.     //
  556.     DebugPrint (("Unload:  unloadn"));
  558.     return;
  559. }
  561. LONG
  562. SampleIoIncrement(
  563.     IN OUT PDEVICE_EXTENSION DeviceExtension
  564.     )
  565. /* ++
  566.  
  567. Routine Description:
  569. Increment deviceExtension->OutStandingIO within the scope of IOCountLock.
  571. Arguments:
  573. deviceExtension - pointer to a device object extension.
  575. Return Value:
  577. deviceExtension->OutStandingIO
  579. --*/
  580. {
  581.     LONG  result = 0;
  582.     KIRQL oldIrql;
  584.     KeAcquireSpinLock(&DeviceExtension->IOCountLock, &oldIrql);
  586.     result = InterlockedIncrement(&DeviceExtension->OutStandingIO);
  588.     //
  589.     // when OutStandingIO bumps from 1 to 2, clear the StopEvent
  590.     //
  592.     if(result == 2) {
  594.         KeClearEvent(&DeviceExtension->StopEvent);
  595.     }
  597.     KeReleaseSpinLock(&DeviceExtension->IOCountLock, oldIrql);
  598. DebugPrint(("SampleIncrement: %dn", result));
  600.     return result;
  601. }
  603. LONG
  604. SampleIoDecrement(
  605.     IN OUT PDEVICE_EXTENSION DeviceExtension
  606.     )
  607. /*++
  608.  
  609. Routine Description:
  611.   Decrement deviceExtension->OutStandingIO within the scope of IOCountLock.
  613. Arguments:
  615. deviceExtension - pointer to a device object extension.
  617. Return Value:
  619. deviceExtension->OutStandingIO
  621. --*/
  622. {
  623.     LONG  result = 0;
  624.     KIRQL oldIrql;
  626.     KeAcquireSpinLock(&DeviceExtension->IOCountLock, &oldIrql);
  628.     result = InterlockedDecrement(&DeviceExtension->OutStandingIO);
  630.     if(result == 1) {
  632.         KeSetEvent(&DeviceExtension->StopEvent, IO_NO_INCREMENT, FALSE);
  633.     }
  635.     if(result == 0) {
  637.         ASSERT(Removed == DeviceExtension->DevicePnPState);
  639.         KeSetEvent(&DeviceExtension->RemoveEvent, IO_NO_INCREMENT, FALSE);
  640.     }
  642.     KeReleaseSpinLock(&DeviceExtension->IOCountLock, oldIrql);
  643. DebugPrint(("SampleIoDecrement: %dn", result));
  646.     return result;
  647. }