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

天云上人

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

复制代码

梦幻雨

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