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

天云上人

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

复制代码

梦幻雨

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