[收藏]在Win9x/NT下获取硬盘物理序列号

天云上人

1. #include <WinIOCtl.h>
   . w$ n  U( E/ D# l- U7 e/ i' d  B
2. #include <stdio.h>
   # U- B( R; p0 u5 ]; e$ A# U: C! S
3. 
     l, o+ x, E6 s1 R. j, d
4. #pragma inline
   3 s3 l- P6 C; v# R5 M; s: P2 M5 [
5. //---------------------------------------------------------------------------
   * F2 s+ a# w8 W& N2 W% m# [4 ]
6. // IDE NT/2000/XP专用变量
   
7. #define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
   + Z# G( G' W9 f8 e
8. #define DFP_GET_VERSION         SMART_GET_VERSION
   4 m& O# ^! }3 n: S) Z
9. #define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
   
10. #define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
    6 r% e; Q& H2 q$ r8 u
11. 
    3 ?4 v+ ]# T- Y
12. const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
    
13. const WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
    ) f- Q% L. U# Q/ ^- s6 F- I9 @# b
14. 
    
15. const int MAX_IDE_DRIVES = 4;
    2 Z% A! }0 ]8 z7 k
16. 
    
17. // SCSI专用变量
    ' T% V8 q" [& w* m# U0 k
18. const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
    ) K% t4 K0 n, O" {
19. const DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
    
20. const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
    
21. const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
    2 X  {' D2 Z7 c  R) n
22. 
    
23. typedef struct _SRB_IO_CONTROL
    : o5 }1 X  O  n! x! I
24. {
    " L. p8 }" L0 s! D- [$ ^
25.    ULONG HeaderLength;
    
26.    UCHAR Signature[8];
    
27.    ULONG Timeout;
    9 V3 b- a4 l1 r
28.    ULONG ControlCode;
    * y  J9 ]1 P* h! N* N' [) M" P& v: @
29.    ULONG ReturnCode;
    3 I& |) Z5 b; ]( T& G  g1 s
30.    ULONG Length;
    : z" ^2 x; h4 L( F% ^6 M! C" G
31. }SRB_IO_CONTROL, *PSRB_IO_CONTROL;
    5 ], ^) L* }  H5 Y4 p! h/ M4 A" h
32. 
    . {4 _- k6 N! [$ t1 z
33. // 读取的主函数
    
34. void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
      Y2 d2 p9 `; F- R9 ]! `& O5 W
35. 
    - F' w& D% o1 ~  _, |( Y( z( L6 T  a
36. // 辅助函数
    $ y4 M6 _. ~2 c. A
37. char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
    
38. // NT/2000/XP函数
    
39. void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
    
40. bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
    & |4 Y2 z* Q5 S7 G& t: x* k# R
41.        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
    
42.        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
    
43. // Windows 9X函数
      j3 n" Q( L1 L: ?, `& U  x
44. void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
    ! S6 a/ H" V6 j
45. void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
    
46.        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);
    
47. 
    
48. // SCSI读取函数(for NT/2000/XP)
    
49. String __fastcall ReadIDEDriveAsScsiDriveOnNT();
    5 ]) P! x3 g% V4 j1 O% Y: ?9 q" Q
50. //---------------------------------------------------------------------------
    
51. // ReadPhysicalDrive
    
52. void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
    
53. {
    
54.    switch(Win32Platform)
    ! s( N6 S. p9 ]% f0 D' r9 d
55.    {
    ! r# M7 N/ F4 a, i
56.        case VER_PLATFORM_WIN32_WINDOWS:
    3 A# h1 ?6 W) ~; H" O& Q' C7 M2 P0 a
57.            ReadPhysicalDriveOnW9X(pSerList, pModeList);
    0 e- N+ h5 o3 @2 x& ]+ @8 \
58.            break;
    
59.        case VER_PLATFORM_WIN32_NT:
    
60.            ReadPhysicalDriveOnNT(pSerList, pModeList);
    
61.            break;
    
62.        default:
    2 ^5 j5 q) X& _
63.            break;
    ' M- h7 A: |4 u/ e: g: o9 B0 j
64.    }
    . }( n) Q. e' M
65. }
    
66. //---------------------------------------------------------------------------
    & U6 q& Q4 K5 j% ^  E7 j
