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

天云上人

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

复制代码

梦幻雨

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