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

天云上人

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

复制代码

梦幻雨

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