67. // ConvertToString
    ( a4 T7 W6 _  e" A9 b+ \
68. char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
    
69. {
    & A; Y) b' C  {  j) c; U8 `9 R
70.    static char szResBuf[1024];
    
71.    int nIndex = 0;
    
72.    int nPosition = 0;
    $ T4 o& R. m# I6 a
73. 
    
74.    // Each integer has two characters stored in it backwards
    
75.    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
    
76.    {
    
77.        // Get high BYTE for 1st character
    
78.        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
    : d5 s0 g: [1 Q
79.        nPosition++;
    $ r: \+ D8 a2 l3 Z' T
80. 
    . \, T! r  E7 j+ T3 B
81.        // Get low BYTE for 2nd character
    
82.        szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
    
83.        nPosition++;
    * i0 x7 W+ e' x' ~, d
84.    }
    8 s1 G' ?) x, A! J' S% S
85. 
    6 o( Z: x& T& v8 [0 H* Y. @
86.    // End the string
    
87.    szResBuf[nPosition] = '\0';
    
88. 
    
89.    // Cut off the trailing blanks
    0 G) Q) w1 r( m+ o3 o& @
90.    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
    
91.        szResBuf[nIndex] = '\0';
    " e% {. X+ ~; z6 Q
92. 
    " X0 ^/ @% E& N9 J
93.    return szResBuf;
    
94. }
    & H3 ]8 @- Q) [8 c' l; ]
95. //---------------------------------------------------------------------------
    % i) l. Y6 c# z2 E5 e+ K' r: Q
96. // Winndows NT4/2000/XP 代码
    1 w" X, F. d* Y
97. //---------------------------------------------------------------------------
    
98. // ReadPhysicalDriveOnNT
    
99. void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
    % Q  o+ \" n! x2 a/ {% A& p
100. {
     
101.    // 输出参数
     ) P0 z# s* S: I3 A- Y) N
102.    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
     2 V2 V  a0 }! s# E4 h6 s2 t# U4 N
103. 
     
104.    for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
     
105.    {
     9 ^9 z9 B$ C" @; [) A, P2 d
106.        HANDLE hPhysicalDriveIOCTL;
     
107.        char szDriveName[32];
     ( p9 U5 C/ z( k/ w' j
108. 
     2 ^* ]; e, O% z5 g: z+ G
109.        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
     
110.        hPhysicalDriveIOCTL = CreateFile(szDriveName,
     
111.                        GENERIC_READ | GENERIC_WRITE,
     
112.                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
     / A5 z8 U7 z0 ^% S
113.                        OPEN_EXISTING, 0, NULL);
     
114. 
     * Q/ Y9 A) q& M) m+ [% C" g  e
115.        if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
     8 g4 Y7 L% m% K
116.        {
     - a' N* _) d4 {9 R# v' a  @( _
117.            DWORD dwBytesReturned = 0;
     
118.            GETVERSIONOUTPARAMS gvopVersionParams;
     
119. 
     
120.            // Get the version, etc of PhysicalDrive IOCTL
     
121.            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
     ) v! L" I0 u- a& f
122. 
     + h7 c: Q% N8 G6 B9 ]6 w
123.            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
     
124.                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
     
125.                    &dwBytesReturned, NULL))
     , s( J5 Y$ d/ o8 a% o
126.            {
     
127.                continue;
     
128.            }
     
129. 
     , ?) y) f3 \6 ~7 J
130.            if(gvopVersionParams.bIDEDeviceMap > 0)
     8 }7 A8 D  |: Y. m3 D" L% V
131.            {
     ( k0 v. ]" U+ G5 \1 T+ J- C
132.                // IDE or ATAPI IDENTIFY cmd
     
133.                BYTE btIDCmd = 0;
     
134.                SENDCMDINPARAMS InParams;
     
135.                // Now, get the ID sector for all IDE devices in the system.
     
136.                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
     
137.                // otherwise use the IDE_ATA_IDENTIFY command
     * {8 g2 r' v$ Z+ `' N8 m
138.                // 具体所得结果请参考头文件中的说明
     ; t& }, v; I: C9 @, N3 T  `
139.                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
     
140.                        IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
     
141.                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
     * F6 a9 I3 N' q
142.                ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
     
143. 
     
144.                if(DoIdentify(hPhysicalDriveIOCTL,
     
145.                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
     
146.                     (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
     % i7 K" V, N' j/ l- W
147.                {
     
148.                    DWORD dwDiskData[256];
     + e2 k% m- n: x6 g% T& _. e8 p
149.                    USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
     ( `$ H/ C: p& H" m  B' n8 S2 N# ^
150.                    char szSerialNumber[21];
     6 I# z) H' q" B: V/ u5 B# b& C
151.                    char szModelNumber[41];
     
152. 
     
153.                    pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
     
154.                    for(int i=0; i < 256; i++)
     % ]. }# K9 r* N8 t* x
