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

天云上人

  #include <WinIOCtl.h>
#include <stdio.h>

#pragma inline
$ e$ L  `: B5 O, t//---------------------------------------------------------------------------
// IDE NT/2000/XP专用变量
; X. j9 J! u: n% `! m7 X! U+ T#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
9 E3 K4 L7 h" G. }8 e. n3 G. K$ Y#define DFP_GET_VERSION         SMART_GET_VERSION
# Y2 E. k$ A$ D+ Q+ |3 l7 u#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA

const WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
0 y2 B2 `! e% A/ h2 v9 A! k; rconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令

0 `/ `! L/ A% J4 G1 v/ X; A. [% |const int MAX_IDE_DRIVES = 4;

// SCSI专用变量
const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
( c8 z2 d; v' w! J! m/ U# b0 mconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
const DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;
7 J$ f, E( I! p7 H8 }9 [! `8 p* j
' @! u$ U8 ~5 P6 ^5 E" D2 c  G3 gtypedef struct _SRB_IO_CONTROL
{
4 s! L# _" Q2 a; U    ULONG HeaderLength;
+ y  T  I! b5 s! ]1 F    UCHAR Signature[8];
. k0 M- g2 {  G7 D3 o# l    ULONG Timeout;
$ B9 t  I8 V: a2 O# v. p1 ]: `% W    ULONG ControlCode;
3 h. i" v% S' _4 ~, }    ULONG ReturnCode;
   ULONG Length;
+ V8 D. N1 l- j, o}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
. Y- m3 A& H1 L+ D$ H5 m- }" f
# j8 ?& q  E" \2 f9 C( t// 读取的主函数
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);

  G% t+ ?& u  A$ u; ]// 辅助函数
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
- {9 e# Y. @; ?  D; ~9 M# g9 L4 T# V// NT/2000/XP函数
1 y: {2 U" R) k3 U" l( cvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
+ e+ N& I/ f2 ?  ]bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
8 f# h! w1 X3 r, G5 M        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
/ v0 G  Z5 G/ B+ X! t8 S  M        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
9 f7 _, q+ K( c* d- E# d// Windows 9X函数
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
- C9 O3 {5 V" p/ }- G2 G6 R/ {void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
       BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

4 D* [# B$ }7 W' n+ @// SCSI读取函数(for NT/2000/XP)
String __fastcall ReadIDEDriveAsScsiDriveOnNT();
, ?: F% p' Z' P8 N5 |//---------------------------------------------------------------------------
4 t# L* ^* z8 E1 G' D  c// ReadPhysicalDrive
: t, c" t# |* c+ vvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
4 ~# ]2 S' [/ o% r$ s. H+ b{
   switch(Win32Platform)
   {
  C+ O" m6 F5 G( l- f        case VER_PLATFORM_WIN32_WINDOWS:
7 ]. y' I8 j7 {4 j. z            ReadPhysicalDriveOnW9X(pSerList, pModeList);
1 D% B+ j3 ~( F' C            break;
0 x- w" X) j: K        case VER_PLATFORM_WIN32_NT:
           ReadPhysicalDriveOnNT(pSerList, pModeList);
           break;
" `( I- S0 J, w7 ^; k        default:
* `8 A, \+ k* d* n/ O            break;
   }
}
8 H5 W7 p. l4 ~; E. \//---------------------------------------------------------------------------
7 A% a2 E/ ]( I& H0 M0 A// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
   static char szResBuf[1024];
+ A% r4 ]# H7 Y3 h6 i" P: @    int nIndex = 0;
( c% m- k' N3 I/ U0 {6 e    int nPosition = 0;

   // Each integer has two characters stored in it backwards
) a* c) S6 t/ p/ g( n/ h1 \: G    for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
9 Y! w. e/ D6 l0 ?* `9 x    {
# b7 D+ N2 K1 Y; L3 y+ \        // Get high BYTE for 1st character
* d$ d% X# S& F( z$ b. b        szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
       nPosition++;
) k2 p! s$ k, R: n) a* p
  Y7 S5 p# K4 j( x        // Get low BYTE for 2nd character
       szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
       nPosition++;
   }

   // End the string
   szResBuf[nPosition] = '\0';

   // Cut off the trailing blanks
' Z' K# H1 S! I2 q    for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
       szResBuf[nIndex] = '\0';

   return szResBuf;
( j4 {: J$ @6 ^4 C}
# {8 m! z+ {; S  `9 ~//---------------------------------------------------------------------------
// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
, H$ S- y, p8 h) ?/ Q# S5 ?void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
" Q( h9 ]; i8 f% U% `  y7 a{
   // 输出参数
   BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];

   for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
   {
       HANDLE hPhysicalDriveIOCTL;
       char szDriveName[32];
1 b( a/ R0 L4 V. S: b
7 M3 r+ X9 m% a# q9 V3 h/ v        sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
       hPhysicalDriveIOCTL = CreateFile(szDriveName,
                       GENERIC_READ | GENERIC_WRITE,
2 D7 L4 t/ p7 I) E4 d                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
: y6 w, l8 ~+ B6 V/ o                        OPEN_EXISTING, 0, NULL);
. C! P4 v; G* A! U; @0 @
       if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
* `( Y7 P9 l8 v1 |        {
! m: i8 c7 ^$ t: ]            DWORD dwBytesReturned = 0;
! q7 k9 q5 `. X            GETVERSIONOUTPARAMS gvopVersionParams;

& u4 ?$ M; e( g. m# X+ z            // Get the version, etc of PhysicalDrive IOCTL
           ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));
5 t- z- P% ^# a4 c9 @5 g  ]6 S
9 y- @  I9 G8 P            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
                   NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                   &dwBytesReturned, NULL))
           {
               continue;
           }

           if(gvopVersionParams.bIDEDeviceMap > 0)
) e* r/ ?, A8 `" w, v3 M* ~- L            {
6 ^0 ^8 v  m/ i                // IDE or ATAPI IDENTIFY cmd
               BYTE btIDCmd = 0;
( F  _8 F6 N" H% i                SENDCMDINPARAMS InParams;
               // Now, get the ID sector for all IDE devices in the system.
. ]& Z% u+ c7 X7 v. P                // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
               // otherwise use the IDE_ATA_IDENTIFY command
" m$ q4 V; e# `( K# c. k                // 具体所得结果请参考头文件中的说明
+ R3 s& _/ V0 y$ b: c                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                       IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
6 g3 S+ i/ P' D) V# m( [                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
               ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));
0 c$ n* j' w* F+ {
               if(DoIdentify(hPhysicalDriveIOCTL,
- a7 W' p+ b4 m! C                     &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                    (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
               {
6 p6 F3 i5 `% o1 v" Q7 s: d0 |                    DWORD dwDiskData[256];
                   USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                   char szSerialNumber[21];
                   char szModelNumber[41];

                   pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                   for(int i=0; i < 256; i++)
                       dwDiskData = pIDSector;
                   // 取系列号
1 Q6 ^: Z: x) o                    ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
                   strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
  j& o' O# G  {, J
                   // 取模型号
8 v& v% l6 j. A$ I% F1 W) k                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                   strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));
. N8 I4 p! f- M! V- h
8 `7 J, f1 l0 C( `, y8 _5 K                    pSerList->Add(szSerialNumber);
                   pModeList->Add(szModelNumber);
               }
           }
3 r0 z: c3 e9 r8 j            CloseHandle (hPhysicalDriveIOCTL);
( L& r/ M! @" ~        }
   }
}
. J% C( n& b/ i9 [! j6 l//---------------------------------------------------------------------------
& Q5 I4 z! Z9 y( D/ q+ z  Z2 {0 ^// DoIdentify
8 q: J7 N' L6 h- ?$ Hbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
             PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
7 ?: J2 Y" R- H. V1 i: r  l              PDWORD pdwBytesReturned)
{
   // Set up data structures for IDENTIFY command.
   pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
   pSCIP->irDriveRegs.bFeaturesReg = 0;
( a! U& O; ~, C! Q+ ?    pSCIP->irDriveRegs.bSectorCountReg  = 1;
! M3 x. ~6 @6 q1 t5 P8 J" ~5 l- k2 j0 ~    pSCIP->irDriveRegs.bSectorNumberReg = 1;
   pSCIP->irDriveRegs.bCylLowReg  = 0;
* I* Z6 ?: \% h  J, Y4 s    pSCIP->irDriveRegs.bCylHighReg = 0;
( G& h0 q6 ]; `
   // Compute the drive number.（主盘和从盘所对应的值是不一样的）
   pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;

* O* O: M% T' U+ g    // The command can either be IDE identify or ATAPI identify.
3 P2 h6 g; t4 ^! k$ g1 B- C    pSCIP->irDriveRegs.bCommandReg = btIDCmd;
   pSCIP->bDriveNumber = btDriveNum;
   pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
8 \) i: h8 R! d0 n
   return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
! V2 X+ S/ O  v( S7 e           (LPVOID)pSCIP,
          sizeof(SENDCMDINPARAMS) - 1,
& D8 P9 r+ U! R/ K' J           (LPVOID)pSCOP,
          sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
& I0 q( w/ h6 R           pdwBytesReturned, NULL);
& |, P3 Q2 t* W- M& j- M}
//---------------------------------------------------------------------------
// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
* |% v% h8 x" r: p8 K// ReadPhysicalDriveOnW9X
void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
{
; l+ @( Y! W5 {: _8 ?" B    WORD wOutData[256];
   SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

   // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
   // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
   // 避免蓝屏的出现。（期待高人能指出原因）
   for(int nDrive = 0; nDrive < 8; nDrive++)
- Z8 O! S4 O, Z9 `    {
       WORD dwBaseAddress;
       BYTE btMasterSlave;         // Master Or Slave
1 z9 @4 S: C0 b6 x        bool bIsIDEExist;
       bool IsDiskExist;

1 E8 l( B: H( _( V1 [/ s# W0 e        switch(nDrive / 2)
& a6 x. m0 x: Y& t  C1 F. Z1 }4 N        {
9 L$ W; Y) \, [' ^+ ^5 B. L            case 0: dwBaseAddress = 0x01F0; break;
           case 1: dwBaseAddress = 0x0170; break;
8 X; w4 ?5 @* J1 n9 R3 B! ?, n' E+ `            case 2: dwBaseAddress = 0x01E8; break;
; Z, o  c" u# G; N3 G            case 3: dwBaseAddress = 0x0168; break;
( G" ?* d5 Y7 h* g" ]3 p# n        }
& |1 i, v" ?$ \( S
       btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);
2 u9 w* _9 W5 `) X5 R  H2 `' |: d
       // 进入Ring0
  J) J3 f0 u5 c/ C        ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
               bIsIDEExist, IsDiskExist, wOutData);
/ S7 r7 H% ^0 k9 ~    }

   // 开始读取
   for(int nDrive = 0; nDrive < 8; nDrive++)
1 {# |5 U( K7 ?& ~' y  }    {
       WORD dwBaseAddress;
       BYTE btMasterSlave;         // Master Or Slave
       bool bIsIDEExist;
       bool bIsDiskExist;
2 c4 F. [; C5 p/ D1 K        switch(nDrive / 2)
! C# h5 N5 T, l        {
           case 0: dwBaseAddress = 0x01F0; break;
1 z& ]3 S. J, i* \, k9 V            case 1: dwBaseAddress = 0x0170; break;
! M+ c2 j" W4 F" a! _            case 2: dwBaseAddress = 0x01E8; break;
           case 3: dwBaseAddress = 0x0168; break;
       }
+ L5 w, f2 b7 m5 P. E" T/ }7 R
       btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

% r8 N7 c8 |  i  j1 }        // 进入Ring0
9 [6 L. D9 A/ \: ]$ D& Q! ?) S* H        bIsIDEExist  = false;
+ @$ u4 O1 m' F" _4 F/ Z        bIsDiskExist = false;
       ZeroMemory(wOutData, sizeof(wOutData));
! R" W  ?, f# n# m, h
/ P  h" N$ c- N2 G# e, ]        ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
% y+ n1 j; c9 z- g3 S  c7 Y6 s  C, g# U                bIsIDEExist, bIsDiskExist, wOutData);
, j) C5 V3 f9 ?% x! e' I- ]
       if(bIsIDEExist && bIsDiskExist)
       {
           DWORD dwDiskData[256];
6 d* s6 {* J. w) u9 A            char  szSerialNumber[21];
           char  szModelNumber[41];
% ]8 O& t/ {( ^' F+ Z
           for(int k=0; k < 256; k++)
               dwDiskData[k] = wOutData[k];
+ Z: D0 b. i5 N2 _
           // 取系列号
0 N" P5 i3 T# f$ r* R            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
" j: m9 u" W0 h7 X& b2 W# Q+ i            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
8 B  e7 Q' v' M9 @: I( M7 z
! s5 o6 |# l5 C% w            // 取模型号
           ZeroMemory(szModelNumber, sizeof(szModelNumber));
           strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

           pSerList->Add(szSerialNumber);
           pModeList->Add(szModelNumber);
       }
   }
( m! b6 t/ g. d5 o    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
& o+ q5 X) }+ M6 p. Q5 B$ W}
  m! `, K5 n7 V: y1 d, {. n1 l//---------------------------------------------------------------------------
8 l1 S1 C% K- |7 C4 |+ i// ReadPhysicalDriveOnW9X_Ring0()
, U/ Q6 r1 S' |" [$ K9 ]) a//
5 m" y( a! {: c4 t7 |: o// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
* r1 _: \# x; h& l// btMasterSlave = Master(0xA0) Or Slave(0xB0)
* t- s) m0 A( S6 k! h1 H: Y//---------------------------------------------------------------------------
6 ^% w: M  R8 v, C+ y5 }6 mvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
       BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
( m4 C& H: G' j& y% W! F  y: f{
   BYTE  btIDTR1[6];
   DWORD dwOldExceptionHook;
   const int nHookExceptionNo = 5;

: U- R/ g5 X2 h+ u9 t    BYTE  btIsIDEExist = 0;
   BYTE  btIsDiskExist = 0;
   WORD  wOutDataBuf[256];
; T  T6 x) m9 n9 t2 U. C4 ^
0 G5 l! e3 F" d3 R- \# b    BYTE  btIsFirst = (BYTE)bIsFirst;
/ A* `! N5 K' V! n9 e
. y0 _) k( z; R; O$ C; g0 X    const BYTE btBit00 = 0x01;
& s. x; c; N9 }5 ?    // const BYTE btBit02 = 0x04;
# y9 D# O# @5 f1 v9 Z* x    const BYTE btBit06 = 0x40;
/ |* Y; X/ `% [9 ~    const BYTE btBit07 = 0x80;
   // const BYTE btERR  = btBit00;
8 f* e1 g% f0 H+ r0 ~9 }    const BYTE btBusy = btBit07;
   const BYTE btAtaCmd   = 0xEC;
   const BYTE btAtapiCmd = 0xA1;
0 z& O; O. w/ _# U1 L! ^
# Y$ l6 [' [8 b4 Y! x2 F: e    __asm
   {
       // 必须先执行这条语句
' H1 N0 H( L- V# S$ ?  l        JMP EnterRing0

; z, q$ {9 E$ O- T! {1 e, R1 {6 a        // 定义过程
5 ~* U' k% H+ Q" S3 T* n5 t+ |        // 等待IDE设备直到其不为忙为止
       WaitWhileBusy proc
- [% U2 Z  `. O" ]- j
& {, C* e% [, ~) ~) I        MOV  EBX, 100000
       MOV  DX, dwBaseAddress
       ADD  DX, 7

