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

天云上人

  #include <WinIOCtl.h>
#include <stdio.h>
2 d$ @* I, j; R" \" [8 z
: {3 y. \4 g. A! u3 I$ ~% `8 D#pragma inline
; G& z; [+ T3 A/ u. o& n+ h4 V//---------------------------------------------------------------------------
% S3 e3 W5 d8 X9 u// IDE NT/2000/XP专用变量
#define GETVERSIONOUTPARAMS     GETVERSIONINPARAMS
8 j4 Z' r$ ~4 U2 o' D: W#define DFP_GET_VERSION         SMART_GET_VERSION
2 X, X  w. ?2 f% l* s7 y#define DFP_SEND_DRIVE_COMMAND  SMART_SEND_DRIVE_COMMAND
7 l8 e+ c5 T* L2 w#define DFP_RCV_DRIVE_DATA      SMART_RCV_DRIVE_DATA
0 _6 B* H, g% A4 D, m- T) Y
- U) ~/ j1 Q( N; p2 ^0 N' Kconst WORD IDE_ATAPI_IDENTIFY = 0xA1;   // 读取ATAPI设备的命令
# u/ Y& G- l3 K% p3 h, A4 Sconst WORD IDE_ATA_IDENTIFY   = 0xEC;   // 读取ATA设备的命令
5 M/ V& o) E: H% q( f  l
4 [3 A, X( u6 Sconst int MAX_IDE_DRIVES = 4;
, q3 p8 M8 G, q% a% B
// SCSI专用变量
- Y! f* P5 W1 x5 G  y7 D4 `const DWORD FILE_DEVICE_SCSI             = 0x0000001B;
. K; n( ]+ D' Z" k7 N' m1 pconst DWORD IOCTL_SCSI_MINIPORT_IDENTIFY = ((FILE_DEVICE_SCSI << 16) + 0x0501);
# {3 \- @' Z" e5 L. ?' I4 Y  ?4 Fconst DWORD IOCTL_SCSI_MINIPORT          = 0x0004D008; // see NTDDSCSI.H for definition
const DWORD SENDIDLENGTH  = sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE;

typedef struct _SRB_IO_CONTROL
{
   ULONG HeaderLength;
' v7 Y0 N; H) A9 W9 X3 Z% A( I# }    UCHAR Signature[8];
   ULONG Timeout;
   ULONG ControlCode;
   ULONG ReturnCode;
  u0 {  g% n: ?4 f9 B6 M: t. h    ULONG Length;
}SRB_IO_CONTROL, *PSRB_IO_CONTROL;
! p. o  ?0 U( i3 b' \$ ]* `; _* ?: k1 P4 ~
& Q" Z: N+ B' i/ y8 k// 读取的主函数
; P) b2 T5 ~1 G) y/ Wvoid __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList);
  q9 {3 V" q3 d. L% p  I  m
. b0 B# }7 I3 v1 l. w/ z9 T// 辅助函数
' ^" Q/ F$ F% Mchar *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex);
// NT/2000/XP函数
9 V9 I5 {$ V: S2 k+ rvoid __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList);
9 X3 `7 B( V, f) I$ ^! x' x; fbool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
$ G5 F/ X7 W# K        PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd,
! o& |5 |  L( m9 i. v        BYTE btDriveNum, PDWORD lpcbBYTEsReturned);
; j) _, t; }# [0 A// Windows 9X函数
0 `2 p4 ]& k- c: }void __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList);
void __fastcall ReadPhysicalDriveOnW9X_Ring0(bool IsFirst, WORD BaseAddress,
4 J0 G5 M4 Z6 e; s7 S/ G5 v, I# K5 g9 S        BYTE MoS, bool &IsIDEExist, bool &IsDiskExist, WORD *OutData);

% f# B( E+ ~$ N! Q// SCSI读取函数(for NT/2000/XP)
6 K9 `9 P# ?% d; w) FString __fastcall ReadIDEDriveAsScsiDriveOnNT();
" t  X, t) k# \" P//---------------------------------------------------------------------------
// ReadPhysicalDrive
void __fastcall ReadPhysicalDrive(TStrings *pSerList, TStrings *pModeList)
  H; w! ^  E  ~" \% V6 {{
% y9 i& q7 S# C, `    switch(Win32Platform)
   {
       case VER_PLATFORM_WIN32_WINDOWS:
. h7 P5 O6 P0 Y- X8 f) {            ReadPhysicalDriveOnW9X(pSerList, pModeList);
           break;
! Z8 r& E; R$ y1 ~+ a7 b3 A        case VER_PLATFORM_WIN32_NT:
           ReadPhysicalDriveOnNT(pSerList, pModeList);
* n* |% @& u# |& V            break;
       default:
           break;
* j5 j# q* W) u+ R    }
/ T$ A% d& k  V# G}
//---------------------------------------------------------------------------
, A  X0 e3 D, d: `; S// ConvertToString
char *__fastcall ConvertToString(DWORD dwDiskData[256], int nFirstIndex, int nLastIndex)
{
) {" @1 G3 a$ D, J) X6 P! w    static char szResBuf[1024];
' e  Q) {: V6 e+ l. r0 K! j+ `    int nIndex = 0;
   int nPosition = 0;
* E4 c' R' H5 N$ ~/ y6 m  b
9 c- |1 r+ s% a$ _    // Each integer has two characters stored in it backwards
   for(nIndex = nFirstIndex; nIndex <= nLastIndex; nIndex++)
' d( y4 |1 J2 v' I' x5 [1 A! ]    {
       // Get high BYTE for 1st character
       szResBuf[nPosition] = (char)(dwDiskData[nIndex] / 256);
0 T6 L1 S% {" H4 X' P        nPosition++;

7 j0 d- }" x" R" z  O) Q! k4 s        // Get low BYTE for 2nd character
       szResBuf[nPosition] = (char)(dwDiskData[nIndex] % 256);
4 |) w) w4 S7 W2 V  _( G        nPosition++;
0 N8 b$ y2 Z2 O    }

   // End the string
   szResBuf[nPosition] = '\0';
