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

天云上人

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

复制代码

梦幻雨

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