Написание Legacy Nt драйвера: исправить код

// init.cpp: Инициализация драйвера
 
 
#include "ek.h"
 
NTSTATUS CreateDevice(IN PDRIVER_OBJECT pdo,IN ULONG port,IN ULONG irq);//порт -330 irq 5 
NTSTATUS DeviceControlRoutine( IN PDEVICE_OBJECT fdo, IN PIRP Irp );//обработчик всех 12 иоклт запросов
VOID     UnloadRoutine(IN PDRIVER_OBJECT DriverObject);//EM_kvv3 exit
NTSTATUS Read_IRPhandler(IN PDEVICE_OBJECT fdo,IN PIRP Irp);//device_read
NTSTATUS Write_IRPhandler( IN PDEVICE_OBJECT fdo, IN PIRP Irp );//device_write
NTSTATUS Create_File_IRPprocessing(IN PDEVICE_OBJECT fdo, IN PIRP Irp);//device_open
NTSTATUS Close_HandleIRPprocessing(IN PDEVICE_OBJECT fdo, IN PIRP Irp);//
NTSTATUS KillWin(IN PDEVICE_OBJECT fdo, IN PIRP Irp);
BOOLEAN OnInterrupt(PKINTERRUPT,PVOID);
 
KSPIN_LOCK MySpinLock; 
static PEM_KVV_DEVICE_EXTENSION dev1;  
 
 
 
extern "C"
NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject,
                      IN PUNICODE_STRING RegistryPath)
{
    NTSTATUS status = STATUS_SUCCESS;
    
 
        DbgPrint("Em_kvv In DriverEntry!");
    DbgPrint("Em_kvv RegistryPath = %ws.", RegistryPath->Buffer);//\REGISTRY\HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\Em_kvv.
 
        
 
    
    DriverObject->DriverUnload = UnloadRoutine;
    DriverObject->MajorFunction[IRP_MJ_CREATE]= Create_File_IRPprocessing;  
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = Close_HandleIRPprocessing;
    DriverObject->MajorFunction[IRP_MJ_READ]  = Read_IRPhandler;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = Write_IRPhandler;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]= DeviceControlRoutine;
       // DriverObject->MajorFunction[IRP_MJ_SHUTDOWN]=KillWin;
    
    
 
        status=CreateDevice(DriverObject,0x330,0x5);
    MmPageEntireDriver(UnloadRoutine);
        return status;
}
//#pragma code_seg()
////////////////////////////////////////////////////////////////////////////////
NTSTATUS CreateDevice(IN PDRIVER_OBJECT DriverObject,IN ULONG port,IN ULONG irq)
{
 
 NTSTATUS status;
 PEM_KVV_DEVICE_EXTENSION pDevExt;
 UNICODE_STRING  devName;
  PDEVICE_OBJECT fdo;
 RtlInitUnicodeString( &devName, L"\\Device\\Em_kvv" );
 
    
        status = IoCreateDevice(DriverObject,
                            sizeof(PEM_KVV_DEVICE_EXTENSION),
                            &devName, //имя девайса
                            FILE_DEVICE_UNKNOWN,
                            0,//ХАРАКТЕРИСТИКИ
                            FALSE, 
                            &fdo);
    if(!NT_SUCCESS(status)) return status;//Error!
         fdo->Flags|=DO_BUFFERED_IO;
        
         pDevExt=(PEM_KVV_DEVICE_EXTENSION)fdo->DeviceExtension;
         pDevExt->fdo=fdo; //ptr to itself
         pDevExt->ustrDeviceName=devName;//for kernel
         pDevExt->irq=irq;//0x5
         pDevExt->port_base=(PUCHAR)port;
         pDevExt->InterruptObject=0;
         pDevExt->byteread=0;
         pDevExt->bytewrite=0;
         pDevExt->count=2;
         pDevExt->delay=0;
    
        DbgPrint("Filling the flags was sucessful!");
        DbgPrint("Em_kvv FDO %X, DevExt=%X.",fdo,pDevExt);
 
           KIRQL kirql;
           KAFFINITY kaffinity;
           ULONG kvector1=HalGetInterruptVector(Isa,0,pDevExt->irq,pDevExt->irq,&kirql,&kaffinity);
          DbgPrint("Interrupt %d converted to KIRQL =%d,kaffinity =%d, kvector1=%X(hex)",pDevExt->irq,kirql,kaffinity,kvector1);
    //=======================================
        status=IoConnectInterrupt(&pDevExt->InterruptObject,
       OnInterrupt,//ISR
        pDevExt,
        0,//without spinblock
        kvector1,
        kirql,
        kirql,
        LevelSensitive,
        FALSE,//non sharable
        kaffinity,//11  2 CPU
        FALSE);//do not save FPU
 
        if(!NT_SUCCESS(status))
        {
        KdPrint(("IoConnectInterrupt returned error %d ",status));
        IoDeleteDevice(fdo);
        return status;
        }
 
        DbgPrint("Interrupt successfully connected!");
    
    UNICODE_STRING symLinkName; 
    
    #define SYM_LINK_NAME   L"\\DosDevices\\Em_kvv"
    RtlInitUnicodeString(&symLinkName, SYM_LINK_NAME );
    pDevExt->ustrSymLinkName = symLinkName;//device-Extension
 
    
    status = IoCreateSymbolicLink( &symLinkName,&devName);
    if (!NT_SUCCESS(status))
    {
                IoDisconnectInterrupt(pDevExt->InterruptObject);
        IoDeleteDevice( fdo ); //??
        return status;
        } 
 
        
        KeInitializeSpinLock(&MySpinLock);
        DbgPrint("EM_KVV DriverEntry successfully finished.");
        status= IoRegisterShutdownNotification(fdo);
         if(!NT_SUCCESS(status))
         DbgPrint("Cannot Register Notification");
         DbgPrint("IoRegisterNotification with ok status here!");
 
}
 
