
msfs.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_MsfsCreate@8>:

NTSTATUS STDCALL
MsfsCreate(PDEVICE_OBJECT DeviceObject,
	   PIRP Irp)
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	57                   	push   %edi
   11004:	56                   	push   %esi
   11005:	53                   	push   %ebx
   11006:	83 ec 24             	sub    $0x24,%esp
   PIO_STACK_LOCATION IoStack;
   PFILE_OBJECT FileObject;
   PMSFS_DEVICE_EXTENSION DeviceExtension;
   PMSFS_MAILSLOT Mailslot;
   PMSFS_FCB Fcb;
   PMSFS_MAILSLOT current;
   PLIST_ENTRY current_entry;
   KIRQL oldIrql;

   DPRINT("MsfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

   IoStack = IoGetCurrentIrpStackLocation(Irp);
   11009:	8b 45 0c             	mov    0xc(%ebp),%eax
   1100c:	8b 50 60             	mov    0x60(%eax),%edx
   DeviceExtension = DeviceObject->DeviceExtension;
   1100f:	8b 45 08             	mov    0x8(%ebp),%eax
   FileObject = IoStack->FileObject;
   11012:	8b 52 18             	mov    0x18(%edx),%edx
   11015:	8b 78 28             	mov    0x28(%eax),%edi
   11018:	89 55 ec             	mov    %edx,0xffffffec(%ebp)

   DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);

   Fcb = ExAllocatePool(NonPagedPool, sizeof(MSFS_FCB));
   1101b:	6a 0c                	push   $0xc
   1101d:	6a 00                	push   $0x0
   1101f:	e8 5c 0a 00 00       	call   11a80 <_ExAllocatePool@8>
   if (Fcb == NULL)
   11024:	85 c0                	test   %eax,%eax
   11026:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11029:	5a                   	pop    %edx
   1102a:	59                   	pop    %ecx
   1102b:	0f 84 06 01 00 00    	je     11137 <_MsfsCreate@8+0x137>
     {
	Irp->IoStatus.Status = STATUS_NO_MEMORY;
	Irp->IoStatus.Information = 0;

	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	return(STATUS_NO_MEMORY);
     }

   KeLockMutex(&DeviceExtension->MailslotListLock);
   11031:	83 ec 0c             	sub    $0xc,%esp
   11034:	8d 4f 08             	lea    0x8(%edi),%ecx
   11037:	6a 00                	push   $0x0
   11039:	6a 00                	push   $0x0
   1103b:	6a 00                	push   $0x0
   1103d:	6a 06                	push   $0x6
   1103f:	89 4d e0             	mov    %ecx,0xffffffe0(%ebp)
   11042:	51                   	push   %ecx
   11043:	e8 48 0a 00 00       	call   11a90 <_KeWaitForSingleObject@20>
   current_entry = DeviceExtension->MailslotListHead.Flink;
   11048:	8b 1f                	mov    (%edi),%ebx
   while (current_entry != &DeviceExtension->MailslotListHead)
   1104a:	83 c4 0c             	add    $0xc,%esp
     {
	current = CONTAINING_RECORD(current_entry,
				    MSFS_MAILSLOT,
				    MailslotListEntry);

	if (!RtlCompareUnicodeString(&FileObject->FileName, &current->Name, TRUE))
	  {
	     break;
	  }

	current_entry = current_entry->Flink;
   1104d:	39 fb                	cmp    %edi,%ebx
   1104f:	74 2a                	je     1107b <_MsfsCreate@8+0x7b>
   11051:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11054:	83 c0 30             	add    $0x30,%eax
   11057:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   1105a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11060:	8d 73 f8             	lea    0xfffffff8(%ebx),%esi
   11063:	50                   	push   %eax
   11064:	6a 01                	push   $0x1
   11066:	56                   	push   %esi
   11067:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   1106a:	51                   	push   %ecx
   1106b:	e8 30 0a 00 00       	call   11aa0 <_RtlCompareUnicodeString@12>
   11070:	5a                   	pop    %edx
   11071:	85 c0                	test   %eax,%eax
   11073:	74 4a                	je     110bf <_MsfsCreate@8+0xbf>
   11075:	8b 1b                	mov    (%ebx),%ebx
   11077:	39 fb                	cmp    %edi,%ebx
   11079:	75 e5                	jne    11060 <_MsfsCreate@8+0x60>
     }

   if (current_entry == &DeviceExtension->MailslotListHead)
     {
	ExFreePool(Fcb);
   1107b:	83 ec 0c             	sub    $0xc,%esp
   1107e:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
   11081:	56                   	push   %esi
   11082:	e8 29 0a 00 00       	call   11ab0 <_ExFreePool@4>
	KeUnlockMutex(&DeviceExtension->MailslotListLock);
   11087:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1108e:	8b 5d e0             	mov    0xffffffe0(%ebp),%ebx
   11091:	53                   	push   %ebx
   11092:	e8 29 0a 00 00       	call   11ac0 <_KeReleaseMutex@8>

	Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
   11097:	8b 55 0c             	mov    0xc(%ebp),%edx
   1109a:	c7 42 18 01 00 00 c0 	movl   $0xc0000001,0x18(%edx)
	Irp->IoStatus.Information = 0;
   110a1:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)

	IoCompleteRequest(Irp, IO_NO_INCREMENT);
   110a8:	6a 00                	push   $0x0
   110aa:	52                   	push   %edx
   110ab:	e8 20 0a 00 00       	call   11ad0 <_IoCompleteRequest@8>

	return(STATUS_UNSUCCESSFUL);
   110b0:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
     }

   Mailslot = current;

   KeAcquireSpinLock(&Mailslot->FcbListLock, &oldIrql);
   InsertTailList(&Mailslot->FcbListHead, &Fcb->FcbListEntry);
   KeReleaseSpinLock(&Mailslot->FcbListLock, oldIrql);

   Mailslot->ReferenceCount++;

   Fcb->Mailslot = Mailslot;

   KeUnlockMutex(&DeviceExtension->MailslotListLock);

   FileObject->FsContext = Fcb;

   Irp->IoStatus.Status = STATUS_SUCCESS;
   Irp->IoStatus.Information = 0;

   IoCompleteRequest(Irp, IO_NO_INCREMENT);

   return(STATUS_SUCCESS);
}
   110b5:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   110b8:	5b                   	pop    %ebx
   110b9:	5e                   	pop    %esi
   110ba:	5f                   	pop    %edi
   110bb:	5d                   	pop    %ebp
   110bc:	c2 08 00             	ret    $0x8
   110bf:	39 fb                	cmp    %edi,%ebx
   110c1:	74 b8                	je     1107b <_MsfsCreate@8+0x7b>
   110c3:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   110c6:	8d 5e 10             	lea    0x10(%esi),%ebx
   110c9:	51                   	push   %ecx
   110ca:	51                   	push   %ecx
   110cb:	50                   	push   %eax
   110cc:	53                   	push   %ebx
   110cd:	e8 ce 0a 00 00       	call   11ba0 <_KeAcquireSpinLock@8>
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   110d2:	8d 46 14             	lea    0x14(%esi),%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   110d5:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   110d8:	8b 50 04             	mov    0x4(%eax),%edx
   110db:	89 01                	mov    %eax,(%ecx)
	Entry->Blink = OldBlink;
   110dd:	89 51 04             	mov    %edx,0x4(%ecx)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   110e0:	89 48 04             	mov    %ecx,0x4(%eax)
   110e3:	31 c0                	xor    %eax,%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
	OldBlink->Flink = Entry;
   110e5:	89 0a                	mov    %ecx,(%edx)
   110e7:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   110ea:	50                   	push   %eax
   110eb:	53                   	push   %ebx
   110ec:	e8 bf 0a 00 00       	call   11bb0 <_KeReleaseSpinLock@8>
   110f1:	8b 56 20             	mov    0x20(%esi),%edx
   110f4:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   110f7:	42                   	inc    %edx
   110f8:	89 56 20             	mov    %edx,0x20(%esi)
   110fb:	89 70 08             	mov    %esi,0x8(%eax)
   110fe:	6a 00                	push   $0x0
   11100:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   11103:	50                   	push   %eax
   11104:	e8 b7 09 00 00       	call   11ac0 <_KeReleaseMutex@8>
   11109:	8b 45 0c             	mov    0xc(%ebp),%eax
   1110c:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   1110f:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11112:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   11119:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11120:	89 4a 0c             	mov    %ecx,0xc(%edx)
   11123:	6a 00                	push   $0x0
   11125:	50                   	push   %eax
   11126:	e8 a5 09 00 00       	call   11ad0 <_IoCompleteRequest@8>
   1112b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1112e:	31 c0                	xor    %eax,%eax
   11130:	5b                   	pop    %ebx
   11131:	5e                   	pop    %esi
   11132:	5f                   	pop    %edi
   11133:	5d                   	pop    %ebp
   11134:	c2 08 00             	ret    $0x8
   11137:	8b 55 0c             	mov    0xc(%ebp),%edx
   1113a:	c7 42 18 17 00 00 c0 	movl   $0xc0000017,0x18(%edx)
   11141:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   11148:	50                   	push   %eax
   11149:	50                   	push   %eax
   1114a:	6a 00                	push   $0x0
   1114c:	52                   	push   %edx
   1114d:	e8 7e 09 00 00       	call   11ad0 <_IoCompleteRequest@8>
   11152:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
   11157:	e9 59 ff ff ff       	jmp    110b5 <_MsfsCreate@8+0xb5>
   1115c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011160 <_MsfsCreateMailslot@8>:


NTSTATUS STDCALL
MsfsCreateMailslot(PDEVICE_OBJECT DeviceObject,
		   PIRP Irp)
{
   11160:	55                   	push   %ebp
   11161:	89 e5                	mov    %esp,%ebp
   11163:	57                   	push   %edi
   11164:	56                   	push   %esi
   11165:	53                   	push   %ebx
   11166:	83 ec 24             	sub    $0x24,%esp
   PIO_STACK_LOCATION IoStack;
   PFILE_OBJECT FileObject;
   PMSFS_DEVICE_EXTENSION DeviceExtension;
   PMSFS_MAILSLOT Mailslot;
   PMSFS_FCB Fcb;
   KIRQL oldIrql;
   PLIST_ENTRY current_entry;
   PMSFS_MAILSLOT current;
   PMAILSLOT_CREATE_PARAMETERS Buffer;

   DPRINT("MsfsCreateMailslot(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

   IoStack = IoGetCurrentIrpStackLocation(Irp);
   11169:	8b 45 0c             	mov    0xc(%ebp),%eax
   1116c:	8b 50 60             	mov    0x60(%eax),%edx
   DeviceExtension = DeviceObject->DeviceExtension;
   1116f:	8b 45 08             	mov    0x8(%ebp),%eax
   FileObject = IoStack->FileObject;
   11172:	8b 4a 18             	mov    0x18(%edx),%ecx
   11175:	8b 40 28             	mov    0x28(%eax),%eax
   11178:	89 4d ec             	mov    %ecx,0xffffffec(%ebp)
   1117b:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   Buffer = IoStack->Parameters.CreateMailslot.Parameters;
   1117e:	8b 5a 10             	mov    0x10(%edx),%ebx

   DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);

   Mailslot = ExAllocatePool(NonPagedPool, sizeof(MSFS_MAILSLOT));
   11181:	6a 58                	push   $0x58
   11183:	6a 00                	push   $0x0
   11185:	e8 f6 08 00 00       	call   11a80 <_ExAllocatePool@8>
   if (Mailslot == NULL)
   1118a:	59                   	pop    %ecx
   1118b:	89 c6                	mov    %eax,%esi
   1118d:	5f                   	pop    %edi
   1118e:	85 c0                	test   %eax,%eax
   11190:	0f 84 b9 01 00 00    	je     1134f <_MsfsCreateMailslot@8+0x1ef>
     {
	Irp->IoStatus.Status = STATUS_NO_MEMORY;
	Irp->IoStatus.Information = 0;

	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	return(STATUS_NO_MEMORY);
     }

   if (!RtlCreateUnicodeString(&Mailslot->Name, FileObject->FileName.Buffer))
   11196:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11199:	50                   	push   %eax
   1119a:	50                   	push   %eax
   1119b:	8b 7a 34             	mov    0x34(%edx),%edi
   1119e:	57                   	push   %edi
   1119f:	56                   	push   %esi
   111a0:	e8 3b 09 00 00       	call   11ae0 <_RtlCreateUnicodeString@8>
   111a5:	5a                   	pop    %edx
   111a6:	84 c0                	test   %al,%al
   111a8:	59                   	pop    %ecx
   111a9:	0f 84 72 01 00 00    	je     11321 <_MsfsCreateMailslot@8+0x1c1>
     {
	ExFreePool(Mailslot);

	Irp->IoStatus.Status = STATUS_NO_MEMORY;
	Irp->IoStatus.Information = 0;

	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	return(STATUS_NO_MEMORY);
     }

   Fcb = ExAllocatePool(NonPagedPool, sizeof(MSFS_FCB));
   111af:	50                   	push   %eax
   111b0:	50                   	push   %eax
   111b1:	6a 0c                	push   $0xc
   111b3:	6a 00                	push   $0x0
   111b5:	e8 c6 08 00 00       	call   11a80 <_ExAllocatePool@8>
   if (Fcb == NULL)
   111ba:	59                   	pop    %ecx
   111bb:	85 c0                	test   %eax,%eax
   111bd:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   111c0:	5f                   	pop    %edi
   111c1:	0f 84 a0 01 00 00    	je     11367 <_MsfsCreateMailslot@8+0x207>
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   111c7:	8d 56 14             	lea    0x14(%esi),%edx
     {
	ExFreePool(Mailslot);

	Irp->IoStatus.Status = STATUS_NO_MEMORY;
	Irp->IoStatus.Information = 0;

	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	return(STATUS_NO_MEMORY);
     }

   Mailslot->ReferenceCount = 0;
   InitializeListHead(&Mailslot->FcbListHead);
   KeInitializeSpinLock(&Mailslot->FcbListLock);
   111ca:	83 ec 0c             	sub    $0xc,%esp
   111cd:	8d 4e 10             	lea    0x10(%esi),%ecx
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   111d0:	89 56 14             	mov    %edx,0x14(%esi)
   111d3:	89 52 04             	mov    %edx,0x4(%edx)
   111d6:	c7 46 20 00 00 00 00 	movl   $0x0,0x20(%esi)
   111dd:	89 4d dc             	mov    %ecx,0xffffffdc(%ebp)
   111e0:	51                   	push   %ecx
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   111e1:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
   111e4:	e8 07 09 00 00       	call   11af0 <_KeInitializeSpinLock@4>

   Mailslot->MaxMessageSize = Buffer->MaximumMessageSize;
   111e9:	8b 43 04             	mov    0x4(%ebx),%eax
   Mailslot->MessageCount = 0;
   111ec:	c7 46 44 00 00 00 00 	movl   $0x0,0x44(%esi)
   111f3:	89 46 40             	mov    %eax,0x40(%esi)
   Mailslot->TimeOut = Buffer->ReadTimeout;
   111f6:	8b 53 0c             	mov    0xc(%ebx),%edx
   111f9:	8b 43 08             	mov    0x8(%ebx),%eax
   111fc:	89 46 28             	mov    %eax,0x28(%esi)
   111ff:	89 56 2c             	mov    %edx,0x2c(%esi)
   KeInitializeEvent(&Mailslot->MessageEvent,
   11202:	5f                   	pop    %edi
   11203:	58                   	pop    %eax
   11204:	8d 46 30             	lea    0x30(%esi),%eax
   11207:	6a 00                	push   $0x0
   11209:	6a 00                	push   $0x0
   1120b:	50                   	push   %eax
   1120c:	e8 ef 08 00 00       	call   11b00 <_KeInitializeEvent@12>
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   11211:	8d 46 4c             	lea    0x4c(%esi),%eax
   11214:	53                   	push   %ebx
   11215:	53                   	push   %ebx
	ListHead->Flink = ListHead->Blink = ListHead;
   11216:	89 40 04             	mov    %eax,0x4(%eax)
   11219:	89 46 4c             	mov    %eax,0x4c(%esi)
		     NotificationEvent,
		     FALSE);

   InitializeListHead(&Mailslot->MessageListHead);
   KeInitializeSpinLock(&Mailslot->MessageListLock);
   1121c:	8d 46 48             	lea    0x48(%esi),%eax
   1121f:	50                   	push   %eax
   11220:	e8 cb 08 00 00       	call   11af0 <_KeInitializeSpinLock@4>

   KeLockMutex(&DeviceExtension->MailslotListLock);
   11225:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11228:	83 c0 08             	add    $0x8,%eax
   1122b:	6a 00                	push   $0x0
   1122d:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   11230:	6a 00                	push   $0x0
   11232:	6a 00                	push   $0x0
   11234:	6a 06                	push   $0x6
   11236:	50                   	push   %eax
   11237:	e8 54 08 00 00       	call   11a90 <_KeWaitForSingleObject@20>
   current_entry = DeviceExtension->MailslotListHead.Flink;
   1123c:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   while (current_entry != &DeviceExtension->MailslotListHead)
   1123f:	83 c4 0c             	add    $0xc,%esp
   11242:	8b 1a                	mov    (%edx),%ebx
     {
	current = CONTAINING_RECORD(current_entry,
				    MSFS_MAILSLOT,
				    MailslotListEntry);

	if (!RtlCompareUnicodeString(&Mailslot->Name, &current->Name, TRUE))
	  {
	     break;
	  }

	current_entry = current_entry->Flink;
   11244:	39 d3                	cmp    %edx,%ebx
   11246:	eb 1b                	jmp    11263 <_MsfsCreateMailslot@8+0x103>
   11248:	8d 7b f8             	lea    0xfffffff8(%ebx),%edi
   1124b:	51                   	push   %ecx
   1124c:	6a 01                	push   $0x1
   1124e:	57                   	push   %edi
   1124f:	56                   	push   %esi
   11250:	e8 4b 08 00 00       	call   11aa0 <_RtlCompareUnicodeString@12>
   11255:	5a                   	pop    %edx
   11256:	85 c0                	test   %eax,%eax
   11258:	0f 84 95 00 00 00    	je     112f3 <_MsfsCreateMailslot@8+0x193>
   1125e:	8b 1b                	mov    (%ebx),%ebx
   11260:	3b 5d e8             	cmp    0xffffffe8(%ebp),%ebx
   11263:	75 e3                	jne    11248 <_MsfsCreateMailslot@8+0xe8>
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   11265:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11268:	8d 46 08             	lea    0x8(%esi),%eax
	Entry->Flink = ListHead;
   1126b:	89 4e 08             	mov    %ecx,0x8(%esi)
   1126e:	8b 51 04             	mov    0x4(%ecx),%edx
	Entry->Blink = OldBlink;
   11271:	89 50 04             	mov    %edx,0x4(%eax)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   11274:	89 41 04             	mov    %eax,0x4(%ecx)
   11277:	89 02                	mov    %eax,(%edx)
     }

   if (current_entry != &DeviceExtension->MailslotListHead)
     {
	RtlFreeUnicodeString(&Mailslot->Name);
	ExFreePool(Mailslot);
	
	Mailslot = current;
     }
   else
     {
	InsertTailList(&DeviceExtension->MailslotListHead,
		       &Mailslot->MailslotListEntry);
     }

   KeAcquireSpinLock(&Mailslot->FcbListLock, &oldIrql);
   11279:	50                   	push   %eax
   1127a:	50                   	push   %eax
   1127b:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   1127e:	50                   	push   %eax
   1127f:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   11282:	50                   	push   %eax
   11283:	e8 18 09 00 00       	call   11ba0 <_KeAcquireSpinLock@8>
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   11288:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
	Entry->Flink = ListHead;
   1128b:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   1128e:	8b 42 04             	mov    0x4(%edx),%eax
   11291:	89 11                	mov    %edx,(%ecx)
	Entry->Blink = OldBlink;
   11293:	89 41 04             	mov    %eax,0x4(%ecx)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   11296:	89 4a 04             	mov    %ecx,0x4(%edx)
   11299:	89 08                	mov    %ecx,(%eax)
   InsertTailList(&Mailslot->FcbListHead, &Fcb->FcbListEntry);
   KeReleaseSpinLock(&Mailslot->FcbListLock, oldIrql);
   1129b:	31 c0                	xor    %eax,%eax
   1129d:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   112a0:	50                   	push   %eax
   112a1:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   112a4:	50                   	push   %eax
   112a5:	e8 06 09 00 00       	call   11bb0 <_KeReleaseSpinLock@8>

   Mailslot->ReferenceCount++;
   112aa:	8b 7e 20             	mov    0x20(%esi),%edi
   Mailslot->ServerFcb = Fcb;
   112ad:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   112b0:	47                   	inc    %edi
   112b1:	89 46 1c             	mov    %eax,0x1c(%esi)
   112b4:	89 7e 20             	mov    %edi,0x20(%esi)
   Fcb->Mailslot = Mailslot;
   112b7:	89 70 08             	mov    %esi,0x8(%eax)

   KeUnlockMutex(&DeviceExtension->MailslotListLock);
   112ba:	8b 5d e0             	mov    0xffffffe0(%ebp),%ebx
   112bd:	6a 00                	push   $0x0
   112bf:	53                   	push   %ebx
   112c0:	e8 fb 07 00 00       	call   11ac0 <_KeReleaseMutex@8>

   FileObject->FsContext = Fcb;

   Irp->IoStatus.Status = STATUS_SUCCESS;
   112c5:	8b 45 0c             	mov    0xc(%ebp),%eax
   112c8:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   112cb:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   112ce:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   Irp->IoStatus.Information = 0;
   112d5:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   112dc:	89 4a 0c             	mov    %ecx,0xc(%edx)

   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   112df:	6a 00                	push   $0x0
   112e1:	50                   	push   %eax
   112e2:	e8 e9 07 00 00       	call   11ad0 <_IoCompleteRequest@8>

   return(STATUS_SUCCESS);
   112e7:	31 c0                	xor    %eax,%eax
}
   112e9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   112ec:	5b                   	pop    %ebx
   112ed:	5e                   	pop    %esi
   112ee:	5f                   	pop    %edi
   112ef:	5d                   	pop    %ebp
   112f0:	c2 08 00             	ret    $0x8
   112f3:	3b 5d e8             	cmp    0xffffffe8(%ebp),%ebx
   112f6:	0f 84 69 ff ff ff    	je     11265 <_MsfsCreateMailslot@8+0x105>
   112fc:	83 ec 0c             	sub    $0xc,%esp
   112ff:	56                   	push   %esi
   11300:	e8 0b 08 00 00       	call   11b10 <_RtlFreeUnicodeString@4>
   11305:	56                   	push   %esi
   11306:	e8 a5 07 00 00       	call   11ab0 <_ExFreePool@4>
   1130b:	89 fe                	mov    %edi,%esi
   1130d:	8d 4f 14             	lea    0x14(%edi),%ecx
   11310:	8d 47 10             	lea    0x10(%edi),%eax
   11313:	83 c4 0c             	add    $0xc,%esp
   11316:	89 4d d8             	mov    %ecx,0xffffffd8(%ebp)
   11319:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   1131c:	e9 58 ff ff ff       	jmp    11279 <_MsfsCreateMailslot@8+0x119>
   11321:	83 ec 0c             	sub    $0xc,%esp
   11324:	56                   	push   %esi
   11325:	e8 86 07 00 00       	call   11ab0 <_ExFreePool@4>
   1132a:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   1132d:	c7 41 18 17 00 00 c0 	movl   $0xc0000017,0x18(%ecx)
   11334:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
   1133b:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11342:	51                   	push   %ecx
   11343:	e8 88 07 00 00       	call   11ad0 <_IoCompleteRequest@8>
   11348:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
   1134d:	eb 9a                	jmp    112e9 <_MsfsCreateMailslot@8+0x189>
   1134f:	8b 45 0c             	mov    0xc(%ebp),%eax
   11352:	c7 40 18 17 00 00 c0 	movl   $0xc0000017,0x18(%eax)
   11359:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11360:	52                   	push   %edx
   11361:	52                   	push   %edx
   11362:	6a 00                	push   $0x0
   11364:	50                   	push   %eax
   11365:	eb dc                	jmp    11343 <_MsfsCreateMailslot@8+0x1e3>
   11367:	83 ec 0c             	sub    $0xc,%esp
   1136a:	56                   	push   %esi
   1136b:	e8 40 07 00 00       	call   11ab0 <_ExFreePool@4>
   11370:	8b 45 0c             	mov    0xc(%ebp),%eax
   11373:	c7 40 18 17 00 00 c0 	movl   $0xc0000017,0x18(%eax)
   1137a:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11381:	5a                   	pop    %edx
   11382:	6a 00                	push   $0x0
   11384:	50                   	push   %eax
   11385:	eb bc                	jmp    11343 <_MsfsCreateMailslot@8+0x1e3>
   11387:	89 f6                	mov    %esi,%esi
   11389:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011390 <_MsfsClose@8>:


