
diskdump.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_DiskDumpScsiPortNotification>:
VOID
DiskDumpScsiPortNotification(IN SCSI_NOTIFICATION_TYPE NotificationType,
			     IN PVOID HwDeviceExtension,
			     ...)
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	8b 45 08             	mov    0x8(%ebp),%eax
  if (NotificationType == RequestComplete)
   11006:	85 c0                	test   %eax,%eax
   11008:	75 09                	jne    11013 <_DiskDumpScsiPortNotification+0x13>
    {
      IrqComplete = TRUE;
   1100a:	c6 05 e8 40 01 00 01 	movb   $0x1,0x140e8
    }
  if (NotificationType == NextRequest)
    {
      IrqNextRequest = TRUE;
    }
}
   11011:	5d                   	pop    %ebp
   11012:	c3                   	ret    
   11013:	48                   	dec    %eax
   11014:	75 fb                	jne    11011 <_DiskDumpScsiPortNotification+0x11>
   11016:	c6 05 f8 40 01 00 01 	movb   $0x1,0x140f8
   1101d:	5d                   	pop    %ebp
   1101e:	c3                   	ret    
   1101f:	90                   	nop    

00011020 <_DiskDumpScsiInvalid>:

VOID
DiskDumpScsiInvalid(VOID)
{
   11020:	55                   	push   %ebp
   11021:	89 e5                	mov    %esp,%ebp
   11023:	83 ec 14             	sub    $0x14,%esp
  DbgPrint("DISKDUMP: Error: Miniport called a function not supported at dump time.\n");
   11026:	68 94 31 01 00       	push   $0x13194
   1102b:	e8 30 06 00 00       	call   11660 <_DbgPrint>
  KeBugCheck(0);
   11030:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11037:	e8 d4 05 00 00       	call   11610 <_KeBugCheck@4>
   1103c:	c9                   	leave  
   1103d:	c3                   	ret    
   1103e:	89 f6                	mov    %esi,%esi

00011040 <_DiskDumpBuildRequest@12>:
}