////////////////////////////////////////////////////////////////////////////////
static BOOLEAN  OnInterrupt(PKINTERRUPT pInterObj,PVOID ServiceContext)
{
 
 
PEM_KVV_DEVICE_EXTENSION dev=(PEM_KVV_DEVICE_EXTENSION)ServiceContext;
if(dev==NULL)return 0;
KeQueryTickCount(dev->time_now);
DbgPrint("Time = %d",++index);
 
return 1;
}
////////////////////////////////////////////////////////////////////////////////
NTSTATUS CompleteIrp(PIRP Irp, NTSTATUS status, ULONG info)
{
 
    Irp->IoStatus.Status = status;//Status_Success
    Irp->IoStatus.Information = info;//  count of processed bytes
    IoCompleteRequest(Irp,IO_NO_INCREMENT); 
    return status;
}
 
 
NTSTATUS Read_IRPhandler( IN PDEVICE_OBJECT fdo, IN PIRP Irp)
{       
       
    ULONG Bytes = 0;//то что считали
    NTSTATUS status = STATUS_SUCCESS; 
        DbgPrint("-Em_kvv in Read_IRPhandler.");
        return CompleteIrp(Irp,status,Bytes);
}
 
NTSTATUS Write_IRPhandler(IN PDEVICE_OBJECT fdo, IN PIRP Irp )
{
      
    ULONG Bytes = 0;
    NTSTATUS status = STATUS_SUCCESS; 
        DbgPrint("-Em_kvv in Write_IRPhandler.");
 
    return CompleteIrp(Irp,status,Bytes);
}
 
 
 
NTSTATUS Create_File_IRPprocessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{      
    PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
 
        DbgPrint("-Em_kvv - Create File is %ws",
        &(IrpStack->FileObject->FileName.Buffer));
 
return CompleteIrp(Irp,STATUS_SUCCESS,0); 
}
 
/////////////////////////////
//Close_FIle_IRPprocessing is about IRP_MJ_CLOSE codes
NTSTATUS Close_HandleIRPprocessing(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
 
 
    DbgPrint("-Em_kvv- In Close_HandleIRPProcessing"); 
 
return CompleteIrp(Irp,STATUS_SUCCESS,0);
}
 
 
///////////////////////
 
 
 
