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

天云上人

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

复制代码

梦幻雨

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