驱动程序怎样和应用程序通信?

1、内核通知应用层方法： 
a、如果是vxd，使用shell_postmessage是最简单的方法，但是只能传递两个DWORD。walter oney的 
那本关于vxd的书中有更详细的描述，该书的中文版可以在侯俊杰的网站上下载。还有一本关于vxd得好书， 
《windows vxd与设备驱动权威指南》，孙喜明译，作者名字太怪，我记不住，但是个msj上的牛人。这本 
书翻译的不错，孙喜明是98/99活跃在tsinghua bbs上的vxd高手。 
b、如果是sys，思路如下：首先在driver中IoCreateDevice，然后让应用层创建一个线程，调用deviceioctl， 
异步调用，然后等待事件。驱动程序到了需要通知应用层的时候，iocompleteirp，应用层的那个事件就 
变成有信号的，然后就可以得到通知的数据。你可以参考我的代码（附件1，附件2）。该方法同样适用于 
vxd，但是由于vxd没有系统队列的概念，因此你需要使用自定义队列管理应用层请求。稍稍费劲，可以参考 
98ddk/src/net/ndis/vpacket目录下的实现。 


附件1、 
请注意看notifyevent函数。 
当驱动程序需要通知应用层的时候，调用notifyevent函数。 

/*++  

Copyright (c) 2001  

Module Name:  

devctrl.c  

Abstract:  



Author:  

Environment:  


Revision History:  


--*/  


#include "ioctl.h"  



NTSTATUS  
IM_CTRL_Open(  
             IN PDEVICE_OBJECT DeviceObject,  
             IN PIRP Irp  
             )  

/*++  

Routine Description:  

This is the dispatch routine for create/open and close requests.  
These requests complete successfully.  

Arguments:  

DeviceObject - Pointer to the device object.  

Irp - Pointer to the request packet.  

Return Value:  

Status is returned.  

--*/  

{  
    NTSTATUS status = STATUS_SUCCESS;  
    
    DBGPRINT(("OpenAdapter "));  
    
    Irp->IoStatus.Status = status;  
    IoCompleteRequest(Irp, IO_NO_INCREMENT);  
    return status;  
    
}  



NTSTATUS  
IM_CTRL_Close(  
              IN PDEVICE_OBJECT DeviceObject,  
              IN PIRP Irp  
              )  

/*++  

Routine Description:  

This is the dispatch routine for create/open and close requests.  
These requests complete successfully.  

Arguments:  

DeviceObject - Pointer to the device object.  

Irp - Pointer to the request packet.  

Return Value:  

Status is returned.  

--*/  

{  
    
    NTSTATUS status = STATUS_SUCCESS;  
    
    DBGPRINT(("CloseAdapter  "));  
    
    Irp->IoStatus.Status = status;  
    IoCompleteRequest(Irp, IO_NO_INCREMENT);  
    return status;  
}  

NTSTATUS  
IM_CTRL_Cleanup(  
                IN PDEVICE_OBJECT DeviceObject,  
                IN PIRP Irp  
                )  

/*++  

Routine Description:  

This is the dispatch routine for cleanup requests.  
This routine is called whenever a handle to the device  
is closed.  

Arguments:  

DeviceObject - Pointer to the device object.  

Irp - Pointer to the request packet.  

Return Value:  

Status is returned.  

--*/  

{  
    
    NTSTATUS status = STATUS_SUCCESS;  
    
    DBGPRINT(("Packet: Cleanup "));  
    
    Irp->IoStatus.Status = status;  
    IoCompleteRequest(Irp, IO_NO_INCREMENT);  
    return status;  
}  
/*  
VOID  
IM_CTRL_Unload(  
IN PDRIVER_OBJECT DriverObject  
)  
{  

UNICODE_STRING win32DeviceName;  

DBGPRINT(("Unload Enter "));  

//  
// First delete the Control deviceobject and the corresponding  
// symbolicLink  
//  

RtlInitUnicodeString(&win32DeviceName, DOS_DEVICE_NAME);  
IoDeleteSymbolicLink(&win32DeviceName);  
if(Globals.ControlDeviceObject)  
IoDeleteDevice(Globals.ControlDeviceObject);  

DBGPRINT(("Unload Exit "));  

}  
*/  