NTSTATUS DeviceControlRoutine( IN PDEVICE_OBJECT fdo, IN PIRP Irp)
{
    NTSTATUS status = STATUS_SUCCESS;
    ULONG BytesTxd =0; 
    PIO_STACK_LOCATION IrpStack=IoGetCurrentIrpStackLocation(Irp);
 
    
    PEM_KVV_DEVICE_EXTENSION dx =
                 (PEM_KVV_DEVICE_EXTENSION)fdo->DeviceExtension;
    
    
    ULONG ControlCode =
    IrpStack->Parameters.DeviceIoControl.IoControlCode;
    ULONG method = ControlCode & 0x03;
 
    
    KIRQL irql,
    currentIrql = KeGetCurrentIrql();
 
 
    DbgPrint("Em_kvv In DeviceControlRoutine (fdo= %X)\n",fdo);
    DbgPrint("Em_kvv DeviceIoControl: IOCTL %x. DeviceMethod %x", ControlCode,method);
    if(currentIrql==PASSIVE_LEVEL)
        DbgPrint("-Example- PASSIVE_LEVEL (val=%d)",currentIrql);
    
    
    KeAcquireSpinLock(&MySpinLock,&irql);
 
    
    switch( ControlCode)
         {
      
    
    }
     // SMALL_VERSION
 
 
    case IOCTL_MAKE_SYSTEM_CRASH:
    {
        int errDetected=0;
        char x = (char)0xFF;
 
        #if DBG  
        DbgPrint("-Example- IOCTL_MAKE_SYSTEM_CRASH.");
        #endif
        
        __try {
        x = *(char*)0x0L; 
        }
        __except(EXCEPTION_EXECUTE_HANDLER)
        {   
            errDetected=1;
        };
        #if DBG
        DbgPrint("-Example- Value of x is %X.",x);
        if(errDetected)
            DbgPrint("-Example- Exception detected in Example driver.");
        #endif
        break;
    }
 
        case IOCTL_GET_TIMER:
        {
        KIRQL currentirql;
        currentirql=KeGetCurrentIrql();
        LARGE_INTEGER tick;
        DbgPrint("Current irql level is %d ",currentirql);
        KeQueryTickCount(&tick);
        DbgPrint("KeQueryTickCOunt after system start is %d",tick);
        ULONG  tick2=0;
        tick2=KeQueryTimeIncrement();
        DbgPrint("Number of 100 ns intervals during 1 unterrupt is %d ",tick2);
        break; 
        }
 
    case IOCTL_TOUCH_PORT_378H:
    {
        unsigned short ECRegister = 0x378+0x402;
        #if DBG
        DbgPrint("-Example- IOCTL_TOUCH_PORT_378H.");
        #endif
        
        _asm  {
            mov dx,ECRegister ;
            xor al,al    ;
            out dx,al    ;    Установить EPP mode 000
            mov al,095h  ;    Биты 7:5 = 100
            out dx,al    ;    Установить EPP mode 100
        }
        
        break;
    }
 
    case IOCTL_SEND_BYTE_TO_USER:
    {   
        
        ULONG InputLength = 
            IrpStack->Parameters.DeviceIoControl.InputBufferLength; //sizeof(xdata)?
        
        ULONG OutputLength =
        IrpStack->Parameters.DeviceIoControl.OutputBufferLength;//sizeof(xdata)?
        #if DBG
        DbgPrint("-Example- Buffer outlength %d",OutputLength);
        #endif
 
        if( OutputLength<1 )
        {
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        unsigned char *buff; 
        if(method==METHOD_BUFFERED)
        {
            buff = (PUCHAR)Irp->AssociatedIrp.SystemBuffer;
            #if DBG
            DbgPrint("-Example- Method : BUFFERED.");
            #endif
        }
        else
            if (method==METHOD_NEITHER)
            {
                buff=(unsigned char*)Irp->UserBuffer;
                #if DBG
                DbgPrint("-Example- Method : NEITHER.");
                #endif
            }
            else //неизвестный метод, нет способа считать?
            {
                #if DBG
                DbgPrint("-Example- Method : unsupported.");
                #endif
                status = STATUS_INVALID_DEVICE_REQUEST;
                break;
            }
 
        DbgPrint("Buffer address %08X",buff);
        
        *buff= 77;     // 
        BytesTxd = OutputLength; // Передали 1 байт
        break;
    }
    
    default: status = STATUS_INVALID_DEVICE_REQUEST;
    }
    
    KeReleaseSpinLock(&MySpinLock,irql);
 
 
    DbgPrint("-Example- DeviceIoControl: %d bytes written.", (int)BytesTxd);
    
 
return CompleteIrp(Irp,status,BytesTxd);
}
 
 
VOID UnloadRoutine(IN PDRIVER_OBJECT pDriverObject)
{
    PDEVICE_OBJECT  pNextDevObj;
    int i;
 
    
    
    DbgPrint("-Em_kvv- In Unload Routine.");
 
    
    
 
 
        pNextDevObj = pDriverObject->DeviceObject;
        
        DbgPrint("Notification should not be deleted here");
    for(i=0; pNextDevObj!=NULL; i++)
    {
        PEM_KVV_DEVICE_EXTENSION dx =
                (PEM_KVV_DEVICE_EXTENSION)pNextDevObj->DeviceExtension;
                if(dx->InterruptObject)
                {
              
                IoDisconnectInterrupt(dx->InterruptObject);
                }
        
        UNICODE_STRING *pLinkName = & (dx->ustrSymLinkName);//хранит симвоссылку
        
        pNextDevObj = pNextDevObj->NextDevice;
 
 
        DbgPrint(" Em_kvv Deleted device (%d) : pointer to FDO = %X.",
                            i,dx->fdo);
        DbgPrint("-Em_kvv3 Deleted symlink = %ws.", pLinkName->Buffer);
        
 
        IoDeleteSymbolicLink(pLinkName);
        IoDeleteDevice( dx->fdo);// установлено в DriverEntry  
    }
MmResetDriverPaging(UnloadRoutine);
}