155.                        dwDiskData = pIDSector;
     6 j2 Y2 J# |7 s8 q3 R
156.                    // 取系列号
     
157.                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
     . P) ?/ z- _6 I& A
158.                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
     ; l- ]+ z9 R- {" F+ X( o
159. 
     
160.                    // 取模型号
     
161.                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
     
162.                    strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
     . B9 v/ m8 @* ^0 ^9 h; w) @# p
163. 
     
164.                    pSerList->Add(szSerialNumber);
     
165.                    pModeList->Add(szModelNumber);
     
166.                }
     
167.            }
     
168.            CloseHandle (hPhysicalDriveIOCTL);
     4 @4 H2 q% o. h4 @2 i: n; b
169.        }
     " L7 {( f& N9 |+ n
170.    }
     
171. }
     
172. //---------------------------------------------------------------------------
     
173. // DoIdentify
     
174. bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
     , I+ }: S6 J/ f+ s
175.              PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
     , i1 ]7 k; [  D# R( o. U/ p2 j
176.              PDWORD pdwBytesReturned)
     9 W# @& m8 |, F
177. {
     
178.    // Set up data structures for IDENTIFY command.
     " d5 B3 N- ~" h" _, ^9 _$ ]
179.    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
     
180.    pSCIP->irDriveRegs.bFeaturesReg = 0;
     6 W% p# [/ T% p" \" ?
181.    pSCIP->irDriveRegs.bSectorCountReg  = 1;
     / Y: N0 k1 q0 o5 @$ M! Y
182.    pSCIP->irDriveRegs.bSectorNumberReg = 1;
     
183.    pSCIP->irDriveRegs.bCylLowReg  = 0;
     
184.    pSCIP->irDriveRegs.bCylHighReg = 0;
     
185. 
     6 S6 D" c( I0 O, K& d
186.    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
     
187.    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
     9 Q0 ?8 D; [2 t
188. 
     4 s5 u' w. f% s+ o! D
189.    // The command can either be IDE identify or ATAPI identify.
     
190.    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
     
191.    pSCIP->bDriveNumber = btDriveNum;
     
192.    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
     2 s; @% J: n; h0 e- ^
193. 
     
194.    return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
     
195.           (LPVOID)pSCIP,
     
196.           sizeof(SENDCMDINPARAMS) - 1,
     ; o3 X; Z1 j) K/ n6 }" K
197.           (LPVOID)pSCOP,
     : z3 e- J* H' |5 f: I' Q
198.           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
     8 A3 Z, y; h2 X" O2 a
199.           pdwBytesReturned, NULL);
     
200. }
     1 _( j+ X3 p" V% V* q1 E
201. //---------------------------------------------------------------------------
     9 v( g$ W4 S& w3 ]) N
202. // Windows 95/98/ME 代码
     $ y# h! d' |5 I  G- n# i
203. //---------------------------------------------------------------------------
     ! y# g$ Q. u! t: M  M/ ]* \4 s
204. // ReadPhysicalDriveOnW9X
     2 w" N+ y" e: W
205. void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
     