NTSTATUS STDCALL
MsfsClose(PDEVICE_OBJECT DeviceObject,
	  PIRP Irp)
{
   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
   PIO_STACK_LOCATION IoStack;
   PFILE_OBJECT FileObject;
   PMSFS_DEVICE_EXTENSION DeviceExtension;
   PMSFS_MAILSLOT Mailslot;
   PMSFS_FCB Fcb;
   PMSFS_MESSAGE Message;
   KIRQL oldIrql;
   
   DPRINT("MsfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
   
   IoStack = IoGetCurrentIrpStackLocation(Irp);
   11399:	8b 55 0c             	mov    0xc(%ebp),%edx
   1139c:	8b 42 60             	mov    0x60(%edx),%eax
   DeviceExtension = DeviceObject->DeviceExtension;
   1139f:	8b 55 08             	mov    0x8(%ebp),%edx
   113a2:	8b 5a 28             	mov    0x28(%edx),%ebx
   FileObject = IoStack->FileObject;
   113a5:	8b 40 18             	mov    0x18(%eax),%eax
   113a8:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   
   KeLockMutex(&DeviceExtension->MailslotListLock);
   113ab:	6a 00                	push   $0x0
   113ad:	8d 43 08             	lea    0x8(%ebx),%eax
   113b0:	6a 00                	push   $0x0
   113b2:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   113b5:	6a 00                	push   $0x0
   113b7:	6a 06                	push   $0x6
   113b9:	50                   	push   %eax
   113ba:	e8 d1 06 00 00       	call   11a90 <_KeWaitForSingleObject@20>
   
   if (DeviceExtension->MailslotListHead.Flink == &DeviceExtension->MailslotListHead)
   113bf:	83 c4 0c             	add    $0xc,%esp
   113c2:	39 1b                	cmp    %ebx,(%ebx)
   113c4:	74 59                	je     1141f <_MsfsClose@8+0x8f>
     {
	KeUnlockMutex(&DeviceExtension->MailslotListLock);
	
	Irp->IoStatus.Status = STATUS_SUCCESS;
	Irp->IoStatus.Information = 0;
	
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	
	return(STATUS_SUCCESS);
     }
   
   Fcb = FileObject->FsContext;
   113c6:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   113c9:	8b 78 0c             	mov    0xc(%eax),%edi
   Mailslot = Fcb->Mailslot;
   113cc:	8b 77 08             	mov    0x8(%edi),%esi
   
   DPRINT("Mailslot name: %wZ\n", &Mailslot->Name);
   
   Mailslot->ReferenceCount--;
   113cf:	8b 5e 20             	mov    0x20(%esi),%ebx
   113d2:	4b                   	dec    %ebx
   if (Mailslot->ServerFcb == Fcb)
   113d3:	39 7e 1c             	cmp    %edi,0x1c(%esi)
   113d6:	89 5e 20             	mov    %ebx,0x20(%esi)
   113d9:	0f 84 b1 00 00 00    	je     11490 <_MsfsClose@8+0x100>
     {
	/* delete all messages from message-list */
	KeAcquireSpinLock(&Mailslot->MessageListLock, &oldIrql);
	
	while (Mailslot->MessageListHead.Flink != &Mailslot->MessageListHead)
	  {
	     Message = CONTAINING_RECORD(Mailslot->MessageListHead.Flink,
					 MSFS_MESSAGE,
					 MessageListEntry);
	     RemoveEntryList(Mailslot->MessageListHead.Flink);
	     ExFreePool(Message);
	  }
	Mailslot->MessageCount = 0;
	
	KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
	Mailslot->ServerFcb = NULL;
     }
   
   KeAcquireSpinLock(&Mailslot->FcbListLock, &oldIrql);
   113df:	8d 55 f3             	lea    0xfffffff3(%ebp),%edx
   113e2:	8d 5e 10             	lea    0x10(%esi),%ebx
   113e5:	50                   	push   %eax
   113e6:	50                   	push   %eax
   113e7:	52                   	push   %edx
   113e8:	53                   	push   %ebx
   113e9:	e8 b2 07 00 00       	call   11ba0 <_KeAcquireSpinLock@8>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   113ee:	8b 17                	mov    (%edi),%edx
  OldBlink = Entry->Blink;
   113f0:	8b 47 04             	mov    0x4(%edi),%eax
  OldFlink->Blink = OldBlink;
   113f3:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   113f6:	89 10                	mov    %edx,(%eax)
   RemoveEntryList(&Fcb->FcbListEntry);
   KeReleaseSpinLock(&Mailslot->FcbListLock, oldIrql);
   113f8:	31 c0                	xor    %eax,%eax
   113fa:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   113fd:	50                   	push   %eax
   113fe:	53                   	push   %ebx
   113ff:	e8 ac 07 00 00       	call   11bb0 <_KeReleaseSpinLock@8>
   ExFreePool(Fcb);
   11404:	50                   	push   %eax
   11405:	57                   	push   %edi
   11406:	e8 a5 06 00 00       	call   11ab0 <_ExFreePool@4>
   FileObject->FsContext = NULL;
   1140b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1140e:	c7 40 0c 00 00 00 00 	movl   $0x0,0xc(%eax)
   
   if (Mailslot->ReferenceCount == 0)
   11415:	8b 46 20             	mov    0x20(%esi),%eax
   11418:	83 c4 0c             	add    $0xc,%esp
   1141b:	85 c0                	test   %eax,%eax
   1141d:	74 32                	je     11451 <_MsfsClose@8+0xc1>
     {
	DPRINT1("ReferenceCount == 0: Deleting mailslot data\n");
	RtlFreeUnicodeString(&Mailslot->Name);
	RemoveEntryList(&Mailslot->MailslotListEntry);
	ExFreePool(Mailslot);
     }
   
   KeUnlockMutex(&DeviceExtension->MailslotListLock);
   1141f:	50                   	push   %eax
   11420:	50                   	push   %eax
   11421:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11424:	6a 00                	push   $0x0
   11426:	50                   	push   %eax
   11427:	e8 94 06 00 00       	call   11ac0 <_KeReleaseMutex@8>
   
   Irp->IoStatus.Status = STATUS_SUCCESS;
   1142c:	8b 55 0c             	mov    0xc(%ebp),%edx
   1142f:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
   Irp->IoStatus.Information = 0;
   11436:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   1143d:	6a 00                	push   $0x0
   1143f:	52                   	push   %edx
   11440:	e8 8b 06 00 00       	call   11ad0 <_IoCompleteRequest@8>
   
   return(STATUS_SUCCESS);
}
   11445:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11448:	31 c0                	xor    %eax,%eax
   1144a:	5b                   	pop    %ebx
   1144b:	5e                   	pop    %esi
   1144c:	5f                   	pop    %edi
   1144d:	5d                   	pop    %ebp
   1144e:	c2 08 00             	ret    $0x8
   11451:	50                   	push   %eax
   11452:	68 26 01 00 00       	push   $0x126
   11457:	68 00 20 01 00       	push   $0x12000
   1145c:	68 09 20 01 00       	push   $0x12009
   11461:	e8 ba 06 00 00       	call   11b20 <_DbgPrint>
   11466:	c7 04 24 14 20 01 00 	movl   $0x12014,(%esp)
   1146d:	e8 ae 06 00 00       	call   11b20 <_DbgPrint>
   11472:	89 34 24             	mov    %esi,(%esp)
   11475:	e8 96 06 00 00       	call   11b10 <_RtlFreeUnicodeString@4>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   1147a:	8b 56 08             	mov    0x8(%esi),%edx
  OldBlink = Entry->Blink;
   1147d:	8b 46 0c             	mov    0xc(%esi),%eax
  OldFlink->Blink = OldBlink;
   11480:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   11483:	89 10                	mov    %edx,(%eax)
   11485:	56                   	push   %esi
   11486:	e8 25 06 00 00       	call   11ab0 <_ExFreePool@4>
   1148b:	83 c4 0c             	add    $0xc,%esp
   1148e:	eb 8f                	jmp    1141f <_MsfsClose@8+0x8f>
   11490:	8d 46 48             	lea    0x48(%esi),%eax
   11493:	8d 55 f3             	lea    0xfffffff3(%ebp),%edx
   11496:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11499:	51                   	push   %ecx
   1149a:	51                   	push   %ecx
   1149b:	52                   	push   %edx
   1149c:	50                   	push   %eax
   1149d:	e8 fe 06 00 00       	call   11ba0 <_KeAcquireSpinLock@8>
   114a2:	8d 5e 4c             	lea    0x4c(%esi),%ebx
   114a5:	58                   	pop    %eax
   114a6:	5a                   	pop    %edx
   114a7:	eb 1d                	jmp    114c6 <_MsfsClose@8+0x136>
   114a9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   114b0:	8b 11                	mov    (%ecx),%edx
  OldBlink = Entry->Blink;
   114b2:	8b 41 04             	mov    0x4(%ecx),%eax
   114b5:	83 ec 0c             	sub    $0xc,%esp
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
   114b8:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   114bb:	89 10                	mov    %edx,(%eax)
   114bd:	51                   	push   %ecx
   114be:	e8 ed 05 00 00       	call   11ab0 <_ExFreePool@4>
   114c3:	83 c4 0c             	add    $0xc,%esp
   114c6:	8b 4e 4c             	mov    0x4c(%esi),%ecx
   114c9:	39 d9                	cmp    %ebx,%ecx
   114cb:	75 e3                	jne    114b0 <_MsfsClose@8+0x120>
   114cd:	c7 46 44 00 00 00 00 	movl   $0x0,0x44(%esi)
   114d4:	50                   	push   %eax
   114d5:	50                   	push   %eax
   114d6:	31 c0                	xor    %eax,%eax
   114d8:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   114db:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   114de:	50                   	push   %eax
   114df:	53                   	push   %ebx
   114e0:	e8 cb 06 00 00       	call   11bb0 <_KeReleaseSpinLock@8>
   114e5:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   114ec:	5a                   	pop    %edx
   114ed:	59                   	pop    %ecx
   114ee:	e9 ec fe ff ff       	jmp    113df <_MsfsClose@8+0x4f>
   114f3:	90                   	nop    
   114f4:	90                   	nop    
   114f5:	90                   	nop    
   114f6:	90                   	nop    
   114f7:	90                   	nop    
   114f8:	90                   	nop    
   114f9:	90                   	nop    
   114fa:	90                   	nop    
   114fb:	90                   	nop    
   114fc:	90                   	nop    
   114fd:	90                   	nop    
   114fe:	90                   	nop    
   114ff:	90                   	nop    

00011500 <_MsfsQueryInformation@8>:
   11500:	55                   	push   %ebp
   11501:	89 e5                	mov    %esp,%ebp
   11503:	57                   	push   %edi
   11504:	56                   	push   %esi
   11505:	53                   	push   %ebx
   11506:	83 ec 1c             	sub    $0x1c,%esp
   11509:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1150c:	8b 7b 60             	mov    0x60(%ebx),%edi
   1150f:	8b 47 18             	mov    0x18(%edi),%eax
   11512:	8b 57 08             	mov    0x8(%edi),%edx
   11515:	8b 40 0c             	mov    0xc(%eax),%eax
   11518:	8b 70 08             	mov    0x8(%eax),%esi
   1151b:	39 46 1c             	cmp    %eax,0x1c(%esi)
   1151e:	74 27                	je     11547 <_MsfsQueryInformation@8+0x47>
   11520:	c7 43 18 22 00 00 c0 	movl   $0xc0000022,0x18(%ebx)
   11527:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   1152e:	50                   	push   %eax
   1152f:	50                   	push   %eax
   11530:	6a 00                	push   $0x0
   11532:	53                   	push   %ebx
   11533:	e8 98 05 00 00       	call   11ad0 <_IoCompleteRequest@8>
   11538:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1153b:	b8 22 00 00 c0       	mov    $0xc0000022,%eax
   11540:	5b                   	pop    %ebx
   11541:	5e                   	pop    %esi
   11542:	5f                   	pop    %edi
   11543:	5d                   	pop    %ebp
   11544:	c2 08 00             	ret    $0x8
   11547:	8b 43 0c             	mov    0xc(%ebx),%eax
   1154a:	83 fa 1a             	cmp    $0x1a,%edx
   1154d:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11550:	8b 47 04             	mov    0x4(%edi),%eax
   11553:	c7 45 e4 02 00 00 c0 	movl   $0xc0000002,0xffffffe4(%ebp)
   1155a:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   1155d:	74 31                	je     11590 <_MsfsQueryInformation@8+0x90>
   1155f:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   11562:	89 4b 18             	mov    %ecx,0x18(%ebx)
   11565:	85 c9                	test   %ecx,%ecx
   11567:	78 36                	js     1159f <_MsfsQueryInformation@8+0x9f>
   11569:	8b 47 04             	mov    0x4(%edi),%eax
   1156c:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   1156f:	29 d0                	sub    %edx,%eax
   11571:	89 43 1c             	mov    %eax,0x1c(%ebx)
   11574:	50                   	push   %eax
   11575:	50                   	push   %eax
   11576:	6a 00                	push   $0x0
   11578:	53                   	push   %ebx
   11579:	e8 52 05 00 00       	call   11ad0 <_IoCompleteRequest@8>
   1157e:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11581:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11584:	5b                   	pop    %ebx
   11585:	5e                   	pop    %esi
   11586:	5f                   	pop    %edi
   11587:	5d                   	pop    %ebp
   11588:	c2 08 00             	ret    $0x8
   1158b:	90                   	nop    
   1158c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11590:	ba 05 00 00 80       	mov    $0x80000005,%edx
   11595:	83 f8 17             	cmp    $0x17,%eax
   11598:	77 0e                	ja     115a8 <_MsfsQueryInformation@8+0xa8>
   1159a:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   1159d:	eb c0                	jmp    1155f <_MsfsQueryInformation@8+0x5f>
   1159f:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   115a6:	eb cc                	jmp    11574 <_MsfsQueryInformation@8+0x74>
   115a8:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   115ab:	8b 46 40             	mov    0x40(%esi),%eax
   115ae:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   115b1:	89 02                	mov    %eax,(%edx)
   115b3:	8b 46 28             	mov    0x28(%esi),%eax
   115b6:	8b 56 2c             	mov    0x2c(%esi),%edx
   115b9:	89 51 14             	mov    %edx,0x14(%ecx)
   115bc:	89 41 10             	mov    %eax,0x10(%ecx)
   115bf:	50                   	push   %eax
   115c0:	50                   	push   %eax
   115c1:	8d 45 ef             	lea    0xffffffef(%ebp),%eax
   115c4:	50                   	push   %eax
   115c5:	8d 46 48             	lea    0x48(%esi),%eax
   115c8:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   115cb:	50                   	push   %eax
   115cc:	e8 cf 05 00 00       	call   11ba0 <_KeAcquireSpinLock@8>
   115d1:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   115d4:	8b 46 44             	mov    0x44(%esi),%eax
   115d7:	c7 42 08 00 00 00 00 	movl   $0x0,0x8(%edx)
   115de:	89 42 0c             	mov    %eax,0xc(%edx)
   115e1:	31 c0                	xor    %eax,%eax
   115e3:	8a 45 ef             	mov    0xffffffef(%ebp),%al
   115e6:	50                   	push   %eax
   115e7:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   115ea:	50                   	push   %eax
   115eb:	e8 c0 05 00 00       	call   11bb0 <_KeReleaseSpinLock@8>
   115f0:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   115f3:	5e                   	pop    %esi
   115f4:	83 e9 18             	sub    $0x18,%ecx
   115f7:	58                   	pop    %eax
   115f8:	31 d2                	xor    %edx,%edx
   115fa:	89 4d f0             	mov    %ecx,0xfffffff0(%ebp)
   115fd:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   11600:	e9 5a ff ff ff       	jmp    1155f <_MsfsQueryInformation@8+0x5f>
   11605:	8d 74 26 00          	lea    0x0(%esi),%esi
   11609:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011610 <_MsfsSetInformation@8>:
   11610:	55                   	push   %ebp
   11611:	89 e5                	mov    %esp,%ebp
   11613:	57                   	push   %edi
   11614:	56                   	push   %esi
   11615:	53                   	push   %ebx
   11616:	83 ec 0c             	sub    $0xc,%esp
   11619:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1161c:	8b 4b 60             	mov    0x60(%ebx),%ecx
   1161f:	8b 41 18             	mov    0x18(%ecx),%eax
   11622:	8b 51 08             	mov    0x8(%ecx),%edx
   11625:	8b 40 0c             	mov    0xc(%eax),%eax
   11628:	8b 70 08             	mov    0x8(%eax),%esi
   1162b:	39 46 1c             	cmp    %eax,0x1c(%esi)
   1162e:	74 27                	je     11657 <_MsfsSetInformation@8+0x47>
   11630:	c7 43 18 22 00 00 c0 	movl   $0xc0000022,0x18(%ebx)
   11637:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   1163e:	50                   	push   %eax
   1163f:	50                   	push   %eax
   11640:	6a 00                	push   $0x0
   11642:	53                   	push   %ebx
   11643:	e8 88 04 00 00       	call   11ad0 <_IoCompleteRequest@8>
   11648:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1164b:	b8 22 00 00 c0       	mov    $0xc0000022,%eax
   11650:	5b                   	pop    %ebx
   11651:	5e                   	pop    %esi
   11652:	5f                   	pop    %edi
   11653:	5d                   	pop    %ebp
   11654:	c2 08 00             	ret    $0x8
   11657:	8b 43 0c             	mov    0xc(%ebx),%eax
   1165a:	8b 49 04             	mov    0x4(%ecx),%ecx
   1165d:	bf 02 00 00 c0       	mov    $0xc0000002,%edi
   11662:	83 fa 1b             	cmp    $0x1b,%edx
   11665:	74 20                	je     11687 <_MsfsSetInformation@8+0x77>
   11667:	89 7b 18             	mov    %edi,0x18(%ebx)
   1166a:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   11671:	50                   	push   %eax
   11672:	50                   	push   %eax
   11673:	6a 00                	push   $0x0
   11675:	53                   	push   %ebx
   11676:	e8 55 04 00 00       	call   11ad0 <_IoCompleteRequest@8>
   1167b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1167e:	89 f8                	mov    %edi,%eax
   11680:	5b                   	pop    %ebx
   11681:	5e                   	pop    %esi
   11682:	5f                   	pop    %edi
   11683:	5d                   	pop    %ebp
   11684:	c2 08 00             	ret    $0x8
   11687:	ba 05 00 00 80       	mov    $0x80000005,%edx
   1168c:	83 f9 07             	cmp    $0x7,%ecx
   1168f:	76 0d                	jbe    1169e <_MsfsSetInformation@8+0x8e>
   11691:	8b 50 04             	mov    0x4(%eax),%edx
   11694:	8b 00                	mov    (%eax),%eax
   11696:	89 46 28             	mov    %eax,0x28(%esi)
   11699:	89 56 2c             	mov    %edx,0x2c(%esi)
   1169c:	31 d2                	xor    %edx,%edx
   1169e:	89 d7                	mov    %edx,%edi
   116a0:	eb c5                	jmp    11667 <_MsfsSetInformation@8+0x57>
   116a2:	90                   	nop    
   116a3:	90                   	nop    
   116a4:	90                   	nop    
   116a5:	90                   	nop    
   116a6:	90                   	nop    
   116a7:	90                   	nop    
   116a8:	90                   	nop    
   116a9:	90                   	nop    
   116aa:	90                   	nop    
   116ab:	90                   	nop    
   116ac:	90                   	nop    
   116ad:	90                   	nop    
   116ae:	90                   	nop    
   116af:	90                   	nop    

000116b0 <_MsfsFileSystemControl@8>:
   116b0:	55                   	push   %ebp
   116b1:	89 e5                	mov    %esp,%ebp
   116b3:	56                   	push   %esi
   116b4:	53                   	push   %ebx
   116b5:	50                   	push   %eax
   116b6:	6a 1f                	push   $0x1f
   116b8:	68 50 20 01 00       	push   $0x12050
   116bd:	68 59 20 01 00       	push   $0x12059
   116c2:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   116c5:	e8 56 04 00 00       	call   11b20 <_DbgPrint>
   116ca:	83 c4 0c             	add    $0xc,%esp
   116cd:	8b 45 08             	mov    0x8(%ebp),%eax
   116d0:	53                   	push   %ebx
   116d1:	50                   	push   %eax
   116d2:	68 64 20 01 00       	push   $0x12064
   116d7:	e8 44 04 00 00       	call   11b20 <_DbgPrint>
   116dc:	8b 43 60             	mov    0x60(%ebx),%eax
   116df:	8b 40 18             	mov    0x18(%eax),%eax
   116e2:	83 c4 0c             	add    $0xc,%esp
   116e5:	8b 40 0c             	mov    0xc(%eax),%eax
   116e8:	8b 70 08             	mov    0x8(%eax),%esi
   116eb:	6a 26                	push   $0x26
   116ed:	68 50 20 01 00       	push   $0x12050
   116f2:	68 59 20 01 00       	push   $0x12059
   116f7:	e8 24 04 00 00       	call   11b20 <_DbgPrint>
   116fc:	59                   	pop    %ecx
   116fd:	58                   	pop    %eax
   116fe:	56                   	push   %esi
   116ff:	68 93 20 01 00       	push   $0x12093
   11704:	e8 17 04 00 00       	call   11b20 <_DbgPrint>
   11709:	58                   	pop    %eax
   1170a:	5a                   	pop    %edx
   1170b:	c7 43 18 02 00 00 c0 	movl   $0xc0000002,0x18(%ebx)
   11712:	c7 43 1c 00 00 00 00 	movl   $0x0,0x1c(%ebx)
   11719:	6a 00                	push   $0x0
   1171b:	53                   	push   %ebx
   1171c:	e8 af 03 00 00       	call   11ad0 <_IoCompleteRequest@8>
   11721:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11724:	b8 02 00 00 c0       	mov    $0xc0000002,%eax
   11729:	5b                   	pop    %ebx
   1172a:	5e                   	pop    %esi
   1172b:	5d                   	pop    %ebp
   1172c:	c2 08 00             	ret    $0x8
   1172f:	90                   	nop    

00011730 <_DriverEntry@8>:

NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject,
	    PUNICODE_STRING RegistryPath)
{
   11730:	55                   	push   %ebp
   11731:	89 e5                	mov    %esp,%ebp
   11733:	56                   	push   %esi
   11734:	53                   	push   %ebx
   11735:	83 ec 18             	sub    $0x18,%esp
   PMSFS_DEVICE_EXTENSION DeviceExtension;
   PDEVICE_OBJECT DeviceObject;
   UNICODE_STRING DeviceName;
   NTSTATUS Status;
   
   DPRINT("Mailslot FSD 0.0.1\n");
   
   DriverObject->Flags = 0;
   DriverObject->MajorFunction[IRP_MJ_CREATE] = MsfsCreate;
   DriverObject->MajorFunction[IRP_MJ_CREATE_MAILSLOT] =
     MsfsCreateMailslot;
   DriverObject->MajorFunction[IRP_MJ_CLOSE] = MsfsClose;
   DriverObject->MajorFunction[IRP_MJ_READ] = MsfsRead;
   DriverObject->MajorFunction[IRP_MJ_WRITE] = MsfsWrite;
   DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
     MsfsQueryInformation;
   DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
     MsfsSetInformation;
//   DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
//     MsfsDirectoryControl;
//   DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = MsfsFlushBuffers;
//   DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = MsfsShutdown;
//   DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = 
//     MsfsQuerySecurity;
//   DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] =
//     MsfsSetSecurity;
   DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
     MsfsFileSystemControl;
   
   DriverObject->DriverUnload = NULL;
   
   RtlInitUnicodeString(&DeviceName,
   11738:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
   1173b:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1173e:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)
   11745:	c7 43 38 00 10 01 00 	movl   $0x11000,0x38(%ebx)
   1174c:	c7 83 84 00 00 00 60 	movl   $0x11160,0x84(%ebx)
   11753:	11 01 00 
   11756:	c7 43 40 90 13 01 00 	movl   $0x11390,0x40(%ebx)
   1175d:	c7 43 44 d0 17 01 00 	movl   $0x117d0,0x44(%ebx)
   11764:	c7 43 48 30 19 01 00 	movl   $0x11930,0x48(%ebx)
   1176b:	c7 43 4c 00 15 01 00 	movl   $0x11500,0x4c(%ebx)
   11772:	c7 43 50 10 16 01 00 	movl   $0x11610,0x50(%ebx)
   11779:	c7 43 6c b0 16 01 00 	movl   $0x116b0,0x6c(%ebx)
   11780:	c7 43 34 00 00 00 00 	movl   $0x0,0x34(%ebx)
   11787:	68 b0 20 01 00       	push   $0x120b0
   1178c:	56                   	push   %esi
   1178d:	e8 9e 03 00 00       	call   11b30 <_RtlInitUnicodeString@8>
			L"\\Device\\MailSlot");
   Status = IoCreateDevice(DriverObject,
   11792:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
   11795:	89 04 24             	mov    %eax,(%esp)
   11798:	6a 00                	push   $0x0
   1179a:	6a 00                	push   $0x0
   1179c:	6a 0c                	push   $0xc
   1179e:	56                   	push   %esi
   1179f:	6a 28                	push   $0x28
   117a1:	53                   	push   %ebx
   117a2:	e8 99 03 00 00       	call   11b40 <_IoCreateDevice@28>
			   sizeof(MSFS_DEVICE_EXTENSION),
			   &DeviceName,
			   FILE_DEVICE_MAILSLOT,
			   0,
			   FALSE,
			   &DeviceObject);
   if (!NT_SUCCESS(Status))
   117a7:	59                   	pop    %ecx
   117a8:	85 c0                	test   %eax,%eax
   117aa:	78 1a                	js     117c6 <_DriverEntry@8+0x96>
     {
	return(Status);
     }

   /* initialize device extension */
   DeviceExtension = DeviceObject->DeviceExtension;
   117ac:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   117af:	8b 40 28             	mov    0x28(%eax),%eax
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   117b2:	89 40 04             	mov    %eax,0x4(%eax)
   117b5:	89 00                	mov    %eax,(%eax)
   InitializeListHead(&DeviceExtension->MailslotListHead);
   KeInitializeMutex(&DeviceExtension->MailslotListLock,
   117b7:	83 c0 08             	add    $0x8,%eax
   117ba:	52                   	push   %edx
   117bb:	52                   	push   %edx
   117bc:	6a 00                	push   $0x0
   117be:	50                   	push   %eax
   117bf:	e8 8c 03 00 00       	call   11b50 <_KeInitializeMutex@8>
		     0);
   
   return(STATUS_SUCCESS);
   117c4:	31 c0                	xor    %eax,%eax
}
   117c6:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   117c9:	5b                   	pop    %ebx
   117ca:	5e                   	pop    %esi
   117cb:	5d                   	pop    %ebp
   117cc:	c2 08 00             	ret    $0x8
   117cf:	90                   	nop    

