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

天云上人

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

复制代码

梦幻雨

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