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

天云上人

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

复制代码

梦幻雨

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