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

天云上人

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

复制代码

梦幻雨

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