3 Copyright (c) 1998-2001 Klaus P. Gerlicher
22 15-Nov-2000: general cleanup of source files
26 This file may be distributed under the terms of the GNU Public License.
30 ////////////////////////////////////////////////////
38 ////////////////////////////////////////////////////
43 char tempFlowChanges
[256];
45 //PMADDRESS_SPACE my_init_mm=NULL;
47 ULONG TwoPagesForPhysMem
[2*_PAGE_SIZE
];
49 // scancode to ASCII table
50 SCANTOASCII ucScanToAscii_DE
[]=
53 {16,'q'},{17,'w'},{18,'e'},{19,'r'},{20,'t'},
54 {21,'z'},{22,'u'},{23,'i'},{24,'o'},{25,'p'},
55 {30,'a'},{31,'s'},{32,'d'},{33,'f'},{34,'g'},
56 {35,'h'},{36,'j'},{37,'k'},{38,'l'},
57 {44,'y'},{45,'x'},{46,'c'},{47,'v'},{48,'b'},
59 {2,'1'},{3,'2'},{4,'3'},{ 5,'4'},{ 6,'5'},
60 {7,'6'},{8,'7'},{9,'8'},{10,'9'},{11,'0'},
61 {12,'ß'}, // 239 = ß
62 {0x39,' '},{0x35,'-'},{0x34,'.'},{0x1b,'+'},
66 SCANTOASCII ucShiftScanToAscii_DE
[]=
68 // German keyboard SHIFTED
69 {16,'Q'},{17,'W'},{18,'E'},{19,'R'},{20,'T'},
70 {21,'Z'},{22,'U'},{23,'I'},{24,'O'},{25,'P'},
71 {30,'A'},{31,'S'},{32,'D'},{33,'F'},{34,'G'},
72 {35,'H'},{36,'J'},{37,'K'},{38,'L'},
73 {44,'Y'},{45,'X'},{46,'C'},{47,'V'},{48,'B'},
75 {2,'!'},{3,'\"'}, // " // (fixes mc syntax highlighting)
76 {4,'@'}, // is pragraph sign on keyboard
78 {7,'&'},{8,'/'},{9,'('},{10,')'},{11,'='},
80 {0x39,' '},{0x35,'_'},{0x34,':'},{0x1b,'*'},
84 SCANTOASCII ucScanToAscii_US
[]=
87 {16,'q'},{17,'w'},{18,'e'},{19,'r'},
88 {20,'t'},{21,'y'},{22,'u'},{23,'i'},
89 {24,'o'},{25,'p'},{30,'a'},{31,'s'},
90 {32,'d'},{33,'f'},{34,'g'},{35,'h'},
91 {36,'j'},{37,'k'},{38,'l'},{44,'z'},
92 {45,'x'},{46,'c'},{47,'v'},{48,'b'},
93 {49,'n'},{50,'m'},{2,'1'},{3,'2'},
94 {4,'3'},{5,'4'},{6,'5'},{7,'6'},
95 {8,'7'},{9,'8'},{10,'9'},{11,'0'},{12,'-'},
96 {0x39,' '},{0x35,'/'},{0x34,'.'},{0x1b,']'},
97 {0x1a,'['},{0x33,','},{0x27,';'},{0x0d,'='},
98 {0x2b,'\\'},{0x28,'\''},{0x29,'`'},
102 SCANTOASCII ucShiftScanToAscii_US
[]=
104 // US keyboard SHIFTED
105 {16,'Q'},{17,'W'},{18,'E'},{19,'R'},
106 {20,'T'},{21,'Y'},{22,'U'},{23,'I'},
107 {24,'O'},{25,'P'},{30,'A'},{31,'S'},
108 {32,'D'},{33,'F'},{34,'G'},{35,'H'},
109 {36,'J'},{37,'K'},{38,'L'},{44,'Z'},
110 {45,'X'},{46,'C'},{47,'V'},{48,'B'},
111 {49,'N'},{50,'M'},{2,'!'},{3,'@'},
112 {4,'#'},{5,'$'},{6,'%'},{7,'^'},
113 {8,'&'},{9,'*'},{10,'('},{11,')'},{12,'_'},
114 {0x39,' '},{0x35,'?'},{0x34,'>'},{0x1b,'}'},
115 {0x1a,'{'},{0x33,'<'},{0x27,':'},{0x0d,'+'},
116 {0x2b,'|'},{0x28,'\"'},{0x29,'~'},
121 SCANTOASCII ucScanToAscii_DK
[]=
124 {16,'q'},{17,'w'},{18,'e'},{19,'r'},
125 {20,'t'},{21,'y'},{22,'u'},{23,'i'},
126 {24,'o'},{25,'p'},{30,'a'},{31,'s'},
127 {32,'d'},{33,'f'},{34,'g'},{35,'h'},
128 {36,'j'},{37,'k'},{38,'l'},{44,'z'},
129 {45,'x'},{46,'c'},{47,'v'},{48,'b'},
130 {49,'n'},{50,'m'},{2,'1'},{3,'2'},
131 {4,'3'},{5,'4'},{6,'5'},{7,'6'},
132 {8,'7'},{9,'8'},{10,'9'},{11,'0'},{12,'+'},
133 {0x39,' '},{0x35,'-'},{0x34,'.'},{0x1b,'¨'},
134 {0x1a,'å'},{0x33,','},{0x27,'æ'},{0x0d,'´'},
135 {0x2b,'\''},{0x28,'ø'},{0x29,' '},
139 SCANTOASCII ucShiftScanToAscii_DK
[]=
141 // Danish keyboard SHIFTED
142 {16,'Q'},{17,'W'},{18,'E'},{19,'R'},
143 {20,'T'},{21,'Y'},{22,'U'},{23,'I'},
144 {24,'O'},{25,'P'},{30,'A'},{31,'S'},
145 {32,'D'},{33,'F'},{34,'G'},{35,'H'},
146 {36,'J'},{37,'K'},{38,'L'},{44,'Z'},
147 {45,'X'},{46,'C'},{47,'V'},{48,'B'},
148 {49,'N'},{50,'M'},{2,'!'},{3,'"'},
149 {4,'#'},{5,'¤'},{6,'%'},{7,'&'},
150 {8,'/'},{9,'('},{10,')'},{11,'='},{12,'?'},
151 {0x39,' '},{0x35,'_'},{0x34,':'},{0x1b,'^'},
152 {0x1a,'Å'},{0x33,';'},{0x27,'Æ'},{0x0d,'`'},
153 {0x2b,'*'},{0x28,'Ø'},{0x29,'§'},
157 SCANTOASCII ucAltScanToAscii_DK
[]=
159 // Danish keyboard ALTED
160 {16,' '},{17,' '},{18,' '},{19,' '},
161 {20,' '},{21,' '},{22,' '},{23,' '},
162 {24,' '},{25,' '},{30,' '},{31,' '},
163 {32,' '},{33,' '},{34,' '},{35,' '},
164 {36,' '},{37,' '},{38,' '},{44,' '},
165 {45,' '},{46,' '},{47,' '},{48,' '},
166 {49,' '},{50,' '},{2,' '},{3,'@'},
167 {4,'£'},{5,'$'},{6,'\80'},{7,' '},
168 {8,'{'},{9,'['},{10,']'},{11,'}'},{12,' '},
169 {0x39,' '},{0x35,' '},{0x34,' '},{0x1b,'~'},
170 {0x1a,' '},{0x33,' '},{0x27,' '},{0x0d,'|'},
171 {0x2b,' '},{0x28,' '},{0x29,' '},
175 KEYBOARD_LAYOUT ucKeyboard
[]=
177 {"de", ucScanToAscii_DE
, ucShiftScanToAscii_DE
, NULL
},
178 {"us", ucScanToAscii_US
, ucShiftScanToAscii_US
, NULL
},
179 {"dk", ucScanToAscii_DK
, ucShiftScanToAscii_DK
, ucAltScanToAscii_DK
},
180 {NULL
, NULL
, NULL
, NULL
}
183 PKEYBOARD_LAYOUT CurrentKeyboard
= NULL
;
186 ////////////////////////////////////////////////////
190 //*************************************************************************
191 // GetKeyboardLayout()
193 //*************************************************************************
194 PKEYBOARD_LAYOUT
GetKeyboardLayout()
196 if (CurrentKeyboard
== NULL
)
198 CurrentKeyboard
= &ucKeyboard
[kbUS
];
201 return CurrentKeyboard
;
204 //*************************************************************************
205 // SetKeyboardLayoutByName()
207 //*************************************************************************
208 PKEYBOARD_LAYOUT
SetKeyboardLayoutByName(LPSTR Name
)
213 for(i
=0;ucKeyboard
[i
].name
!= NULL
;i
++)
215 if(PICE_strcmpi(ucKeyboard
[i
].name
, Name
) == 0)
217 CurrentKeyboard
= &ucKeyboard
[i
];
218 return CurrentKeyboard
;
221 return GetKeyboardLayout();
224 //*************************************************************************
227 //*************************************************************************
228 void PICE_memset(void* p
,unsigned char c
,int sz
)
230 unsigned char *p2
= (unsigned char *)p
;
235 //*************************************************************************
238 //*************************************************************************
239 void PICE_memcpy(void* t
,void* s
,int sz
)
244 //*************************************************************************
247 //*************************************************************************
248 BOOLEAN
PICE_isprint(char c
)
250 BOOLEAN bResult
= FALSE
;
252 if((ULONG
)c
>=0x20 && (ULONG
)c
<=0x7f)
258 //*************************************************************************
261 //*************************************************************************
262 char* PICE_strchr(char* s
,char c
)
264 while(IsAddressValid((ULONG
)s
) && *s
)
271 if(!IsAddressValid((ULONG
)s
) )
273 DPRINT((0,"PICE_strchr(): ********************\n"));
274 DPRINT((0,"PICE_strchr(): EXCEPTION @ %.8X\n",(ULONG
)s
));
275 DPRINT((0,"PICE_strchr(): ********************\n"));
282 //*************************************************************************
285 //*************************************************************************
286 char* PICE_strncpy(char* s1
,char* s2
,int len
)
288 ULONG len2
= PICE_strlen(s2
);
291 PICE_memcpy(s1
,s2
,len2
+1);
293 PICE_memcpy(s1
,s2
,len
);
298 //*************************************************************************
301 //*************************************************************************
302 char* PICE_strcpy(char* s1
,char* s2
)
304 ULONG len2
= PICE_strlen(s2
);
306 PICE_memcpy(s1
,s2
,len2
+1);
311 //*************************************************************************
314 //*************************************************************************
315 char* PICE_strcat(char* s1
,char* s2
)
317 ULONG len1
= PICE_strlen(s1
);
318 ULONG len2
= PICE_strlen(s2
);
320 PICE_memcpy(&s1
[len1
],s2
,len2
+1);
325 //*************************************************************************
328 //*************************************************************************
329 char PICE_toupper(char c
)
337 int PICE_isdigit( int c
)
339 return ((c
>=0x30) && (c
<=0x39));
342 int PICE_isxdigit( int c
)
344 return (PICE_isdigit(c
) || ((c
>=0x41) && (c
<=0x46)) || ((c
>=0x61) && (c
<=0x66)));
347 int PICE_islower( int c
)
349 return ((c
>=0x61) && (c
<=0x7a));
352 int PICE_isalpha( int c
)
354 return ((c
>= 'A' && c
<= 'Z') || (c
>= 'a' && c
<= 'z'));
357 //*************************************************************************
360 // my version of strncmpi()
361 //*************************************************************************
362 ULONG
PICE_strncmpi(char* s1
,char* s2
,ULONG len
)
367 IsAddressValid((ULONG
)s1
) && *s1
&& // not end of string
368 IsAddressValid((ULONG
)s2
) && *s2
&& // not end of string
369 PICE_toupper(*s1
)==PICE_toupper(*s2
) ) // char are the same except case
375 // strings same length
382 //*************************************************************************
385 // my version of strcmp()
386 //*************************************************************************
387 ULONG
PICE_strcmpi(char* s1
,char* s2
)
391 while(IsAddressValid((ULONG
)s1
) && *s1
&& // not end of string
392 IsAddressValid((ULONG
)s2
) && *s2
&& // not end of string
393 PICE_toupper(*s1
)==PICE_toupper(*s2
) ) // char are the same except case
398 // strings same length
405 //*************************************************************************
408 // my version of strcmp()
409 //*************************************************************************
410 ULONG
PICE_strcmp(char* s1
,char* s2
)
414 while(IsAddressValid((ULONG
)s1
) && *s1
&& // not end of string
415 IsAddressValid((ULONG
)s2
) && *s2
&& // not end of string
421 // strings same length
428 //*************************************************************************
431 // compare function names ignoring decorations:
432 // leading '_' or '@" and trailing "@xx"
433 //*************************************************************************
434 ULONG
PICE_fncmp(char* s1
,char* s2
)
438 if( IsAddressValid((ULONG
)s1
) && (*s1
== '_' || *s1
== '@'))
441 if( IsAddressValid((ULONG
)s2
) && (*s2
== '_' || *s2
== '@'))
444 while(IsAddressValid((ULONG
)s1
) && *s1
&& // not end of string
445 IsAddressValid((ULONG
)s2
) && *s2
)
447 if( (*s1
!= *s2
) || *s1
=='@' || *s2
=='@' )
452 // strings same length
453 if((*s1
==0 || *s1
=='@') && (*s2
==0 || *s2
=='@')){
459 //*************************************************************************
462 // compare function names ignoring decorations:
463 // leading '_' or '@" and trailing "@xx" . Decorations are included in total length.
464 //*************************************************************************
465 ULONG
PICE_fnncmp(char* s1
,char* s2
, ULONG len
)
468 ULONG len1
= len
, len2
= len
;
470 if( IsAddressValid((ULONG
)s1
) && (*s1
== '_' || *s1
== '@')){
475 if( IsAddressValid((ULONG
)s2
) && (*s2
== '_' || *s2
== '@')){
480 while(len1
&& len2
&& IsAddressValid((ULONG
)s1
) && *s1
&& // not end of string
481 IsAddressValid((ULONG
)s2
) && *s2
)
483 if( (*s1
!= *s2
) || *s1
=='@' || *s2
=='@' )
490 // strings are the same length
491 if((*s1
=='\0' || *s1
=='@') && (*s2
=='\0' || *s2
=='@')){
497 wchar_t PICE_towlower(wchar_t c
)
499 if ( c
>=L
'A' && c
<=L
'Z' )
500 return (c
- (L
'A' - L
'a'));
504 ULONG
PICE_wcsicmp(WCHAR
* s1
, WCHAR
* s2
)
508 while(IsAddressValid((ULONG
)s1
) && *s1
&& // not end of string
509 IsAddressValid((ULONG
)s2
) && *s2
&& // not end of string
510 PICE_towlower(*s1
)==PICE_towlower(*s2
) ) // char are the same except case
515 // strings same length
522 //*************************************************************************
525 // my version of strrev()
526 //*************************************************************************
527 char* PICE_strrev(char* s
)
529 ULONG i
,j
,len
=PICE_strlen(s
)-1;
532 for(i
=0,j
=len
;i
<j
;i
++,j
--)
534 c
=s
[i
]; s
[i
]=s
[j
]; s
[j
]=c
;
540 //*************************************************************************
543 // my version of strlen()
545 // does a page validity check on every character in th string
546 //*************************************************************************
547 USHORT
PICE_strlen(const char* s
)
551 for(i
=0;IsAddressValid((ULONG
)&s
[i
]) && s
[i
]!=0 && i
<_PAGE_SIZE
;i
++);
553 if(IsAddressValid((ULONG
)&s
[i
]) && s
[i
]==0)
559 WCHAR
* PICE_wcscpy(WCHAR
* str1
,const WCHAR
* str2
)
563 for (; (*str1
= *str2
); ++str2
, ++str1
);
568 //*************************************************************************
571 // separates module name from path
572 //*************************************************************************
573 LPSTR
GetShortName(LPSTR p
)
577 // scan backwards till backslash or start
578 for(i
=PICE_strlen(p
);p
[i
]!='\\' && &p
[i
]!=p
;i
--);
579 // it's not start, inc. counter
582 // return section of string containing mod name
586 //*************************************************************************
589 // copy wide string to ANSI string
590 //*************************************************************************
591 void CopyWideToAnsi(LPSTR pAnsi
,PWSTR pWide
)
595 for(j
=0;pWide
[j
]!=0;j
++)
597 if((char)(pWide
[j
]>>8)==0)
598 pAnsi
[j
]=(char)(pWide
[j
]);
607 //*************************************************************************
610 //*************************************************************************
611 BOOLEAN
IsAddressValid(ULONG address
)
615 BOOLEAN bResult
= FALSE
;
617 address
&= (~(_PAGE_SIZE
-1));
619 pPGD
= ADDR_TO_PDE(address
);
620 if(pPGD
&& ((*pPGD
)&_PAGE_PRESENT
))
623 if(!((*pPGD
)&_PAGE_4M
))
625 pPTE
= ADDR_TO_PTE(address
);
628 bResult
= (*pPTE
)&(_PAGE_PRESENT
| _PAGE_PSE
);
642 //*************************************************************************
643 // IsAddressWriteable()
646 // TRUE if adress/page is writeable
647 // FALSE if adress/page is not writeable
649 //*************************************************************************
650 BOOLEAN
IsAddressWriteable(ULONG address
)
655 //address &= (~(_PAGE_SIZE-1));
656 pPGD
= ADDR_TO_PDE(address
);
657 if(pPGD
&& ((*pPGD
)&_PAGE_PRESENT
))
660 if(!((*pPGD
)&_PAGE_4M
))
662 if(!((*pPGD
) & _PAGE_RW
))
665 pPTE
= ADDR_TO_PTE(address
);
668 if( ((*pPTE
)&(_PAGE_PRESENT
| _PAGE_PSE
)) &&
669 ((*pPTE
) & _PAGE_RW
))
677 return ((*pPGD
) & _PAGE_RW
);
684 //*************************************************************************
685 // SetAddressWriteable()
687 //*************************************************************************
688 BOOLEAN
SetAddressWriteable(ULONG address
,BOOLEAN bSet
)
693 //address &= (~(_PAGE_SIZE-1));
695 pPGD
= ADDR_TO_PDE(address
);
696 if(pPGD
&& ((*pPGD
)&_PAGE_PRESENT
))
699 if(!((*pPGD
)&_PAGE_4M
))
701 pPTE
= ADDR_TO_PTE(address
);
704 if( (*pPTE
)&(_PAGE_PRESENT
| _PAGE_PSE
) )
730 //*************************************************************************
733 // scan range for page present
734 //*************************************************************************
735 BOOLEAN
IsRangeValid(ULONG Addr
,ULONG Length
)
737 ULONG i
,NumPages
,PageNum
;
739 // need to only touch one byte per page
740 // calculate PICE_number of pages to touch
741 NumPages
=(Length
+(_PAGE_SIZE
-1))>>12;
743 // calculate PICE_number of page
744 PageNum
=Addr
>>PAGE_SHIFT
;
746 // touch all pages containing range
747 for(i
=0;i
<NumPages
;i
++)
749 // if any one page is invalid range is invalid
750 if(!IsAddressValid((ULONG
)((PageNum
+i
)*_PAGE_SIZE
)) )
757 //*************************************************************************
760 // return flat address of GDT
761 //*************************************************************************
769 __asm__("sgdt %0;":"=m" (gdtr
));
770 pGdt
=(PGDT
)(((ULONG
)(gdtr
[1]<<16))|((ULONG
)(gdtr
[0]>>16)));
777 //*************************************************************************
778 // GetLinearAddress()
780 // return flat address for SEGMENT:OFFSET
781 //*************************************************************************
782 ULONG
GetLinearAddress(USHORT Segment
,ULONG Offset
)
787 USHORT OriginalSegment
=Segment
;
791 pSel
=(struct tagDESCRIPTOR
*)&Segment
;
795 DPRINT((0,"GetLinearAddress(): pGDT = %.8X\n",pGdt
));
796 DPRINT((0,"GetLinearAddress(): original Segment:Offset = %.4X:%.8X\n",Segment
,Offset
));
798 // see if segment selector is in LDT
801 DPRINT((0,"GetLinearAddress(): Segment is in LDT\n"));
809 DPRINT((0,"GetLinearAddress(): no LDT\n"));
811 pGdt
=(PGDT
)((pGdt
[pSel
->Val
].Base_31_24
<<24)|
812 (pGdt
[pSel
->Val
].Base_23_16
<<16)|
813 (pGdt
[pSel
->Val
].Base_15_0
));
814 if(!IsRangeValid((ULONG
)pGdt
,0x8) )
825 DPRINT((0,"GetLinearAddress(): Segment:Offset = %.4X:%.8X\n",Segment
,Offset
));
826 result
=pGdt
[OriginalSegment
>>3].Base_15_0
|
827 (pGdt
[OriginalSegment
>>3].Base_23_16
<<16)|
828 (pGdt
[OriginalSegment
>>3].Base_31_24
<<24);
831 DPRINT((0,"GetLinearAddress(%.4X:%.8X)=%.8X\n",OriginalSegment
,Offset
,result
));
838 //*************************************************************************
841 // place RUNNING message
842 //*************************************************************************
843 void ShowRunningMsg(void)
847 SetForegroundColor(COLOR_TEXT
);
848 SetBackgroundColor(COLOR_CAPTION
);
849 ClrLine(wWindow
[OUTPUT_WINDOW
].y
+wWindow
[OUTPUT_WINDOW
].cy
);
850 PutChar(" Reactos is running... (Press CTRL-D to stop) ",1,wWindow
[OUTPUT_WINDOW
].y
+wWindow
[OUTPUT_WINDOW
].cy
);
856 //*************************************************************************
859 // place STOPPED message
860 //*************************************************************************
861 void ShowStoppedMsg(void)
865 SetForegroundColor(COLOR_TEXT
);
866 SetBackgroundColor(COLOR_CAPTION
);
867 ClrLine(wWindow
[OUTPUT_WINDOW
].y
+wWindow
[OUTPUT_WINDOW
].cy
);
868 PutChar(" Stopped... (Type 'x' to continue) ",1,wWindow
[OUTPUT_WINDOW
].y
+wWindow
[OUTPUT_WINDOW
].cy
);
874 //*************************************************************************
875 // SetHardwareBreakPoint()
877 //*************************************************************************
878 void SetHardwareBreakPoint(ULONG ulAddress
,ULONG ulReg
)
881 ULONG enable_mask
= 0x3;
883 DPRINT((0,"SetHardwareBreakPoint(%x,DR%x)\n",ulAddress
,ulReg
));
885 enable_mask
<<= (ulReg
*2);
888 DPRINT((0,"mask = %x\n",mask
));
892 xorl %%eax,%%eax\n\t \
893 mov %%eax,%%dr6\n\t \
894 mov %%dr7,%%eax\n\t \
896 mov %%eax,%%dr7\n\t \
908 mov %%eax,%%dr0\n\t \
918 mov %%eax,%%dr1\n\t \
928 mov %%eax,%%dr2\n\t \
938 mov %%eax,%%dr3\n\t \
947 //*************************************************************************
948 // SetHardwareBreakPoints()
950 // install HW breakpoints
951 //*************************************************************************
952 void SetHardwareBreakPoints(void)
956 ULONG LinAddr0
,LinAddr1
,LinAddr2
,LinAddr3
;
957 PULONG LinAddr
[4]={&LinAddr0
,&LinAddr1
,&LinAddr2
,&LinAddr3
};
961 // cancel all debug activity
969 for(mask
=0,i
=0;i
<4;i
++)
972 if(Bp
[i
].Active
&& Bp
[i
].Used
&& !Bp
[i
].Virtual
)
975 *LinAddr
[3-i
]=Bp
[i
].LinearAddress
;
976 DPRINT((0,"breakpoint %u at %.8X\n",i
,Bp
[i
].LinearAddress
));
984 andl $0x000000FF,%%eax\n\t \
985 orl $0x300,%%eax\n\t \
986 mov %%eax,%%dr7\n\t \
988 mov %%eax,%%dr0\n\t \
990 mov %%eax,%%dr1\n\t \
992 mov %%eax,%%dr2\n\t \
994 mov %%eax,%%dr3\n\t \
997 :"m" (mask
),"m" (LinAddr0
),"m" (LinAddr1
),"m" (LinAddr2
),"m" (LinAddr3
));
1003 //*************************************************************************
1004 // IsCallInstrAtEIP()
1006 // check if instruction at CS:EIP changes program flow
1007 //*************************************************************************
1008 BOOLEAN
IsCallInstrAtEIP(void)
1011 BOOLEAN result
=FALSE
;
1014 DPRINT((0,"IsCallInstrAtEIP()\n"));
1016 linear
=(PUCHAR
)GetLinearAddress(CurrentCS
,CurrentEIP
);
1017 if(IsRangeValid((ULONG
)linear
,2))
1019 if(*linear
== 0xE8 || // call
1020 (*linear
== 0xFF && ( ((*(linear
+1)>>3)&0x7)==0x2 || ((*(linear
+1)>>3)&0x7)==0x3) ) || // call
1021 *linear
== 0x9A || // call
1022 *linear
== 0xF2 || // REP
1023 *linear
== 0xF3) // REP
1033 //*************************************************************************
1036 // check if instruction at CS:EIP is a return instruction
1037 //*************************************************************************
1038 BOOLEAN
IsRetAtEIP(void)
1041 BOOLEAN bResult
= FALSE
;
1044 DPRINT((0,"IsRetAtEIP()\n"));
1046 linear
=(PUCHAR
)GetLinearAddress(CurrentCS
,CurrentEIP
);
1054 case 0xcf: // IRET/IRETD
1064 //*************************************************************************
1067 // display CPU EFLAGS as string
1068 //*************************************************************************
1069 LPSTR
VisualizeFlags(ULONG EFlags
)
1071 static UCHAR FlagNames
[]={'c',0,'p',0,'a',0,'z','s','t','i','d','o'};
1073 static char temp
[32];
1075 for(j
=0,i
=0;i
<sizeof(FlagNames
);i
++)
1080 temp
[j
++] = PICE_toupper(FlagNames
[i
]);
1082 temp
[j
++] = FlagNames
[i
];
1092 //*************************************************************************
1095 // display CPU registers
1096 //*************************************************************************
1097 void DisplayRegs(void)
1099 char tempDisplayRegs
[48];
1103 // Clear(REGISTER_WINDOW);
1104 Home(REGISTER_WINDOW
);
1106 Print(REGISTER_WINDOW
,"EAX=");
1107 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentEAX
);
1108 if(OldEAX
!=CurrentEAX
)
1110 SetForegroundColor(WHITE
);
1112 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1113 if(OldEAX
!=CurrentEAX
)
1119 Print(REGISTER_WINDOW
," EBX=");
1120 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentEBX
);
1121 if(OldEBX
!=CurrentEBX
)
1123 SetForegroundColor(WHITE
);
1125 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1126 if(OldEBX
!=CurrentEBX
)
1132 Print(REGISTER_WINDOW
," ECX=");
1133 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentECX
);
1134 if(OldECX
!=CurrentECX
)
1136 SetForegroundColor(WHITE
);
1138 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1139 if(OldECX
!=CurrentECX
)
1145 Print(REGISTER_WINDOW
," EDX=");
1146 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentEDX
);
1147 if(OldEDX
!=CurrentEDX
)
1149 SetForegroundColor(COLOR_HILITE
);
1151 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1152 if(OldEDX
!=CurrentEDX
)
1158 Print(REGISTER_WINDOW
," ESI=");
1159 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentESI
);
1160 if(OldESI
!=CurrentESI
)
1162 SetForegroundColor(COLOR_HILITE
);
1164 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1165 if(OldESI
!=CurrentESI
)
1171 Print(REGISTER_WINDOW
," EDI=");
1172 PICE_sprintf(tempDisplayRegs
,"%.8X\n",CurrentEDI
);
1173 if(OldEDI
!=CurrentEDI
)
1175 SetForegroundColor(COLOR_HILITE
);
1177 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1178 if(OldEDI
!=CurrentEDI
)
1184 Print(REGISTER_WINDOW
,"EBP=");
1185 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentEBP
);
1186 if(OldEBP
!=CurrentEBP
)
1188 SetForegroundColor(COLOR_HILITE
);
1190 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1191 if(OldEBP
!=CurrentEBP
)
1197 Print(REGISTER_WINDOW
," ESP=");
1198 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentESP
);
1199 if(OldESP
!=CurrentESP
)
1201 SetForegroundColor(COLOR_HILITE
);
1203 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1204 if(OldESP
!=CurrentESP
)
1210 Print(REGISTER_WINDOW
," EIP=");
1211 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentEIP
);
1212 if(OldEIP
!=CurrentEIP
)
1214 SetForegroundColor(COLOR_HILITE
);
1216 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1217 if(OldEIP
!=CurrentEIP
)
1223 Print(REGISTER_WINDOW
," EFLAGS=");
1224 PICE_sprintf(tempDisplayRegs
,"%.8X",CurrentEFL
);
1225 if(OldEFL
!=CurrentEFL
)
1227 SetForegroundColor(COLOR_HILITE
);
1229 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1230 if(OldEFL
!=CurrentEFL
)
1236 PICE_sprintf(tempDisplayRegs
," %s\n",VisualizeFlags(CurrentEFL
));
1237 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1240 Print(REGISTER_WINDOW
,"CS=");
1241 PICE_sprintf(tempDisplayRegs
,"%.4X",CurrentCS
);
1242 if(OldCS
!=CurrentCS
)
1244 SetForegroundColor(COLOR_HILITE
);
1246 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1247 if(OldCS
!=CurrentCS
)
1253 Print(REGISTER_WINDOW
," DS=");
1254 PICE_sprintf(tempDisplayRegs
,"%.4X",CurrentDS
);
1255 if(OldDS
!=CurrentDS
)
1257 SetForegroundColor(COLOR_HILITE
);
1259 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1260 if(OldDS
!=CurrentDS
)
1266 Print(REGISTER_WINDOW
," ES=");
1267 PICE_sprintf(tempDisplayRegs
,"%.4X",CurrentES
);
1268 if(OldES
!=CurrentES
)
1270 SetForegroundColor(COLOR_HILITE
);
1272 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1273 if(OldES
!=CurrentES
)
1279 Print(REGISTER_WINDOW
," FS=");
1280 PICE_sprintf(tempDisplayRegs
,"%.4X",CurrentFS
);
1281 if(OldFS
!=CurrentFS
)
1283 SetForegroundColor(COLOR_HILITE
);
1285 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1286 if(OldFS
!=CurrentFS
)
1292 Print(REGISTER_WINDOW
," GS=");
1293 PICE_sprintf(tempDisplayRegs
,"%.4X",CurrentGS
);
1294 if(OldGS
!=CurrentGS
)
1298 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1299 if(OldGS
!=CurrentGS
)
1305 Print(REGISTER_WINDOW
," SS=");
1306 PICE_sprintf(tempDisplayRegs
,"%.4X",CurrentSS
);
1307 if(OldSS
!=CurrentSS
)
1309 SetForegroundColor(COLOR_HILITE
);
1311 Print(REGISTER_WINDOW
,tempDisplayRegs
);
1312 if(OldSS
!=CurrentSS
)
1320 //*************************************************************************
1323 //*************************************************************************
1324 void SaveOldRegs(void)
1349 //*************************************************************************
1352 //*************************************************************************
1353 UCHAR
GetKeyStatus(void)
1356 ucRet
= inb_p((PUCHAR
)(I8042_PHYSICAL_BASE
+ I8042_STATUS_REGISTER_OFFSET
));
1360 //*************************************************************************
1363 //*************************************************************************
1364 UCHAR
GetKeyData(void)
1367 ucRet
= inb_p((PUCHAR
)(I8042_PHYSICAL_BASE
+ I8042_DATA_REGISTER_OFFSET
));
1371 //*************************************************************************
1374 //*************************************************************************
1375 UCHAR
KeyboardGetKeyPolled(void)
1379 static BOOLEAN bExtended
= FALSE
;
1381 while(ucKey
=0,(ucStatus
=GetKeyStatus())&OUTPUT_BUFFER_FULL
)
1384 ucKey
= GetKeyData();
1386 if(ucStatus
&MOUSE_OUTPUT_BUFFER_FULL
)
1389 DPRINT((1,"GetKeyPolled(): key = %x bExtended=%s\n",ucKey
,bExtended
?"TRUE":"FALSE"));
1391 if(SCANCODE_EXTENDED
== ucKey
)
1393 DPRINT((1,"extended switched ON\n"));
1399 if(!(ucKey
&0x80)) // keypress
1403 case SCANCODE_L_CTRL
:
1404 case SCANCODE_R_CTRL
:
1408 case SCANCODE_L_SHIFT
:
1409 case SCANCODE_R_SHIFT
:
1413 case SCANCODE_L_ALT
:
1414 case SCANCODE_R_ALT
:
1419 DPRINT((0,"GetKeyPolled(): control = %u shift = %u alt = %u\n",bControl
,bShift
,bAlt
));
1427 case SCANCODE_L_CTRL
:
1428 case SCANCODE_R_CTRL
:
1432 case SCANCODE_L_SHIFT
:
1433 case SCANCODE_R_SHIFT
:
1437 case SCANCODE_L_ALT
:
1438 case SCANCODE_R_ALT
:
1451 //*************************************************************************
1452 // KeyboardFlushKeyboardQueue()
1454 //*************************************************************************
1455 void KeyboardFlushKeyboardQueue(void)
1458 KeStallExecutionProcessor(10);
1459 while(GetKeyStatus()&OUTPUT_BUFFER_FULL
)
1463 KeStallExecutionProcessor(10);
1467 //*************************************************************************
1470 //*************************************************************************
1471 BOOLEAN
CheckLoadAbort(void)
1478 SaveGraphicsState();
1480 FlushKeyboardQueue();
1488 PICE_sprintf(tempUtil
,"\n LOAD WILL CONTINUE IN %u SEC (HIT 'C' TO CONTINUE OR ANY OTHER KEY TO ABORT)\n",5-i
/1000);
1489 Clear(REGISTER_WINDOW
);
1490 Print(REGISTER_WINDOW
,tempUtil
);
1494 ucKey
= GetKeyPolled();
1498 if((ucKey
&0x7f)!=46)
1500 RestoreGraphicsState();
1507 KeStallExecutionProcessor(1000);
1510 Clear(REGISTER_WINDOW
);
1514 FlushKeyboardQueue();
1516 RestoreGraphicsState();
1526 //*************************************************************************
1529 //*************************************************************************
1530 void IntelStackWalk(ULONG pc
,ULONG ebp
,ULONG esp
)
1532 PULONG pFrame
, pPrevFrame
;
1535 DPRINT((0,"IntelStackWalk(): pc = %X ebp = %X esp = %X\n",pc
,ebp
,esp
));
1537 pFrame
= pPrevFrame
= (PULONG
)ebp
;
1539 PutStatusText("EIP FRAME NAME\n");
1542 DPRINT((0,"IntelStackWalk(): pFrame = %X pPrevFrame = %X pc =%X\n",(ULONG
)pFrame
,(ULONG
)pPrevFrame
,pc
));
1543 if ( ( (ULONG
)pFrame
& 3 ) ||
1544 ( (pFrame
<= pPrevFrame
) ) )
1546 DPRINT((0,"IntelStackWalk(): pFrame is either unaligned or not less than previous\n"));
1547 if( !IsRangeValid((ULONG
)pFrame
, sizeof(PVOID
)*2) )
1549 DPRINT((0,"IntelStackWalk(): pFrame not valid pointer!\n"));
1554 if((pSymbolName
= FindFunctionByAddress(pc
,NULL
,NULL
)) )
1555 PICE_sprintf(tempUtil
,"%08X %08X %s\n",pc
, (ULONG
)pFrame
,pSymbolName
);
1557 PICE_sprintf(tempUtil
,"%08X %08X\n",pc
, (ULONG
)pFrame
);
1558 Print(OUTPUT_WINDOW
,tempUtil
);
1559 if(WaitForKey()==FALSE
)break;
1563 pPrevFrame
= pFrame
;
1565 pFrame
= (PULONG
)pFrame
[0]; // proceed to next higher frame on stack
1569 //*************************************************************************
1570 // FindPteForLinearAddress()
1572 //*************************************************************************
1573 PULONG
FindPteForLinearAddress(ULONG address
)
1577 BOOLEAN bResult
= FALSE
;
1578 PEPROCESS my_current
= IoGetCurrentProcess();
1582 address
&= (~(_PAGE_SIZE
-1));
1586 pPGD
= ADDR_TO_PDE(address
);
1587 if(pPGD
&& ((*pPGD
)&_PAGE_PRESENT
))
1590 if(!((*pPGD
)&_PAGE_4M
))
1592 pPTE
= ADDR_TO_PTE(address
);
1612 //*************************************************************************
1615 //*************************************************************************
1616 void InvalidateLB(void)
1619 __asm__ __volatile__
1622 mov %%cr3,%%ecx\n\t \
1629 //*************************************************************************
1632 //*************************************************************************
1633 ULONG
ReadPhysMem(ULONG Address
,ULONG ulSize
)
1635 ULONG Page
= ((ULONG
)TwoPagesForPhysMem
+_PAGE_SIZE
)&~(_PAGE_SIZE
-1);
1641 DPRINT((0,"ReadPhysMem(%.8X,%u)\n",Address
,ulSize
));
1642 DPRINT((0,"ReadPhysMem(): Page = %.8X\n",Page
));
1643 pPTE
= (PULONG
)FindPteForLinearAddress(Page
);
1644 DPRINT((0,"ReadPhysMem(): pPTE = %.8X\n",pPTE
));
1648 DPRINT((0,"ReadPhysMem(): oldPTE = %.8X\n",oldPTE
));
1649 temp
= (Address
& ~(_PAGE_SIZE
-1));
1650 DPRINT((0,"ReadPhysMem(): page-aligned Address = %.8X\n",temp
));
1652 DPRINT((0,"ReadPhysMem(): new PTE = %.8X\n",*pPTE
));
1656 case sizeof(UCHAR
): // BYTE
1657 temp
= *(PUCHAR
)(Page
+ (Address
& (_PAGE_SIZE
-1)));
1660 case sizeof(USHORT
): // WORD
1661 temp
= *(PUSHORT
)(Page
+ (Address
& (_PAGE_SIZE
-1)));
1662 temp
= (USHORT
)temp
;
1664 case sizeof(ULONG
): // DWORD
1665 temp
= *(PULONG
)(Page
+ (Address
& (_PAGE_SIZE
-1)));
1676 //*************************************************************************
1679 //*************************************************************************
1680 void WritePhysMem(ULONG Address
,ULONG Datum
,ULONG ulSize
)
1682 ULONG Page
= ((ULONG
)TwoPagesForPhysMem
+_PAGE_SIZE
)&~(_PAGE_SIZE
-1);
1687 pPTE
= (PULONG
)FindPteForLinearAddress(Page
);
1691 temp
= (Address
& ~(_PAGE_SIZE
-1));
1692 *pPTE
= temp
| 0x3; // present and writable
1696 case sizeof(UCHAR
): // BYTE
1697 *(PUCHAR
)(Page
+ (Address
& (_PAGE_SIZE
-1))) = (UCHAR
)Datum
;
1699 case sizeof(USHORT
): // WORD
1700 *(PUSHORT
)(Page
+ (Address
& (_PAGE_SIZE
-1))) = (USHORT
)Datum
;
1702 case sizeof(ULONG
): // DWORD
1703 *(PULONG
)(Page
+ (Address
& (_PAGE_SIZE
-1))) = Datum
;
1711 /////////////////////////////////////////////////////////////////////////////
1712 unsigned long simple_strtoul(const char *cp
,char **endp
,unsigned int base
)
1714 unsigned long result
= 0,value
;
1721 if ((*cp
== 'x') && PICE_isxdigit(cp
[1])) {
1727 while (PICE_isxdigit(*cp
) && (value
= PICE_isdigit(*cp
) ? *cp
-'0' : (PICE_islower(*cp
)
1728 ? PICE_toupper(*cp
) : *cp
)-'A'+10) < base
) {
1729 result
= result
*base
+ value
;
1737 long simple_strtol(const char *cp
,char **endp
,unsigned int base
)
1740 return -simple_strtoul(cp
+1,endp
,base
);
1741 return simple_strtoul(cp
,endp
,base
);
1744 /* we use this so that we can do without the ctype library */
1745 #define is_digit(c) ((c) >= '0' && (c) <= '9')
1747 static int skip_atoi(const char **s
)
1751 while (is_digit(**s
))
1752 i
= i
*10 + *((*s
)++) - '0';
1756 size_t PICE_strnlen(const char * s
, size_t count
)
1760 for (sc
= s
; count
-- && IsAddressValid((ULONG
)sc
) && *sc
!= '\0'; ++sc
)
1766 #define NUM_ZEROPAD 1 /* pad with zero */
1767 #define NUM_SIGN 2 /* unsigned/signed long */
1768 #define NUM_PLUS 4 /* show plus */
1769 #define NUM_SPACE 8 /* space if plus */
1770 #define NUM_LEFT 16 /* left justified */
1771 #define NUM_SPECIAL 32 /* 0x */
1772 #define NUM_LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
1774 #define do_div(n,base) ({ \
1776 __res = ((unsigned long) n) % (unsigned) base; \
1777 n = ((unsigned long) n) / (unsigned) base; \
1780 static char * PICE_number(char * str
, long num
, int base
, int size
, int precision
1783 char c
,sign
,tmp
[66];
1784 const char *digits
="0123456789abcdefghijklmnopqrstuvwxyz";
1787 if (type
& NUM_LARGE
)
1788 digits
= "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1789 if (type
& NUM_LEFT
)
1790 type
&= ~NUM_ZEROPAD
;
1791 if (base
< 2 || base
> 36)
1793 c
= (type
& NUM_ZEROPAD
) ? '0' : ' ';
1795 if (type
& NUM_SIGN
) {
1800 } else if (type
& NUM_PLUS
) {
1803 } else if (type
& NUM_SPACE
) {
1808 if (type
& NUM_SPECIAL
) {
1817 else while (num
!= 0)
1818 tmp
[i
++] = digits
[do_div(num
,base
)];
1822 if (!(type
&(NUM_ZEROPAD
+NUM_LEFT
)))
1827 if (type
& NUM_SPECIAL
) {
1830 else if (base
==16) {
1832 *str
++ = digits
[33];
1835 if (!(type
& NUM_LEFT
))
1838 while (i
< precision
--)
1847 /* Forward decl. needed for IP address printing stuff... */
1848 int PICE_sprintf(char * buf
, const char *fmt
, ...);
1850 int PICE_vsprintf(char *buf
, const char *fmt
, va_list args
)
1859 int flags
; /* flags to PICE_number() */
1861 int field_width
; /* width of output field */
1862 int precision
; /* min. # of digits for integers; max
1863 PICE_number of chars for from string */
1864 int qualifier
; /* 'h', 'l', or 'L' for integer fields */
1866 for (str
=buf
; *fmt
; ++fmt
) {
1875 ++fmt
; /* this also skips first '%' */
1877 case '-': flags
|= NUM_LEFT
; goto repeat
;
1878 case '+': flags
|= NUM_PLUS
; goto repeat
;
1879 case ' ': flags
|= NUM_SPACE
; goto repeat
;
1880 case '#': flags
|= NUM_SPECIAL
; goto repeat
;
1881 case '0': flags
|= NUM_ZEROPAD
; goto repeat
;
1884 /* get field width */
1887 field_width
= skip_atoi(&fmt
);
1888 else if (*fmt
== '*') {
1890 /* it's the next argument */
1891 field_width
= va_arg(args
, int);
1892 if (field_width
< 0) {
1893 field_width
= -field_width
;
1898 /* get the precision */
1903 precision
= skip_atoi(&fmt
);
1904 else if (*fmt
== '*') {
1906 /* it's the next argument */
1907 precision
= va_arg(args
, int);
1913 /* get the conversion qualifier */
1915 if (*fmt
== 'h' || *fmt
== 'l' || *fmt
== 'L') {
1925 if (!(flags
& NUM_LEFT
))
1926 while (--field_width
> 0)
1928 *str
++ = (unsigned char) va_arg(args
, int);
1929 while (--field_width
> 0)
1934 s
= va_arg(args
, char *);
1938 len
= PICE_strnlen(s
, precision
);
1940 if (!(flags
& NUM_LEFT
))
1941 while (len
< field_width
--)
1943 for (i
= 0; i
< len
; ++i
)
1945 while (len
< field_width
--)
1950 if (qualifier
== 'h') {
1951 /* print ascii string */
1952 s
= va_arg(args
, char *);
1956 len
= PICE_strlen (s
);
1957 if ((unsigned int)len
> (unsigned int)precision
)
1960 if (!(flags
& NUM_LEFT
))
1961 while (len
< field_width
--)
1963 for (i
= 0; i
< len
; ++i
)
1965 while (len
< field_width
--)
1968 /* print unicode string */
1969 sw
= va_arg(args
, wchar_t *);
1974 if ((unsigned int)len
> (unsigned int)precision
)
1977 if (!(flags
& NUM_LEFT
))
1978 while (len
< field_width
--)
1980 for (i
= 0; i
< len
; ++i
)
1981 *str
++ = (unsigned char)(*sw
++);
1982 while (len
< field_width
--)
1988 if (field_width
== -1) {
1989 field_width
= 2*sizeof(void *);
1990 flags
|= NUM_ZEROPAD
;
1992 str
= PICE_number(str
,
1993 (unsigned long) va_arg(args
, void *), 16,
1994 field_width
, precision
, flags
);
1999 if (qualifier
== 'l') {
2000 long * ip
= va_arg(args
, long *);
2003 int * ip
= va_arg(args
, int *);
2012 /* integer PICE_number formats - set up the flags and "break" */
2037 if (qualifier
== 'l')
2038 num
= va_arg(args
, unsigned long);
2039 else if (qualifier
== 'h') {
2040 num
= (unsigned short) va_arg(args
, int);
2041 if (flags
& NUM_SIGN
)
2043 } else if (flags
& NUM_SIGN
)
2044 num
= va_arg(args
, int);
2046 num
= va_arg(args
, unsigned int);
2047 str
= PICE_number(str
, num
, base
, field_width
, precision
, flags
);
2053 int PICE_sprintf(char * buf
, const char *fmt
, ...)
2058 va_start(args
, fmt
);
2059 i
= PICE_vsprintf(buf
,fmt
,args
);
2064 //*************************************************************************
2067 // Convert Scancode to ASCII
2068 //*************************************************************************
2069 UCHAR
AsciiFromScan(UCHAR s
)
2078 table
= GetKeyboardLayout()->shifted
;
2082 table
= GetKeyboardLayout()->alted
;
2086 table
= GetKeyboardLayout()->normal
;
2092 for(i
=0;table
[i
].s
!= 0;i
++)
2102 DPRINT((0,"AsciiFromScan(): no translation for key\n"));
2108 //*************************************************************************
2111 // Convert Scancode to ASCII
2112 //*************************************************************************
2113 UCHAR
AsciiToScan(UCHAR s
)
2122 table
= GetKeyboardLayout()->shifted
;
2126 table
= GetKeyboardLayout()->alted
;
2130 table
= GetKeyboardLayout()->normal
;
2135 for(i
=0;table
[i
].s
!= 0;i
++)
2145 DPRINT((0,"AsciiToScan(): no translation for ASCII code\n"));
2150 //************************************************************************
2153 //************************************************************************
2154 void outportb(PUCHAR port
,UCHAR data
)
2156 WRITE_PORT_UCHAR((PUCHAR
)port
, data
);
2159 void outb_p(UCHAR data
, PUCHAR port
)
2161 WRITE_PORT_UCHAR((PUCHAR
)port
, data
);
2164 VOID
outl(ULONG data
, PULONG port
)
2166 WRITE_PORT_ULONG(port
, data
);
2170 //************************************************************************
2173 //************************************************************************
2174 UCHAR
inportb(PUCHAR port
)
2176 return READ_PORT_UCHAR((PUCHAR
)port
);
2179 UCHAR
inb_p(PUCHAR port
)
2181 return READ_PORT_UCHAR((PUCHAR
)port
);
2184 ULONG
inl(PULONG port
)
2186 return READ_PORT_ULONG(port
);
2189 //*************************************************************************
2190 // EnablePassThrough()
2192 // enable MDA passthrough on AGP chipset
2193 //*************************************************************************
2194 void EnablePassThrough(void)
2201 oldCF8
= inl((PULONG
)0xcf8);
2202 outl(0x80000050,(PULONG
)0xcf8);
2203 outl(inl((PULONG
)0xcfc)|0x00000020,(PULONG
)0xcfc);
2204 outl(oldCF8
,(PULONG
)0xcf8);
2206 restore_flags(flags
);
2209 //***********************************************************************************
2210 // Pice_malloc - allocate memory from paged or non-paged pool
2211 //***********************************************************************************
2212 void * PICE_malloc( size_t numBytes
, BOOLEAN fromPaged
)
2214 void* res
= ExAllocatePool( (fromPaged
)?PagedPool
:NonPagedPool
, numBytes
);
2219 //***********************************************************************************
2220 // PICE_free - free memory allocated by PICE_malloc
2221 //***********************************************************************************
2222 void PICE_free( void* p
)
2228 long PICE_read(HANDLE hFile
, LPVOID lpBuffer
, long lBytes
)
2230 DWORD NumberOfBytesRead
;
2231 IO_STATUS_BLOCK iosb
;
2235 if (!NT_SUCCESS(NtReadFile(
2237 NULL
, NULL
, NULL
, &iosb
,
2246 NumberOfBytesRead
= iosb
.Information
;
2247 return NumberOfBytesRead
;
2250 HANDLE
PICE_open (LPCWSTR lpPathName
, int iReadWrite
)
2252 DWORD dwAccessMask
= 0;
2253 DWORD dwShareMode
= 0;
2254 UNICODE_STRING TmpFileName
;
2255 OBJECT_ATTRIBUTES ObjectAttributes
;
2256 IO_STATUS_BLOCK StatusBlock
;
2261 DPRINT((0,"PICE_open: %S\n", lpPathName
));
2263 if ( (iReadWrite
& OF_READWRITE
) == OF_READWRITE
)
2264 dwAccessMask
= GENERIC_READ
| GENERIC_WRITE
;
2265 else if ( (iReadWrite
& OF_READ
) == OF_READ
)
2266 dwAccessMask
= GENERIC_READ
;
2267 else if ( (iReadWrite
& OF_WRITE
) == OF_WRITE
)
2268 dwAccessMask
= GENERIC_WRITE
;
2270 if ((iReadWrite
& OF_SHARE_COMPAT
) == OF_SHARE_COMPAT
)
2271 dwShareMode
= FILE_SHARE_WRITE
| FILE_SHARE_READ
| FILE_SHARE_DELETE
;
2272 else if ((iReadWrite
& OF_SHARE_DENY_NONE
) == OF_SHARE_DENY_NONE
)
2273 dwShareMode
= FILE_SHARE_WRITE
| FILE_SHARE_READ
| FILE_SHARE_DELETE
;
2274 else if ((iReadWrite
& OF_SHARE_DENY_READ
) == OF_SHARE_DENY_READ
)
2275 dwShareMode
= FILE_SHARE_WRITE
| FILE_SHARE_DELETE
;
2276 else if ((iReadWrite
& OF_SHARE_DENY_WRITE
) == OF_SHARE_DENY_WRITE
)
2277 dwShareMode
= FILE_SHARE_READ
| FILE_SHARE_DELETE
;
2278 else if ((iReadWrite
& OF_SHARE_EXCLUSIVE
) == OF_SHARE_EXCLUSIVE
)
2281 RtlInitUnicodeString (&TmpFileName
, lpPathName
);
2282 InitializeObjectAttributes(&ObjectAttributes
,
2288 status
= NtOpenFile( &hfile
,
2291 &StatusBlock
, dwShareMode
, FILE_NO_INTERMEDIATE_BUFFERING
);
2292 //BUG BUG check status!!!
2293 if( !NT_SUCCESS( status
) ){
2294 DPRINT((0,"PICE_open: NtOpenFile error: %x\n", status
));
2300 int PICE_close (HANDLE hFile
)
2302 if (NT_SUCCESS( ZwClose((HANDLE
)hFile
)))
2306 DPRINT((0,"ZwClose failed:\n"));
2310 size_t PICE_len( HANDLE hFile
)
2312 FILE_STANDARD_INFORMATION fs
;
2313 IO_STATUS_BLOCK iosb
;
2316 status
= ZwQueryInformationFile( hFile
, &iosb
, &fs
, sizeof fs
, FileStandardInformation
);
2317 if( !NT_SUCCESS( status
) ){
2318 DPRINT((0,"PICE_len: ZwQueryInformationFile error: %x\n", status
));
2321 //ASSERT(fs.EndOfFile.u.HighPart == 0);
2322 return (size_t)fs
.EndOfFile
.u
.LowPart
;
2327 * A raw converter for now. It assumes lpMultiByteStr is
2328 * NEVER multi-byte (that is each input character is
2329 * 8-bit ASCII) and is ALWAYS NULL terminated.
2330 * FIXME-FIXME-FIXME-FIXME
2335 PICE_MultiByteToWideChar (
2338 LPCSTR lpMultiByteStr
,
2340 LPWSTR lpWideCharStr
,
2344 int InStringLength
= 0;
2345 BOOL InIsNullTerminated
= TRUE
;
2351 * Check the parameters.
2353 if ( /* --- CODE PAGE --- */
2354 ( (CP_ACP
!= CodePage
)
2355 && (CP_MACCP
!= CodePage
)
2356 && (CP_OEMCP
!= CodePage
))
2358 /*|| (dwFlags ^ ( MB_PRECOMPOSED
2360 | MB_ERR_INVALID_CHARS
2364 /* --- INPUT BUFFER --- */
2365 || (NULL
== lpMultiByteStr
)
2368 DPRINT((0,"ERROR_INVALID_PARAMETER\n"));
2372 * Compute the input buffer length.
2374 if (-1 == cchMultiByte
)
2376 InStringLength
= PICE_strlen(lpMultiByteStr
);
2380 InIsNullTerminated
= FALSE
;
2381 InStringLength
= cchMultiByte
;
2384 * Does caller query for output
2387 if (0 == cchWideChar
)
2389 DPRINT((0,"ERROR_SUCCESS\n"));
2390 return InStringLength
;
2393 * Is space provided for the translated
2396 if (cchWideChar
< InStringLength
)
2398 DPRINT((0,"ERROR_INSUFFICIENT_BUFFER: cchWideChar: %d, InStringLength: %d\n", cchWideChar
, InStringLength
));
2402 * Raw 8- to 16-bit conversion.
2404 for ( cchConverted
= 0,
2405 r
= (PCHAR
) lpMultiByteStr
,
2406 w
= (PWCHAR
) lpWideCharStr
;
2408 ((*r
) && (cchConverted
< cchWideChar
));
2417 * Is the input string NULL terminated?
2419 if (TRUE
== InIsNullTerminated
)
2425 * Return how many characters we
2426 * wrote in the output buffer.
2428 return cchConverted
;