NTSTATUS  
IM_CTRL_IoControl(  
                  IN PDEVICE_OBJECT DeviceObject,  
                  IN PIRP Irp  
                  )  
{  
    NTSTATUS Status = STATUS_SUCCESS;  
    PIO_STACK_LOCATION irpStack;  
    PVOID ioBuffer;  
    ULONG inputBufferLength;  
    ULONG outputBufferLength;  
    ULONG ioControlCode;  
    ULONG RequireLength=0;  
    PADAPT pAdapt;  
    UINT AdapterNum;  
    PDEVICE_EXTENSION pDevExt;  
    KIRQL OldIRQL;  
    
    pDevExt = DeviceObject->DeviceExtension;  
    
    irpStack = IoGetCurrentIrpStackLocation(Irp);  
    
    ioControlCode= irpStack->Parameters.DeviceIoControl.IoControlCode;  
    
    ioBuffer = Irp->AssociatedIrp.SystemBuffer;  
    inputBufferLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;  
    outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;  
    Status = NDIS_STATUS_SUCCESS;  
    
    KeAcquireSpinLock(&ImdGlobals.SpinLock,&OldIRQL);  
    
    switch (ioControlCode)  
    {  
    case GET_EVENT_MSG:  
        if(outputBufferLength<sizeof(EVENTMSG))  
        {  
            Status = STATUS_BUFFER_TOO_SMALL;  
            break;  
        }  
        
        IoMarkIrpPending(Irp);  
        IoStartPacket(DeviceObject,Irp,NULL,CancelIrp);  
        Status = STATUS_PENDING;  
        KeReleaseSpinLock(&ImdGlobals.SpinLock,OldIRQL);  
        return Status;  
    case SET_OPTION :  
        // ............ more case  
    default:  
        Status = STATUS_INVALID_PARAMETER;  
        break;  
    }  
    
    KeReleaseSpinLock(&ImdGlobals.SpinLock,OldIRQL);  
    
    Irp->IoStatus.Status = Status;  
    Irp->IoStatus.Information = outputBufferLength;  
    
    IoCompleteRequest(Irp, IO_NO_INCREMENT);  
    
    return Status;  
}  

VOID  
CancelIrp(  
          IN PDEVICE_OBJECT DeviceObject,  
          IN PIRP Irp  
          )  
{  
    if(Irp == DeviceObject->CurrentIrp)  
    {  
        IoReleaseCancelSpinLock(Irp->CancelIrql);  
        IoStartNextPacket(DeviceObject,TRUE);  
    }  
    else  
    {  
        KeRemoveEntryDeviceQueue(  
            &DeviceObject->DeviceQueue,  
            &Irp->Tail.Overlay.DeviceQueueEntry  
            );  
        IoReleaseCancelSpinLock(Irp->CancelIrql);  
    }  
    Irp->IoStatus.Status = STATUS_CANCELLED;  
    Irp->IoStatus.Information;  
    IoCompleteRequest(Irp,IO_NO_INCREMENT);  
    return;  
}  

VOID  
StartIo(  
        IN PDEVICE_OBJECT DeviceObject,  
        IN PIRP Irp  
        )  
{  
    return;  
}  

BOOLEAN  
NotifyEvent(  
            IN PEVENTMSG EventMsg  
            )  
{  
    PDEVICE_OBJECT DeviceObject = ImdGlobals.ControlDeviceObject ;  
    PIRP Irp ;  
    PVOID ioBuffer;  
    ULONG inputBufferLength;  
    ULONG outputBufferLength;  
    NTSTATUS Status = STATUS_SUCCESS;  
    PIO_STACK_LOCATION irpStack;  
    KIRQL CancelIrql;  
    
    Irp = DeviceObject->CurrentIrp;  
    
    if(!Irp) return FALSE;  
    
    IoAcquireCancelSpinLock(&CancelIrql);  
    if(Irp->Cancel)  
    {  
        IoReleaseCancelSpinLock(CancelIrql);  
        return FALSE;  
    }  
    IoSetCancelRoutine(Irp,NULL);  
    IoReleaseCancelSpinLock(CancelIrql);  
    irpStack = IoGetCurrentIrpStackLocation(Irp);  
    ioBuffer = Irp->AssociatedIrp.SystemBuffer;  
    inputBufferLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;  
    outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;  
    
    if(outputBufferLength<sizeof(EVENTMSG))  
    {  
        outputBufferLength = 0;  
        Status = STATUS_BUFFER_TOO_SMALL;  
    }  
    else  
    {  
        RtlCopyMemory(ioBuffer,EventMsg,sizeof(EVENTMSG));  
        outputBufferLength = sizeof(EVENTMSG);  
    }  
    
    Irp->IoStatus.Status = Status;  
    Irp->IoStatus.Information = outputBufferLength;  
    
    IoStartNextPacket(DeviceObject,TRUE);  
    
    IoCompleteRequest(Irp,IO_NO_INCREMENT);  
    
    return TRUE;  
    
}  

附件2、 
你需要仔细看的函数是GetEventMsg。 

 

#include "stdafx.h"  
#include "winioctl.h"  
#include "define.h"  





typedef struct _ANSY_IMD_EVENT_MSG  
{  
    OVERLAPPED OverLapped;  
    UCHAR Buffer[sizeof(IMDEVENTMSG)];  
} ANSY_IMDEVENTMSG, *PANSY_IMDEVENTMSG;  

//  
// hEventStop must be created by such code:  
// hEventStop = CreateEvent(  
// 0,  
// TRUE,  
// FALSE,  
// NULL  
// );  
// when caller want the GetEventMsg exit the block,  
// just SetEvent(hEventStop);  

BOOL  
GetEventMsg(  
            IN HANDLE hDev,  
            IN HANDLE hEventStop,  
            OUT PIMDEVENTMSG EventMsg  
            )  
{  
    BOOL bRet;  
    static ANSY_IMDEVENTMSG Packet[32];  
    static HANDLE hEvent[32+1];  
    static bool s_bFirstCall = TRUE;  
    DWORD cb;  
    HANDLE hEventNew;  
    int i,j,k;  
    
    if(s_bFirstCall) // if first call ,let's call 32 times readfile first  
    {  
        for(i=0;i<32;i++)  
        {  
            Packet.OverLapped.Offset=0;  
            Packet.OverLapped.OffsetHigh=0;  
            Packet.OverLapped.hEvent=CreateEvent(  
                0,  
                TRUE,  
                FALSE,  
                NULL  
                ); // manual reset,initial=false  
            hEvent=Packet.OverLapped.hEvent;  
            
            bRet = DeviceIoControl(  
                hDev,  
                GET_EVENT_MSG,  
                NULL,  
                0,  
                Packet.Buffer,  
                sizeof(IMDEVENTMSG),  
                &cb,  
                &Packet.OverLapped  
                );  
        }  
        hEvent[32]=hEventStop;  
        
        s_bFirstCall=false;  
    }  
    
    i= WaitForMultipleObjects( // which read return?  
        33,  
        hEvent,  
        false, // wait untill one hevent signal  
        INFINITE // wait forever  
        );  
    
    if(i==WAIT_FAILED) return false;  
    
    if(i==32)  
    {  
        ASSERT(hEvent == hEventStop);  
        return true; // hEventStop raise  
    }  
    
    for(j=0;j<32;j++)  
    {  
        if(Packet[j].OverLapped.hEvent ==hEvent) break; // which read return?  
    }  
    
    k=j;  
    
    cb=0;  
    bRet=GetOverlappedResult(  
        hDev,  
        &Packet[k].OverLapped,  
        &cb,  
        false  
        );  
    
    if(!bRet)  
    {  
        printf("GetOverlappedResult failed!!! ");  
        return false;  
    }  
    
    ASSERT(cb == sizeof(IMDEVENTMSG));  
    
    memcpy((void *)EventMsg,(void *)Packet[k].Buffer,cb);  
    
    CloseHandle(Packet[k].OverLapped.hEvent);  
    
    for(j=i;j<32;i++) hEvent=hEvent[++j];  
    
    hEventNew=CreateEvent(0, TRUE, 0, NULL);  
    if(!hEventNew)  
    {  
        printf("Can not create event! ");  
        return false;  
    }  
    
    Packet[k].OverLapped.hEvent=hEventNew;  
    memset(Packet[k].Buffer,0,sizeof(IMDEVENTMSG));  
    hEvent[31]=hEventNew;  
    
    // k返回了，就再读K一次  
    bRet = DeviceIoControl(  
        hDev,  
        GET_EVENT_MSG,  
        NULL,  
        0,  
        Packet[k].Buffer,  
        sizeof(IMDEVENTMSG),  
        &cb,  
        &Packet[k].OverLapped  
        );  
    
    return bRet;  
}