206. {
     
207.    WORD wOutData[256];
     
208.    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
     8 ^* S1 I% k; O
209. 
     
210.    // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
     , ~: h2 o! T, \( h0 [. E
211.    // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
     
212.    // 避免蓝屏的出现。（期待高人能指出原因）
     
213.    for(int nDrive = 0; nDrive < 8; nDrive++)
     9 S/ ^+ k1 r& q2 o
214.    {
     
215.        WORD dwBaseAddress;
     9 g$ O& ?% s. e4 n1 b
216.        BYTE btMasterSlave;         // Master Or Slave
     % F0 U/ L1 y' [6 U8 |) T
217.        bool bIsIDEExist;
     
218.        bool IsDiskExist;
     1 c9 X5 u5 t/ `  n6 w' W
219. 
     
220.        switch(nDrive / 2)
     
221.        {
     
222.            case 0: dwBaseAddress = 0x01F0; break;
     . ]2 S& c) h1 e. D6 ~" |  y* U: _
223.            case 1: dwBaseAddress = 0x0170; break;
     
224.            case 2: dwBaseAddress = 0x01E8; break;
     3 G! Q& l/ ]: o, H" ?
225.            case 3: dwBaseAddress = 0x0168; break;
     
226.        }
     & }9 r* a/ y+ X6 @) a6 W. T
227. 
     
228.        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
     % n7 a% ?5 U+ a- L
229. 
     " _9 D& p* e" y/ ?
230.        // 进入Ring0
     
231.        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
     $ }( G( N! i* b/ G7 F' x" q
232.                bIsIDEExist, IsDiskExist, wOutData);
     ) h$ H% W, H& }( Q& X, C9 T+ i
233.    }
     ! p1 Y3 C) _7 c. G7 Y  ^
234. 
     0 ^. t: L2 H7 e! G
235.    // 开始读取
     
236.    for(int nDrive = 0; nDrive < 8; nDrive++)
     9 `) |. k( ~* U$ Z7 A/ x* ~: f2 Y
237.    {
     
238.        WORD dwBaseAddress;
     + C, l& h8 E: c5 N5 @
239.        BYTE btMasterSlave;         // Master Or Slave
     # n) ?( v4 T, p) T
240.        bool bIsIDEExist;
     ) ^& N( Y# H2 [
241.        bool bIsDiskExist;
     
242.        switch(nDrive / 2)
     
243.        {
     
244.            case 0: dwBaseAddress = 0x01F0; break;
     : G0 h7 n: {: D5 [7 C2 n% b( h
245.            case 1: dwBaseAddress = 0x0170; break;
     
246.            case 2: dwBaseAddress = 0x01E8; break;
     
247.            case 3: dwBaseAddress = 0x0168; break;
     5 q1 D" W+ @1 h8 X# r8 i* g  @& y1 w
248.        }
     
249. 
     
250.        btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
     
251. 
     ; [3 s+ Y4 L( }. F& F- k
252.        // 进入Ring0
     
253.        bIsIDEExist  = false;
     
254.        bIsDiskExist = false;
     
255.        ZeroMemory(wOutData, sizeof(wOutData));
     , _/ `$ l9 T2 {+ K7 I
256. 
     
257.        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
     6 o- \; _" q4 H6 V7 q
258.                bIsIDEExist, bIsDiskExist, wOutData);
     
259. 
     
260.        if(bIsIDEExist && bIsDiskExist)
     - B. l7 a- [4 ^+ ]4 M
261.        {
     
262.            DWORD dwDiskData[256];
       }/ w4 E+ P: p$ Z+ s, T; d% i
263.            char  szSerialNumber[21];
     
264.            char  szModelNumber[41];
     
265. 
     : [* Z- y* {9 f" e$ b6 H
266.            for(int k=0; k < 256; k++)
     3 J% d$ N7 D. ~. J
267.                dwDiskData[k] = wOutData[k];
     
268. 
     
269.            // 取系列号
     7 B/ @/ K- M5 Z* K: S! i
270.            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
     
271.            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
     , b2 Z! x. |0 M8 p) [, X4 ]
272. 
     ' ~% b* `4 S3 O4 w+ B3 \
273.            // 取模型号
     
274.            ZeroMemory(szModelNumber, sizeof(szModelNumber));
     9 J# f+ \- K/ S# s2 l
275.            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
     ; e; E/ x: t/ _
276. 
     , X4 w% G" W! ^; J% H4 V
277.            pSerList->Add(szSerialNumber);
     
278.            pModeList->Add(szModelNumber);
     
279.        }
     
280.    }
     # ^, q$ |- {5 r$ R; }# P
281.    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
     
282. }
     9 t% _; Z+ M, r6 }+ Z: ^
283. //---------------------------------------------------------------------------
     ; F5 r3 @) o9 j) U/ e
284. // ReadPhysicalDriveOnW9X_Ring0()
     
285. //
     
286. // dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
     2 N7 B0 I, b* C. K- j/ ^/ I; b! L
287. // btMasterSlave = Master(0xA0) Or Slave(0xB0)
     - k2 m0 ^+ C$ A
288. //---------------------------------------------------------------------------
     7 J7 K: `% d7 y: M' X% X
289. void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
     * m. l. y$ c, |" K/ R
290.        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
     4 @& V3 P  x  v" S# J8 ]6 h
291. {
     * _7 P% H( }- `; y7 d0 G& _
292.    BYTE  btIDTR1[6];
     " J( K/ E( t$ Z8 q
293.    DWORD dwOldExceptionHook;
     
294.    const int nHookExceptionNo = 5;
     ! w% [7 l; ~7 f) S$ M8 k5 e2 D
295. 
     
296.    BYTE  btIsIDEExist = 0;
     4 u, h6 ^/ F2 S2 x* C
297.    BYTE  btIsDiskExist = 0;
     
298.    WORD  wOutDataBuf[256];
     
299. 
     
300.    BYTE  btIsFirst = (BYTE)bIsFirst;
     
301. 
     
302.    const BYTE btBit00 = 0x01;
     ' n5 b; Q+ S, ]- w- e
303.    // const BYTE btBit02 = 0x04;
     ( ]: J7 @2 L6 E2 y. Z
304.    const BYTE btBit06 = 0x40;
     " W1 \) w4 N- ~3 [% o( a+ C$ h
305.    const BYTE btBit07 = 0x80;
     
306.    // const BYTE btERR  = btBit00;
     5 h  o& }: |" A- R- Q3 h: `+ o
307.    const BYTE btBusy = btBit07;
     % |1 n5 J# S1 @# D
308.    const BYTE btAtaCmd   = 0xEC;
     + z* `# e4 I! ~! d8 r
309.    const BYTE btAtapiCmd = 0xA1;
     + J  f/ J, n' o' r; N* E" ?/ W
310. 
     
311.    __asm
     , H( n. l; q! Z0 e/ u* M1 I
312.    {
     0 v1 a- t) ]9 ~: u- f3 H1 W' t, L1 ~$ v
313.        // 必须先执行这条语句
     6 \0 x8 |) M! p0 R
314.        JMP EnterRing0
     
315. 
     1 X/ C9 C( F  P3 @
316.        // 定义过程
     ! J, J- J: r! V% F* r; C9 @$ H
317.        // 等待IDE设备直到其不为忙为止
     4 }7 A! @' ?8 c
318.        WaitWhileBusy proc
     8 t- [. z; q. j; T3 X
319. 
     & G# v* W/ l) E1 R& v2 {" J  ?
320.        MOV  EBX, 100000
     5 x( G+ s5 c8 j& D  g$ }4 K$ e- o& h1 E
321.        MOV  DX, dwBaseAddress
     
322.        ADD  DX, 7
     " E; c8 f% h- l" ^5 n0 c- @
323. 
     - _/ k# b. W# F
324.        LoopWhileBusy:
     
325. 
     
326.        DEC  EBX
     6 K5 c$ l( K3 O9 _$ c( N& _. Y) Y* N
327.        CMP  EBX, 0
     
328.        JZ   Timeout
     ) m5 X. J& F; A. `9 H3 z' J2 N3 O- S
329.        in   AL, DX
     5 p$ |+ e6 v$ F/ m/ G1 N
330.        TEST AL, btBusy
     ' S' c# U( U( G- z% W0 i
331.        JNZ  LoopWhileBusy
     . g2 S7 ^) C' u  z1 ?4 K
332.        JMP  DriveReady
     
333. 
     + h; p3 j4 w% l5 n' X$ P- r+ I5 U$ z* t
334.        // 超时，直接退出
     ) ~2 Q$ R4 K2 n7 U& B, |( g
335.        Timeout:
     4 }0 F7 {. u1 G6 d: y/ z
336.        JMP  LeaveRing0
     + c* M/ k9 c! j
337.        DriveReady:
     
338.        RET
     
339.        ENDP   // End of WaitWhileBusy Procedure
     
340. 
     0 n1 T( l* _% u8 L' d
341.        // 设置主盘和从盘标志
     + Q9 M; S# ]. c. V; j
342.        SelectDevice proc
     + S8 r" H: z0 T* Y
343. 
     
344.        MOV  DX, dwBaseAddress
     - J- ?1 ~* W: w; t
345.        ADD  DX, 6
     
346.        MOV  AL, btMasterSlave
     , ^, ]+ r$ I( U/ s$ v
347. 
     
348.        out  DX, AL
     
349.        RET
     0 T- A/ V9 G0 E8 t+ S5 Z
350. 
     
351.        ENDP  // End of SelectDevice Procedure
     
352. 
     
353.        // 向IDE设备发送存取指令
     
354.        SendCmd proc
     - m/ u1 X! z' ?' U/ q1 w
355. 
     
356.        MOV DX, dwBaseAddress
     : h. V3 Y# B0 m0 r' J' [
357.        ADD DX, 7
     
358.        MOV AL, BL // BL是主从盘标识，在过程外设置
     
359.        out DX, AL
     
360.        RET
     
361.        ENDP  // End of SendCmd Procedure
     " X! M; n4 f; f& D% o) H9 b9 p
362. 
     / V2 Q, y" O, J- H; D. _( x
363.        // Ring0代码
     
364.        Ring0Proc:
     6 y; [" w! ^' S$ ]
365.        PUSHAD
     
366.        // 查询IDE设备是否存在
     " E/ f2 ?/ j/ f1 m# Z' m# o# \
367.        MOV DX, dwBaseAddress
     0 Y. I+ J  W4 v
368.        ADD DX, 7
     # `" w' @. a6 G: S1 x
369.        in  AL,DX
     
370. 
     ( V/ d' y6 u* S$ g+ [
371.        // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
     
372.        CMP AL,0xFF
     
373.        JZ  LeaveRing0
     
374.        CMP AL, 0x7F
     1 S* ]4 I; }6 c/ u5 o+ _) Q: l0 X
375.        JZ  LeaveRing0
     
376. 
     : e9 j1 I( L6 u- X6 `3 U. e  S
377.        // 设置IDE设备存在标志
     
378.        MOV btIsIDEExist, 1
     
379. 
     6 y) S, Z, I' r# T# g+ P
380.        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
     + a' u. K+ k$ S
381.        CALL WaitWhileBusy
     # i, G. |( l4 I$ j6 O
382.        CALL SelectDevice
     7 w; s# A) }# k! K2 ?& l6 X  O$ |
383. 
     
384.        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
     1 u4 t7 O- c" D+ M
385.        CMP  btIsFirst, 1
     
386.        JZ   LeaveRing0
     
387. 
     
388.        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
     , o- [3 g4 g/ ~5 |  P  r
389.        CALL WaitWhileBusy
     
390. 
     * \* r$ Q. O& O, D' v) _
391.        // AL的值等于cBit06时，不存在驱动器，直接返回
     
392.        TEST AL, btBit06
     7 p" k0 N: g" b/ U8 {6 [  P
393.        JZ   LeaveRing0
     
394. 
     6 |4 \3 B  W" g+ P5 m! d) N3 _3 o  q
395.        // 设置驱动器存在标志
     
396.        MOV  btIsDiskExist, 1
     
397. 
     + B5 p0 w" g9 {/ K* ?3 x. i
398.        // 发送存取端口命令
     
399.        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
     
400.        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
       ?/ l; k" i9 A# x7 H: u
401.        CALL WaitWhileBusy
     0 T: B  w3 |. Y3 G- G' j
402.        CALL SelectDevice    // 设置主从盘标识
     . }6 `7 @& u  }4 ^
403.        MOV  BL, btAtaCmd      // 发送读取命令
     
404.        CALL SendCmd
     ! L5 H: p8 q# h8 ^
405.        CALL WaitWhileBusy
     
406. 
     
407.        // 检查是否出错
     2 j  p/ Q7 V$ u
408.        MOV  DX, dwBaseAddress
     
409.        ADD  DX, 7
     
410. 
     ' ~2 Q; g& |" M9 b& E& j2 z
411.        in   AL, DX
     9 ^7 L. D4 g. w% c4 X
412. 
     
413.        TEST AL, btBit00
     
414.        JZ   RetrieveInfo   // 没有错误时则读数据
     
415. 
     
416.        // 如果出错，则进一步尝试使用ATAPI设备命令
     ) L. \' Z: m/ g
