📄 newdll.cpp
字号:
// newdll.cpp : Defines the entry point for the DLL application.
//
#include "stdafx.h"
#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <devioctl.h>
#include "..\\..\\include\\rtmdll.h"
#define _CRT_NON_CONFORMING_SWPRINTFS
int systhread(void *param);
typedef struct _tagRTMDIG {
unsigned short port;
unsigned mask;
BOOL bbyte;
BOOL inout;
unsigned nvalue;
unsigned quantum;
unsigned curquantum;
unsigned dbgtm;
}RTM_DIG;
typedef struct _tagRTANL {
unsigned short port;
unsigned mask;
BOOL bbyte;
BOOL inout;
unsigned nvalue;
unsigned quantum;
unsigned curquantum;
unsigned dbgtm;
}RTM_ANL;
#pragma bss_seg( "RTMBSS" )
int k_stack;
int k_stack1;
#pragma bss_seg()
HANDLE hRTMDLL;
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
hRTMDLL = hModule;
return TRUE;
}
#pragma data_seg("RTMDATA")
unsigned int b_data[200] = {0};
unsigned nstop = 0;
unsigned n_anlval = 0;
unsigned glbtm = 0;
RTM_DIG stdig = {0};
RTM_ANL stanl = {0};
DWORD _isr = 0;
int initLpt =0;
unsigned short dbit = 1;
#pragma data_seg()
#pragma check_stack(off)
#pragma code_seg("RTMCODE")
extern "C" void timer1(void);
extern "C" void timer2(int);
class CNew{
int k1;
public:
CNew();// {k1=10;}
virtual int f01(int n);
virtual int f02(int n);
};
CNew::CNew()
{
k1=10;
}
int CNew::f01(int n)
{
return k1*n;
}
int CNew::f02(int n)
{
return k1*n;
}
void newintr(void *)
{
// generate exception
// char *p = NULL;
// *p =1;
_isr++;
}
void timer_dig(unsigned dwmess)
{
int i;
unsigned nstate;
unsigned nvalue;
unsigned short ndigport;
DWORD *p1 = NULL;
double x;
CNew *pw;
CNew k;
if(nstop ) return ;
pw = &k;
i = pw->f02(15);
if(k_stack == 110) k_stack = 508;
if(k_stack == 0x200) k_stack = 1008;
glbtm++;
stdig.dbgtm = glbtm;
if(dwmess == 0x100 )
b_data[90] = 0x100;
/*
test data
*/
// generate exception page fault
// *p1 = 0;
b_data[0]++;
if(b_data[10] == 78)
b_data[11] = 150;
if(initLpt == 0)
{
_asm {
mov dx,378h
mov ax,0
out dx,ax ;//outp(BASE_LPT,0);
add dx,2; CR
mov ax,2eh
out dx,ax ;//outp(BASE_LPT+CR,0x2e);
}
initLpt =1;
}
ndigport = stdig.port;
stdig.curquantum = 0;
if( dbit == 1){
nstate = stdig.mask;
dbit = 0;
}
else{
nstate = 0x0;
dbit = 1;
}
if(stdig.inout ){
_asm mov dx,ndigport
// _asm out dx,al
switch(stdig.bbyte)
{
case 0:
_asm mov eax,nstate
_asm out dx,al
break;
case 1:
_asm mov eax,nstate
_asm out dx,ax
break;
case 2:
_asm mov eax,nstate
_asm out dx,eax
break;
default:
break;
}
stdig.nvalue = nstate;
}
else{
_asm mov dx,ndigport
_asm xor eax,eax
switch(stdig.bbyte)
{
case 0:
_asm in al,dx
break;
case 1:
_asm in ax,dx
break;
case 2:
_asm in eax,dx
break;
default:
break;
}
_asm mov nvalue,eax
stdig.nvalue = nvalue;
}
x=sqrt(1.5);
}
void timer_anl(unsigned dwmess)
{
int i;
unsigned nvalue;
unsigned short nanlport;
int *p8 = NULL;
while(1)
{
if(nstop) return ;
if(dwmess == 0x100 )
b_data[90] = 0x100;
rtmbreakpoint(TRUE);
// rtmsettimerinterval(100);
// rtmdeletetimer();
nanlport = stanl.port;
stanl.nvalue +=100;
stanl.curquantum = 0;
if((unsigned)n_anlval++>(unsigned)stanl.mask)
n_anlval = 0;
if(stanl.inout ){
_asm mov dx,nanlport
// _asm mov eax,n_anlval
switch(stanl.bbyte)
{
case 0:
_asm mov eax,n_anlval
_asm out dx,al
break;
case 1:
_asm mov eax,n_anlval
_asm out dx,ax
break;
case 2:
_asm mov eax,n_anlval
_asm out dx,eax
break;
default:
break;
}
stanl.nvalue = n_anlval;
}
else{
_asm mov dx,nanlport
switch(stanl.bbyte)
{
case 0:
_asm in al,dx
break;
case 1:
_asm in ax,dx
break;
case 2:
_asm in eax,dx
break;
default:
break;
}
_asm mov nvalue,eax
stanl.nvalue = nvalue;
}
for(i=0;i<10;i++)
{
b_data[0]+=4;
sqrt(1.5);
}
RtmSleep(1000000);
}
}
void timer2(int i)
{
b_data[1]++;
}
#pragma code_seg()
#pragma check_stack(on)
extern "C" int WINAPI GetValue(RTM_DIG *stdg, RTM_ANL *stan )
{
stdg->nvalue = stdig.nvalue;
stdg->dbgtm = stdig.dbgtm;
stan->nvalue = stanl.nvalue;
stan->dbgtm = stanl.dbgtm;
return 1;
}
extern "C" int WINAPI StopTimer()
{
nstop = 1;
return 1;
}
HANDLE th;
HANDLE th1;
HANDLE m_hThread;
HANDLE tmd = 0;
HANDLE tma = 0;
int th_end = 1;
ULONG WINAPI UserThread(void* pParam)
{
char *perror = NULL;
DWORD BytesReturned = 0;
int i =0;
th = RtmCreateThread(hRTMDLL ,(THREAD_START_ROUTINE)systhread,NULL);
Sleep(3000);
while(th_end)
{
/*--------------------------------------------------------------*/
Sleep(10);
if(i++==30)
{
i = 0;
RtmTimerStepover(hRTMDLL ,tma);
}
}
return 0;
}
extern "C" int WINAPI PCIResource(BOOL bmode,PCIINFO *pci)
{
char *pDev = NULL;
int rez = -1;
rez = CheckPci(TRUE,pci->pcidata.VendorID,pci->pcidata.DeviceID,pDev);
if(rez!= -1)
{
if(bmode == TRUE)
return RtmAssignResources(pci->bus,pci->slot.u.AsULONG,pci->pcidata.VendorID,pci->pcidata.DeviceID);
else
return RtmReleaseResources(pci->bus,pci->slot.u.AsULONG,pci->pcidata.VendorID,pci->pcidata.DeviceID);
}
return rez;
}
extern "C" int WINAPI ScanPci(char *pcibuff)
{
int count = 0;
RtmGetPciInfo(pcibuff,&count);
return count;
}
extern "C" int WINAPI StartDebug(BOOL bmode)
{
RtmDebug(hRTMDLL ,bmode);//TRUE);
return 0;
}
extern "C" void ReadPhysicalAddress(int nIndex,unsigned naddr,void *buffer,int ncount,int nsize)
{
RtmReadPhysicalAddress(nIndex,naddr,buffer,ncount,nsize);
}
extern "C" void WritePhysicalAddress(int nIndex,unsigned naddr,void *buffer,int ncount,int nsize)
{
RtmWritePhysicalAddress(nIndex,naddr,buffer,ncount,nsize);
}
HANDLE pi1;
HANDLE pi2;
extern "C" int WINAPI StartTimer(RTM_DIG *std, RTM_ANL *sta )
{
stdig = *std;
stanl = *sta;
n_anlval = 0;
nstop = 0;
RtmSetTimerInterval(hRTMDLL ,tmd,std->quantum );
RtmSetTimerInterval(hRTMDLL ,tma,sta->quantum );
return 1;
}
extern "C" int WINAPI RTXEntry(int tmresol)
{
RTMCONNINTERRUPT cinter;
int error;
HANDLE tm;
unsigned long m_dwThreadID;
MEMPAGEU* pm;
// if(RtmInit(hRTMDLL,USER_MODE) == FALSE) return 0;
if(RtmInit(hRTMDLL,KERNEL_MODE) == FALSE) return 0;
m_hThread = CreateThread(
NULL,
0,
&UserThread, // thread proc
NULL, // parm
CREATE_SUSPENDED,
&m_dwThreadID
);
ResumeThread(m_hThread);
k_stack = 110;
RtmDebug(hRTMDLL ,FALSE);
/* test timer functions */
tmd = tm = RtmCreateTimer(hRTMDLL ,timer_dig,0x2000,500,KERNEL_MODE);
if(tm == NULL)
{
::MessageBox(NULL,"Error RtmCreateTimer","RTM error",MB_OK);
}
if(RtmStartTimer(hRTMDLL ,tm,0x3000) == FALSE)
{
::MessageBox(NULL,"Error RtmStartTimer","RTM error",MB_OK);
}
/*
if(RtmDeleteTimer(hRTMDLL ,tm) == FALSE)
{
::MessageBox(NULL,"Error RtmDeleteTimer","RTM error",MB_OK);
}
*/
// tma = tm = RtmCreateTimer(hRTMDLL ,timer_anl,0x2000,500,USER_MODE);
tma = tm = RtmCreateTimer(hRTMDLL ,timer_anl,0x2000,500,KERNEL_MODE);
Sleep(10);
RtmStartTimer(hRTMDLL ,tm,0x3000);
// RtmTimerPostMessage(hRTMDLL ,tm,0x100);
// RtmTimerPostMessage(hRTMDLL ,tmd,0x100);
/* test memory functions */
pm = RtmAllocMem(0x1000);
RtmFreeMem(pm);
cinter.BusNumber = 0;
cinter.nVector = 1;
cinter.itype = Isa;
cinter.lpParameter = NULL;
cinter.newintr = newintr;
pi1 = RtmHookInterrupt (hRTMDLL ,&cinter);
error = _isr;
error = _isr;
error = _isr;
RtmUnhookInterrupt (hRTMDLL ,pi1);
return 1;
}
extern "C" int WINAPI CloseRTM()
{
th_end = 0;
WaitForSingleObject(m_hThread, INFINITE);
CloseHandle(m_hThread);
RtmDeleteThread(hRTMDLL,th);
return RtmClose(hRTMDLL);
}
extern "C" int WINAPI GetQuantum()
{
unsigned i;
RtmGetTimerQuantum(&i);
return i;
}
#define UNICODE
#include "..\\..\\include\\xntddk.h"
#pragma check_stack(off)
#pragma code_seg("RTMTHR")
void writetofile(PWSTR pfl,UINT addr,int nsize)
{
IO_STATUS_BLOCK IoStatus;
OBJECT_ATTRIBUTES objectAttributes;
HANDLE FileHandle = NULL;
UNICODE_STRING fileName1;
NTSTATUS status;
fileName1.Buffer = NULL;
fileName1.Length = 0;
fileName1.MaximumLength = 256;
DbgPrint("start");
fileName1.Buffer = (PWSTR)ExAllocatePool(PagedPool,
fileName1.MaximumLength);
DbgPrint("step 1");
RtlZeroMemory(fileName1.Buffer, fileName1.MaximumLength);
status = RtlAppendUnicodeToString(&fileName1, pfl);
InitializeObjectAttributes (&objectAttributes,
(PUNICODE_STRING)&fileName1,
OBJ_CASE_INSENSITIVE,
NULL,
NULL );
DbgPrint("step 2");
status = ZwCreateFile(&FileHandle,
FILE_APPEND_DATA,
&objectAttributes,
&IoStatus,
0,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_WRITE,
FILE_OPEN_IF,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0 );
if(NT_SUCCESS(status))
{
ZwWriteFile(FileHandle,
NULL,
NULL,
NULL,
&IoStatus,
(void *)addr,
nsize,
NULL,
NULL );
ZwClose(FileHandle);
DbgPrint ("Close file");
}
else
DbgPrint("error ZwCreateFile");
if(fileName1.Buffer)
ExFreePool(fileName1.Buffer);
}
#define PAUSE_1_MS (1 * 10000)
int systhread(void *param)
{
unsigned int k = 0;
PVOID pv = NULL;
PKTHREAD pkt =0;
DWORD *p1 = NULL;
unsigned n_count_task = 0;
char buff_s[32] = {0};
double x;
DbgPrint ("Test systhread");
k = atoi("123");
printf ("k =%d ",k);
x = sin(1.3);
sprintf(&buff_s[0],"x=%f",x);
printf (buff_s);
return 0;
}
#undef UNICODE
#pragma check_stack(on)
#pragma code_seg()
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -