📄 hdwsim.c
字号:
case 0xda: _asm { int 0xda }
break;
case 0xdb: _asm { int 0xdb }
break;
case 0xdc: _asm { int 0xdc }
break;
case 0xdd: _asm { int 0xdd }
break;
case 0xde: _asm { int 0xde }
break;
case 0xdf: _asm { int 0xdf }
break;
case 0xe0: _asm { int 0xe0 }
break;
case 0xe1: _asm { int 0xe1 }
break;
case 0xe2: _asm { int 0xe2 }
break;
case 0xe3: _asm { int 0xe3 }
break;
case 0xe4: _asm { int 0xe4 }
break;
case 0xe5: _asm { int 0xe5 }
break;
case 0xe6: _asm { int 0xe6 }
break;
case 0xe7: _asm { int 0xe7 }
break;
case 0xe8: _asm { int 0xe8 }
break;
case 0xe9: _asm { int 0xe9 }
break;
case 0xea: _asm { int 0xea }
break;
case 0xeb: _asm { int 0xeb }
break;
case 0xec: _asm { int 0xec }
break;
case 0xed: _asm { int 0xed }
break;
case 0xee: _asm { int 0xee }
break;
case 0xef: _asm { int 0xef }
break;
case 0xf0: _asm { int 0xf0 }
break;
case 0xf1: _asm { int 0xf1 }
break;
case 0xf2: _asm { int 0xf2 }
break;
case 0xf3: _asm { int 0xf3 }
break;
case 0xf4: _asm { int 0xf4 }
break;
case 0xf5: _asm { int 0xf5 }
break;
case 0xf6: _asm { int 0xf6 }
break;
case 0xf7: _asm { int 0xf7 }
break;
case 0xf8: _asm { int 0xf8 }
break;
case 0xf9: _asm { int 0xf9 }
break;
case 0xfa: _asm { int 0xfa }
break;
case 0xfb: _asm { int 0xfb }
break;
case 0xfc: _asm { int 0xfc }
break;
case 0xfd: _asm { int 0xfd }
break;
case 0xfe: _asm { int 0xfe }
break;
case 0xff: _asm { int 0xff }
break;
}
}
/****************************************************************************
Function:
HdwSimDeviceControl
Arguments:
Description:
Returns:
*****************************************************************************/
NTSTATUS HdwSimDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp )
{
NTSTATUS ret = STATUS_SUCCESS;
PIO_STACK_LOCATION irpStack;
HDW_SIM_DATA_OUTPUT *pOutBuffer;
HDW_SIM_DATA_INPUT *pInBuffer;
PHDW_SIM_DEVICE_EXTENSION extension;
NTSTATUS status;
extension = DeviceObject->DeviceExtension;
if(extension->debugMask & (DEBUGMASK_TRACE_IOCTLS | DEBUGMASK_TRACE_REGISTERS))
{ /* trace */
KdPrint( ("%s Device Control!!\n", DBG_MSG_HDR) );
} /* trace */
irpStack = IoGetCurrentIrpStackLocation(Irp);
pInBuffer = (HDW_SIM_DATA_INPUT *)Irp->AssociatedIrp.SystemBuffer; // for buffered i/o
pOutBuffer = (HDW_SIM_DATA_OUTPUT *)Irp->AssociatedIrp.SystemBuffer; // for buffered i/o
switch(irpStack->Parameters.DeviceIoControl.IoControlCode)
{
case IOCTL_HDW_SIM_SET_TRACE:
KdPrint( ("%s Device Control -- enter IOCTL_HDW_SIM_SET_TRACE\n", DBG_MSG_HDR) );
extension->debugMask = pInBuffer->mask.value;
Irp->IoStatus.Information = 0;
break;
case IOCTL_HDW_SIM_GET_TRACE:
if(extension->debugMask & DEBUGMASK_TRACE_IOCTLS)
{ /* trace */
KdPrint( ("%s Device Control -- enter IOCTL_HDW_SIM_GET_TRACE\n", DBG_MSG_HDR) );
} /* trace */
pOutBuffer->mask.value = extension->debugMask;
Irp->IoStatus.Information = 0;
break;
case IOCTL_HDW_SIM_INITIALIZE:
if(extension->debugMask & DEBUGMASK_TRACE_IOCTLS)
{ /* trace */
KdPrint( ("%s Device Control -- enter IOCTL_HDW_SIM_INITIALIZE\n", DBG_MSG_HDR) );
} /* trace */
Irp->IoStatus.Information = 0;
break;
case IOCTL_HDW_SIM_SET_INTR:
if(extension->debugMask & DEBUGMASK_TRACE_IOCTLS)
{ /* trace */
KdPrint( ("%s Device Control -- enter IOCTL_HDW_SIM_SET_INTR\n", DBG_MSG_HDR) );
} /* trace */
extension->interrupt_Line = pInBuffer->setInterrupt.interrupt_Line ;
extension->Level = extension->interrupt_Line;
extension->Vector = extension->interrupt_Line;
extension->mappedSysVect = HalGetInterruptVector(Isa,
0, // BusNumber,
extension->Level, // Level
extension->Vector, // Vector,
&extension->irql, // IRQL
&extension->Affinity); // Affinity mask
//
// Save mapping in registry
//
ret = saveConfig( extension->ephemeralRegistryPath.Buffer,
extension->interrupt_Line,
extension->interrupt_IDT,
(VOID *)extension->pSimulatedRegisterLogicalAddress,
extension->pSimulatedRegisterPhysicalAddress
);
Irp->IoStatus.Information = 0;
break;
case IOCTL_HDW_SIM_REGS:
if(extension->debugMask & DEBUGMASK_TRACE_IOCTLS)
{ /* trace */
KdPrint( ("%s Device Control -- enter IOCTL_HDW_SIM_REGS\n", DBG_MSG_HDR) );
} /* trace */
{
HDW_SIM_REGS inBuf = pInBuffer->registers; // COPY new register contents from Ap
// they will be overwritten before we are ready for them
if(extension->debugMask & DEBUGMASK_TRACE_REGISTERS)
{ /* trace */
KdPrint(("%s Regs - inCommand inStatus inData outCommand outStatus outData\n", DBG_MSG_HDR));
KdPrint(("%s Regs - initial state = 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x \n", DBG_MSG_HDR,
extension->simulatedRegister[INDEX_inCommand ],
extension->simulatedRegister[INDEX_inStatus ],
extension->simulatedRegister[INDEX_inData ],
extension->simulatedRegister[INDEX_outCommand ],
extension->simulatedRegister[INDEX_outStatus ],
extension->simulatedRegister[INDEX_outData ]));
KdPrint(("%s Regs - specified write mask = 0x%02x \n", DBG_MSG_HDR, inBuf.writeBitmap ));
KdPrint(("%s Regs - specified = 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x \n", DBG_MSG_HDR, inBuf.registers[INDEX_inCommand ],
inBuf.registers[INDEX_inStatus ],
inBuf.registers[INDEX_inData ],
inBuf.registers[INDEX_outCommand],
inBuf.registers[INDEX_outStatus ],
inBuf.registers[INDEX_outData ]));
} /* trace */
//?? TO DO ?? get spin lock
pOutBuffer->registers.registers[INDEX_inCommand ] = extension->simulatedRegister[INDEX_inCommand ] ;
pOutBuffer->registers.registers[INDEX_inStatus ] = extension->simulatedRegister[INDEX_inStatus ] ;
pOutBuffer->registers.registers[INDEX_inData ] = extension->simulatedRegister[INDEX_inData ] ;
pOutBuffer->registers.registers[INDEX_outCommand] = extension->simulatedRegister[INDEX_outCommand ] ;
pOutBuffer->registers.registers[INDEX_outStatus ] = extension->simulatedRegister[INDEX_outStatus ] ;
pOutBuffer->registers.registers[INDEX_outData ] = extension->simulatedRegister[INDEX_outData ] ;
pOutBuffer->registers.interrupt_Line = extension->interrupt_Line;
pOutBuffer->registers.interrupt_IDT = extension->interrupt_IDT;
if (writeBitmap_inCommand & inBuf.writeBitmap)
{
extension->simulatedRegister[ INDEX_inCommand] = inBuf.registers[INDEX_inCommand];
}
if (writeBitmap_inStatus & inBuf.writeBitmap)
{
extension->simulatedRegister[ INDEX_inStatus] = inBuf.registers[INDEX_inStatus];
}
if (writeBitmap_inData & inBuf.writeBitmap)
{
extension->simulatedRegister[ INDEX_inData] = inBuf.registers[INDEX_inData];
}
if (writeBitmap_outCommand & inBuf.writeBitmap)
{
extension->simulatedRegister[ INDEX_outCommand] = inBuf.registers[INDEX_outCommand];
}
if (writeBitmap_outStatus & inBuf.writeBitmap)
{
extension->simulatedRegister[ INDEX_outStatus] = inBuf.registers[INDEX_outStatus];
}
if (writeBitmap_outData & inBuf.writeBitmap)
{
extension->simulatedRegister[ INDEX_outData] = inBuf.registers[INDEX_outData];
}
if(extension->debugMask & DEBUGMASK_TRACE_REGISTERS)
{ /* trace */
KdPrint(("%s Regs - final state = 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x \n", DBG_MSG_HDR,
extension->simulatedRegister[INDEX_inCommand ],
extension->simulatedRegister[INDEX_inStatus ],
extension->simulatedRegister[INDEX_inData ],
extension->simulatedRegister[INDEX_outCommand ],
extension->simulatedRegister[INDEX_outStatus ],
extension->simulatedRegister[INDEX_outData ]));
} /* trace */
Irp->IoStatus.Information = sizeof(HDW_SIM_REGS);
}
break;
case IOCTL_HDW_SIM_GEN_INTR:
KdPrint( ("%s Device Control -- enter IOCTL_HDW_SIM_GEN_INTR\n", DBG_MSG_HDR) );
generateInterrupt((UCHAR)extension->interrupt_IDT);
break;
default:
ret = STATUS_UNSUCCESSFUL;
}
if(extension->debugMask & DEBUGMASK_TRACE_IOCTLS)
{ /* print */
KdPrint( ("%s Device Control -- return\n", DBG_MSG_HDR) );
} /* print */
//
// Fill these in before calling IoCompleteRequest.
//
Irp->IoStatus.Status = ret;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return ret;
}
VOID HdwSimUnload( IN PDRIVER_OBJECT DriverObject)
{
UNICODE_STRING uniDosNameString;
PHDW_SIM_DEVICE_EXTENSION extension;
NTSTATUS status;
extension = DriverObject->DeviceObject->DeviceExtension;
//
// All *THIS* driver needs to do is to delete the allocated memory objects,
// the device object and the
// symbolic link between our device name and the Win32 visible name.
//
// Almost every other driver ever witten would need to do a
// significant amount of work here deallocating stuff.
//
KdPrint( ("%s Unloading!!\n", DBG_MSG_HDR) );
// ???? iterate over all deviceObjects linked to the driver object
// ExFreePool(extension->pSimulatedRegisterLogicalAddress);
//
// Free ephemeral registry entries
//
if (extension->ephemeralRegistryPath.Buffer)
{
HANDLE hKey;
//
// Free devices key
//
if (NT_SUCCESS(OpenDevicesKey(extension->ephemeralRegistryPath.Buffer, &hKey)))
{
// Delete the open key from the registry
ZwDeleteKey(hKey);
// Close object handles. A named object is not actually deleted until all
// of its valid handles are closed and no referenced pointers remain.
ZwClose(hKey);
KdPrint( ("%s Deleted ephemeral key\n", DBG_MSG_HDR) );
}
else
{
KdPrint( ("%s can't open ephemeral key\n", DBG_MSG_HDR) );
}
// ExFreePool(extension->ephemeralRegistryPath.Buffer);
}
//
// We don't need the path anymore.
//
ExFreePool(extension->parameterRegistryPath.Buffer);
ExFreePool(extension->registryPathName.Buffer);
//
// Create counted string version of our Win32 device name.
//
RtlInitUnicodeString( &uniDosNameString, DOS_DEVICE_NAME );
//
// Delete the link from our device name to a name in the Win32 namespace.
//
IoDeleteSymbolicLink( &uniDosNameString );
//
// Finally delete our device object
//
IoDeleteDevice( DriverObject->DeviceObject );
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -