← 返回目录

回顾 WINDOWS98 NEST V8086模式和中断服务调用

原文链接: https://blog.csdn.net/aerror/article/details/3659164
发布时间: 2008-12-31 00:30:00
浏览量: 9048
标签: windows, buffer, struct, 磁盘, ios, system
新的一年到了,不禁回头望了一下，写些老掉牙的东西以作纪念。早在2004年,我当时正在写个wdm的驱动程序，因为软件的版本允许在windows 98, windows NT 4.0 , windows 2000和windows XP上运行，我不想每个写了一个wdm后，再实现一个相同功能的Vxd，在当时我的想法里，这是不利行维护，是不明智的行为，于是我决定让我的WDM程序可以在上面所说的所有win

新的一年到了,不禁回头望了一下，写些老掉牙的东西以作纪念。

早在2004年,我当时正在写个wdm的驱动程序，因为软件的版本允许在windows 98, windows NT 4.0 , windows 2000和windows XP上运行，我不想每个写了一个wdm后，再实现一个相同功能的Vxd，在当时我的想法里，这是不利行维护，是不明智的行为，于是我决定让我的WDM程序可以在上面所说的所有windows版本上正确运行。想法是美好的，但实现的过程中吃不少苦头。

 

其中有一项功能是涉及到对磁盘扇区的直接读写取的，有很多种方式的来解决这个问题，在NT系统下，最简单莫过直接构造IRP传递给磁盘驱动程序，或者最直接的IO PORT操作，BIOS 中断 INT 13等。 使用IO PORT,这适用于NT 和windows 98，看来完美解决方案，但问题的是兼容性比较差，实际的效果表明驱动使用这种方式也表现得很不稳定。而最偷懒最简单最稳定的方式却是直接构造IRP传递给磁盘驱动程序，可惜只能用于NT，原因是虽然windows 98 ntkern.vxd这个系统模块中包括有大量NT内核支持函数的windoes 98实现，号称wdm程序几乎区别不了这两个环境，但事实上却没有这样高度的统一，没有像NT一样所有的内核模式都使用一个公用的数据结构(IRP)，如串口的驱动程序要遵从VCOMM.vxd规定的port驱动程序函数调用规范，而磁盘驱动程序则遵从IOS.vxd实现的包驱动层次结构，NTKERN.VXD实事上遗留了不少未实现的函数。所以当时最开始的打算是在NT 系统下使用IRP传递给磁盘驱动程序的方式，而windows 98则采用类似的Ios_SendCommand的方式向磁盘驱动投递请求。

在windows98下Ios_SendCommand工作得像windows 2000下的IoCallDriver一样简单优雅，但是不幸的是，程序需要在驱动初始化的也要进行对磁盘的读取，在这个阶段Ios_SendCommand完全不能工作，是因为NTKERN.VXD把WDM的驱动在IOS.SYS初始化完成一份硬盘驱动器表之前就初始化了，同时WDM的序动顺序也无法像在WINDOWS2000下面那样多的级别可以指定，而我驱动程序要刚好在系统加载SYSTEM32下面的RING3层DLL之前，这样初始化动作才有效（事实上我需要修改那

些SYSTEM32目录下的DLL,如果它们一旦给初始化,就无法进行写入的操作了）。而我不想使用直接IO的方式，没有办法，我只能求助于BIOS的INT 13H(及INT 13H的对于大硬盘的扩展功能)。

在这里我使用了nest_v86_execute来进入16bit的实模式环境来执行INT 13h，使用了VMMGR 的服务接口来申请1MB以下的内存，并在16 bit实模式和32 bit 保护模式两种模式下交换数据。

呵呵，当初有趣的尝试，带来了不少的乐趣和新知识。