5 w* X8 `3 V4 o5 [& [
4 u1 m8 N; Q! w! f* r- B    // Cut off the trailing blanks
   for(nIndex = nPosition - 1; nIndex > 0 && ' ' == szResBuf[nIndex]; nIndex--)
4 R: B! a: X. Q6 V) f3 a# D        szResBuf[nIndex] = '\0';

   return szResBuf;
2 Y: t1 X, d. h  Y/ Z}
//---------------------------------------------------------------------------
# ?+ @" R# C: t3 `// Winndows NT4/2000/XP 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnNT
void __fastcall ReadPhysicalDriveOnNT(TStrings *pSerList, TStrings *pModeList)
{
   // 输出参数
7 A2 B  p$ `$ B# ~& g    BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
) t7 f1 G! @! D0 C7 U% d
   for(int nDrive=0; nDrive < MAX_IDE_DRIVES; nDrive++)
   {
       HANDLE hPhysicalDriveIOCTL;
       char szDriveName[32];
# A* I& W/ a! c1 I8 @; }+ Y/ E% R
       sprintf(szDriveName, "\\\\.\\PhysicalDrive%d", nDrive);
       hPhysicalDriveIOCTL = CreateFile(szDriveName,
3 @, G4 ]: X2 e1 h2 c                        GENERIC_READ | GENERIC_WRITE,
                       FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                       OPEN_EXISTING, 0, NULL);

       if(hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
& |; g5 v$ |. z% Y6 \# O        {
, a' ]% H9 l; q3 N, h            DWORD dwBytesReturned = 0;
           GETVERSIONOUTPARAMS gvopVersionParams;
! [' x! g- O" C9 B& A& ^
           // Get the version, etc of PhysicalDrive IOCTL
: q7 w7 r4 C$ t# F            ZeroMemory(&gvopVersionParams, sizeof(GETVERSIONOUTPARAMS));

2 M2 Z% [! t3 `# p            if(!DeviceIoControl(hPhysicalDriveIOCTL, DFP_GET_VERSION,
& h* t. R/ d- D- n' @; Z" c                    NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams),
                   &dwBytesReturned, NULL))