417.        CALL WaitWhileBusy
     % _/ J0 J$ B- h1 s
418.        CALL SelectDevice
     4 v% V6 ]3 h8 C# L
419.        MOV  BL, btAtapiCmd
     
420.        CALL SendCmd
     
421.        CALL WaitWhileBusy
     . K6 m4 k1 d# w: m3 t0 J
422. 
     $ }7 B4 M/ _, u' I& I
423.        // 检查是否还出错
     
424.        MOV  DX, dwBaseAddress
     6 b' F$ z+ j8 c- k9 m7 Z) f4 ^
425.        ADD  DX, 7
     ! b- V! X2 m6 |7 r
426.        in   AL, DX
     " Z# J/ G$ q4 W4 n
427.        TEST AL, btBit00
     1 P: c% u& g7 X/ i% m% Q1 z3 }
428.        JZ   RetrieveInfo   // 没有错误时则读数据
     5 e% P4 j: u/ ^
429.        JMP  LeaveRing0     // 如果还是出错，直接返回
     
430. 
     
431.        // 读取数据
     % T6 P8 ~0 I0 g& [7 l1 a6 t
432.        RetrieveInfo:
     9 ^3 @7 Y' F9 f% v5 W* D; D( V
433. 
     
434.        LEA  EDI, wOutDataBuf
     4 m$ j2 \1 f1 X& N
435.        MOV  ECX, 256
     : H9 u$ L% j; J' j# K% Y: f+ G
436.        MOV  DX, dwBaseAddress
     0 {& b: V" h- M3 L
437.        CLD
     / j+ B' }2 R& B: l, L
438. 
     
439.        REP  INSW
     - p9 ]- o8 e# o8 U! A! o
440. 
     7 j8 G0 `) w! R
441.        // 退出Ring0代码
     6 ]  |0 L6 q0 M. F& m  s/ `# C( w
442.        LeaveRing0:
     
443. 
     
444.        POPAD
     
445.        IRETD
     
446. 
     
447.        // 激活Ring0代码
     
448.        EnterRing0:
     
449. 
     ) L8 E" Z( U+ u5 t