VOID STDCALL
DiskDumpBuildRequest(LARGE_INTEGER StartingOffset, PMDL Mdl)
{
   11040:	55                   	push   %ebp
  LARGE_INTEGER StartingBlock;
  PSCSI_REQUEST_BLOCK Srb;
  PCDB Cdb;
  ULONG LogicalBlockAddress;
  USHORT TransferBlocks;

  /* Calculate logical block address */
  StartingBlock.QuadPart = StartingOffset.QuadPart >> CoreDumpClass2DeviceExtension->SectorShift;
   11041:	31 c9                	xor    %ecx,%ecx
   11043:	89 e5                	mov    %esp,%ebp
   11045:	56                   	push   %esi
   11046:	53                   	push   %ebx
   11047:	83 ec 10             	sub    $0x10,%esp
   1104a:	8b 15 88 40 01 00    	mov    0x14088,%edx
   11050:	8b 75 0c             	mov    0xc(%ebp),%esi
   11053:	8b 5d 08             	mov    0x8(%ebp),%ebx
   11056:	8a 8a c0 00 00 00    	mov    0xc0(%edx),%cl
   1105c:	0f ad f3             	shrd   %cl,%esi,%ebx
   1105f:	d3 fe                	sar    %cl,%esi
   11061:	83 e1 20             	and    $0x20,%ecx
   11064:	74 02                	je     11068 <_DiskDumpBuildRequest@12+0x28>
   11066:	89 f3                	mov    %esi,%ebx
  LogicalBlockAddress = (ULONG)StartingBlock.u.LowPart;

  DPRINT("Logical block address: %lu\n", LogicalBlockAddress);

  /* Allocate and initialize an SRB */
  Srb = &CoreDumpSrb;

  Srb->SrbFlags = 0;
   11068:	c7 05 14 40 01 00 00 	movl   $0x0,0x14014
   1106f:	00 00 00 
  Srb->Length = sizeof(SCSI_REQUEST_BLOCK); //SCSI_REQUEST_BLOCK_SIZE;
  Srb->OriginalRequest = NULL;
   11072:	c7 05 2c 40 01 00 00 	movl   $0x0,0x1402c
   11079:	00 00 00 
   1107c:	66 c7 05 08 40 01 00 	movw   $0x40,0x14008
   11083:	40 00 
   11085:	89 5d f4             	mov    %ebx,0xfffffff4(%ebp)
  Srb->PathId = CoreDumpClass2DeviceExtension->PathId;
   11088:	8a 82 bd 00 00 00    	mov    0xbd(%edx),%al
   1108e:	a2 0d 40 01 00       	mov    %al,0x1400d
  Srb->TargetId = CoreDumpClass2DeviceExtension->TargetId;
   11093:	8a 82 be 00 00 00    	mov    0xbe(%edx),%al
   11099:	a2 0e 40 01 00       	mov    %al,0x1400e
  Srb->Lun = CoreDumpClass2DeviceExtension->Lun;
   1109e:	8a 82 bf 00 00 00    	mov    0xbf(%edx),%al
  Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
   110a4:	c6 05 0a 40 01 00 00 	movb   $0x0,0x1400a
   110ab:	a2 0f 40 01 00       	mov    %al,0x1400f
  Srb->DataBuffer = Mdl->MappedSystemVa;
   110b0:	8b 45 10             	mov    0x10(%ebp),%eax
  Srb->DataTransferLength = PAGE_SIZE;
  Srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
  Srb->QueueSortKey = LogicalBlockAddress;
   110b3:	89 1d 34 40 01 00    	mov    %ebx,0x14034
   110b9:	c7 05 18 40 01 00 00 	movl   $0x1000,0x14018
   110c0:	10 00 00 
   110c3:	8b 40 0c             	mov    0xc(%eax),%eax
   110c6:	c6 05 11 40 01 00 20 	movb   $0x20,0x14011

  Srb->SenseInfoBuffer = DiskDumpSenseData;
  Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
   110cd:	c6 05 13 40 01 00 12 	movb   $0x12,0x14013
   110d4:	a3 20 40 01 00       	mov    %eax,0x14020

  Srb->TimeOutValue =
   110d9:	8b 42 50             	mov    0x50(%edx),%eax
   110dc:	c7 05 24 40 01 00 c8 	movl   $0x140c8,0x14024
   110e3:	40 01 00 
   110e6:	a3 1c 40 01 00       	mov    %eax,0x1401c
    ((Srb->DataTransferLength + 0xFFFF) >> 16) * CoreDumpClass2DeviceExtension->TimeOutValue;

  Srb->SrbStatus = SRB_STATUS_SUCCESS;
  Srb->ScsiStatus = 0;
  Srb->NextSrb = 0;

  Srb->CdbLength = 10;
  Cdb = (PCDB)Srb->Cdb;

  /* Initialize ATAPI packet (12 bytes) */
  RtlZeroMemory(Cdb, MAXIMUM_CDB_SIZE);
   110eb:	52                   	push   %edx
   110ec:	c6 05 0b 40 01 00 01 	movb   $0x1,0x1400b
   110f3:	52                   	push   %edx
   110f4:	c6 05 0c 40 01 00 00 	movb   $0x0,0x1400c
   110fb:	6a 0c                	push   $0xc
   110fd:	c7 05 28 40 01 00 00 	movl   $0x0,0x14028
   11104:	00 00 00 
   11107:	c6 05 12 40 01 00 0a 	movb   $0xa,0x14012
   1110e:	68 38 40 01 00       	push   $0x14038
   11113:	e8 08 05 00 00       	call   11620 <_RtlZeroMemory@8>

  Cdb->CDB10.LogicalUnitNumber = CoreDumpClass2DeviceExtension->Lun;
   11118:	8b 0d 88 40 01 00    	mov    0x14088,%ecx
   1111e:	a0 39 40 01 00       	mov    0x14039,%al
   11123:	8a 91 bf 00 00 00    	mov    0xbf(%ecx),%dl
   11129:	c1 e2 05             	shl    $0x5,%edx
   1112c:	83 e0 1f             	and    $0x1f,%eax
   1112f:	09 d0                	or     %edx,%eax
   11131:	bb 00 10 00 00       	mov    $0x1000,%ebx
   11136:	a2 39 40 01 00       	mov    %al,0x14039
  TransferBlocks = (USHORT)(PAGE_SIZE >> 
			    CoreDumpClass2DeviceExtension->SectorShift);

  /* Copy little endian values into CDB in big endian format */
  Cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte3;
   1113b:	8a 45 f7             	mov    0xfffffff7(%ebp),%al
   1113e:	8a 89 c0 00 00 00    	mov    0xc0(%ecx),%cl
   11144:	a2 3a 40 01 00       	mov    %al,0x1403a
   11149:	81 e1 ff 00 00 00    	and    $0xff,%ecx
  Cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte2;
   1114f:	8a 45 f6             	mov    0xfffffff6(%ebp),%al
   11152:	d3 fb                	sar    %cl,%ebx
   11154:	a2 3b 40 01 00       	mov    %al,0x1403b
  Cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte1;
   11159:	8a 45 f5             	mov    0xfffffff5(%ebp),%al
   1115c:	66 89 5d f2          	mov    %bx,0xfffffff2(%ebp)
   11160:	a2 3c 40 01 00       	mov    %al,0x1403c
  Cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&LogicalBlockAddress)->Byte0;
   11165:	8a 45 f4             	mov    0xfffffff4(%ebp),%al

  Cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&TransferBlocks)->Byte1;
  Cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&TransferBlocks)->Byte0;


  /* Write Command. */
  Srb->SrbFlags |= SRB_FLAGS_DATA_OUT;
  Cdb->CDB10.OperationCode = SCSIOP_WRITE;
   11168:	c6 05 38 40 01 00 2a 	movb   $0x2a,0x14038
   1116f:	a2 3d 40 01 00       	mov    %al,0x1403d
   11174:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11177:	a2 3f 40 01 00       	mov    %al,0x1403f
   1117c:	8a 45 f2             	mov    0xfffffff2(%ebp),%al
   1117f:	a2 40 40 01 00       	mov    %al,0x14040
   11184:	a1 14 40 01 00       	mov    0x14014,%eax
   11189:	0c 80                	or     $0x80,%al
   1118b:	a3 14 40 01 00       	mov    %eax,0x14014
   11190:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11193:	5b                   	pop    %ebx
   11194:	5e                   	pop    %esi
   11195:	5d                   	pop    %ebp
   11196:	c2 0c 00             	ret    $0xc
   11199:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000111a0 <_DiskDumpIsr@8>:

  /* Leave caching disabled. */
}

BOOLEAN STDCALL
DiskDumpIsr(PKINTERRUPT Interrupt, PVOID ServiceContext)
{
   111a0:	55                   	push   %ebp
   111a1:	89 e5                	mov    %esp,%ebp
   111a3:	83 ec 14             	sub    $0x14,%esp
  if (!CoreDumpPortDeviceExtension->HwInterrupt(&CoreDumpPortDeviceExtension->MiniPortDeviceExtension))
   111a6:	8b 15 a8 40 01 00    	mov    0x140a8,%edx
   111ac:	8d 82 8c 00 00 00    	lea    0x8c(%edx),%eax
   111b2:	50                   	push   %eax
   111b3:	ff 52 4c             	call   *0x4c(%edx)
   111b6:	83 c4 0c             	add    $0xc,%esp
    {
      return(FALSE);
   111b9:	84 c0                	test   %al,%al
   111bb:	0f 95 c0             	setne  %al
   111be:	25 ff 00 00 00       	and    $0xff,%eax
    }
  return(TRUE);
}
   111c3:	c9                   	leave  
   111c4:	c2 08 00             	ret    $0x8
   111c7:	89 f6                	mov    %esi,%esi
   111c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000111d0 <_DiskDumpInit@0>:

NTSTATUS STDCALL
DiskDumpInit(VOID)
{
   111d0:	55                   	push   %ebp
   111d1:	89 e5                	mov    %esp,%ebp
   111d3:	51                   	push   %ecx
   111d4:	51                   	push   %ecx
  KIRQL CurrentIrql = KeGetCurrentIrql();
   111d5:	e8 96 04 00 00       	call   11670 <_KeGetCurrentIrql@0>
  IsDumping = TRUE;
  if (CurrentIrql >= CoreDumpPortDeviceExtension->Interrupt->SynchLevel)
   111da:	8b 15 a8 40 01 00    	mov    0x140a8,%edx
   111e0:	c6 05 00 40 01 00 01 	movb   $0x1,0x14000
   111e7:	8b 52 18             	mov    0x18(%edx),%edx
   111ea:	38 42 25             	cmp    %al,0x25(%edx)
   111ed:	76 0b                	jbe    111fa <_DiskDumpInit@0+0x2a>
    {
      DbgPrint("DISKDUMP: Error: Crash inside high priority interrupt routine.\n");
      return(STATUS_UNSUCCESSFUL);
    }  
  CoreDumpPortDeviceExtension->Interrupt->ServiceRoutine = DiskDumpIsr;
   111ef:	c7 42 14 a0 11 01 00 	movl   $0x111a0,0x14(%edx)
  
  return(STATUS_SUCCESS);
   111f6:	31 c0                	xor    %eax,%eax
}
   111f8:	c9                   	leave  
   111f9:	c3                   	ret    
   111fa:	83 ec 0c             	sub    $0xc,%esp
   111fd:	68 e0 31 01 00       	push   $0x131e0
   11202:	e8 59 04 00 00       	call   11660 <_DbgPrint>
   11207:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   1120c:	c9                   	leave  
   1120d:	c3                   	ret    
   1120e:	89 f6                	mov    %esi,%esi

00011210 <_DiskDumpFinish@0>:

NTSTATUS STDCALL
DiskDumpFinish(VOID)
{
   11210:	55                   	push   %ebp
  return(STATUS_SUCCESS);
}
   11211:	31 c0                	xor    %eax,%eax
   11213:	89 e5                	mov    %esp,%ebp
   11215:	5d                   	pop    %ebp
   11216:	c3                   	ret    
   11217:	89 f6                	mov    %esi,%esi
   11219:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011220 <_DiskDumpWrite@12>:

NTSTATUS STDCALL
DiskDumpWrite(LARGE_INTEGER Address, PMDL Mdl)
{
   11220:	55                   	push   %ebp
   11221:	89 e5                	mov    %esp,%ebp
   11223:	57                   	push   %edi
   11224:	56                   	push   %esi
   11225:	53                   	push   %ebx
   11226:	83 ec 0c             	sub    $0xc,%esp
   11229:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1122c:	8b 75 0c             	mov    0xc(%ebp),%esi
  KIRQL OldIrql, OldIrql2;
  KIRQL CurrentIrql = KeGetCurrentIrql();
   1122f:	e8 3c 04 00 00       	call   11670 <_KeGetCurrentIrql@0>

  if (CurrentIrql < (CoreDumpPortDeviceExtension->Interrupt->SynchLevel - 1))
   11234:	88 c2                	mov    %al,%dl
   11236:	89 c7                	mov    %eax,%edi
   11238:	a1 a8 40 01 00       	mov    0x140a8,%eax
   1123d:	81 e2 ff 00 00 00    	and    $0xff,%edx
   11243:	8b 48 18             	mov    0x18(%eax),%ecx
   11246:	31 c0                	xor    %eax,%eax
   11248:	8a 41 25             	mov    0x25(%ecx),%al
   1124b:	48                   	dec    %eax
   1124c:	39 c2                	cmp    %eax,%edx
   1124e:	0f 8c d4 00 00 00    	jl     11328 <_DiskDumpWrite@12+0x108>
    {
      KeRaiseIrql(CoreDumpPortDeviceExtension->Interrupt->SynchLevel - 1, &OldIrql);
    }  

  /* Adjust the address for the start of the partition. */
  Address.QuadPart +=
   11254:	8b 0d 88 40 01 00    	mov    0x14088,%ecx
   1125a:	31 d2                	xor    %edx,%edx
   1125c:	8b 41 18             	mov    0x18(%ecx),%eax
   1125f:	03 41 10             	add    0x10(%ecx),%eax
   11262:	13 51 14             	adc    0x14(%ecx),%edx
   11265:	01 c3                	add    %eax,%ebx
   11267:	11 d6                	adc    %edx,%esi
    (CoreDumpClass2DeviceExtension->StartingOffset.QuadPart + CoreDumpClass2DeviceExtension->DMByteSkew);

  /* Assume the device is always able to transfer a page so no need to split up the transfer. */

  /* Build an SRB to describe the write. */
  DiskDumpBuildRequest(Address, Mdl);
   11269:	50                   	push   %eax
   1126a:	8b 45 10             	mov    0x10(%ebp),%eax
   1126d:	50                   	push   %eax
   1126e:	56                   	push   %esi
   1126f:	53                   	push   %ebx
   11270:	e8 cb fd ff ff       	call   11040 <_DiskDumpBuildRequest@12>

  /* Start i/o on the HBA. */
  IrqComplete = IrqNextRequest = FALSE;
   11275:	c6 05 f8 40 01 00 00 	movb   $0x0,0x140f8
   1127c:	c6 05 e8 40 01 00 00 	movb   $0x0,0x140e8
  KeRaiseIrql(CoreDumpPortDeviceExtension->Interrupt->SynchLevel, &OldIrql2);
   11283:	50                   	push   %eax
   11284:	8d 45 f2             	lea    0xfffffff2(%ebp),%eax
   11287:	50                   	push   %eax
   11288:	a1 a8 40 01 00       	mov    0x140a8,%eax
   1128d:	8b 40 18             	mov    0x18(%eax),%eax
   11290:	8a 40 25             	mov    0x25(%eax),%al
   11293:	25 ff 00 00 00       	and    $0xff,%eax
   11298:	50                   	push   %eax
   11299:	e8 e2 03 00 00       	call   11680 <_KeRaiseIrql@8>
  if (!CoreDumpPortDeviceExtension->HwStartIo(&CoreDumpPortDeviceExtension->MiniPortDeviceExtension,
   1129e:	8b 15 a8 40 01 00    	mov    0x140a8,%edx
   112a4:	68 08 40 01 00       	push   $0x14008
   112a9:	8d 82 8c 00 00 00    	lea    0x8c(%edx),%eax
   112af:	50                   	push   %eax
   112b0:	ff 52 48             	call   *0x48(%edx)
   112b3:	5b                   	pop    %ebx
   112b4:	84 c0                	test   %al,%al
   112b6:	5e                   	pop    %esi
   112b7:	0f 84 ae 00 00 00    	je     1136b <_DiskDumpWrite@12+0x14b>
					      &CoreDumpSrb))
    {
      KeLowerIrql(OldIrql);
      DbgPrint("DISKDUMP: Error: Miniport HwStartIo failed.\n");
      return(STATUS_UNSUCCESSFUL);
    }
  KeLowerIrql(OldIrql2);
   112bd:	83 ec 0c             	sub    $0xc,%esp
   112c0:	31 c0                	xor    %eax,%eax
   112c2:	8a 45 f2             	mov    0xfffffff2(%ebp),%al
   112c5:	50                   	push   %eax
   112c6:	e8 c5 03 00 00       	call   11690 <_KeLowerIrql@4>

  /* Wait for the miniport to finish. */
  __asm__ ("sti\n\t");
   112cb:	fb                   	sti    
  while (!IrqComplete || !IrqNextRequest)
    {
      __asm__ ("hlt\n\t");
   112cc:	8a 15 e8 40 01 00    	mov    0x140e8,%dl
   112d2:	83 c4 0c             	add    $0xc,%esp
   112d5:	84 d2                	test   %dl,%dl
   112d7:	75 48                	jne    11321 <_DiskDumpWrite@12+0x101>
   112d9:	a0 f8 40 01 00       	mov    0x140f8,%al
   112de:	89 f6                	mov    %esi,%esi
   112e0:	f4                   	hlt    
   112e1:	84 d2                	test   %dl,%dl
   112e3:	74 fb                	je     112e0 <_DiskDumpWrite@12+0xc0>
   112e5:	84 c0                	test   %al,%al
   112e7:	74 f7                	je     112e0 <_DiskDumpWrite@12+0xc0>
    }  
  if (CurrentIrql < (CoreDumpPortDeviceExtension->Interrupt->SynchLevel - 1))
   112e9:	a1 a8 40 01 00       	mov    0x140a8,%eax
   112ee:	89 fa                	mov    %edi,%edx
   112f0:	81 e2 ff 00 00 00    	and    $0xff,%edx
   112f6:	8b 40 18             	mov    0x18(%eax),%eax
   112f9:	8a 40 25             	mov    0x25(%eax),%al
   112fc:	25 ff 00 00 00       	and    $0xff,%eax
   11301:	48                   	dec    %eax
   11302:	39 c2                	cmp    %eax,%edx
   11304:	7c 3e                	jl     11344 <_DiskDumpWrite@12+0x124>
    {
      KeLowerIrql(OldIrql);
    }
  __asm__("cli\n\t");
   11306:	fa                   	cli    

  /* Check the result. */
  if (SRB_STATUS(CoreDumpSrb.SrbStatus) != SRB_STATUS_SUCCESS)
   11307:	31 c0                	xor    %eax,%eax
    {
      DbgPrint("DISKDUMP: Error: SRB failed.\n");
      return(STATUS_UNSUCCESSFUL);
    }
  return(STATUS_SUCCESS);
   11309:	31 d2                	xor    %edx,%edx
   1130b:	a0 0b 40 01 00       	mov    0x1400b,%al
   11310:	24 3f                	and    $0x3f,%al
   11312:	48                   	dec    %eax
   11313:	75 42                	jne    11357 <_DiskDumpWrite@12+0x137>
}
   11315:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11318:	89 d0                	mov    %edx,%eax
   1131a:	5b                   	pop    %ebx
   1131b:	5e                   	pop    %esi
   1131c:	5f                   	pop    %edi
   1131d:	5d                   	pop    %ebp
   1131e:	c2 0c 00             	ret    $0xc
   11321:	a0 f8 40 01 00       	mov    0x140f8,%al
   11326:	eb bd                	jmp    112e5 <_DiskDumpWrite@12+0xc5>
   11328:	50                   	push   %eax
   11329:	50                   	push   %eax
   1132a:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1132d:	50                   	push   %eax
   1132e:	8a 41 25             	mov    0x25(%ecx),%al
   11331:	48                   	dec    %eax
   11332:	25 ff 00 00 00       	and    $0xff,%eax
   11337:	50                   	push   %eax
   11338:	e8 43 03 00 00       	call   11680 <_KeRaiseIrql@8>
   1133d:	58                   	pop    %eax
   1133e:	5a                   	pop    %edx
   1133f:	e9 10 ff ff ff       	jmp    11254 <_DiskDumpWrite@12+0x34>
   11344:	83 ec 0c             	sub    $0xc,%esp
   11347:	31 c0                	xor    %eax,%eax
   11349:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   1134c:	50                   	push   %eax
   1134d:	e8 3e 03 00 00       	call   11690 <_KeLowerIrql@4>
   11352:	83 c4 0c             	add    $0xc,%esp
   11355:	eb af                	jmp    11306 <_DiskDumpWrite@12+0xe6>
   11357:	83 ec 0c             	sub    $0xc,%esp
   1135a:	68 20 32 01 00       	push   $0x13220
   1135f:	e8 fc 02 00 00       	call   11660 <_DbgPrint>
   11364:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   11369:	eb aa                	jmp    11315 <_DiskDumpWrite@12+0xf5>
   1136b:	83 ec 0c             	sub    $0xc,%esp
   1136e:	31 c0                	xor    %eax,%eax
   11370:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11373:	50                   	push   %eax
   11374:	e8 17 03 00 00       	call   11690 <_KeLowerIrql@4>
   11379:	68 40 32 01 00       	push   $0x13240
   1137e:	e8 dd 02 00 00       	call   11660 <_DbgPrint>
   11383:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
   11388:	eb 8b                	jmp    11315 <_DiskDumpWrite@12+0xf5>
   1138a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011390 <_DiskDumpPrepare@8>:

NTSTATUS STDCALL
DiskDumpPrepare(PDEVICE_OBJECT DeviceObject, PDUMP_POINTERS DumpPointers)
{
   11390:	55                   	push   %ebp
   11391:	89 e5                	mov    %esp,%ebp
   11393:	57                   	push   %edi
   11394:	56                   	push   %esi
   11395:	53                   	push   %ebx
   11396:	83 ec 28             	sub    $0x28,%esp
   11399:	8b 55 0c             	mov    0xc(%ebp),%edx
   1139c:	8b 4d 08             	mov    0x8(%ebp),%ecx
  PIMAGE_NT_HEADERS NtHeader;
  PVOID ImportDirectory;
  ULONG ImportDirectorySize;
  PIMAGE_IMPORT_MODULE_DIRECTORY ImportModuleDirectory;
  PVOID DriverBase;
  PCH Name;
  ULONG i;
  ULONG Hint;
  PVOID* ImportAddressList;
  PULONG FunctionNameList;

  /* Save the information from the kernel. */
  CoreDumpClassDevice = DeviceObject;
   1139f:	89 0d 78 40 01 00    	mov    %ecx,0x14078
  CoreDumpPointers = *DumpPointers;
   113a5:	8b 02                	mov    (%edx),%eax
   113a7:	a3 48 40 01 00       	mov    %eax,0x14048
   113ac:	8b 42 04             	mov    0x4(%edx),%eax
   113af:	a3 4c 40 01 00       	mov    %eax,0x1404c
   113b4:	8b 42 08             	mov    0x8(%edx),%eax
   113b7:	a3 50 40 01 00       	mov    %eax,0x14050
   113bc:	8b 42 0c             	mov    0xc(%edx),%eax
   113bf:	a3 54 40 01 00       	mov    %eax,0x14054
   113c4:	8b 42 10             	mov    0x10(%edx),%eax
   113c7:	a3 58 40 01 00       	mov    %eax,0x14058
   113cc:	8b 42 14             	mov    0x14(%edx),%eax
   113cf:	a3 5c 40 01 00       	mov    %eax,0x1405c
   113d4:	8b 42 18             	mov    0x18(%edx),%eax
   113d7:	a3 60 40 01 00       	mov    %eax,0x14060
   113dc:	8b 42 1c             	mov    0x1c(%edx),%eax
   113df:	a3 64 40 01 00       	mov    %eax,0x14064
   113e4:	8b 42 20             	mov    0x20(%edx),%eax
   113e7:	a3 68 40 01 00       	mov    %eax,0x14068
  CoreDumpClass2DeviceExtension = (PDEVICE_EXTENSION)CoreDumpClassDevice->DeviceExtension;
   113ec:	8b 41 28             	mov    0x28(%ecx),%eax
   113ef:	a3 88 40 01 00       	mov    %eax,0x14088
  CoreDumpPortDevice = DumpPointers->DeviceObject;
   113f4:	8b 42 20             	mov    0x20(%edx),%eax
   113f7:	a3 98 40 01 00       	mov    %eax,0x14098
  CoreDumpPortDeviceExtension = CoreDumpPortDevice->DeviceExtension;
   113fc:	8b 50 28             	mov    0x28(%eax),%edx

  /* Replace all the miniport driver's imports with our functions. */
  DriverBase = CoreDumpPortDevice->DriverObject->DriverStart;
   113ff:	8b 40 08             	mov    0x8(%eax),%eax
   11402:	89 15 a8 40 01 00    	mov    %edx,0x140a8
   11408:	8b 40 0c             	mov    0xc(%eax),%eax
   1140b:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
  NtHeader = RtlImageNtHeader(DriverBase);
   1140e:	50                   	push   %eax
   1140f:	e8 1c 02 00 00       	call   11630 <_RtlImageNtHeader@4>
  ImportDirectory = RtlImageDirectoryEntryToData(DriverBase,
   11414:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
   11417:	83 c4 0c             	add    $0xc,%esp
   1141a:	50                   	push   %eax
   1141b:	6a 01                	push   $0x1
   1141d:	6a 01                	push   $0x1
   1141f:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11422:	51                   	push   %ecx
   11423:	e8 18 02 00 00       	call   11640 <_RtlImageDirectoryEntryToData@16>
						 TRUE,
						 IMAGE_DIRECTORY_ENTRY_IMPORT,
						 &ImportDirectorySize);
  if (ImportDirectory == NULL || ImportDirectorySize == 0)
   11428:	85 c0                	test   %eax,%eax
   1142a:	74 07                	je     11433 <_DiskDumpPrepare@8+0xa3>
   1142c:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   1142f:	85 d2                	test   %edx,%edx
   11431:	75 1c                	jne    1144f <_DiskDumpPrepare@8+0xbf>
    {
      DbgPrint("DISKDUMP: Error: Miniport has no imports?\n");
   11433:	83 ec 0c             	sub    $0xc,%esp
   11436:	68 70 32 01 00       	push   $0x13270
      return(STATUS_UNSUCCESSFUL);
    }
  /*  Process each import module  */
  ImportModuleDirectory = (PIMAGE_IMPORT_MODULE_DIRECTORY)ImportDirectory;
  DPRINT("Processeing import directory at %p\n", ImportModuleDirectory);
  while (ImportModuleDirectory->dwRVAModuleName)
    {
      /*  Check to make sure that import lib is kernel  */
      Name = (PCHAR) DriverBase + ImportModuleDirectory->dwRVAModuleName;

      if (strcmp(Name, "scsiport.sys") != 0)
	{
	  DbgPrint("DISKDUMP: Warning: Miniport has illegal imports.\n");
	  ImportModuleDirectory++;
	  continue;
	}

      /*  Get the import address list  */
      ImportAddressList = (PVOID *) ((PUCHAR)DriverBase + 
				     ImportModuleDirectory->dwRVAFunctionAddressList);
      
      /*  Get the list of functions to import  */
      if (ImportModuleDirectory->dwRVAFunctionNameList != 0)
	{
	  FunctionNameList = (PULONG) ((PUCHAR)DriverBase + 
				       ImportModuleDirectory->dwRVAFunctionNameList);
	}
      else
	{
	  FunctionNameList = (PULONG) ((PUCHAR)DriverBase + 
				       ImportModuleDirectory->dwRVAFunctionAddressList);
	}
      /*  Walk through function list and fixup addresses  */
      while (*FunctionNameList != 0L)
	{
	  if ((*FunctionNameList) & 0x80000000) // hint
	    {
	      Name = NULL;
	      	      
	      Hint = (*FunctionNameList) & 0xffff;
	    }
	  else // hint-name
	    {
	      Name = (PCHAR)((DWORD)DriverBase + 
			      *FunctionNameList + 2);
	      Hint = *(PWORD)((DWORD)DriverBase + *FunctionNameList);
	    }
	  DPRINT("  Hint:%04x  Name:%s\n", Hint, pName);

	  for (i = 0; i < (sizeof(DiskDumpExports) / sizeof(DiskDumpExports[0])); i++)
	    {
	      if (DiskDumpExports[i].Ordinal == Hint ||
		  (Name != NULL && strcmp(DiskDumpExports[i].Name, Name) == 0))
		{
		  break;
		}
	    }
	  if (i == (sizeof(DiskDumpExports) / sizeof(DiskDumpExports[0])))
	    {
	      DbgPrint("DISKDUMP: Error: Miniport imports unknown symbol %s.\n", Name);
   1143b:	e8 20 02 00 00       	call   11660 <_DbgPrint>
	      return(STATUS_UNSUCCESSFUL);
	    }
	  if (strcmp(Name, "ScsiPortNotification") == 0)
	    {
	      OldScsiPortNotification = *ImportAddressList;
	    }
	  DiskDumpExports[i].OldFunction = *ImportAddressList;
	  if (DiskDumpExports[i].NewFunction != NULL)
	    {	      
	      *ImportAddressList = DiskDumpExports[i].NewFunction;
	    }
	  
	  ImportAddressList++;
	  FunctionNameList++;
	}
      ImportModuleDirectory++;
    }
  return(STATUS_SUCCESS);
}
   11440:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11443:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   11448:	5b                   	pop    %ebx
   11449:	5e                   	pop    %esi
   1144a:	5f                   	pop    %edi
   1144b:	5d                   	pop    %ebp
   1144c:	c2 08 00             	ret    $0x8
   1144f:	89 c2                	mov    %eax,%edx
   11451:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11454:	8b 42 0c             	mov    0xc(%edx),%eax
   11457:	85 c0                	test   %eax,%eax
   11459:	0f 84 17 01 00 00    	je     11576 <_DiskDumpPrepare@8+0x1e6>
   1145f:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11462:	bf 9b 32 01 00       	mov    $0x1329b,%edi
   11467:	fc                   	cld    
   11468:	8d 1c 08             	lea    (%eax,%ecx,1),%ebx
   1146b:	b9 0d 00 00 00       	mov    $0xd,%ecx
   11470:	89 de                	mov    %ebx,%esi
   11472:	f3 a6                	repz cmpsb %es:(%edi),%ds:(%esi)
   11474:	0f 85 1f 01 00 00    	jne    11599 <_DiskDumpPrepare@8+0x209>
   1147a:	8b 7d ec             	mov    0xffffffec(%ebp),%edi
   1147d:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11480:	8b 77 10             	mov    0x10(%edi),%esi
   11483:	01 f0                	add    %esi,%eax
   11485:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   11488:	8b 07                	mov    (%edi),%eax
   1148a:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   1148d:	85 c0                	test   %eax,%eax
   1148f:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   11492:	0f 85 ea 00 00 00    	jne    11582 <_DiskDumpPrepare@8+0x1f2>
   11498:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   1149b:	8b 01                	mov    (%ecx),%eax
   1149d:	85 c0                	test   %eax,%eax
   1149f:	0f 84 ba 00 00 00    	je     1155f <_DiskDumpPrepare@8+0x1cf>
   114a5:	85 c0                	test   %eax,%eax
   114a7:	0f 88 e2 00 00 00    	js     1158f <_DiskDumpPrepare@8+0x1ff>
   114ad:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   114b0:	01 c8                	add    %ecx,%eax
   114b2:	8d 58 02             	lea    0x2(%eax),%ebx
   114b5:	66 8b 00             	mov    (%eax),%ax
   114b8:	89 c6                	mov    %eax,%esi
   114ba:	81 e6 ff ff 00 00    	and    $0xffff,%esi
   114c0:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
   114c7:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   114ca:	c1 e0 04             	shl    $0x4,%eax
   114cd:	39 b0 24 20 01 00    	cmp    %esi,0x12024(%eax)
   114d3:	74 27                	je     114fc <_DiskDumpPrepare@8+0x16c>
   114d5:	85 db                	test   %ebx,%ebx
   114d7:	74 16                	je     114ef <_DiskDumpPrepare@8+0x15f>
   114d9:	52                   	push   %edx
   114da:	52                   	push   %edx
   114db:	53                   	push   %ebx
   114dc:	8b 80 20 20 01 00    	mov    0x12020(%eax),%eax
   114e2:	50                   	push   %eax
   114e3:	e8 68 01 00 00       	call   11650 <_strcmp>
   114e8:	83 c4 10             	add    $0x10,%esp
   114eb:	85 c0                	test   %eax,%eax
   114ed:	74 0d                	je     114fc <_DiskDumpPrepare@8+0x16c>
   114ef:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   114f2:	40                   	inc    %eax
   114f3:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   114f6:	83 7d dc 0f          	cmpl   $0xf,0xffffffdc(%ebp)
   114fa:	76 cb                	jbe    114c7 <_DiskDumpPrepare@8+0x137>
   114fc:	83 7d dc 10          	cmpl   $0x10,0xffffffdc(%ebp)
   11500:	0f 84 b1 00 00 00    	je     115b7 <_DiskDumpPrepare@8+0x227>
   11506:	b8 a1 30 01 00       	mov    $0x130a1,%eax
   1150b:	b9 15 00 00 00       	mov    $0x15,%ecx
   11510:	fc                   	cld    
   11511:	89 de                	mov    %ebx,%esi
   11513:	89 c7                	mov    %eax,%edi
   11515:	f3 a6                	repz cmpsb %es:(%edi),%ds:(%esi)
   11517:	75 0a                	jne    11523 <_DiskDumpPrepare@8+0x193>
   11519:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   1151c:	8b 02                	mov    (%edx),%eax
   1151e:	a3 10 41 01 00       	mov    %eax,0x14110
   11523:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   11526:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   11529:	c1 e2 04             	shl    $0x4,%edx
   1152c:	8b 01                	mov    (%ecx),%eax
   1152e:	89 82 28 20 01 00    	mov    %eax,0x12028(%edx)
   11534:	8b 82 2c 20 01 00    	mov    0x1202c(%edx),%eax
   1153a:	85 c0                	test   %eax,%eax
   1153c:	74 02                	je     11540 <_DiskDumpPrepare@8+0x1b0>
   1153e:	89 01                	mov    %eax,(%ecx)
   11540:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11543:	83 c0 04             	add    $0x4,%eax
   11546:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   11549:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   1154c:	83 c0 04             	add    $0x4,%eax
   1154f:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   11552:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
   11555:	8b 07                	mov    (%edi),%eax
   11557:	85 c0                	test   %eax,%eax
   11559:	0f 85 46 ff ff ff    	jne    114a5 <_DiskDumpPrepare@8+0x115>
   1155f:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11562:	83 c0 14             	add    $0x14,%eax
   11565:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11568:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   1156b:	8b 42 0c             	mov    0xc(%edx),%eax
   1156e:	85 c0                	test   %eax,%eax
   11570:	0f 85 e9 fe ff ff    	jne    1145f <_DiskDumpPrepare@8+0xcf>
   11576:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11579:	31 c0                	xor    %eax,%eax
   1157b:	5b                   	pop    %ebx
   1157c:	5e                   	pop    %esi
   1157d:	5f                   	pop    %edi
   1157e:	5d                   	pop    %ebp
   1157f:	c2 08 00             	ret    $0x8
   11582:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   11585:	01 d8                	add    %ebx,%eax
   11587:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   1158a:	e9 09 ff ff ff       	jmp    11498 <_DiskDumpPrepare@8+0x108>
   1158f:	31 db                	xor    %ebx,%ebx
   11591:	0f b7 f0             	movzwl %ax,%esi
   11594:	e9 27 ff ff ff       	jmp    114c0 <_DiskDumpPrepare@8+0x130>
   11599:	83 ec 0c             	sub    $0xc,%esp
   1159c:	68 a8 32 01 00       	push   $0x132a8
   115a1:	e8 ba 00 00 00       	call   11660 <_DbgPrint>
   115a6:	8b 7d ec             	mov    0xffffffec(%ebp),%edi
   115a9:	83 c4 10             	add    $0x10,%esp
   115ac:	83 c7 14             	add    $0x14,%edi
   115af:	89 7d ec             	mov    %edi,0xffffffec(%ebp)
   115b2:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   115b5:	eb b4                	jmp    1156b <_DiskDumpPrepare@8+0x1db>
   115b7:	50                   	push   %eax
   115b8:	50                   	push   %eax
   115b9:	53                   	push   %ebx
   115ba:	68 dc 32 01 00       	push   $0x132dc
   115bf:	e9 77 fe ff ff       	jmp    1143b <_DiskDumpPrepare@8+0xab>
   115c4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   115ca:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000115d0 <_DriverEntry@8>:

/**********************************************************************
 * NAME							EXPORTED
 *	DriverEntry
 *
 * DESCRIPTION
 *	This function initializes the driver, locates and claims 
 *	hardware resources, and creates various NT objects needed
 *	to process I/O requests.
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	DriverObject
 *		System allocated Driver Object for this driver
 *
 *	RegistryPath
 *		Name of registry driver service key
 *
 * RETURN VALUE
 *	Status
 */

NTSTATUS STDCALL
DriverEntry(IN PDRIVER_OBJECT DriverObject,
	    IN PUNICODE_STRING RegistryPath)
{
   115d0:	55                   	push   %ebp
   115d1:	89 e5                	mov    %esp,%ebp
  DiskDumpDriver = DriverObject;
   115d3:	8b 45 08             	mov    0x8(%ebp),%eax
  return(STATUS_SUCCESS);
}
   115d6:	5d                   	pop    %ebp
   115d7:	a3 b8 40 01 00       	mov    %eax,0x140b8
   115dc:	31 c0                	xor    %eax,%eax
   115de:	c2 08 00             	ret    $0x8
   115e1:	90                   	nop    
   115e2:	90                   	nop    
   115e3:	90                   	nop    
   115e4:	90                   	nop    
   115e5:	90                   	nop    
   115e6:	90                   	nop    
   115e7:	90                   	nop    
   115e8:	90                   	nop    
   115e9:	90                   	nop    
   115ea:	90                   	nop    
   115eb:	90                   	nop    
   115ec:	90                   	nop    
   115ed:	90                   	nop    
   115ee:	90                   	nop    
   115ef:	90                   	nop    

