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

天云上人

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

复制代码

梦幻雨

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