: |* J. ^, G0 ~! V; \' A        LoopWhileBusy:
" u1 b5 m" D0 l+ c3 n
       DEC  EBX
6 @2 h" V5 X% i: Q; s. U! b; i        CMP  EBX, 0
       JZ   Timeout
' C4 B% f3 [, R7 H3 @" c        in   AL, DX
       TEST AL, btBusy
2 J" C% V4 B6 B        JNZ  LoopWhileBusy
+ j- |! |5 v$ F6 h6 L        JMP  DriveReady
/ v2 A% r2 L+ w" K, j* D8 A/ N
! M- |9 U/ t1 N) s        // 超时，直接退出
       Timeout:
       JMP  LeaveRing0
& a! D6 l& V7 w; B        DriveReady:
2 k, O9 l7 K* C6 j/ c        RET
       ENDP   // End of WaitWhileBusy Procedure
; \6 Z- a- N9 C- `
       // 设置主盘和从盘标志
       SelectDevice proc

       MOV  DX, dwBaseAddress
; x2 G+ q* ^: L( C: Q. w  s9 Q, v        ADD  DX, 6
       MOV  AL, btMasterSlave

       out  DX, AL
       RET

       ENDP  // End of SelectDevice Procedure

3 t! I, {: |5 e/ |2 R0 L  r2 f7 e        // 向IDE设备发送存取指令
3 ~) R, B! p+ O; o# y        SendCmd proc

' P1 n- n' A- h- X" \) L; }5 n        MOV DX, dwBaseAddress
$ M, W0 a  b& I" d' x3 S        ADD DX, 7
, O" o8 b7 j- M4 B/ n0 D        MOV AL, BL // BL是主从盘标识，在过程外设置
$ O8 u+ d9 q% E; ^6 K$ g) |        out DX, AL
- L3 X: b1 {1 T9 `) O6 N" Q        RET
       ENDP  // End of SendCmd Procedure

