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

天云上人

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

复制代码

梦幻雨

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