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

天云上人

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

复制代码

梦幻雨

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