000115f0 <__DiskDumpScsiPortNotification>:
.globl __DiskDumpScsiPortNotification		
__DiskDumpScsiPortNotification:
	cmp	$0, _IsDumping
   115f0:	83 3d 00 40 01 00 00 	cmpl   $0x0,0x14000
	je	.l1
   115f7:	74 05                	je     115fe <.l1>
	jmp	_DiskDumpScsiPortNotification
   115f9:	e9 02 fa ff ff       	jmp    11000 <_DiskDumpScsiPortNotification>

000115fe <.l1>:
.l1:
	jmp	*_OldScsiPortNotification
   115fe:	ff 25 10 41 01 00    	jmp    *0x14110
.L2:	
	jmp	.L2
   11604:	eb fe                	jmp    11604 <.l1+0x6>
   11606:	90                   	nop    
   11607:	90                   	nop    
   11608:	90                   	nop    
   11609:	90                   	nop    
   1160a:	90                   	nop    
   1160b:	90                   	nop    
   1160c:	90                   	nop    
   1160d:	90                   	nop    
   1160e:	90                   	nop    
   1160f:	90                   	nop    

00011610 <_KeBugCheck@4>:
   11610:	ff 25 8c 60 01 00    	jmp    *0x1608c
   11616:	90                   	nop    
   11617:	90                   	nop    
	...