以下附录一些代码:

  2. //WINDOWS nt/2000使用IRP的IoCallDriver来访问硬盘
  3. //
  4.  // Initialize unicode string
  5.     //
  6.     RtlInitUnicodeString(&uszDeviceName, L"//DosDevices//PhysicalDrive0");
  7.     ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  9.     // Get a pointer to PhysicalDrive0
  10.     //
  11.     ntStatus = IoGetDeviceObjectPointer(&uszDeviceName,
  12.                                         FILE_ANY_ACCESS,
  13.                                         &fileObject,
  14.                                         &pDriveDeviceObject);
  16.     // If the device object pointer is valid...
  17.     //
  18.     if(NT_SUCCESS(ntStatus))
  19.     {
  20.         IO_STATUS_BLOCK    ioStatus; 
  21.         KEVENT             event; 
  22.         PIRP               pIrp;
  24.                    
  25.         KeInitializeEvent(event, NotificationEvent, FALSE); 
  26.             
  28.         pIrp = IoBuildSynchronousFsdRequest(bRead?IRP_MJ_READ:IRP_MJ_WRITE,
  29.                                             pDriveDeviceObject,
  30.                                             pBuffer,
  31.                                             512,
  32.                                             &llSectorNum,
  33.                                             event,
  34.                                             &ioStatus);
  36.         if(!pIrp)
  37.         {
  38.            ObDereferenceObject(fileObject);
  39.            return STATUS_BAD_STACK; 
  40.         }
  42.         ntStatus = IoCallDriver(pDriveDeviceObject, pIrp);
  44.         if(ntStatus == STATUS_PENDING)
  45.         {
  46.             KeWaitForSingleObject(event, Suspended, KernelMode, FALSE, NULL);
  47.             ntStatus = ioStatus.Status;
  48.         } 
  49.             
  50.         // Ditch the fileObject pointer created earlier
  51.         //
  52.         ObDereferenceObject(fileObject);
  53.     }
  55. //WINDOWS98使用ios_sendCommand来访问硬盘
  56. //
  57. #include "ior.h"
  58. int TestIos_SendCmd(void * pbuffer)
  59. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  60.     Routine Description:
  62.         Just a testing for Ios_SendCommand,I try to pass the
  63.     request to ios.sys.
  64.     Arguments:
  66.         pbuffer -- a buffer.        
  68.     Return Value:
  69.         
  70.         if all thing ok return 1,else return 0.
  72. -------------------------------------------------------*/
  73. {
  74.     IOR iorStru;
  75.     UCHAR nDisk = 0x80;
  76.     
  77. readBein:
  78.     memset(&iorStru,0,sizeof(iorStru));
  79.     iorStru.IOR_func  =IOR_READ; 
  80.     iorStru.IOR_flags  =IORF_PHYS_CMD|IORF_VERSION_002|IORF_SYNC_COMMAND|IORF_HIGH_PRIORITY|IORF_WIN32;
  81.     iorStru.IOR_start_addr[0]=0;    //start position los
  82.     iorStru.IOR_start_addr[1]=0;    //start position high
  83.     iorStru.IOR_xfer_count = 1;     //num of sector to read.
  84.     iorStru.IOR_buffer_ptr = (ULONG)pbuffer; //Address of the buffer
  85.     iorStru.IOR_vol_designtr = nDisk;   //disknum.
  87.     _asm {
  88.         push esi;
  89.         lea esi,iorStru
  90.         _asm _emit 0xcd 
  91.         _asm _emit 0x20 
  92.         _asm _emit (0x00100004 & 0xff) 
  93.         _asm _emit (0x00100004) >> 8 & 0xff 
  94.         _asm _emit (0x00100004) >> 16 & 0xff 
  95.         _asm _emit (0x00100004) >> 24 & 0xff    //Ios_SendCommand
  96.         pop esi;
  97.     }
  98.     if(iorStru.IOR_status == 0x17)
  99.     {
  100.         if(nDisk == 0x80)
  101.         {
  102.             nDisk = 0x81;
  103.             goto readBein;
  104.         }
  105.         else if (nDisk == 0x81)
  106.         {
  107.             nDisk = 0x2;
  108.             goto readBein;
  109.         }
  111.     }
  112.     else
  113.         return 1;
  114. }
  116. //使用BIOS INT 13扩展功能来访问硬盘
  117. //
  118. //
  119. /**
  121.         purpose:    define Some Useful defines and structure for using int 13h
  123.       here's the v86mgr real data.
  124.  */
  125. FFFFFFFF    V86MMGR
  126. 00060000    V86MMGR_Get_Version
  127. 00060001    V86MMGR_Allocate_V86_Pages
  128. 00060002    V86MMGR_Set_EMS_XMS_Limits
  129. 00060003    V86MMGR_Get_EMS_XMS_Limits
  130. 00060004    V86MMGR_Set_Mapping_Info
  131. 00060005    V86MMGR_Get_Mapping_Info
  132. 00060006    V86MMGR_Xlat_API
  133. 00060007    V86MMGR_Load_Client_Ptr
  134. 00060008    V86MMGR_Allocate_Buffer
  135. 00060009    V86MMGR_Free_Buffer
  136. 0006000A    V86MMGR_Get_Xlat_Buff_State
  137. 0006000B    V86MMGR_Set_Xlat_Buff_State
  138. 0006000C    V86MMGR_Get_VM_Flat_Sel
  139. 0006000D    V86MMGR_Map_Pages
  140. 0006000E    V86MMGR_Free_Page_Map_Region
  141. 0006000F    V86MMGR_LocalGlobalReg
  142. 00060010    V86MMGR_GetPgStatus
  143. 00060011    V86MMGR_SetLocalA20
  144. 00060012    V86MMGR_ResetBasePages
  145. 00060013    V86MMGR_SetAvailMapPgs
  146. 00060014    V86MMGR_NoUMBInitCalls
  147. 00060015    V86MMGR_Get_EMS_XMS_Avail
  148. 00060016    V86MMGR_Toggle_HMA
  149. 00060017    V86MMGR_Dev_Init
  150. 00060018    V86MMGR_Alloc_UM_Page
  151.  */
  153. #define  _VMMCALL_V86MMGR_Allocate_Buffer   _asm _emit 0xcd /
  154.     _asm _emit 0x20 /
  155.     _asm _emit (0x00060008 & 0xff) /
  156.     _asm _emit (0x00060008 >> 8) & 0xff /
  157.     _asm _emit (0x00060008 >> 16) & 0xff /
  158.     _asm _emit (0x00060008 >> 24) & 0xff /
  160. #define  _VMMCALL_V86MMGR_Free_Buffer  _asm _emit 0xcd /
  161.     _asm _emit 0x20 /
  162.     _asm _emit (0x00060009 & 0xff) /
  163.     _asm _emit (0x00060009  >> 8) & 0xff /
  164.     _asm _emit (0x00060009  >> 16) & 0xff /
  165.     _asm _emit (0x00060009  >> 24) & 0xff /
  169. #define _MICRO_V86MMGR_ALLOCATE_BUFFER_COPIED(VMHANDLE,PCLIENTSTRU,LPBUFFER,CONST_NUM,NUMCOPIED,FPTR)   /
  170.     _asm{mov ebx,VMHANDLE} /
  171.     _asm{push   esi} /
  172.     _asm{mov    esi,LPBUFFER} /
  173.     _asm{mov    ecx,CONST_NUM} /
  174.     _asm{push   ebp } /
  175.     _asm{mov    ebp,PCLIENTSTRU} /
  176.     _asm{STC    } /
  177.     _asm{push   ds} /
  178.     _asm{pop    fs} /
  179.     {_VMMCALL_V86MMGR_Allocate_Buffer} /
  180.     _asm{pop ebp} /
  181.     _asm{pop esi} /
  182.     _asm{mov NUMCOPIED,ECX} /
  183.     _asm{mov FPTR,EDI} /
  186. #define _MICRO_V86MMGR_ALLOCATE_BUFFER_NOTCOPIED(VMHANDLE,PCLIENTSTRU,CONST_NUM,NUMALLOCATED,FPTR)  /
  187.     _asm{mov    ebx,VMHANDLE} /
  188.     _asm{mov    ecx,CONST_NUM} /
  189.     _asm{push   ebp } /
  190.     _asm{mov    ebp,PCLIENTSTRU} /
  191.     _asm{CLC    } /
  192.     {_VMMCALL_V86MMGR_Allocate_Buffer} /
  193.     _asm{pop ebp} /
  194.     _asm{mov NUMALLOCATED,ECX} /
  195.     _asm{mov FPTR,EDI} /
  198. #define _MICRO_V86MMGR_FREE_BUFFER_COPIED(VMHANDLE,PCLIENTSTRU,LPBUFFER,NUMCOPIED)  /
  199.     _asm{mov  ebx, VMHANDLE} /
  200.     _asm{push   esi} /
  201.     _asm{mov    esi, LPBUFFER} /
  202.     _asm{mov    ecx, NUMCOPIED} /
  203.     _asm{push   ebp} /
  204.     _asm{mov    ebp, PCLIENTSTRU} /
  205.     _asm{push   ds} /
  206.     _asm{pop    fs} /
  207.     _asm{stc    } /
  208.     {_VMMCALL_V86MMGR_Free_Buffer} /
  209.     _asm{pop    ebp} /
  210.     _asm{pop    esi} /
  213. #define _MICRO_V86MMGR_FREE_BUFFER_NOTCOPIED(VMHANDLE,PCLIENTSTRU,NUMCOPIED)    /
  214.     _asm{mov    ebx, VMHANDLE} /
  215.     _asm{mov    ecx, NUMCOPIED} /
  216.     _asm{push   ebp} /
  217.     _asm{mov    ebp, PCLIENTSTRU} /
  218.     _asm{CLC    } /
  219.     {_VMMCALL_V86MMGR_Free_Buffer} /
  220.     _asm{pop    ebp} /
  221.     
  224. #define _SAVE_CLIENT_STATE(SAVEREGS)  /
  225.     _asm{push edi}/
  226.     _asm{lea edi,SAVEREGS} /
  227.     VMMCall(Save_Client_State) /
  228.     _asm{pop edi}
  230. #define _RESTORE_CLIENT_STATE(SAVEREGS) /
  231.     _asm push esi /
  232.     _asm lea esi,SAVEREGS /
  233.     VMMCall(Restore_Client_State) /
  234.     _asm pop esi /
  238. #define _CALL_INT13_V86_(VMHANDLE,PCLIENTSTRU) /
  239.     _asm{mov ebx,VMHANDLE}/
  240.     _asm{push ebp}/
  241.     _asm{mov ebp,PCLIENTSTRU} /
  242.     VMMCall(Begin_Nest_V86_Exec) /
  243.     _asm{mov eax,13h} /
  244.     {VMMCall(Exec_Int)} /
  245.     End_Nest_Exec();/
  246.     _asm{pop ebp}/
  249. #define GETVM_HANDLE_CLIENTSTRU(VMHANDLE,PCLIENTSTRU) /
  250.     VMHANDLE = (struct cb_s *)Get_Cur_VM_Handle();/
  251.     _asm{mov ebx,VMHANDLE} /
  252.     PCLIENTSTRU = (CLIENT_STRUCT *)VMHANDLE->CB_Client_Pointer;/
  255. //
  256. //The next few lines, will map the values into
  257. //the registers as need by INT13
  258. //
  260. #define  MAKE_INT13CHSD_IN_HS(CYL,HEA,SEC,DISK) /
  261.     _asm{MOVZX EAX ,CYL}/
  262.     _asm{MOVZX EDX ,HEA}/
  263.     _asm{MOVZX ECX ,SEC}/
  264.     _asm{MOV   CH,AL}/
  265.     _asm{ROR   AH,1}/
  266.     _asm{ROR   AH,1}/
  267.     _asm{OR    CL,AH}/
  268.     _asm{MOV   DH,DL}/
  269.     _asm{MOV   DL,DISK} /
  270.     _asm{MOV   HEA,CX}/
  271.     _asm{MOV   SEC,DX} /
  274. #pragma pack(1)
  275. typedef struct _tagDiskAddressPacket 
  276. { 
  277.     BYTE PacketSize;     // Packet Length(16bytes) 
  278.     BYTE Reserved;       // ==0 
  279.     WORD BlockCount;     // Transfer block count(Sector) 
  280.     DWORD BufferAddr;    // Transfer buffer pointer(segment:offset) 
  281.     QWORD BlockNum;      // Position To Start.
  282. }DISKADDRESSPACKETI13E; 
  285. typedef struct _tagDriveParametersPacket
  286. { 
  287.     WORD  InfoSize;         // Packet Leggth (26 Bytes) 
  288.     WORD  Flags;            // flag
  289.     DWORD Cylinders;        // 
  290.     DWORD Heads;            // 
  291.     DWORD SectorsPerTrack;  // Sectors per Track
  292.     QWORD Sectors;          // Amout of sectors.
  293.     WORD  SectorSize;       // Bytes per sector.
  294. }DRIVEPARAMETERSPACKETI13E; 
  295. #pragma pack()
  296. int LBAToCHS(ULONG LbaNum,
  297.              USHORT Sectors,
  298.              USHORT Heads,
  299.              PUSHORT pSectorNum,
  300.              PUSHORT pHeadNum,
  301.              PUSHORT pCylinderNum)
  302. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  303.     Routine Description:
  305.         convert the LBA address to CHS address.
  306.     Arguments:
  308.         LbaNum  -- The LBA address.
  309.         Sectors -- Sectors per Track 
  310.         Heads   -- Amount Heads,you should to use Get DiskParams
  311.                    To Get the sectors and heads.
  312.         pSectorNum  -- pointer to sector's result
  313.         pHeadNum    -- pointer to Head's result
  314.         pCylinderNum -- pointer to Cylinder's result
  316.     Return Value:
  317.         
  318.         if all thing ok return 1,else return 0.
  320.     **********************
  321.     
  322.     
  323. -------------------------------------------------------*/
  324. {
  325.     USHORT uSectorNum,uHeadNum,uCylinderNum;
  326.     _asm{
  327.         MOV     EAX,LbaNum
  328.         MOVZX   EBX,Sectors     
  329.         XOR     EDX,EDX
  330.         DIV     EBX         //LbaNum / sectors 
  331.         INC     EDX         //EDX is the remainder,EAX is the quotient 
  332.         MOV     ECX,EDX     
  333.         MOVZX   EBX,Heads   
  334.         XOR     EDX,EDX
  335.         DIV     EBX
  336.         MOV uCylinderNum,AX
  337.         MOV uHeadNum,DX
  338.         MOV uSectorNum,CX 
  339.     }
  340.     *pSectorNum =uSectorNum;
  341.     *pHeadNum = uHeadNum;
  342.     *pCylinderNum = uCylinderNum;
  343.     return 1;
  344. }
  349. int GetHardDiskParamsI13(UCHAR nDiskNumber,PUSHORT pCylinders,PUSHORT pHeads,PUSHORT pSectors)
  350. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  351.     Routine Description:
  353.         Get the Disk's params which specified by nDiskNumber using bios int 13h.
  355.     Arguments:
  357.         nDiskNumber --Disk ID,0-5 for   Fixed hardDisk.
  358.         pCylinders -- pointer for amount of the disk Cylinders.if 
  359.                      the disk bigger than 8GB(Should be greater the 1024), 
  360.                      it return only 1024.
  361.         pHeads     --  pointer for heads.
  362.         pSectors   --  pointer for Sectors.
  364.     Return Value:
  365.         
  366.         if all thing ok return 1,else return 0.
  368.     **********************
  369.     
  370.     
  371. -------------------------------------------------------*/
  373. {
  374.     USHORT Cylinders,Heads,Sectors;
  375.     UCHAR DiskIDs[6] = {0x80,0x81,0x82,0x83,0x84,0x85};
  376.     UCHAR nDisk;
  377.     CLIENT_STRUCT saveregs; 
  378.     CLIENT_STRUCT *pClStru;
  379.     struct cb_s * hvm;
  380.     if(nDiskNumber > 5 )
  381.     {
  382.         return 0;
  383.     }
  384.     nDisk = DiskIDs[nDiskNumber];
  386.     GETVM_HANDLE_CLIENTSTRU(hvm,pClStru);
  387.     _SAVE_CLIENT_STATE(saveregs);
  388.     
  389.     //
  390.     //Fill the client struct.
  391.     //
  392.     pClStru->CBRS.Client_AH  = 0x08;
  393.     pClStru->CBRS.Client_DL  = nDisk;
  395.     _CALL_INT13_V86_(hvm,pClStru);
  397.     //
  398.     //Save the interest value to AX,DX,CX.
  399.     //
  400.     _asm mov ebx,pClStru
  401.     _asm mov AX,[ebx.Client_Flags]
  402.     _asm mov DX,[ebx.Client_DX]
  403.     _asm mov CX,[ebx.Client_CX]
  405.     _RESTORE_CLIENT_STATE(saveregs);
  406.     //
  407.     //Now Get the proper params from DX,CX
  408.     //
  409.     _asm{
  410.         test    AX,1
  411.         jnz    loc_error
  412.         MOV     AL,DH           //
  413.         XOR     AH,AH
  414.         INC     AX
  415.         MOV     Heads,AX        // save head count
  417.         MOV     AL,CL           // put sector number in AL
  418.         AND     AX,3FH          // and mask off cylinder bits
  419.         MOV     Sectors,AX      // save sector count
  421.         MOV     AL,CH           // AL = cylinder LO
  422.         MOV     AH,CL           // AH = cylinder HI...
  423.         MOV     CL,6
  424.         SHR     AH,CL           // shift the HI bits down
  425.         INC     AX
  426.         MOV     Cylinders,AX    // save cylinder count
  427.         jmp loc_success
  428.     }
  429. loc_error:
  430.     return 0;
  431. loc_success:
  432.     *pCylinders = Cylinders;
  433.     *pHeads = Heads;
  434.     *pSectors = Sectors;
  435.     return 1;
  436. }
  439. int absDiskReadI13(
  440. UCHAR nDiskNumber,  //0~5;
  441. USHORT nCylinders,
  442. USHORT nHeads,      // 
  443. USHORT nSectors,    // sector position
  444. USHORT wSectors,    //How many To read
  445. void* pBuffer)      //pointer to the buffer.
  446. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  447.     Routine Description:
  449.         Read the Disk which specified by nDiskNumber using bios int 13h.
  451.     Arguments:
  453.         nDiskNumber -- Disk ID,0-5 for   Fixed hardDisk.
  454.         nCylinders --  Starting Position's Cylinders .it should not be greater than 1024.
  455.         nHeads     --  Starting Position's heads.
  456.         nSectors   --  Starting Position's Sectors.
  457.         wSector    --  How many sector to read.
  458.         pBuffer    --  Buffer for receive the result of reading.
  460.     Return Value:
  461.         
  462.         if all thing ok return 1,else return 0.
  464.     **********************
  465.     
  466.     
  467. -------------------------------------------------------*/
  468. {
  470.     UCHAR DiskIDs[6] = {0x80,0x81,0x82,0x83,0x84,0x85};
  471.     UCHAR nDisk;
  472.     CLIENT_STRUCT saveregs; 
  473.     CLIENT_STRUCT *pClStru;
  474.     struct cb_s * hvm;
  475.     WORD  nsegsel,noffset;
  476.     DWORD FarPtrBuffer = 0;
  477.     DWORD dwBytesCopied = 0;
  478.     DWORD dwAssumBuffLen = 0;
  479.     DWORD vmpnum = 0x10;
  480.     DWORD retu = 1;
  481.     if(nDiskNumber > 5 || wSectors == 0  )
  482.     {
  483.         return 0;
  484.     }
  485.     
  486.     dwAssumBuffLen = 512 *  wSectors;
  487.     nDisk =  DiskIDs[nDiskNumber];
  488.     hvm = (struct cb_s *)Get_Cur_VM_Handle();
  489.     pClStru = (CLIENT_STRUCT *)hvm->CB_Client_Pointer;
  490.        
  491.     _MICRO_V86MMGR_ALLOCATE_BUFFER_NOTCOPIED(hvm,pClStru,dwAssumBuffLen,
  492.         dwBytesCopied,FarPtrBuffer);
  493.     _asm jc Loc_ret_Failed ;
  495.     _SAVE_CLIENT_STATE(saveregs);
  497.     //
  498.     //Fill Int13 entries..
  499.     //
  500.     nsegsel = HIWORD(FarPtrBuffer);
  501.     noffset = LOWORD(FarPtrBuffer);
  502.     MAKE_INT13CHSD_IN_HS(nCylinders,nHeads,nSectors,nDisk);
  503.     pClStru->CWRS.Client_CX = nHeads;
  504.     pClStru->CWRS.Client_DX  = nSectors;
  505.     pClStru->CBRS.Client_AH  = 0x02; //To Read 
  506.     pClStru->CBRS.Client_AL = (UCHAR)wSectors;//How many to read.
  507.     pClStru->CRS.Client_ES  = nsegsel;
  508.     pClStru->CWRS.Client_BX = noffset;
  509.     
  510.     _CALL_INT13_V86_(hvm,pClStru)
  511.     
  512.     _asm{
  513.         mov ebx,pClStru
  514.         mov ax,[ebx.Client_Flags]
  515.         _asm mov  retu ,eax
  516.     }
  518.     _RESTORE_CLIENT_STATE(saveregs)
  519.     
  520.     _MICRO_V86MMGR_FREE_BUFFER_COPIED(hvm,pClStru,pBuffer,dwBytesCopied);
  522.     if(!(retu&1))
  523.     {
  524.         return 1;
  525.     }
  527. Loc_ret_Failed:
  528.     return 0;
  529. }
  532. int absDiskWriteI13(
  533. UCHAR nDiskNumber,           //0~5;
  534. USHORT nCylinders,
  535. USHORT nHeads,      // 
  536. USHORT nSectors,    //Where to start.
  537. USHORT wSectors,    //How many To read
  538. void* pBuffer)      // 
  539. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  540.     Routine Description:
  542.         Write the Disk which specified by nDiskNumber using bios int 13h.
  544.     Arguments:
  546.         nDiskNumber -- Disk ID,0-5 for   Fixed hardDisk.
  547.         nCylinders --  Starting Position's Cylinders .it should not be greater than 1024.
  548.         nHeads     --  Starting Position's heads.
  549.         nSectors   --  Starting Position's Sectors.
  550.         wSector    --  How many sector to Write.
  551.         pBuffer    --  Buffer for the content of writing.
  553.     Return Value:
  554.         
  555.         if all thing ok return 1,else return 0.
  557.     **********************
  558.     
  559.     
  560. -------------------------------------------------------*/
  561. {
  562.     UCHAR DiskIDs[6] = {0x80,0x81,0x82,0x83,0x84,0x85};
  563.     UCHAR nDisk;
  564.     CLIENT_STRUCT saveregs; 
  565.     CLIENT_STRUCT *pClStru;
  566.     struct cb_s * hvm;
  567.     WORD  nsegsel,noffset;
  568.     DWORD FarPtrBuffer = 0;
  569.     DWORD dwBytesCopied = 0;
  570.     DWORD dwAssumBuffLen = 0;
  571.     DWORD vmpnum = 0x10;
  572.     DWORD retu = 1;
  573.     if(nDiskNumber > 5 || wSectors == 0  )
  574.     {
  575.         return 0;
  576.     }
  577.     
  578.     dwAssumBuffLen = 512 *  wSectors;
  579.     nDisk =  DiskIDs[nDiskNumber];
  580.     hvm = (struct cb_s *)Get_Cur_VM_Handle();
  581.     pClStru = (CLIENT_STRUCT *)hvm->CB_Client_Pointer;
  582.        
  583.     _MICRO_V86MMGR_ALLOCATE_BUFFER_COPIED(hvm,pClStru,pBuffer,dwAssumBuffLen,
  584.         dwBytesCopied,FarPtrBuffer);
  585.     _asm jc Loc_ret_Failed ;
  587.     _SAVE_CLIENT_STATE(saveregs);
  589.     //
  590.     //Fill Int13 entries..
  591.     //
  592.     nsegsel = HIWORD(FarPtrBuffer);
  593.     noffset = LOWORD(FarPtrBuffer);
  594.     MAKE_INT13CHSD_IN_HS(nCylinders,nHeads,nSectors,nDisk);
  595.     pClStru->CWRS.Client_CX = nHeads;
  596.     pClStru->CWRS.Client_DX  = nSectors;
  597.     pClStru->CBRS.Client_AH  = 0x03; //To Write
  598.     pClStru->CBRS.Client_AL = (UCHAR)wSectors;//How many to read.
  599.     pClStru->CRS.Client_ES  = nsegsel;
  600.     pClStru->CWRS.Client_BX = noffset;
  601.     
  602.     _CALL_INT13_V86_(hvm,pClStru)
  603.     
  604.     _asm{
  605.         mov ebx,pClStru
  606.         mov ax,[ebx.Client_Flags]
  607.         _asm mov  retu ,eax
  608.     }
  610.     _RESTORE_CLIENT_STATE(saveregs)
  611.     
  612.     _MICRO_V86MMGR_FREE_BUFFER_NOTCOPIED(hvm,pClStru,dwBytesCopied);
  614.     if(!(retu&1))
  615.     {
  616.         return 1;
  617.     }
  619. Loc_ret_Failed:
  620.     return 0;
  621. }
  624. int IsInt13ExtentHere(
  625.                       UCHAR nDiskNumber          //0~5;
  626.                       )
  627. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  628.     Routine Description:
  630.         Check if the Disk which specified by nDiskNumber support int 13h extent,
  631.         using bios int 13h.
  633.     Arguments:
  635.         nDiskNumber -- 0~5.
  637.     Return Value:
  638.         
  639.         if Int 13h exsist return 1,else return 0.
  641.     **********************
  642.     
  643.     
  644. -------------------------------------------------------*/
  645. {
  646.     UCHAR DiskIDs[6] = {0x80,0x81,0x82,0x83,0x84,0x85};
  647.     UCHAR nDisk;
  648.     CLIENT_STRUCT saveregs; 
  649.     CLIENT_STRUCT *pClStru;
  650.     struct cb_s * hvm;
  653.     if(nDiskNumber > 5 )
  654.     {
  655.         return 0;
  656.     }
  657.     nDisk = DiskIDs[nDiskNumber];
  659.     hvm = (struct cb_s *)Get_Cur_VM_Handle();
  660.     pClStru = (CLIENT_STRUCT *)hvm->CB_Client_Pointer;
  662.     _SAVE_CLIENT_STATE(saveregs)    
  664.     pClStru->CBRS.Client_AH =  0x41;
  665.     pClStru->CWRS.Client_BX =  0x55AA;
  666.     pClStru->CBRS.Client_DL = nDisk;
  668.     _CALL_INT13_V86_(hvm,pClStru)
  670.     _asm{
  671.         mov edx,pClStru;
  672.         mov ax,[edx.Client_Flags]
  673.         mov bx,[edx.Client_BX]
  674.         mov cx,[edx.Client_CX]
  675.     }
  677.     _RESTORE_CLIENT_STATE(saveregs)
  678.     
  679.     _asm
  680.     {
  681.         test ax,1
  682.         jnz loc_error
  683.         xor BX,0xAA55
  684.         JNZ loc_error
  685.         test cx,1
  686.         jnz loc_i13EHere
  687.     }
  688. loc_error:
  689.     return 0;
  690. loc_i13EHere:
  691.     return 1;
  692. }
  695. int absDiskReadI13Ex(
  696.                       UCHAR nDiskNumber,          //0~5;
  697.                       DISKADDRESSPACKETI13E *pAddressPacket
  698.                       )
  699. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  700.     Routine Description:
  702.         Read the Disk which specified by nDiskNumber using 
  703.     bios int 13h extent function 42h.
  705.     Arguments:
  707.         nDiskNumber -- Disk ID,0-5 for   Fixed hardDisk.
  708.         pAddressPacket -- pointer for DISKADDRESSPACKETI13E.
  710.     Return Value:
  711.         
  712.         if all thing ok return 1,else return 0.
  714.     **********************
  715.     
  716.     
  717. -------------------------------------------------------*/
  718. {
  719.     
  720.     UCHAR DiskIDs[6] = {0x80,0x81,0x82,0x83,0x84,0x85};
  721.     CLIENT_STRUCT saveregs; 
  722.     CLIENT_STRUCT *pClStru;
  723.     struct cb_s * hvm;
  724.     DWORD PacketFarPtrBuffer = 0;
  725.     DWORD SizeOfAddrPacket  = 0;
  726.     DWORD PacketBuffAllocateNum = 0;
  727.     DWORD DataFarPtrBuffer = 0;
  728.     DWORD DataBuffAllocateNum = 0;
  729.     DWORD dwAssumBuffLen = 0;
  730.     DWORD pDataBuffer = 0;
  732.     int retcode = 1;
  733.     if(nDiskNumber > 5 )
  734.     {
  735.         return 0;
  736.     }
  737.     UCHAR nDisk = DiskIDs[nDiskNumber];
  738.     dwAssumBuffLen = 512 * (pAddressPacket->BlockCount);
  739.     SizeOfAddrPacket =sizeof(DISKADDRESSPACKETI13E);
  740.     
  741.     //
  742.     //Save the procted mode address.
  743.     //
  744.     pDataBuffer = pAddressPacket->BufferAddr;
  746.     hvm = (struct cb_s *)Get_Cur_VM_Handle();
  747.     pClStru = (CLIENT_STRUCT *)hvm->CB_Client_Pointer;
  749.     
  750.     //
  751.     //Allocated the FarBuffer which below 1MB for data
  752.     //
  753.     _MICRO_V86MMGR_ALLOCATE_BUFFER_NOTCOPIED(hvm,
  754.         pClStru,
  755.         dwAssumBuffLen, //<--number of bytes to allocate.
  756.         DataBuffAllocateNum,//<--Allocate 
  757.         DataFarPtrBuffer);
  758.     _asm jc Loc_DataAddr_Failed;
  760.     pAddressPacket->BufferAddr = DataFarPtrBuffer;
  763.     //
  764.     //Allocated the FarBuffer which below 1MB for addressPacket,
  765.     //and Copy the data to it.
  766.     //
  767.     _MICRO_V86MMGR_ALLOCATE_BUFFER_COPIED(hvm,
  768.         pClStru,
  769.         pAddressPacket,
  770.         SizeOfAddrPacket,
  771.         PacketBuffAllocateNum,
  772.         PacketFarPtrBuffer);
  773.     _asm jc Loc_PackAddr_Failed ;
  775.     
  776.     _SAVE_CLIENT_STATE(saveregs)    
  777.     //
  778.     //fill int ext entries.
  779.     //
  780.     pClStru->CBRS.Client_AH = 0x42 ;
  781.     pClStru->CBRS.Client_DL = nDisk;
  782.     pClStru->CRS.Client_DS = HIWORD(PacketFarPtrBuffer);
  783.     pClStru->CWRS.Client_SI = LOWORD(PacketFarPtrBuffer);
  785.     _CALL_INT13_V86_(hvm,pClStru)
  786.     
  787.     retcode = pClStru->CWRS.Client_Flags;
  788.     
  789.     _RESTORE_CLIENT_STATE(saveregs)
  792.     //
  793.     //Free  the Packet  FarBuffer;
  794.     //The buffers are maintained as a stack. 
  795.     //Therefore, the last buffer allocated must 
  796.     //be the first buffer freed.
  797.     //
  798.     _MICRO_V86MMGR_FREE_BUFFER_NOTCOPIED(hvm,pClStru,PacketBuffAllocateNum);
  800.     //
  801.     //Restore the procted mode address.
  802.     //
  803.     pAddressPacket->BufferAddr = pDataBuffer;
  804.     
  805.     //
  806.     //Free and copy back the data FarBuffer.
  807.     //
  808.     _MICRO_V86MMGR_FREE_BUFFER_COPIED(hvm,pClStru,
  809.         pDataBuffer,DataBuffAllocateNum);
  811.     return !(retcode &1);
  813. Loc_DataAddr_Failed:
  814.     return 0;
  816. Loc_PackAddr_Failed:
  817.     _MICRO_V86MMGR_FREE_BUFFER_NOTCOPIED(hvm,pClStru,DataFarPtrBuffer);
  818.     return 0;
  819.     
  821. }
  823. int absDiskWriteI13Ex( 
  824.                       UCHAR nDiskNumber,          //0~5;
  825.                       DISKADDRESSPACKETI13E *pAddressPacket
  826.                       )
  827. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++
  828.     Routine Description:
  830.         Write the Disk which specified by nDiskNumber using 
  831.     bios int 13h extent function 43h.
  833.     Arguments:
  835.         nDiskNumber -- Disk ID,0-5 for   Fixed hardDisk.
  836.         pAddressPacket -- pointer for DISKADDRESSPACKETI13E.
  838.     Return Value:
  839.         
  840.         if all thing ok return 1,else return 0.
  842.     **********************
  843.     
  844.     
  845. -------------------------------------------------------*/
  846. {
  849.     UCHAR DiskIDs[6] = {0x80,0x81,0x82,0x83,0x84,0x85};
  850.     CLIENT_STRUCT saveregs; 
  851.     CLIENT_STRUCT *pClStru;
  852.     struct cb_s * hvm;
  853.     DWORD PacketFarPtrBuffer = 0;
  854.     DWORD SizeOfAddrPacket  = 0;
  855.     DWORD PacketBuffAllocateNum = 0;
  856.     DWORD DataFarPtrBuffer = 0;
  857.     DWORD DataBuffAllocateNum = 0;
  858.     DWORD dwAssumBuffLen = 0;
  859.     DWORD pDataBuffer = 0;
  861.     int retcode = 1;
  862.     if(nDiskNumber > 5 )
  863.     {
  864.         return 0;
  865.     }
  866.     UCHAR nDisk = DiskIDs[nDiskNumber];
  867.     dwAssumBuffLen = 512 * (pAddressPacket->BlockCount);
  868.     SizeOfAddrPacket =sizeof(DISKADDRESSPACKETI13E);
  869.     
  870.     //
  871.     //Save the procted mode address.
  872.     //
  873.     pDataBuffer = pAddressPacket->BufferAddr;
  875.     hvm = (struct cb_s *)Get_Cur_VM_Handle();
  876.     pClStru = (CLIENT_STRUCT *)hvm->CB_Client_Pointer;
  878.     
  879.     //
  880.     //Allocated the FarBuffer which below 1MB for data
  881.     //
  882.     _MICRO_V86MMGR_ALLOCATE_BUFFER_COPIED(hvm,
  883.         pClStru,
  884.         pDataBuffer,
  885.         dwAssumBuffLen, //<--number of bytes to allocate.
  886.         DataBuffAllocateNum,//<--Allocate 
  887.         DataFarPtrBuffer);
  888.     _asm jc Loc_DataAddr_Failed;
  890.     pAddressPacket->BufferAddr = DataFarPtrBuffer;
  892.     //
  893.     //Allocated the FarBuffer for addressPacket,
  894.     //and Copy the data to it.
  895.     //
  896.     _MICRO_V86MMGR_ALLOCATE_BUFFER_COPIED(hvm,
  897.         pClStru,
  898.         pAddressPacket,
  899.         SizeOfAddrPacket,
  900.         PacketBuffAllocateNum,
  901.         PacketFarPtrBuffer);
  902.     _asm jc Loc_PackAddr_Failed ;
  904.     
  905.     _SAVE_CLIENT_STATE(saveregs)    
  906.     //
  907.     //fill int ext entries.
  908.     //
  909.     pClStru->CBRS.Client_AH = 0x43; //Extent Write.
  910.     pClStru->CBRS.Client_AL = 0 ;   //don't verify write.
  911.     pClStru->CBRS.Client_DL = nDisk;
  912.     pClStru->CRS.Client_DS = HIWORD(PacketFarPtrBuffer);
  913.     pClStru->CWRS.Client_SI = LOWORD(PacketFarPtrBuffer);
  915.     _CALL_INT13_V86_(hvm,pClStru)
  916.     
  917.     retcode = pClStru->CWRS.Client_Flags;
  918.     
  919.     _RESTORE_CLIENT_STATE(saveregs)
  922.     //
  923.     //Free  the Packet  FarBuffer;
  924.     //The buffers are maintained as a stack. 
  925.     //Therefore, the last buffer allocated must 
  926.     //be the first buffer freed.
  927.     //
  928.     _MICRO_V86MMGR_FREE_BUFFER_NOTCOPIED(hvm,pClStru,PacketBuffAllocateNum);
  930.     //
  931.     //Restore the procted mode address.
  932.     //
  933.     pAddressPacket->BufferAddr = pDataBuffer;
  934.     
  935.     //
  936.     //Free and copy back the data FarBuffer.
  937.     //
  938.     _MICRO_V86MMGR_FREE_BUFFER_NOTCOPIED(hvm,pClStru,DataBuffAllocateNum);
  940.     return !(retcode &1);
  942. Loc_DataAddr_Failed:
  943.     return 0;
  945. Loc_PackAddr_Failed:
  946.     _MICRO_V86MMGR_FREE_BUFFER_NOTCOPIED(hvm,pClStru,DataFarPtrBuffer);
  947.     return 0;
  948.     
  949. }

 

 

  1. //直接端口读写的方式来访问硬盘扇区
  2. //
  3. //       Commented codes Below that were use to Read write the harddisk with direct i/o,
  4. //Because It highly depend the hardware with the high risk of failure.
  5. //
  6. UCHAR inportb(USHORT ports)
  7. {
  8.    return READ_PORT_UCHAR((PUCHAR)ports);
  9. }
  11. VOID outportb(USHORT ports,UCHAR cchar)
  12. {
  13.     WRITE_PORT_UCHAR((PUCHAR)ports,cchar);
  14. }
  17. #define  WAIT_WHILE_BUSY /
  18.     for(i=0;i<WAITING_TIMES;i++) {/
  19.         rt = inportb((USHORT)(BasePort+7));/
  20.         if((rt&cDriveBusy)==0)/
  21.             break; /
  22.     }  /
  23.     if(i>=WAITING_TIMES) return FALSE/
  25. #define  WAIT_WHILE_BUSY_NOTREADY /
  26.     for(i=0;i<WAITING_TIMES;i++) {/
  27.         rt = inportb((USHORT)(BasePort+7));/
  28.         if(rt & cDriveERR) return FALSE;/
  29.         if((rt&cDriveBusy)==0 && (rt&cDriveReady)) break; /
  30.     }  /
  31.     if(i>=WAITING_TIMES) return FALSE/
  35. ULONG  IOReadHardDisk(PUSHORT params,USHORT idePorts,PLBASECTORSTRU  psecNum)
  36. {
  37.     
  38.     int i;
  39.     USHORT BasePort = idePorts;
  40.     UCHAR SectorCount = 1;
  41.     UCHAR SectorNum   = psecNum->LBA0_7;
  42.     UCHAR cylinderLow = psecNum->LBA8_15;
  43.     UCHAR cylinderHi  = psecNum->LBA16_23;
  44.     UCHAR hd_devSel = psecNum->LBA24_27;
  45.     
  46.     UCHAR rt = inportb((USHORT)(BasePort+7));
  47.     if(rt == 0xff || rt == 0x7f)
  48.     {
  49.         return FALSE;   //when the ide port not exsist;
  50.     }
  52.     WAIT_WHILE_BUSY;
  53.     outportb((USHORT)(BasePort+6), hd_devSel); //master or slave hard disk
  54.     WAIT_WHILE_BUSY;
  55.     if(rt&cDriveERR)
  56.     {
  57.         return FALSE;
  58.     }
  59.     outportb((USHORT)(BasePort+6), hd_devSel); //master or slave hard disk
  60.     WAIT_WHILE_BUSY;
  61.     
  62.     if(inportb((USHORT)(BasePort+7))!=0x50)
  63.         return FALSE;//HDD ready: 0101 0000
  64.     
  65.     outportb((USHORT)(BasePort+6), hd_devSel);          //master or slave hard disk
  66.     outportb((USHORT)(BasePort+2), SectorCount);            //读一个扇区  
  67.     outportb((USHORT)(BasePort+3), SectorNum);          //扇区号为1
  68.     outportb((USHORT)(BasePort+4), cylinderLow);            //要读写的柱面的低8位
  69.     outportb((USHORT)(BasePort+5), cylinderHi);         //用来存放读写柱面的高2位字节(其高6位恒为0)
  70.     outportb((USHORT)(BasePort+7), 0x20);                   //读硬盘
  71.         
  72.     for(i=0;i<WAITING_TIMES;i++) //Get HDD Status, wait until HDD not busy
  73.     {
  74.         if(inportb((USHORT)(BasePort+7))==0x58) //retrieved OK
  75.             break;
  76.     }
  77.     if(i>=WAITING_TIMES)
  78.         return FALSE;
  80.     _asm cli;
  81.     READ_PORT_BUFFER_USHORT((PUSHORT)BasePort,(PUSHORT)params,256);
  82.     _asm sti;
  83.     return TRUE;
  84. }
  86. ULONG IOWriteHardDisk(PUSHORT params,USHORT idePorts,PLBASECTORSTRU  psecNum)
  87. {
  88.     int i;
  89.     USHORT BasePort = idePorts;
  90.     UCHAR SectorCount = 1;
  91.     UCHAR SectorNum   = psecNum->LBA0_7;
  92.     UCHAR cylinderLow = psecNum->LBA8_15;
  93.     UCHAR cylinderHi  = psecNum->LBA16_23;
  94.     UCHAR hd_devSel = psecNum->LBA24_27;
  95.     
  96.     UCHAR rt = inportb((USHORT)(BasePort+7));
  97.     if(rt == 0xff || rt == 0x7f)
  98.     {
  99.         return FALSE;   //when the ide port not exsist;
  100.     }
  101.     WAIT_WHILE_BUSY;
  102.     outportb((USHORT)(BasePort+6), hd_devSel); //master or slave hard disk
  103.     WAIT_WHILE_BUSY_NOTREADY;
  105.     if(inportb((USHORT)(BasePort+7))!=0x50) return FALSE;//HDD ready: 0101 0000
  107.     outportb((USHORT)(BasePort+6), hd_devSel);          //master or slave hard disk
  108.     outportb((USHORT)(BasePort+2), SectorCount);            //读一个扇区  
  109.     outportb((USHORT)(BasePort+3), SectorNum);          //扇区号为1
  110.     outportb((USHORT)(BasePort+4), cylinderLow);            //要读写的柱面的低8位
  111.     outportb((USHORT)(BasePort+5), cylinderHi);         //用来存放读写柱面的高2位字节(其高6位恒为0)
  112.     outportb((USHORT)(BasePort+7), 0x30);                   //写硬盘
  113.     
  114.     for(i=0;i<WAITING_TIMES;i++) //Get HDD Status, wait until HDD not busy
  115.     {
  116.         if(inportb((USHORT)(BasePort+7))==0x58) //retrieved OK
  117.             break;
  118.     }
  119.     if(i>=WAITING_TIMES)
  120.         return FALSE;
  122.     _asm cli;
  123.     WRITE_PORT_BUFFER_USHORT((PUSHORT)BasePort,(PUSHORT)params,256);
  124.     _asm sti;
  126.     return TRUE;
  127. }

发表时间: 2008-12-31 00:30:00