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

天云上人

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

复制代码

梦幻雨

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