000117d0 <_MsfsRead@8>:
   117d0:	55                   	push   %ebp
   117d1:	89 e5                	mov    %esp,%ebp
   117d3:	57                   	push   %edi
   117d4:	56                   	push   %esi
   117d5:	53                   	push   %ebx
   117d6:	83 ec 1c             	sub    $0x1c,%esp
   117d9:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   117e0:	8b 45 0c             	mov    0xc(%ebp),%eax
   117e3:	8b 50 60             	mov    0x60(%eax),%edx
   117e6:	8b 42 18             	mov    0x18(%edx),%eax
   117e9:	8b 40 0c             	mov    0xc(%eax),%eax
   117ec:	8b 70 08             	mov    0x8(%eax),%esi
   117ef:	39 46 1c             	cmp    %eax,0x1c(%esi)
   117f2:	0f 85 0c 01 00 00    	jne    11904 <_MsfsRead@8+0x134>
   117f8:	8b 45 0c             	mov    0xc(%ebp),%eax
   117fb:	8b 52 04             	mov    0x4(%edx),%edx
   117fe:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
   11801:	8b 50 04             	mov    0x4(%eax),%edx
   11804:	85 d2                	test   %edx,%edx
   11806:	0f 85 ba 00 00 00    	jne    118c6 <_MsfsRead@8+0xf6>
   1180c:	8b 55 0c             	mov    0xc(%ebp),%edx
   1180f:	8b 5a 3c             	mov    0x3c(%edx),%ebx
   11812:	83 ec 0c             	sub    $0xc,%esp
   11815:	8d 46 30             	lea    0x30(%esi),%eax
   11818:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   1181b:	6a 00                	push   $0x0
   1181d:	6a 00                	push   $0x0
   1181f:	6a 00                	push   $0x0
   11821:	6a 06                	push   $0x6
   11823:	50                   	push   %eax
   11824:	e8 67 02 00 00       	call   11a90 <_KeWaitForSingleObject@20>
   11829:	83 c4 0c             	add    $0xc,%esp
   1182c:	89 c7                	mov    %eax,%edi
   1182e:	85 c0                	test   %eax,%eax
   11830:	78 72                	js     118a4 <_MsfsRead@8+0xd4>
   11832:	8b 46 44             	mov    0x44(%esi),%eax
   11835:	85 c0                	test   %eax,%eax
   11837:	74 6b                	je     118a4 <_MsfsRead@8+0xd4>
   11839:	8b 56 4c             	mov    0x4c(%esi),%edx
   1183c:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   1183f:	8b 52 08             	mov    0x8(%edx),%edx
   11842:	3b 55 e8             	cmp    0xffffffe8(%ebp),%edx
   11845:	0f 87 8b 00 00 00    	ja     118d6 <_MsfsRead@8+0x106>
   1184b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1184e:	83 c0 0c             	add    $0xc,%eax
   11851:	51                   	push   %ecx
   11852:	52                   	push   %edx
   11853:	50                   	push   %eax
   11854:	53                   	push   %ebx
   11855:	e8 36 03 00 00       	call   11b90 <_memcpy>
   1185a:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   1185d:	58                   	pop    %eax
   1185e:	8d 5e 48             	lea    0x48(%esi),%ebx
   11861:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   11864:	8b 52 08             	mov    0x8(%edx),%edx
   11867:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   1186a:	5a                   	pop    %edx
   1186b:	50                   	push   %eax
   1186c:	53                   	push   %ebx
   1186d:	e8 2e 03 00 00       	call   11ba0 <_KeAcquireSpinLock@8>
{
  PLIST_ENTRY Flink;
  PLIST_ENTRY Entry;

  Entry = ListHead->Flink;
   11872:	8b 46 4c             	mov    0x4c(%esi),%eax
  Flink = Entry->Flink;
   11875:	8b 00                	mov    (%eax),%eax
   11877:	8d 56 4c             	lea    0x4c(%esi),%edx
  ListHead->Flink = Flink;
   1187a:	89 46 4c             	mov    %eax,0x4c(%esi)
  Flink->Blink = ListHead;
   1187d:	89 50 04             	mov    %edx,0x4(%eax)
	RemoveHeadList(&Mailslot->MessageListHead);
	KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
   11880:	31 c0                	xor    %eax,%eax
   11882:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   11885:	50                   	push   %eax
   11886:	53                   	push   %ebx
   11887:	e8 24 03 00 00       	call   11bb0 <_KeReleaseSpinLock@8>

	ExFreePool(Message);
   1188c:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
   1188f:	50                   	push   %eax
   11890:	53                   	push   %ebx
   11891:	e8 1a 02 00 00       	call   11ab0 <_ExFreePool@4>
	Mailslot->MessageCount--;
   11896:	8b 46 44             	mov    0x44(%esi),%eax
   11899:	48                   	dec    %eax
	if (Mailslot->MessageCount == 0)
   1189a:	83 c4 0c             	add    $0xc,%esp
   1189d:	89 46 44             	mov    %eax,0x44(%esi)
   118a0:	85 c0                	test   %eax,%eax
   118a2:	74 4f                	je     118f3 <_MsfsRead@8+0x123>
	  {
	     KeClearEvent(&Mailslot->MessageEvent);
	  }
     }

   Irp->IoStatus.Status = Status;
   118a4:	8b 45 0c             	mov    0xc(%ebp),%eax
   Irp->IoStatus.Information = LengthRead;
   118a7:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   118aa:	89 50 1c             	mov    %edx,0x1c(%eax)
   118ad:	89 78 18             	mov    %edi,0x18(%eax)

   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   118b0:	52                   	push   %edx
   118b1:	52                   	push   %edx
   118b2:	6a 00                	push   $0x0
   118b4:	50                   	push   %eax
   118b5:	e8 16 02 00 00       	call   11ad0 <_IoCompleteRequest@8>

   return(Status);
   118ba:	89 f8                	mov    %edi,%eax
}
   118bc:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   118bf:	5b                   	pop    %ebx
   118c0:	5e                   	pop    %esi
   118c1:	5f                   	pop    %edi
   118c2:	5d                   	pop    %ebp
   118c3:	c2 08 00             	ret    $0x8
   118c6:	66 8b 42 06          	mov    0x6(%edx),%ax
   118ca:	a8 05                	test   $0x5,%al
   118cc:	74 12                	je     118e0 <_MsfsRead@8+0x110>
   118ce:	8b 5a 0c             	mov    0xc(%edx),%ebx
   118d1:	e9 3c ff ff ff       	jmp    11812 <_MsfsRead@8+0x42>
   118d6:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   118d9:	e9 6d ff ff ff       	jmp    1184b <_MsfsRead@8+0x7b>
   118de:	89 f6                	mov    %esi,%esi
   118e0:	53                   	push   %ebx
   118e1:	53                   	push   %ebx
   118e2:	6a 00                	push   $0x0
   118e4:	52                   	push   %edx
   118e5:	e8 76 02 00 00       	call   11b60 <_MmMapLockedPages@8>
   118ea:	5a                   	pop    %edx
   118eb:	89 c3                	mov    %eax,%ebx
   118ed:	59                   	pop    %ecx
   118ee:	e9 1f ff ff ff       	jmp    11812 <_MsfsRead@8+0x42>
   118f3:	83 ec 0c             	sub    $0xc,%esp
   118f6:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   118f9:	51                   	push   %ecx
   118fa:	e8 71 02 00 00       	call   11b70 <_KeClearEvent@4>
   118ff:	83 c4 0c             	add    $0xc,%esp
   11902:	eb a0                	jmp    118a4 <_MsfsRead@8+0xd4>
   11904:	8b 55 0c             	mov    0xc(%ebp),%edx
   11907:	c7 42 18 22 00 00 c0 	movl   $0xc0000022,0x18(%edx)
   1190e:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   11915:	56                   	push   %esi
   11916:	56                   	push   %esi
   11917:	6a 00                	push   $0x0
   11919:	52                   	push   %edx
   1191a:	e8 b1 01 00 00       	call   11ad0 <_IoCompleteRequest@8>
   1191f:	b8 22 00 00 c0       	mov    $0xc0000022,%eax
   11924:	eb 96                	jmp    118bc <_MsfsRead@8+0xec>
   11926:	8d 76 00             	lea    0x0(%esi),%esi
   11929:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011930 <_MsfsWrite@8>:


NTSTATUS STDCALL
MsfsWrite(PDEVICE_OBJECT DeviceObject,
	  PIRP Irp)
{
   11930:	55                   	push   %ebp
   11931:	89 e5                	mov    %esp,%ebp
   11933:	57                   	push   %edi
   11934:	56                   	push   %esi
   11935:	53                   	push   %ebx
   11936:	83 ec 0c             	sub    $0xc,%esp
   PIO_STACK_LOCATION IoStack;
   PFILE_OBJECT FileObject;
   PMSFS_MAILSLOT Mailslot;
   PMSFS_FCB Fcb;
   PMSFS_MESSAGE Message;
   KIRQL oldIrql;
   ULONG Length;
   PVOID Buffer;
   
   DPRINT("MsfsWrite(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
   
   IoStack = IoGetCurrentIrpStackLocation (Irp);
   11939:	8b 45 0c             	mov    0xc(%ebp),%eax
   1193c:	8b 50 60             	mov    0x60(%eax),%edx
   FileObject = IoStack->FileObject;
   1193f:	8b 42 18             	mov    0x18(%edx),%eax
   Fcb = (PMSFS_FCB)FileObject->FsContext;
   11942:	8b 40 0c             	mov    0xc(%eax),%eax
   Mailslot = Fcb->Mailslot;
   11945:	8b 78 08             	mov    0x8(%eax),%edi
   
   DPRINT("MailslotName: %wZ\n", &Mailslot->Name);
   
   /* writing is not permitted on server side */
   if (Fcb->Mailslot->ServerFcb == Fcb)
   11948:	39 47 1c             	cmp    %eax,0x1c(%edi)
   1194b:	0f 84 02 01 00 00    	je     11a53 <_MsfsWrite@8+0x123>
     {
	Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
	Irp->IoStatus.Information = 0;
	
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	
	return(STATUS_ACCESS_DENIED);
     }

   Length = IoStack->Parameters.Write.Length;
   if (Irp->MdlAddress)
   11951:	8b 45 0c             	mov    0xc(%ebp),%eax
   11954:	8b 52 04             	mov    0x4(%edx),%edx
   11957:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   1195a:	8b 50 04             	mov    0x4(%eax),%edx
   1195d:	85 d2                	test   %edx,%edx
   1195f:	0f 85 91 00 00 00    	jne    119f6 <_MsfsWrite@8+0xc6>
     Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
   else
     Buffer = Irp->UserBuffer;
   11965:	8b 55 0c             	mov    0xc(%ebp),%edx
   11968:	8b 5a 3c             	mov    0x3c(%edx),%ebx
   
   DPRINT("Length: %lu Message: %s\n", Length, (PUCHAR)Buffer);
   
   /* Allocate new message */
   Message = ExAllocatePool(NonPagedPool,
   1196b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1196e:	83 c0 10             	add    $0x10,%eax
   11971:	51                   	push   %ecx
   11972:	51                   	push   %ecx
   11973:	50                   	push   %eax
   11974:	6a 00                	push   $0x0
   11976:	e8 05 01 00 00       	call   11a80 <_ExAllocatePool@8>
   1197b:	89 c6                	mov    %eax,%esi
			    sizeof(MSFS_MESSAGE) + Length);
   if (Message == NULL)
   1197d:	58                   	pop    %eax
   1197e:	85 f6                	test   %esi,%esi
   11980:	5a                   	pop    %edx
   11981:	0f 84 aa 00 00 00    	je     11a31 <_MsfsWrite@8+0x101>
     {
	Irp->IoStatus.Status = STATUS_NO_MEMORY;
	Irp->IoStatus.Information = 0;
	
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	
	return(STATUS_NO_MEMORY);
     }
   
   Message->Size = Length;
   11987:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   memcpy(&Message->Buffer, Buffer, Length);
   1198a:	8d 46 0c             	lea    0xc(%esi),%eax
   1198d:	89 56 08             	mov    %edx,0x8(%esi)
   11990:	51                   	push   %ecx
   11991:	52                   	push   %edx
   11992:	53                   	push   %ebx
   11993:	50                   	push   %eax
   11994:	e8 f7 01 00 00       	call   11b90 <_memcpy>
   
   KeAcquireSpinLock(&Mailslot->MessageListLock, &oldIrql);
   11999:	5b                   	pop    %ebx
   1199a:	8d 5f 48             	lea    0x48(%edi),%ebx
   1199d:	58                   	pop    %eax
   1199e:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   119a1:	50                   	push   %eax
   119a2:	53                   	push   %ebx
   119a3:	e8 f8 01 00 00       	call   11ba0 <_KeAcquireSpinLock@8>
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   119a8:	8d 47 4c             	lea    0x4c(%edi),%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   119ab:	8b 50 04             	mov    0x4(%eax),%edx
	Entry->Flink = ListHead;
   119ae:	89 06                	mov    %eax,(%esi)
	Entry->Blink = OldBlink;
   119b0:	89 56 04             	mov    %edx,0x4(%esi)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   119b3:	89 70 04             	mov    %esi,0x4(%eax)
   InsertTailList(&Mailslot->MessageListHead, &Message->MessageListEntry);
   KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
   119b6:	31 c0                	xor    %eax,%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
	OldBlink->Flink = Entry;
   119b8:	89 32                	mov    %esi,(%edx)
   119ba:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   119bd:	50                   	push   %eax
   119be:	53                   	push   %ebx
   119bf:	e8 ec 01 00 00       	call   11bb0 <_KeReleaseSpinLock@8>
   
   Mailslot->MessageCount++;
   119c4:	8b 47 44             	mov    0x44(%edi),%eax
   119c7:	40                   	inc    %eax
   119c8:	89 47 44             	mov    %eax,0x44(%edi)
   if (Mailslot->MessageCount == 1)
   119cb:	48                   	dec    %eax
   119cc:	5a                   	pop    %edx
   119cd:	59                   	pop    %ecx
   119ce:	74 50                	je     11a20 <_MsfsWrite@8+0xf0>
     {
	KeSetEvent(&Mailslot->MessageEvent,
		   0,
		   FALSE);
     }
   
   Irp->IoStatus.Status = STATUS_SUCCESS;
   119d0:	8b 45 0c             	mov    0xc(%ebp),%eax
   Irp->IoStatus.Information = Length;
   119d3:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   119d6:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   119dd:	89 50 1c             	mov    %edx,0x1c(%eax)
   
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   119e0:	57                   	push   %edi
   119e1:	57                   	push   %edi
   119e2:	6a 00                	push   $0x0
   119e4:	50                   	push   %eax
   119e5:	e8 e6 00 00 00       	call   11ad0 <_IoCompleteRequest@8>
   
   return(STATUS_SUCCESS);
   119ea:	31 c0                	xor    %eax,%eax
}
   119ec:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   119ef:	5b                   	pop    %ebx
   119f0:	5e                   	pop    %esi
   119f1:	5f                   	pop    %edi
   119f2:	5d                   	pop    %ebp
   119f3:	c2 08 00             	ret    $0x8
   119f6:	66 8b 42 06          	mov    0x6(%edx),%ax
   119fa:	a8 05                	test   $0x5,%al
   119fc:	74 08                	je     11a06 <_MsfsWrite@8+0xd6>
   119fe:	8b 5a 0c             	mov    0xc(%edx),%ebx
   11a01:	e9 65 ff ff ff       	jmp    1196b <_MsfsWrite@8+0x3b>
   11a06:	50                   	push   %eax
   11a07:	50                   	push   %eax
   11a08:	6a 00                	push   $0x0
   11a0a:	52                   	push   %edx
   11a0b:	e8 50 01 00 00       	call   11b60 <_MmMapLockedPages@8>
   11a10:	5b                   	pop    %ebx
   11a11:	89 c3                	mov    %eax,%ebx
   11a13:	5e                   	pop    %esi
   11a14:	e9 52 ff ff ff       	jmp    1196b <_MsfsWrite@8+0x3b>
   11a19:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11a20:	50                   	push   %eax
   11a21:	8d 47 30             	lea    0x30(%edi),%eax
   11a24:	6a 00                	push   $0x0
   11a26:	6a 00                	push   $0x0
   11a28:	50                   	push   %eax
   11a29:	e8 52 01 00 00       	call   11b80 <_KeSetEvent@12>
   11a2e:	58                   	pop    %eax
   11a2f:	eb 9f                	jmp    119d0 <_MsfsWrite@8+0xa0>
   11a31:	8b 45 0c             	mov    0xc(%ebp),%eax
   11a34:	c7 40 18 17 00 00 c0 	movl   $0xc0000017,0x18(%eax)
   11a3b:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11a42:	53                   	push   %ebx
   11a43:	53                   	push   %ebx
   11a44:	6a 00                	push   $0x0
   11a46:	50                   	push   %eax
   11a47:	e8 84 00 00 00       	call   11ad0 <_IoCompleteRequest@8>
   11a4c:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
   11a51:	eb 99                	jmp    119ec <_MsfsWrite@8+0xbc>
   11a53:	8b 55 0c             	mov    0xc(%ebp),%edx
   11a56:	c7 42 18 22 00 00 c0 	movl   $0xc0000022,0x18(%edx)
   11a5d:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   11a64:	50                   	push   %eax
   11a65:	50                   	push   %eax
   11a66:	6a 00                	push   $0x0
   11a68:	52                   	push   %edx
   11a69:	e8 62 00 00 00       	call   11ad0 <_IoCompleteRequest@8>
   11a6e:	b8 22 00 00 c0       	mov    $0xc0000022,%eax
   11a73:	e9 74 ff ff ff       	jmp    119ec <_MsfsWrite@8+0xbc>
   11a78:	90                   	nop    
   11a79:	90                   	nop    
   11a7a:	90                   	nop    
   11a7b:	90                   	nop    
   11a7c:	90                   	nop    
   11a7d:	90                   	nop    
   11a7e:	90                   	nop    
   11a7f:	90                   	nop    

00011a80 <_ExAllocatePool@8>:
   11a80:	ff 25 b4 30 01 00    	jmp    *0x130b4
   11a86:	90                   	nop    
   11a87:	90                   	nop    
	...

00011a90 <_KeWaitForSingleObject@20>:
   11a90:	ff 25 dc 30 01 00    	jmp    *0x130dc
   11a96:	90                   	nop    
   11a97:	90                   	nop    
	...

00011aa0 <_RtlCompareUnicodeString@12>:
   11aa0:	ff 25 e4 30 01 00    	jmp    *0x130e4
   11aa6:	90                   	nop    
   11aa7:	90                   	nop    
	...

00011ab0 <_ExFreePool@4>:
   11ab0:	ff 25 b8 30 01 00    	jmp    *0x130b8
   11ab6:	90                   	nop    
   11ab7:	90                   	nop    
	...

00011ac0 <_KeReleaseMutex@8>:
   11ac0:	ff 25 d4 30 01 00    	jmp    *0x130d4
   11ac6:	90                   	nop    
   11ac7:	90                   	nop    
	...

00011ad0 <_IoCompleteRequest@8>:
   11ad0:	ff 25 bc 30 01 00    	jmp    *0x130bc
   11ad6:	90                   	nop    
   11ad7:	90                   	nop    
	...

00011ae0 <_RtlCreateUnicodeString@8>:
   11ae0:	ff 25 e8 30 01 00    	jmp    *0x130e8
   11ae6:	90                   	nop    
   11ae7:	90                   	nop    
	...

00011af0 <_KeInitializeSpinLock@4>:
   11af0:	ff 25 d0 30 01 00    	jmp    *0x130d0
   11af6:	90                   	nop    
   11af7:	90                   	nop    
	...

00011b00 <_KeInitializeEvent@12>:
   11b00:	ff 25 c8 30 01 00    	jmp    *0x130c8
   11b06:	90                   	nop    
   11b07:	90                   	nop    
	...

00011b10 <_RtlFreeUnicodeString@4>:
   11b10:	ff 25 ec 30 01 00    	jmp    *0x130ec
   11b16:	90                   	nop    
   11b17:	90                   	nop    
	...

00011b20 <_DbgPrint>:
   11b20:	ff 25 b0 30 01 00    	jmp    *0x130b0
   11b26:	90                   	nop    
   11b27:	90                   	nop    
	...

00011b30 <_RtlInitUnicodeString@8>:
   11b30:	ff 25 f0 30 01 00    	jmp    *0x130f0
   11b36:	90                   	nop    
   11b37:	90                   	nop    
	...

00011b40 <_IoCreateDevice@28>:
   11b40:	ff 25 c0 30 01 00    	jmp    *0x130c0
   11b46:	90                   	nop    
   11b47:	90                   	nop    
	...

00011b50 <_KeInitializeMutex@8>:
   11b50:	ff 25 cc 30 01 00    	jmp    *0x130cc
   11b56:	90                   	nop    
   11b57:	90                   	nop    
	...

00011b60 <_MmMapLockedPages@8>:
   11b60:	ff 25 e0 30 01 00    	jmp    *0x130e0
   11b66:	90                   	nop    
   11b67:	90                   	nop    
	...

00011b70 <_KeClearEvent@4>:
   11b70:	ff 25 c4 30 01 00    	jmp    *0x130c4
   11b76:	90                   	nop    
   11b77:	90                   	nop    
	...

00011b80 <_KeSetEvent@12>:
   11b80:	ff 25 d8 30 01 00    	jmp    *0x130d8
   11b86:	90                   	nop    
   11b87:	90                   	nop    
	...

00011b90 <_memcpy>:
   11b90:	ff 25 f4 30 01 00    	jmp    *0x130f4
   11b96:	90                   	nop    
   11b97:	90                   	nop    
	...

00011ba0 <_KeAcquireSpinLock@8>:
   11ba0:	ff 25 a0 30 01 00    	jmp    *0x130a0
   11ba6:	90                   	nop    
   11ba7:	90                   	nop    
	...

00011bb0 <_KeReleaseSpinLock@8>:
   11bb0:	ff 25 a4 30 01 00    	jmp    *0x130a4
   11bb6:	90                   	nop    
   11bb7:	90                   	nop    
	...

00011bc0 <__CTOR_LIST__>:
   11bc0:	ff                   	(bad)  
   11bc1:	ff                   	(bad)  
   11bc2:	ff                   	(bad)  
   11bc3:	ff 00                	incl   (%eax)
   11bc5:	00 00                	add    %al,(%eax)
	...

00011bc8 <__DTOR_LIST__>:
   11bc8:	ff                   	(bad)  
   11bc9:	ff                   	(bad)  
   11bca:	ff                   	(bad)  
   11bcb:	ff 00                	incl   (%eax)
   11bcd:	00 00                	add    %al,(%eax)
	...
