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

天云上人

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

复制代码

梦幻雨

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