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

天云上人

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

复制代码

梦幻雨

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