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

天云上人

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

复制代码

梦幻雨

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