1 G6 g9 K1 v; V/ r, ]        // Ring0代码
. s$ ^. C9 G# N: M9 m: X! l8 W        Ring0Proc:
  N4 k  c) c3 ]  g" M) l        PUSHAD
" I1 I- W$ P. v& M( Z( r5 X! L        // 查询IDE设备是否存在
: y9 c  ?- z2 s6 g        MOV DX, dwBaseAddress
       ADD DX, 7
       in  AL,DX
; B: [; j  `4 {; i+ e1 F
       // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
; l' b& D; Q0 u- G        CMP AL,0xFF
       JZ  LeaveRing0
; D$ H2 I7 M1 W& k; j        CMP AL, 0x7F
       JZ  LeaveRing0
( F( G  {+ H2 j  p$ C4 T$ u
       // 设置IDE设备存在标志
+ H/ _2 {1 |3 o        MOV btIsIDEExist, 1

       // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
, I3 {# k, Z5 {; y        CALL WaitWhileBusy
       CALL SelectDevice
' f/ s$ x4 d4 z3 T. O2 }
       // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
       CMP  btIsFirst, 1
6 _9 e9 w2 r& |0 _        JZ   LeaveRing0
* d; p1 }  ]3 B; r% o! M6 X
2 A3 V. y3 w( J3 Y: ~        // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
- Z6 Q! S' |, \+ e( v        CALL WaitWhileBusy
) u5 X, I) Q  A
, O- _- {0 F% Y6 l5 T        // AL的值等于cBit06时，不存在驱动器，直接返回
6 A! e4 W4 ]9 Y+ {) U        TEST AL, btBit06
# m% U, Y; U1 j/ x6 T( q$ }4 B1 Q        JZ   LeaveRing0
. [+ a/ n% r4 l4 o
       // 设置驱动器存在标志
( E! o7 G: a# b# Y% E$ }& e        MOV  btIsDiskExist, 1

0 b1 R) n0 w+ t7 I9 D1 [) h, }1 F        // 发送存取端口命令
) F: L7 ^( ]) u- Z7 ]2 ?5 x& M        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
* @+ j9 P( }5 v' v        // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
       CALL WaitWhileBusy
       CALL SelectDevice    // 设置主从盘标识
       MOV  BL, btAtaCmd      // 发送读取命令
       CALL SendCmd
) |& u$ a; T. a& W: {' e        CALL WaitWhileBusy

$ w# a% m2 O0 c/ t( M        // 检查是否出错
       MOV  DX, dwBaseAddress
# M& ^8 ~: d: ^7 k# F        ADD  DX, 7
1 |3 t( E$ d) I
, B5 V% O: C0 G" V6 m0 {        in   AL, DX

       TEST AL, btBit00
       JZ   RetrieveInfo   // 没有错误时则读数据

' n# i. |' T, F1 C* S  F' A. f        // 如果出错，则进一步尝试使用ATAPI设备命令
- A% A" I/ a. |* I3 A        CALL WaitWhileBusy
) ^. y" ^( K0 j0 G0 G' o2 d# A        CALL SelectDevice
7 F& X" E, n' o7 N9 o+ R# i7 r5 l% x        MOV  BL, btAtapiCmd
       CALL SendCmd
       CALL WaitWhileBusy

       // 检查是否还出错
       MOV  DX, dwBaseAddress
       ADD  DX, 7
       in   AL, DX
       TEST AL, btBit00
       JZ   RetrieveInfo   // 没有错误时则读数据
* F$ y" V/ m7 K8 R8 Q        JMP  LeaveRing0     // 如果还是出错，直接返回
' H! a3 A9 L9 J1 [' f0 p8 W
       // 读取数据
       RetrieveInfo:
1 J+ x! A+ I4 E; O. ]
       LEA  EDI, wOutDataBuf
/ s# |4 z! G3 }% A! n. Q2 z! Y' h        MOV  ECX, 256
       MOV  DX, dwBaseAddress
       CLD
" s  }! V! O3 {: C( n6 c  n
3 {4 T1 H0 y$ I& s, ^# \        REP  INSW

/ M5 |7 p* l- d0 B  R* x4 ~: ?# V        // 退出Ring0代码
       LeaveRing0:

6 K  _+ [5 [, M' b5 _8 D! i( ^        POPAD
       IRETD

  v$ Y% z+ y" E# B- |# ]( V/ [, N        // 激活Ring0代码
, C. H8 \% g" _        EnterRing0:
0 V4 \" Y" q9 j& O5 i
' w7 D8 f1 z2 I8 w        // 修改中断门
6 k) R! m) g1 F        SIDT FWORD PTR btIDTR1
( |6 b9 ?- d9 k/ ^; j) ?: P        MOV EAX, DWORD PTR btIDTR1 + 02h
       ADD EAX, nHookExceptionNo * 08h + 04h
: s3 K+ L) u; ]% }* L4 R! y: B. H        CLI
3 G1 l/ Q5 E7 m( L* K3 u
; q1 V3 _( e2 S1 [# Z, U        // 保存原异常处理例程入口
5 i  U! `% m9 p# }& `8 T+ z        MOV ECX, DWORD PTR [EAX]
3 ^; z2 s4 M3 l# K: Y/ j' n        MOV CX, WORD PTR [EAX-04h]
       MOV dwOldExceptionHook, ECX
1 W7 `1 v" N. L8 D+ B4 W# P/ q
" r  i# v, e0 A6 p+ e$ l$ w        // 指定新入口
: c: H! k$ ?. I        LEA EBX, Ring0Proc
       MOV WORD PTR [EAX-04h],BX
6 M2 U1 O. D& \0 s% e        SHR EBX, 10h
7 X" C8 D) x! a9 a        MOV WORD PTR[EAX+02h], BX

       // 激活Ring0代码
       INT nHookExceptionNo

3 a9 X& M" L1 o6 g2 L; l" t        // 复原入口
       MOV ECX,dwOldExceptionHook
6 z4 d$ Y, i# }3 e  C4 N        MOV WORD PTR[EAX-04h], CX
       SHR ECX,10h
. d! h0 e2 [# W, D% w" C        MOV WORD PTR[EAX+02h], CX
  Q* u; ]0 }7 m) O) M, I/ k# f        STI
   }
   if(!bIsFirst)
8 ?) ~% `- O0 h% |    {
+ Z5 c; d6 O( Z, }* k: H        bIsIDEExist  = (bool)btIsIDEExist;
1 Q: K7 {3 M0 d; w) Z" G! r* {. T        bIsDiskExist = (bool)btIsDiskExist;
: \# R7 Q( O$ B2 ~        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
& a0 M: s+ I  n! X, q" Z6 _, W    }
}
9 d1 H) E8 H* F; s* _9 q& G5 e//---------------------------------------------------------------------------
// 调用方法：
void __fastcall TForm1::Button1Click(TObject *Sender)
3 }# ~' V) r* p/ G{
2 E" ^: M; W. p* Q" _    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
6 y# z. J2 u9 o3 C  p+ x5 S}