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

天云上人

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

复制代码

梦幻雨

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