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

天云上人

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

复制代码

梦幻雨

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