//=============================================================================
//
// Compuware Corporation
// NuMega Lab
// 9 Townsend West
// Nashua, NH 03060 USA
//
// Copyright (c) 1998 Compuware Corporation. All Rights Reserved.
// Unpublished - rights reserved under the Copyright laws of the
// United States.
//
//=============================================================================
// RFSDIOS.C - I/O Subsystem interface for Registry File System
// Copyright (c) 1996, Compuware Corporation
// This module contains functions that are called by the IOS.
#include "ramdisk.h"
#include PAGEABLE_CODE_SEGMENT
#include PAGEABLE_DATA_SEGMENT
//BYTE Drive;
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// DoCallDown passes a request to the next lower layer. Note that the
// documentation about how to do this is totally wrong: you don't just
// add sizeof(DCB_cd_entry) to the calldown pointer, you follow a
// linked list from one calldown entry to the next.
void __declspec(naked) DoCallDown(IOP* iop)
{ // DoCallDown
_asm
{ // call down to next layer
mov ecx, [esp+4]
mov eax, [ecx]IOP.IOP_calldown_ptr
mov eax, [eax]DCB_cd_entry.DCB_cd_next
mov [ecx]IOP.IOP_calldown_ptr, eax
jmp [eax]DCB_cd_entry.DCB_cd_io_address
} // call down to next layer
} // DoCallDown
// DoCallBack handles completion of an I/O request by calling the
// previous level's callback routine.
void __declspec(naked) DoCallBack(IOP* iop)
{ // DoCallBack
_asm
{ // call back to previous layer
mov ecx, [esp+4]
sub [ecx]IOP.IOP_callback_ptr, size IOP_callback_entry
mov eax, [ecx]IOP.IOP_callback_ptr
jmp [eax]IOP_callback_entry.IOP_CB_address
} // call back to previous layer
} // DoCallBack
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Function
// RAMDISK_Aer
//
// Purpose
// Async Event Routine for RFSD
//
// Parameters
// pAep pointer to the AEP structure
//
// Return Value
// Depends on AEP subfunction.
//
// Remarks
// The function name is required by usage of the macro
// Define_Port_Driver (see regfsd.c).
//
// We handle the following AEPs:
//
// AEP_INITIALIZE: create a DDB for our virtual drive
// AEP_INQUIRY: set up a fake DCB
// AEP_CONFIG_DCB: associate drive letter and insert into
// calldown list
// AEP_BOOT_COMPLETE: signal OK
//
VOID OnRequest(IOP* iop);
int ndevices = 0; // # devices we've found
VOID __cdecl RAMDISK_Aer(AEP* pAep)
{
DCB* pDcb;
IOSDDB* pNewDDB;
ISP_ddb_create CreateDDBPacket;
ISP_calldown_insert InsertISP;
switch (pAep->AEP_func)
{
case AEP_INITIALIZE:
// Create a DDB for our "controller". This will cause IOS to send
// AEP_INQUIRY packets for each unit on the controller.
CreateDDBPacket.ISP_ddb_hdr.ISP_func = ISP_CREATE_DDB;
CreateDDBPacket.ISP_ddb_hdr.ISP_result = 0;
CreateDDBPacket.ISP_ddb_size = sizeof(IOSDDB);
CreateDDBPacket.ISP_ddb_ptr = 0;
CreateDDBPacket.ISP_ddb_flags = 0;
RAMDISK_Ilb.ILB_service_rtn((PISP)&CreateDDBPacket);
pNewDDB = (IOSDDB*)CreateDDBPacket.ISP_ddb_ptr;
pAep->AEP_result = AEP_SUCCESS;
break;
case AEP_UNINITIALIZE:
pAep->AEP_result = AEP_SUCCESS;
break;
case AEP_DEVICE_INQUIRY:
// The IOS sends this in response to the creation of the DDB. On the
// first call (DCB_unit_on_ctl == 0) we set up the supplied fake DCB
// with the parametes for our virtual drive. On subsequent calls, we
// anwer "no more devices". This terminates the inquiry.
pDcb = (DCB*)(((AEP_inquiry_device*)pAep)->AEP_i_d_dcb);
ASSERT(pDcb);
if (pDcb->DCB_unit_on_ctl == 0)
{
strcpy(pDcb->DCB_vendor_id, "ZXYZLL");
strcpy(pDcb->DCB_product_id, "VRAMDISK");
strcpy(pDcb->DCB_port_name, "VRAMDISK");
pAep->AEP_result = AEP_SUCCESS;
}
else
pAep->AEP_result = AEP_NO_MORE_DEVICES;
break;
case AEP_CONFIG_DCB:
// The IOS sends this AEP after each successful inquiry call. We
// associate the DCB with a drive letter and insert the request
// handler into the calldown chain.
pDcb = (DCB*)(((AEP_dcb_config*)pAep)->AEP_d_c_dcb);
ASSERT(pDcb);
if (!(pDcb->DCB_cmn.DCB_device_flags & DCB_DEV_PHYSICAL))
{
pAep->AEP_result = AEP_SUCCESS;
break;
}
ASSERT(memcmp(pDcb->DCB_vendor_id, "ZXYZLL", 6) == 0);
SetupDCB(pDcb);
//Drive = AssociateDriveLetter((DCB_COMMON*)pDcb);
memset(&InsertISP, 0, sizeof(InsertISP));
InsertISP.ISP_i_cd_hdr.ISP_func = ISP_INSERT_CALLDOWN;
InsertISP.ISP_i_cd_hdr.ISP_result = 0;
InsertISP.ISP_i_cd_dcb = (DCB_COMMON *)pDcb;
InsertISP.ISP_i_cd_req = OnRequest;
InsertISP.ISP_i_cd_ddb = (PDDB) (((AEP_dcb_config*)pAep)->AEP_d_c_hdr.AEP_ddb);
InsertISP.ISP_i_cd_expan_len = 0;
InsertISP.ISP_i_cd_flags = pDcb->DCB_cmn.DCB_dmd_flags | DCB_dmd_serialize;
InsertISP.ISP_i_cd_lgn = ((AEP_dcb_config*)pAep)->AEP_d_c_hdr.AEP_lgn;
RAMDISK_Ilb.ILB_service_rtn((PISP)&InsertISP);
++ndevices; // this will cause us to stay loader after next AEP_BOOT_COMPLETE
pAep->AEP_result = AEP_SUCCESS;
break;
case AEP_UNCONFIG_DCB:
pDcb = (DCB*)(((PAEP_dcb_unconfig)pAep)->AEP_d_u_dcb);
ASSERT(pDcb);
if (!(pDcb->DCB_cmn.DCB_device_flags & DCB_DEV_PHYSICAL)
|| memcmp(pDcb->DCB_vendor_id, "ZXYZLL", 6) != 0)
{
pAep->AEP_result = AEP_SUCCESS;
break;
}
--ndevices; // this will cause to unload after next AEP_BOOT_COMPLETE
ASSERT(ndevices >= 0);
pAep->AEP_result = AEP_SUCCESS;
break;
case AEP_BOOT_COMPLETE:
pAep->AEP_result = ndevices ? AEP_SUCCESS : AEP_FAILURE; // unload if no devices
break;
default:
pAep->AEP_result = AEP_FAILURE;
break;
}
}
VOID OnRequest(IOP* iop)
{ // OnRequest
#define ior iop->IOP_ior
DWORD funcode = ior.IOR_func;
PDCB dcb = (PDCB) iop->IOP_physical_dcb;
ior.IOR_status = IORS_SUCCESS; // assume it'll succeed
dcb->DCB_cmn.DCB_device_flags |= DCB_DEV_IO_ACTIVE;
switch (funcode)
{ // dispatch function processor
///////////////////////////////////////////////////////////////////////
case IOR_READ: // IOR_func == 0
{ // IOR_READ
DWORD sector = ior.IOR_start_addr[0];
PBYTE diskdata = (PBYTE) (base + sector * dcb->DCB_actual_blk_size);
ASSERT(sector < dcb->DCB_actual_sector_cnt[0]);
ASSERT(ior.IOR_start_addr[1] == 0);
if (ior.IOR_flags & IORF_SCATTER_GATHER)
{ // have scatter/gather structures
_BlockDev_Scatter_Gather* sgd = (_BlockDev_Scatter_Gather*) ior.IOR_buffer_ptr;
PBYTE memdata;
DWORD nbytes;
while ((nbytes = sgd->BD_SG_Count))
{ // for each s/g structure
memdata = (PBYTE) sgd->BD_SG_Buffer_Ptr; // linear address!
if (!(ior.IOR_flags & IORF_CHAR_COMMAND))
nbytes *= dcb->DCB_actual_blk_size;
memcpy(memdata, diskdata, nbytes);
diskdata += nbytes;
++sgd;
} // for each s/g structure
} // have scatter/gather structures
else
{ // have simple buffer address
PBYTE memdata = (PBYTE) ior.IOR_buffer_ptr;
DWORD nbytes = ior.IOR_xfer_count;
if (!(ior.IOR_flags & IORF_CHAR_COMMAND))
nbytes *= dcb->DCB_actual_blk_size;
memcpy(memdata, diskdata, nbytes);
} // have simple buffer address
break;
} // IOR_READ
///////////////////////////////////////////////////////////////////////
case IOR_WRITE: // IOR_func == 1
{ // IOR_WRITE
DWORD sector = ior.IOR_start_addr[0];
PBYTE diskdata = (PBYTE) (base + sector * dcb->DCB_actual_blk_size);
ASSERT(sector); // why is anyone rewriting the boot sector??
ASSERT(sector < dcb->DCB_actual_sector_cnt[0]);
ASSERT(ior.IOR
评论0