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

天云上人

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

复制代码

梦幻雨

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