450.        // 修改中断门
     6 z2 D# {2 P% b# b2 W9 ^. W/ T; z8 l
451.        SIDT FWORD PTR btIDTR1
     5 B4 r8 {$ d! L
452.        MOV EAX, DWORD PTR btIDTR1 + 02h
     
453.        ADD EAX, nHookExceptionNo * 08h + 04h
     
454.        CLI
     
455. 
     : S8 g7 I1 m4 w! e0 {9 Y% S' b
456.        // 保存原异常处理例程入口
     6 j. d/ N3 g1 h( ^  g
457.        MOV ECX, DWORD PTR [EAX]
     ) U# \8 E8 A; Z- Y, P& U  G; u
458.        MOV CX, WORD PTR [EAX-04h]
     
459.        MOV dwOldExceptionHook, ECX
     
460. 
     
461.        // 指定新入口
     1 E1 {$ s; y* h2 a% f, X" ^. f
462.        LEA EBX, Ring0Proc
     % n, _( q- c# f9 @, z9 X) u+ H3 m
463.        MOV WORD PTR [EAX-04h],BX
     
464.        SHR EBX, 10h
     % K5 V% E& Y5 X( w$ a
465.        MOV WORD PTR[EAX+02h], BX
     
466. 
     
467.        // 激活Ring0代码
     % x$ f6 f1 P' _) \% F. b+ J  H
468.        INT nHookExceptionNo
     ; Y9 |% p6 c8 f; k$ |( \
469. 
     ) C, B  [( M) T5 B9 `# e
470.        // 复原入口
     ! C3 W1 b( A& ~( _
471.        MOV ECX,dwOldExceptionHook
     
472.        MOV WORD PTR[EAX-04h], CX
     
473.        SHR ECX,10h
     # F" h- i' h. A1 H
474.        MOV WORD PTR[EAX+02h], CX
     
475.        STI
     0 q* {* n! r% F
476.    }
     6 f  B. ?2 `. d# `
477.    if(!bIsFirst)
       D3 p/ k7 {  e- z& D' f; V3 W
478.    {
     
479.        bIsIDEExist  = (bool)btIsIDEExist;
     
480.        bIsDiskExist = (bool)btIsDiskExist;
     
481.        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
     ( A# U2 \$ Y8 l
482.    }
     6 K# D. w0 m9 R( D: e
483. }
     ( A( r2 x( o. y" U( R
484. //---------------------------------------------------------------------------
     . ^) N7 h5 Y4 A
485. // 调用方法：
     
486. void __fastcall TForm1::Button1Click(TObject *Sender)
     6 X. d% P2 ^# _- M! x6 r: r
487. {
     / _$ I) j! A9 C7 }! k
488.    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
     ; S6 n* |  x% Y
489. }

复制代码

梦幻雨

晕乎乎。。。怎么看８　洞阿