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

天云上人

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

复制代码

梦幻雨

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