: S, {+ I6 Z$ k: k0 j            {
               continue;
/ b' \5 L7 w6 b5 ]1 ]8 _            }

           if(gvopVersionParams.bIDEDeviceMap > 0)
- Q$ F# e# K  y1 K& p# r            {
               // IDE or ATAPI IDENTIFY cmd
               BYTE btIDCmd = 0;
               SENDCMDINPARAMS InParams;
               // Now, get the ID sector for all IDE devices in the system.
               // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
               // otherwise use the IDE_ATA_IDENTIFY command
. A( P7 ^8 f- W4 l& A8 c# u                // 具体所得结果请参考头文件中的说明
, S' w1 ~  M5 m' `8 p                btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ?
                       IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
6 h- y1 `$ N4 d) q                ZeroMemory(&InParams, sizeof(SENDCMDINPARAMS));
               ZeroMemory(btIDOutCmd, sizeof(btIDOutCmd));

               if(DoIdentify(hPhysicalDriveIOCTL,
                    &InParams, (PSENDCMDOUTPARAMS)btIDOutCmd,
                    (BYTE)btIDCmd, (BYTE)nDrive, &dwBytesReturned))
( a; j+ @( g5 c                {
                   DWORD dwDiskData[256];
                   USHORT *pIDSector; // 对应结构IDSECTOR，见头文件
                   char szSerialNumber[21];
                   char szModelNumber[41];
/ c4 x' z+ Q9 v5 y
                   pIDSector = (USHORT*)((SENDCMDOUTPARAMS*)btIDOutCmd)->bBuffer;
                   for(int i=0; i < 256; i++)
                       dwDiskData = pIDSector;
                   // 取系列号
                   ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
8 l1 i1 ?, h7 M& O. s                    strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));

                   // 取模型号
4 t! w5 v* [/ g9 D                    ZeroMemory(szModelNumber, sizeof(szModelNumber));
                   strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

                   pSerList->Add(szSerialNumber);
7 ~. B0 L$ d% |' v                    pModeList->Add(szModelNumber);
; Y0 i; a& U- G. @! O( l8 u! R                }
           }
           CloseHandle (hPhysicalDriveIOCTL);
5 z& O1 Z$ L7 n' |$ ~        }
   }
}
//---------------------------------------------------------------------------
// DoIdentify
bool __fastcall DoIdentify(HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
             PSENDCMDOUTPARAMS pSCOP, BYTE btIDCmd, BYTE btDriveNum,
+ P+ N6 X6 O3 E' o+ T              PDWORD pdwBytesReturned)
{
6 a( m. ~8 R7 a! R- R8 O    // Set up data structures for IDENTIFY command.
   pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
   pSCIP->irDriveRegs.bFeaturesReg = 0;
   pSCIP->irDriveRegs.bSectorCountReg  = 1;
8 @4 a9 x5 X* [$ B    pSCIP->irDriveRegs.bSectorNumberReg = 1;
  b9 }2 x' Q" l5 H  q' S    pSCIP->irDriveRegs.bCylLowReg  = 0;
   pSCIP->irDriveRegs.bCylHighReg = 0;
$ ^& F2 `' @  j5 N" Q
. h5 n8 E6 p$ e, ]  H1 l: I& I    // Compute the drive number.（主盘和从盘所对应的值是不一样的）
, [0 z" B: R( o7 H% I4 \    pSCIP->irDriveRegs.bDriveHeadReg = (btDriveNum & 1) ? 0xB0 : 0xA0;
+ _3 M1 y% ~' c3 c  D9 |( l
   // The command can either be IDE identify or ATAPI identify.
   pSCIP->irDriveRegs.bCommandReg = btIDCmd;
   pSCIP->bDriveNumber = btDriveNum;
1 k3 h6 e5 f- I; ~4 n- }    pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
0 i8 o# J4 f" q* J6 F. N1 c: n
   return DeviceIoControl(hPhysicalDriveIOCTL, DFP_RCV_DRIVE_DATA,
! i2 |' A6 c3 K$ ~1 n           (LPVOID)pSCIP,
3 x$ ~) U: \' N' o" U0 X! Q           sizeof(SENDCMDINPARAMS) - 1,
          (LPVOID)pSCOP,
+ _5 m, x) x( w- w+ G( h8 [           sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
          pdwBytesReturned, NULL);
}
//---------------------------------------------------------------------------
! t7 |9 s- {# Y$ N2 O$ b+ m3 @// Windows 95/98/ME 代码
//---------------------------------------------------------------------------
// ReadPhysicalDriveOnW9X
: W) C3 P' r! j7 U& r4 S: svoid __fastcall ReadPhysicalDriveOnW9X(TStrings *pSerList, TStrings *pModeList)
7 w% b& I/ t. l{
- j; i, a- u* z: ?    WORD wOutData[256];
   SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

   // 经过测试，发现第一次调用而且Drive >= 2时会在Ring0代码中出现错误，导致蓝屏。
   // 经过N（N > 15）次的蓝屏后仍找不到原因：（，不得不在这里增加一段无用代码以
   // 避免蓝屏的出现。（期待高人能指出原因）
, v8 E. L+ L8 h% X    for(int nDrive = 0; nDrive < 8; nDrive++)
   {
       WORD dwBaseAddress;
3 l; X1 B( i, f, n$ }! A! L7 X# c        BYTE btMasterSlave;         // Master Or Slave
       bool bIsIDEExist;
       bool IsDiskExist;

       switch(nDrive / 2)
8 J- F, X2 x9 |3 M0 P        {
           case 0: dwBaseAddress = 0x01F0; break;
0 Q5 k- Y; a/ \8 W$ Y* t. J1 l: T            case 1: dwBaseAddress = 0x0170; break;
           case 2: dwBaseAddress = 0x01E8; break;
           case 3: dwBaseAddress = 0x0168; break;
       }
9 l1 }' ~3 z- Y+ M& x; a2 B, z
       btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

       // 进入Ring0
       ReadPhysicalDriveOnW9X_Ring0(true, dwBaseAddress, btMasterSlave,
               bIsIDEExist, IsDiskExist, wOutData);
8 [. t8 R* V# `8 i    }

   // 开始读取
3 t; S: F# {/ h    for(int nDrive = 0; nDrive < 8; nDrive++)
   {
0 a# C$ o) H0 n) N3 q        WORD dwBaseAddress;
       BYTE btMasterSlave;         // Master Or Slave
       bool bIsIDEExist;
       bool bIsDiskExist;
       switch(nDrive / 2)
       {
* C5 c& _* m9 N$ j            case 0: dwBaseAddress = 0x01F0; break;
           case 1: dwBaseAddress = 0x0170; break;
           case 2: dwBaseAddress = 0x01E8; break;
           case 3: dwBaseAddress = 0x0168; break;
3 j" i1 u# C1 d. `4 h2 z' t% M1 n        }
  X% _: M+ H$ W: Q+ R' _
       btMasterSlave = (BYTE)(((nDrive % 2) == 0) ? 0xA0 : 0xB0);

       // 进入Ring0
# p( z6 W6 ^  J' R. T        bIsIDEExist  = false;
5 I' h: e1 a7 n5 V        bIsDiskExist = false;
  b4 |$ N' \# ?* F  {( V        ZeroMemory(wOutData, sizeof(wOutData));
' J% Q! ^3 H( r& p: N
       ReadPhysicalDriveOnW9X_Ring0(false, dwBaseAddress, btMasterSlave,
4 ]  H; o4 q1 E# d( }; L, ~                bIsIDEExist, bIsDiskExist, wOutData);

' F3 R* O3 T7 o# N; X4 S6 ?        if(bIsIDEExist && bIsDiskExist)
       {
# w' Y! Q) p, r: \2 d, t: ^            DWORD dwDiskData[256];
$ G8 Q- y7 U( l# q1 n! s            char  szSerialNumber[21];
           char  szModelNumber[41];
3 j+ g* @; W' U, N$ N0 G
           for(int k=0; k < 256; k++)
+ }! f/ W% u; h% C5 B                dwDiskData[k] = wOutData[k];
! d/ o) i$ o( h2 `
           // 取系列号
' Z- ?8 q1 x* d2 V) o% c' V            ZeroMemory(szSerialNumber, sizeof(szSerialNumber));
& a/ L% N6 m; P6 C            strcpy(szSerialNumber, ConvertToString(dwDiskData, 10, 19));
% G! X0 x- Q  l& C
           // 取模型号
% \' V/ ?6 M0 f: h            ZeroMemory(szModelNumber, sizeof(szModelNumber));
9 u4 h1 u2 s- P' j; U            strcpy(szModelNumber, ConvertToString(dwDiskData, 27, 46));

           pSerList->Add(szSerialNumber);
           pModeList->Add(szModelNumber);
       }
; J  t( _$ v+ A: ~" B& e7 O5 @    }
0 b8 f, K, k% n0 W6 B/ s0 r- {0 e! e    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
}
: r9 j* `- o, i! u- f- G; @//---------------------------------------------------------------------------
3 L' Z* ]6 }" f3 I! [1 P' p// ReadPhysicalDriveOnW9X_Ring0()
- i3 z! ?( y/ k) Z9 c//
* L* L: r; Z, P6 n3 }2 l4 T// dwBaseAddress = IDE(0,1,2,3) : 1F0h, 170h, 1E8h, 168h
5 D  l( @# H0 Z$ `+ N% s) ~// btMasterSlave = Master(0xA0) Or Slave(0xB0)
//---------------------------------------------------------------------------
' Q. Y$ {) L# r# q. y4 pvoid __fastcall ReadPhysicalDriveOnW9X_Ring0(bool bIsFirst, WORD dwBaseAddress,
) ?) u9 l* Q9 a" R# u# P/ A        BYTE btMasterSlave, bool &bIsIDEExist, bool &bIsDiskExist, WORD *pOutData)
8 a( g5 n( F& {, {3 @{
7 x) q+ d+ u& H9 t# Q: I# E0 q+ N    BYTE  btIDTR1[6];
   DWORD dwOldExceptionHook;
   const int nHookExceptionNo = 5;

   BYTE  btIsIDEExist = 0;
   BYTE  btIsDiskExist = 0;
; V8 |- C+ B- c& n+ {5 q3 J+ U, I    WORD  wOutDataBuf[256];

   BYTE  btIsFirst = (BYTE)bIsFirst;
/ e, }8 z& X7 D" T
" g$ Y; z0 l3 h# ]    const BYTE btBit00 = 0x01;
   // const BYTE btBit02 = 0x04;
! p! l* T3 h9 `! ~    const BYTE btBit06 = 0x40;
0 X9 D8 y+ f2 Z4 N* K* v/ e8 @$ i    const BYTE btBit07 = 0x80;
! M% _  E& i( v5 h    // const BYTE btERR  = btBit00;
   const BYTE btBusy = btBit07;
: i& Q% y, V  q6 t    const BYTE btAtaCmd   = 0xEC;
   const BYTE btAtapiCmd = 0xA1;

; j. ]& u' {& v, I    __asm
   {
       // 必须先执行这条语句
% `. E" Z. m3 X  ]: B8 H, ]8 j        JMP EnterRing0

% K) t2 p6 S9 Q1 I* Z7 g        // 定义过程
       // 等待IDE设备直到其不为忙为止
" [2 i2 B' r. @  K3 f/ |% g  b  p        WaitWhileBusy proc

0 o; N. S% j& }        MOV  EBX, 100000
       MOV  DX, dwBaseAddress
* B$ x* x! a! p( V9 w) |        ADD  DX, 7

       LoopWhileBusy:
8 Q6 w$ k+ Z: S. ~% A+ G
4 ^4 a% Q; C# [$ i. {6 V! F        DEC  EBX
       CMP  EBX, 0
       JZ   Timeout
6 i4 V& F$ Z, b. [. @        in   AL, DX
7 ~  @5 B2 c2 ]" n        TEST AL, btBusy
       JNZ  LoopWhileBusy
       JMP  DriveReady
) a. u! Y2 p( C7 r' l
* T# y) Z/ U  a3 v5 H1 u' j        // 超时，直接退出
( }) ^- y/ r4 t/ }; `0 S        Timeout:
' m) Y- `6 I. R2 L        JMP  LeaveRing0
( E: ~( m5 w7 D- m) G9 T* Q, K        DriveReady:
       RET
       ENDP   // End of WaitWhileBusy Procedure
$ }. m  e" k* T/ k% I  c9 w
       // 设置主盘和从盘标志
8 t- ]9 ~9 u' v- {% L7 p1 i* ^        SelectDevice proc
7 `7 w  L, Y% u3 o: T: ?
/ \% L: y% p0 d! j  D0 `        MOV  DX, dwBaseAddress
6 ^0 {+ j; a3 l0 _# k( @        ADD  DX, 6
       MOV  AL, btMasterSlave

       out  DX, AL
$ P" D& U+ J) E) a5 E        RET

. V6 q+ F" `- N; r. K/ F. F2 [        ENDP  // End of SelectDevice Procedure

5 E2 S; t- \& w7 _% N' \        // 向IDE设备发送存取指令
       SendCmd proc
+ L8 W9 [4 a6 b/ ^
       MOV DX, dwBaseAddress
       ADD DX, 7
       MOV AL, BL // BL是主从盘标识，在过程外设置
       out DX, AL
       RET
       ENDP  // End of SendCmd Procedure
; {' N7 B* }0 d6 P3 v5 |5 [
       // Ring0代码
       Ring0Proc:
" ?+ J2 M& M8 N9 C# {  G$ `1 |        PUSHAD
       // 查询IDE设备是否存在
       MOV DX, dwBaseAddress
6 e& _; {8 w' O) Q& g9 l' Z        ADD DX, 7
       in  AL,DX

       // 当AL的值是0xFF或者0x7F时，IDE设备不存在，这时候直接返回
6 f( _2 K/ g( B) S: {        CMP AL,0xFF
       JZ  LeaveRing0
7 z2 H% S) @4 `8 q: R% T! R; W1 R        CMP AL, 0x7F
       JZ  LeaveRing0

$ ~" A8 W' b7 `* g0 M        // 设置IDE设备存在标志
       MOV btIsIDEExist, 1
" n% V# H# P- D4 V
* s9 [2 z% F5 _" n7 b        // 查询IDE设备上的驱动器是否存在（有IDE插槽在主板上，但是却不一定有硬盘插在上面）
       CALL WaitWhileBusy
       CALL SelectDevice

: L% V5 M! T$ l5 u- ]        // 如果是第一次调用，则直接返回，否则执行下行语句时会出现蓝屏
% g; Z( s$ w. z' |) b$ u        CMP  btIsFirst, 1
       JZ   LeaveRing0
) l& _. Y! w0 C/ P4 M# y% P9 z
       // 第一次调用时，如果执行这行语句会导致蓝屏，Why？？？
' G: G1 b! l& V" s        CALL WaitWhileBusy

       // AL的值等于cBit06时，不存在驱动器，直接返回
, q5 Y' B4 k! {) r7 A        TEST AL, btBit06
3 t& c4 ^5 Z) g1 f        JZ   LeaveRing0
: {2 g2 h$ s  K; _% I7 B
       // 设置驱动器存在标志
       MOV  btIsDiskExist, 1

! |: C- h; h; @! r4 t3 Q" D        // 发送存取端口命令
1 [9 v$ P. N: k6 j9 i        // 无法像NT/2000/XP那样可以通过查询VERSION的值得到驱动器的类型，
       // 所以只能一步一步地测试，如果不是ATA设备，再尝试使用ATAPI设备命令
       CALL WaitWhileBusy
/ q$ Z% s/ w! X        CALL SelectDevice    // 设置主从盘标识
       MOV  BL, btAtaCmd      // 发送读取命令
# G# [! O+ ]* a5 y) w8 b8 i9 @        CALL SendCmd
7 C3 C* ^1 m) [/ X        CALL WaitWhileBusy

2 C9 f8 J' c, @, M$ b        // 检查是否出错
       MOV  DX, dwBaseAddress
7 V  N9 s! R2 v2 t) J/ @        ADD  DX, 7
# F' t; p* N6 C( a
       in   AL, DX
: O/ _: A* L# P# y
       TEST AL, btBit00
: R4 d/ a# M0 W* n  L        JZ   RetrieveInfo   // 没有错误时则读数据

       // 如果出错，则进一步尝试使用ATAPI设备命令
4 m- ~; }: A7 L% p! X6 M        CALL WaitWhileBusy
0 v2 _( l3 C# n        CALL SelectDevice
       MOV  BL, btAtapiCmd
       CALL SendCmd
. |/ G! [# W$ u  e        CALL WaitWhileBusy

0 j2 |8 _; _7 D$ x  c# s' d5 v7 e        // 检查是否还出错
       MOV  DX, dwBaseAddress
3 }! n7 e1 c6 @9 J# p( \9 c        ADD  DX, 7
5 B( _) Y$ _# v        in   AL, DX
       TEST AL, btBit00
       JZ   RetrieveInfo   // 没有错误时则读数据
3 o: m0 }& f6 A3 c        JMP  LeaveRing0     // 如果还是出错，直接返回

6 S7 P. \; L$ z5 P5 m        // 读取数据
. g; Y- V5 H% ~1 N( g: P  P1 O        RetrieveInfo:
* e7 @! d! p. S, [; Q7 a5 l5 \
       LEA  EDI, wOutDataBuf
       MOV  ECX, 256
4 G/ D; I5 X! z        MOV  DX, dwBaseAddress
       CLD

       REP  INSW
8 g" w1 n' `. F  L# s+ O
' S5 q) _+ U3 P        // 退出Ring0代码
" Y0 P: p% p6 b: J        LeaveRing0:

       POPAD
; c1 c$ V2 x! [& q2 w        IRETD

+ Y8 N5 u8 e/ w7 U0 \8 [        // 激活Ring0代码
       EnterRing0:

       // 修改中断门
       SIDT FWORD PTR btIDTR1
9 v: e( z' D9 H( x" U3 `3 b( G0 p5 ~        MOV EAX, DWORD PTR btIDTR1 + 02h
9 p/ z4 D, s* H        ADD EAX, nHookExceptionNo * 08h + 04h
       CLI
( t0 f( h5 l9 R
       // 保存原异常处理例程入口
! l1 n, x4 V4 z3 |+ L% z( y: y% h        MOV ECX, DWORD PTR [EAX]
- i3 R3 x8 k: c( A/ e) A5 U        MOV CX, WORD PTR [EAX-04h]
2 l; a! o  H; C. U- f        MOV dwOldExceptionHook, ECX
( s) n: j0 ^. X$ G+ r+ d: V
       // 指定新入口
       LEA EBX, Ring0Proc
* Y  T9 N0 J' \+ y5 a# u+ @) ^        MOV WORD PTR [EAX-04h],BX
4 H" Q5 }9 i8 ~* `/ I( X, @        SHR EBX, 10h
; @  ]6 `& t% }+ t, t& M        MOV WORD PTR[EAX+02h], BX
) A; t; I& N7 i7 C. B3 W
# U1 ]+ ?# L- b4 D: r        // 激活Ring0代码
8 ]2 @/ e" Y, h$ C% x* W        INT nHookExceptionNo

       // 复原入口
       MOV ECX,dwOldExceptionHook
. J% c. \1 j  }2 A& @6 F6 q        MOV WORD PTR[EAX-04h], CX
       SHR ECX,10h
4 K- p- |% c) l6 T% B8 e7 g        MOV WORD PTR[EAX+02h], CX
       STI
, r+ j% h+ n- f6 r; z/ }    }
% ^+ m5 R1 [& p3 W$ N, S    if(!bIsFirst)
+ H! P* M# ]6 `, @9 r& j    {
       bIsIDEExist  = (bool)btIsIDEExist;
       bIsDiskExist = (bool)btIsDiskExist;
2 B! w% y! P: s8 z" X        CopyMemory(pOutData, wOutDataBuf, sizeof(wOutDataBuf));
2 s0 b& B4 W- W! o. C" l8 j, Y    }
}
//---------------------------------------------------------------------------
// 调用方法：
" a+ ~# j, W9 s! x. y5 Evoid __fastcall TForm1::Button1Click(TObject *Sender)
" T: f) w/ C% _4 G* i# \8 Y{
% |. J3 L; ]% n! l6 i$ M% [, X    ReadPhysicalDrive(Memo1->Lines, Memo2->Lines);
- D9 [3 {( o" L% b0 V5 h9 f}