00011620 <_RtlZeroMemory@8>:
   11620:	ff 25 98 60 01 00    	jmp    *0x16098
   11626:	90                   	nop    
   11627:	90                   	nop    
	...

00011630 <_RtlImageNtHeader@4>:
   11630:	ff 25 94 60 01 00    	jmp    *0x16094
   11636:	90                   	nop    
   11637:	90                   	nop    
	...

00011640 <_RtlImageDirectoryEntryToData@16>:
   11640:	ff 25 90 60 01 00    	jmp    *0x16090
   11646:	90                   	nop    
   11647:	90                   	nop    
	...

00011650 <_strcmp>:
   11650:	ff 25 9c 60 01 00    	jmp    *0x1609c
   11656:	90                   	nop    
   11657:	90                   	nop    
	...

00011660 <_DbgPrint>:
   11660:	ff 25 88 60 01 00    	jmp    *0x16088
   11666:	90                   	nop    
   11667:	90                   	nop    
	...

00011670 <_KeGetCurrentIrql@0>:
   11670:	ff 25 74 60 01 00    	jmp    *0x16074
   11676:	90                   	nop    
   11677:	90                   	nop    
	...

00011680 <_KeRaiseIrql@8>:
   11680:	ff 25 7c 60 01 00    	jmp    *0x1607c
   11686:	90                   	nop    
   11687:	90                   	nop    
	...

00011690 <_KeLowerIrql@4>:
   11690:	ff 25 78 60 01 00    	jmp    *0x16078
   11696:	90                   	nop    
   11697:	90                   	nop    
	...

000116a0 <__CTOR_LIST__>:
   116a0:	ff                   	(bad)  
   116a1:	ff                   	(bad)  
   116a2:	ff                   	(bad)  
   116a3:	ff 00                	incl   (%eax)
   116a5:	00 00                	add    %al,(%eax)
	...

000116a8 <__DTOR_LIST__>:
   116a8:	ff                   	(bad)  
   116a9:	ff                   	(bad)  
   116aa:	ff                   	(bad)  
   116ab:	ff 00                	incl   (%eax)
   116ad:	00 00                	add    %al,(%eax)
	...
