Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-11 15:15:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

The MSFS_PIPE struct is actually an FCB (File Control Block). Rename it accordingly and store pointers to it in FileObject->FsContext.

Browse source 
svn path=/trunk/; revision=21962
This commit is contained in:
Eric Kohl 2006-05-21 13:19:10 +00:00
parent b3460406ae
commit 99e8a7e6cb
5 changed files with 190 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

223
reactos/drivers/filesystems/np/create.c
View file

@ -15,23 +15,23 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
static PNPFS_PIPE static PNPFS_FCB
NpfsFindPipe(PNPFS_DEVICE_EXTENSION DeviceExt, NpfsFindPipe(PNPFS_DEVICE_EXTENSION DeviceExt,
PUNICODE_STRING PipeName) PUNICODE_STRING PipeName)
{ {
PLIST_ENTRY CurrentEntry; PLIST_ENTRY CurrentEntry;
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
CurrentEntry = DeviceExt->PipeListHead.Flink; CurrentEntry = DeviceExt->PipeListHead.Flink;
while (CurrentEntry != &DeviceExt->PipeListHead) while (CurrentEntry != &DeviceExt->PipeListHead)
{ {
Pipe = CONTAINING_RECORD(CurrentEntry, NPFS_PIPE, PipeListEntry); Fcb = CONTAINING_RECORD(CurrentEntry, NPFS_FCB, PipeListEntry);
if (RtlCompareUnicodeString(PipeName, if (RtlCompareUnicodeString(PipeName,
&Pipe->PipeName, &Fcb->PipeName,
TRUE) == 0) TRUE) == 0)
{ {
DPRINT("<%wZ> = <%wZ>\n", PipeName, &Pipe->PipeName); DPRINT("<%wZ> = <%wZ>\n", PipeName, &Fcb->PipeName);
return Pipe; return Fcb;
} }
CurrentEntry = CurrentEntry->Flink; CurrentEntry = CurrentEntry->Flink;
@ -42,15 +42,15 @@ NpfsFindPipe(PNPFS_DEVICE_EXTENSION DeviceExt,
static PNPFS_CCB static PNPFS_CCB
NpfsFindListeningServerInstance(PNPFS_PIPE Pipe) NpfsFindListeningServerInstance(PNPFS_FCB Fcb)
{ {
PLIST_ENTRY CurrentEntry; PLIST_ENTRY CurrentEntry;
PNPFS_WAITER_ENTRY Waiter; PNPFS_WAITER_ENTRY Waiter;
KIRQL oldIrql; KIRQL oldIrql;
PIRP Irp; PIRP Irp;
CurrentEntry = Pipe->WaiterListHead.Flink; CurrentEntry = Fcb->WaiterListHead.Flink;
while (CurrentEntry != &Pipe->WaiterListHead) while (CurrentEntry != &Fcb->WaiterListHead)
{ {
Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext); Irp = CONTAINING_RECORD(Waiter, IRP, Tail.Overlay.DriverContext);
@ -76,15 +76,15 @@ NpfsFindListeningServerInstance(PNPFS_PIPE Pipe)
static VOID static VOID
NpfsSignalAndRemoveListeningServerInstance(PNPFS_PIPE Pipe, NpfsSignalAndRemoveListeningServerInstance(PNPFS_FCB Fcb,
PNPFS_CCB Ccb) PNPFS_CCB Ccb)
{ {
PLIST_ENTRY CurrentEntry; PLIST_ENTRY CurrentEntry;
PNPFS_WAITER_ENTRY Waiter; PNPFS_WAITER_ENTRY Waiter;
PIRP Irp; PIRP Irp;
CurrentEntry = Pipe->WaiterListHead.Flink; CurrentEntry = Fcb->WaiterListHead.Flink;
while (CurrentEntry != &Pipe->WaiterListHead) while (CurrentEntry != &Fcb->WaiterListHead)
{ {
Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry); Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
if (Waiter->Ccb == Ccb) if (Waiter->Ccb == Ccb)
@ -109,7 +109,7 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
{ {
PEXTENDED_IO_STACK_LOCATION IoStack; PEXTENDED_IO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
PNPFS_CCB ClientCcb; PNPFS_CCB ClientCcb;
PNPFS_CCB ServerCcb = NULL; PNPFS_CCB ServerCcb = NULL;
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
@ -137,9 +137,9 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
* Step 1. Find the pipe we're trying to open. * Step 1. Find the pipe we're trying to open.
*/ */
KeLockMutex(&DeviceExt->PipeListLock); KeLockMutex(&DeviceExt->PipeListLock);
Pipe = NpfsFindPipe(DeviceExt, Fcb = NpfsFindPipe(DeviceExt,
&FileObject->FileName); &FileObject->FileName);
if (Pipe == NULL) if (Fcb == NULL)
{ {
/* Not found, bail out with error. */ /* Not found, bail out with error. */
DPRINT("No pipe found!\n"); DPRINT("No pipe found!\n");
@ -155,7 +155,7 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
* Acquire the lock for CCB lists. From now on no modifications to the * Acquire the lock for CCB lists. From now on no modifications to the
* CCB lists are allowed, because it can cause various misconsistencies. * CCB lists are allowed, because it can cause various misconsistencies.
*/ */
KeLockMutex(&Pipe->CcbListLock); KeLockMutex(&Fcb->CcbListLock);
/* /*
* Step 2. Create the client CCB. * Step 2. Create the client CCB.
@ -164,14 +164,14 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
if (ClientCcb == NULL) if (ClientCcb == NULL)
{ {
DPRINT("No memory!\n"); DPRINT("No memory!\n");
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
ClientCcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread; ClientCcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
ClientCcb->Pipe = Pipe; ClientCcb->Fcb = Fcb;
ClientCcb->PipeEnd = FILE_PIPE_CLIENT_END; ClientCcb->PipeEnd = FILE_PIPE_CLIENT_END;
ClientCcb->OtherSide = NULL; ClientCcb->OtherSide = NULL;
ClientCcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE; ClientCcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE;
@ -180,14 +180,14 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
DPRINT("CCB: %p\n", ClientCcb); DPRINT("CCB: %p\n", ClientCcb);
/* Initialize data list. */ /* Initialize data list. */
if (Pipe->OutboundQuota) if (Fcb->OutboundQuota)
{ {
ClientCcb->Data = ExAllocatePool(PagedPool, Pipe->OutboundQuota); ClientCcb->Data = ExAllocatePool(PagedPool, Fcb->OutboundQuota);
if (ClientCcb->Data == NULL) if (ClientCcb->Data == NULL)
{ {
DPRINT("No memory!\n"); DPRINT("No memory!\n");
ExFreePool(ClientCcb); ExFreePool(ClientCcb);
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
@ -201,8 +201,8 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
ClientCcb->ReadPtr = ClientCcb->Data; ClientCcb->ReadPtr = ClientCcb->Data;
ClientCcb->WritePtr = ClientCcb->Data; ClientCcb->WritePtr = ClientCcb->Data;
ClientCcb->ReadDataAvailable = 0; ClientCcb->ReadDataAvailable = 0;
ClientCcb->WriteQuotaAvailable = Pipe->OutboundQuota; ClientCcb->WriteQuotaAvailable = Fcb->OutboundQuota;
ClientCcb->MaxDataLength = Pipe->OutboundQuota; ClientCcb->MaxDataLength = Fcb->OutboundQuota;
ExInitializeFastMutex(&ClientCcb->DataListLock); ExInitializeFastMutex(&ClientCcb->DataListLock);
KeInitializeEvent(&ClientCcb->ConnectEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&ClientCcb->ConnectEvent, SynchronizationEvent, FALSE);
KeInitializeEvent(&ClientCcb->ReadEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&ClientCcb->ReadEvent, SynchronizationEvent, FALSE);
@ -221,7 +221,7 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
* complete even this request. * complete even this request.
*/ */
ServerCcb = NpfsFindListeningServerInstance(Pipe); ServerCcb = NpfsFindListeningServerInstance(Fcb);
if (ServerCcb == NULL) if (ServerCcb == NULL)
{ {
PLIST_ENTRY CurrentEntry; PLIST_ENTRY CurrentEntry;
@ -232,8 +232,8 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
* one of the listing server CCB on the pipe. * one of the listing server CCB on the pipe.
*/ */
CurrentEntry = Pipe->ServerCcbListHead.Flink; CurrentEntry = Fcb->ServerCcbListHead.Flink;
while (CurrentEntry != &Pipe->ServerCcbListHead) while (CurrentEntry != &Fcb->ServerCcbListHead)
{ {
Ccb = CONTAINING_RECORD(CurrentEntry, NPFS_CCB, CcbListEntry); Ccb = CONTAINING_RECORD(CurrentEntry, NPFS_CCB, CcbListEntry);
if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE) if (Ccb->PipeState == FILE_PIPE_LISTENING_STATE)
@ -254,7 +254,7 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
DPRINT("No listening server CCB found!\n"); DPRINT("No listening server CCB found!\n");
if (ClientCcb->Data) if (ClientCcb->Data)
ExFreePool(ClientCcb->Data); ExFreePool(ClientCcb->Data);
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
Irp->IoStatus.Status = STATUS_PIPE_BUSY; Irp->IoStatus.Status = STATUS_PIPE_BUSY;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_PIPE_BUSY; return STATUS_PIPE_BUSY;
@ -264,13 +264,13 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
{ {
/* Signal the server thread and remove it from the waiter list */ /* Signal the server thread and remove it from the waiter list */
/* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */ /* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */
NpfsSignalAndRemoveListeningServerInstance(Pipe, ServerCcb); NpfsSignalAndRemoveListeningServerInstance(Fcb, ServerCcb);
} }
} }
else if (IsListEmpty(&Pipe->ServerCcbListHead)) else if (IsListEmpty(&Fcb->ServerCcbListHead))
{ {
DPRINT("No server fcb found!\n"); DPRINT("No server fcb found!\n");
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL; Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
@ -281,7 +281,7 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
*/ */
/* Add the client CCB to the pipe CCB list. */ /* Add the client CCB to the pipe CCB list. */
InsertTailList(&Pipe->ClientCcbListHead, &ClientCcb->CcbListEntry); InsertTailList(&Fcb->ClientCcbListHead, &ClientCcb->CcbListEntry);
/* Connect to listening server side */ /* Connect to listening server side */
if (ServerCcb) if (ServerCcb)
@ -292,8 +292,9 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
ServerCcb->PipeState = FILE_PIPE_CONNECTED_STATE; ServerCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
} }
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
FileObject->FsContext = Fcb;
FileObject->FsContext2 = ClientCcb; FileObject->FsContext2 = ClientCcb;
FileObject->Flags |= FO_NAMED_PIPE; FileObject->Flags |= FO_NAMED_PIPE;
@ -313,7 +314,7 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
PEXTENDED_IO_STACK_LOCATION IoStack; PEXTENDED_IO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
PNPFS_CCB Ccb; PNPFS_CCB Ccb;
PNAMED_PIPE_CREATE_PARAMETERS Buffer; PNAMED_PIPE_CREATE_PARAMETERS Buffer;
BOOLEAN NewPipe = FALSE; BOOLEAN NewPipe = FALSE;
@ -352,9 +353,9 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
/* /*
* First search for existing Pipe with the same name. * First search for existing Pipe with the same name.
*/ */
Pipe = NpfsFindPipe(DeviceExt, Fcb = NpfsFindPipe(DeviceExt,
&FileObject->FileName); &FileObject->FileName);
if (Pipe != NULL) if (Fcb != NULL)
{ {
/* /*
* Found Pipe with the same name. Check if we are * Found Pipe with the same name. Check if we are
@ -362,7 +363,7 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
*/ */
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
if (Pipe->CurrentInstances >= Pipe->MaximumInstances) if (Fcb->CurrentInstances >= Fcb->MaximumInstances)
{ {
DPRINT("Out of instances.\n"); DPRINT("Out of instances.\n");
ExFreePool(Ccb); ExFreePool(Ccb);
@ -372,8 +373,8 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
} }
/* FIXME: Check pipe modes also! */ /* FIXME: Check pipe modes also! */
if (Pipe->MaximumInstances != Buffer->MaximumInstances || if (Fcb->MaximumInstances != Buffer->MaximumInstances ||
Pipe->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart) Fcb->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart)
{ {
DPRINT("Asked for invalid pipe mode.\n"); DPRINT("Asked for invalid pipe mode.\n");
ExFreePool(Ccb); ExFreePool(Ccb);
@ -385,8 +386,8 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
else else
{ {
NewPipe = TRUE; NewPipe = TRUE;
Pipe = ExAllocatePool(NonPagedPool, sizeof(NPFS_PIPE)); Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB));
if (Pipe == NULL) if (Fcb == NULL)
{ {
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
@ -395,13 +396,13 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
Pipe->PipeName.Length = FileObject->FileName.Length; Fcb->PipeName.Length = FileObject->FileName.Length;
Pipe->PipeName.MaximumLength = Pipe->PipeName.Length + sizeof(UNICODE_NULL); Fcb->PipeName.MaximumLength = Fcb->PipeName.Length + sizeof(UNICODE_NULL);
Pipe->PipeName.Buffer = ExAllocatePool(NonPagedPool, Pipe->PipeName.MaximumLength); Fcb->PipeName.Buffer = ExAllocatePool(NonPagedPool, Fcb->PipeName.MaximumLength);
if (Pipe->PipeName.Buffer == NULL) if (Fcb->PipeName.Buffer == NULL)
{ {
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
ExFreePool(Pipe); ExFreePool(Fcb);
ExFreePool(Ccb); ExFreePool(Ccb);
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
@ -409,88 +410,88 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
RtlCopyUnicodeString(&Pipe->PipeName, &FileObject->FileName); RtlCopyUnicodeString(&Fcb->PipeName, &FileObject->FileName);
InitializeListHead(&Pipe->ServerCcbListHead); InitializeListHead(&Fcb->ServerCcbListHead);
InitializeListHead(&Pipe->ClientCcbListHead); InitializeListHead(&Fcb->ClientCcbListHead);
InitializeListHead(&Pipe->WaiterListHead); InitializeListHead(&Fcb->WaiterListHead);
KeInitializeMutex(&Pipe->CcbListLock, 0); KeInitializeMutex(&Fcb->CcbListLock, 0);
Pipe->PipeType = Buffer->NamedPipeType; Fcb->PipeType = Buffer->NamedPipeType;
Pipe->WriteMode = Buffer->ReadMode; Fcb->WriteMode = Buffer->ReadMode;
Pipe->ReadMode = Buffer->ReadMode; Fcb->ReadMode = Buffer->ReadMode;
Pipe->CompletionMode = Buffer->CompletionMode; Fcb->CompletionMode = Buffer->CompletionMode;
switch (IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE)) switch (IoStack->Parameters.CreatePipe.ShareAccess & (FILE_SHARE_READ|FILE_SHARE_WRITE))
{ {
case FILE_SHARE_READ: case FILE_SHARE_READ:
Pipe->PipeConfiguration = FILE_PIPE_OUTBOUND; Fcb->PipeConfiguration = FILE_PIPE_OUTBOUND;
break; break;
case FILE_SHARE_WRITE: case FILE_SHARE_WRITE:
Pipe->PipeConfiguration = FILE_PIPE_INBOUND; Fcb->PipeConfiguration = FILE_PIPE_INBOUND;
break; break;
case FILE_SHARE_READ|FILE_SHARE_WRITE: case FILE_SHARE_READ|FILE_SHARE_WRITE:
Pipe->PipeConfiguration = FILE_PIPE_FULL_DUPLEX; Fcb->PipeConfiguration = FILE_PIPE_FULL_DUPLEX;
break; break;
} }
Pipe->MaximumInstances = Buffer->MaximumInstances; Fcb->MaximumInstances = Buffer->MaximumInstances;
Pipe->CurrentInstances = 0; Fcb->CurrentInstances = 0;
Pipe->TimeOut = Buffer->DefaultTimeout; Fcb->TimeOut = Buffer->DefaultTimeout;
if (!(Pipe->PipeConfiguration & FILE_PIPE_OUTBOUND) || if (!(Fcb->PipeConfiguration & FILE_PIPE_OUTBOUND) ||
Pipe->PipeConfiguration & FILE_PIPE_FULL_DUPLEX) Fcb->PipeConfiguration & FILE_PIPE_FULL_DUPLEX)
{ {
if (Buffer->InboundQuota == 0) if (Buffer->InboundQuota == 0)
{ {
Pipe->InboundQuota = DeviceExt->DefaultQuota; Fcb->InboundQuota = DeviceExt->DefaultQuota;
} }
else else
{ {
Pipe->InboundQuota = PAGE_ROUND_UP(Buffer->InboundQuota); Fcb->InboundQuota = PAGE_ROUND_UP(Buffer->InboundQuota);
if (Pipe->InboundQuota < DeviceExt->MinQuota) if (Fcb->InboundQuota < DeviceExt->MinQuota)
{ {
Pipe->InboundQuota = DeviceExt->MinQuota; Fcb->InboundQuota = DeviceExt->MinQuota;
} }
else if (Pipe->InboundQuota > DeviceExt->MaxQuota) else if (Fcb->InboundQuota > DeviceExt->MaxQuota)
{ {
Pipe->InboundQuota = DeviceExt->MaxQuota; Fcb->InboundQuota = DeviceExt->MaxQuota;
} }
} }
} }
else else
{ {
Pipe->InboundQuota = 0; Fcb->InboundQuota = 0;
} }
if (Pipe->PipeConfiguration & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND)) if (Fcb->PipeConfiguration & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND))
{ {
if (Buffer->OutboundQuota == 0) if (Buffer->OutboundQuota == 0)
{ {
Pipe->OutboundQuota = DeviceExt->DefaultQuota; Fcb->OutboundQuota = DeviceExt->DefaultQuota;
} }
else else
{ {
Pipe->OutboundQuota = PAGE_ROUND_UP(Buffer->OutboundQuota); Fcb->OutboundQuota = PAGE_ROUND_UP(Buffer->OutboundQuota);
if (Pipe->OutboundQuota < DeviceExt->MinQuota) if (Fcb->OutboundQuota < DeviceExt->MinQuota)
{ {
Pipe->OutboundQuota = DeviceExt->MinQuota; Fcb->OutboundQuota = DeviceExt->MinQuota;
} }
else if (Pipe->OutboundQuota > DeviceExt->MaxQuota) else if (Fcb->OutboundQuota > DeviceExt->MaxQuota)
{ {
Pipe->OutboundQuota = DeviceExt->MaxQuota; Fcb->OutboundQuota = DeviceExt->MaxQuota;
} }
} }
} }
else else
{ {
Pipe->OutboundQuota = 0; Fcb->OutboundQuota = 0;
} }
InsertTailList(&DeviceExt->PipeListHead, &Pipe->PipeListEntry); InsertTailList(&DeviceExt->PipeListHead, &Fcb->PipeListEntry);
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
} }
if (Pipe->InboundQuota) if (Fcb->InboundQuota)
{ {
Ccb->Data = ExAllocatePool(PagedPool, Pipe->InboundQuota); Ccb->Data = ExAllocatePool(PagedPool, Fcb->InboundQuota);
if (Ccb->Data == NULL) if (Ccb->Data == NULL)
{ {
ExFreePool(Ccb); ExFreePool(Ccb);
@ -498,10 +499,10 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
if (NewPipe) if (NewPipe)
{ {
KeLockMutex(&DeviceExt->PipeListLock); KeLockMutex(&DeviceExt->PipeListLock);
RemoveEntryList(&Pipe->PipeListEntry); RemoveEntryList(&Fcb->PipeListEntry);
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
RtlFreeUnicodeString(&Pipe->PipeName); RtlFreeUnicodeString(&Fcb->PipeName);
ExFreePool(Pipe); ExFreePool(Fcb);
} }
Irp->IoStatus.Status = STATUS_NO_MEMORY; Irp->IoStatus.Status = STATUS_NO_MEMORY;
@ -517,14 +518,14 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
Ccb->ReadPtr = Ccb->Data; Ccb->ReadPtr = Ccb->Data;
Ccb->WritePtr = Ccb->Data; Ccb->WritePtr = Ccb->Data;
Ccb->ReadDataAvailable = 0; Ccb->ReadDataAvailable = 0;
Ccb->WriteQuotaAvailable = Pipe->InboundQuota; Ccb->WriteQuotaAvailable = Fcb->InboundQuota;
Ccb->MaxDataLength = Pipe->InboundQuota; Ccb->MaxDataLength = Fcb->InboundQuota;
InitializeListHead(&Ccb->ReadRequestListHead); InitializeListHead(&Ccb->ReadRequestListHead);
ExInitializeFastMutex(&Ccb->DataListLock); ExInitializeFastMutex(&Ccb->DataListLock);
Pipe->CurrentInstances++; Fcb->CurrentInstances++;
Ccb->Pipe = Pipe; Ccb->Fcb = Fcb;
Ccb->PipeEnd = FILE_PIPE_SERVER_END; Ccb->PipeEnd = FILE_PIPE_SERVER_END;
Ccb->PipeState = FILE_PIPE_LISTENING_STATE; Ccb->PipeState = FILE_PIPE_LISTENING_STATE;
Ccb->OtherSide = NULL; Ccb->OtherSide = NULL;
@ -535,10 +536,11 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
KeInitializeEvent(&Ccb->ReadEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&Ccb->ReadEvent, SynchronizationEvent, FALSE);
KeInitializeEvent(&Ccb->WriteEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&Ccb->WriteEvent, SynchronizationEvent, FALSE);
KeLockMutex(&Pipe->CcbListLock); KeLockMutex(&Fcb->CcbListLock);
InsertTailList(&Pipe->ServerCcbListHead, &Ccb->CcbListEntry); InsertTailList(&Fcb->ServerCcbListHead, &Ccb->CcbListEntry);
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
FileObject->FsContext = Fcb;
FileObject->FsContext2 = Ccb; FileObject->FsContext2 = Ccb;
FileObject->Flags |= FO_NAMED_PIPE; FileObject->Flags |= FO_NAMED_PIPE;
@ -559,7 +561,7 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_CCB Ccb, OtherSide; PNPFS_CCB Ccb, OtherSide;
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
BOOLEAN Server; BOOLEAN Server;
DPRINT("NpfsCleanup(DeviceObject %p Irp %p)\n", DeviceObject, Irp); DPRINT("NpfsCleanup(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
@ -579,11 +581,11 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
} }
DPRINT("CCB %p\n", Ccb); DPRINT("CCB %p\n", Ccb);
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
DPRINT("Cleaning pipe %wZ\n", &Pipe->PipeName); DPRINT("Cleaning pipe %wZ\n", &Fcb->PipeName);
KeLockMutex(&Pipe->CcbListLock); KeLockMutex(&Fcb->CcbListLock);
Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);
@ -637,8 +639,8 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
KIRQL oldIrql; KIRQL oldIrql;
PIRP tmpIrp; PIRP tmpIrp;
Entry = Ccb->Pipe->WaiterListHead.Flink; Entry = Ccb->Fcb->WaiterListHead.Flink;
while (Entry != &Ccb->Pipe->WaiterListHead) while (Entry != &Ccb->Fcb->WaiterListHead)
{ {
WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry);
if (WaitEntry->Ccb == Ccb) if (WaitEntry->Ccb == Ccb)
@ -666,7 +668,7 @@ NpfsCleanup(PDEVICE_OBJECT DeviceObject,
} }
Ccb->PipeState = FILE_PIPE_CLOSING_STATE; Ccb->PipeState = FILE_PIPE_CLOSING_STATE;
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
ExAcquireFastMutex(&Ccb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
if (Ccb->Data) if (Ccb->Data)
@ -694,8 +696,8 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_FCB Fcb;
PNPFS_CCB Ccb; PNPFS_CCB Ccb;
PNPFS_PIPE Pipe;
BOOLEAN Server; BOOLEAN Server;
DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp); DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
@ -715,18 +717,18 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
} }
DPRINT("CCB %x\n", Ccb); DPRINT("CCB %x\n", Ccb);
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
DPRINT("Closing pipe %wZ\n", &Pipe->PipeName); DPRINT("Closing pipe %wZ\n", &Fcb->PipeName);
KeLockMutex(&Pipe->CcbListLock); KeLockMutex(&Fcb->CcbListLock);
Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END); Server = (Ccb->PipeEnd == FILE_PIPE_SERVER_END);
if (Server) if (Server)
{ {
DPRINT("Server\n"); DPRINT("Server\n");
Pipe->CurrentInstances--; Fcb->CurrentInstances--;
} }
else else
{ {
@ -741,16 +743,17 @@ NpfsClose(PDEVICE_OBJECT DeviceObject,
ExFreePool(Ccb); ExFreePool(Ccb);
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
if (IsListEmpty(&Pipe->ServerCcbListHead) && if (IsListEmpty(&Fcb->ServerCcbListHead) &&
IsListEmpty(&Pipe->ClientCcbListHead)) IsListEmpty(&Fcb->ClientCcbListHead))
{ {
RtlFreeUnicodeString(&Pipe->PipeName); RtlFreeUnicodeString(&Fcb->PipeName);
KeLockMutex(&DeviceExt->PipeListLock); KeLockMutex(&DeviceExt->PipeListLock);
RemoveEntryList(&Pipe->PipeListEntry); RemoveEntryList(&Fcb->PipeListEntry);
KeUnlockMutex(&DeviceExt->PipeListLock); KeUnlockMutex(&DeviceExt->PipeListLock);
ExFreePool(Pipe); ExFreePool(Fcb);
FileObject->FsContext = NULL;
} }
Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Status = STATUS_SUCCESS;

60
reactos/drivers/filesystems/np/finfo.c
View file

@ -22,17 +22,17 @@ NpfsSetPipeInformation(PDEVICE_OBJECT DeviceObject,
PFILE_PIPE_INFORMATION Info, PFILE_PIPE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
PFILE_PIPE_INFORMATION Request; PFILE_PIPE_INFORMATION Request;
DPRINT("NpfsSetPipeInformation()\n"); DPRINT("NpfsSetPipeInformation()\n");
/* Get the Pipe and data */ /* Get the Pipe and data */
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
Request = (PFILE_PIPE_INFORMATION)Info; Request = (PFILE_PIPE_INFORMATION)Info;
/* Set Pipe Data */ /* Set Pipe Data */
Pipe->ReadMode = Request->ReadMode; Fcb->ReadMode = Request->ReadMode;
Pipe->CompletionMode = Request->CompletionMode; Fcb->CompletionMode = Request->CompletionMode;
/* Return Success */ /* Return Success */
return STATUS_SUCCESS; return STATUS_SUCCESS;
@ -45,17 +45,17 @@ NpfsSetPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
PFILE_PIPE_INFORMATION Info, PFILE_PIPE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
PFILE_PIPE_REMOTE_INFORMATION Request; PFILE_PIPE_REMOTE_INFORMATION Request;
DPRINT("NpfsSetPipeRemoteInformation()\n"); DPRINT("NpfsSetPipeRemoteInformation()\n");
/* Get the Pipe and data */ /* Get the Pipe and data */
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
Request = (PFILE_PIPE_REMOTE_INFORMATION)Info; Request = (PFILE_PIPE_REMOTE_INFORMATION)Info;
/* Set the Settings */ /* Set the Settings */
Pipe->TimeOut = Request->CollectDataTime; Fcb->TimeOut = Request->CollectDataTime;
Pipe->InboundQuota = Request->MaximumCollectionCount; Fcb->InboundQuota = Request->MaximumCollectionCount;
/* Return Success */ /* Return Success */
return STATUS_SUCCESS; return STATUS_SUCCESS;
@ -68,18 +68,18 @@ NpfsQueryPipeInformation(PDEVICE_OBJECT DeviceObject,
PFILE_PIPE_INFORMATION Info, PFILE_PIPE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
DPRINT("NpfsQueryPipeInformation()\n"); DPRINT("NpfsQueryPipeInformation()\n");
/* Get the Pipe */ /* Get the Pipe */
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
/* Clear Info */ /* Clear Info */
RtlZeroMemory(Info, sizeof(FILE_PIPE_INFORMATION)); RtlZeroMemory(Info, sizeof(FILE_PIPE_INFORMATION));
/* Return Info */ /* Return Info */
Info->CompletionMode = Pipe->CompletionMode; Info->CompletionMode = Fcb->CompletionMode;
Info->ReadMode = Pipe->ReadMode; Info->ReadMode = Fcb->ReadMode;
/* Return success */ /* Return success */
*BufferLength -= sizeof(FILE_PIPE_INFORMATION); *BufferLength -= sizeof(FILE_PIPE_INFORMATION);
@ -93,18 +93,18 @@ NpfsQueryPipeRemoteInformation(PDEVICE_OBJECT DeviceObject,
PFILE_PIPE_REMOTE_INFORMATION Info, PFILE_PIPE_REMOTE_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
DPRINT("NpfsQueryPipeRemoteInformation()\n"); DPRINT("NpfsQueryPipeRemoteInformation()\n");
/* Get the Pipe */ /* Get the Pipe */
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
/* Clear Info */ /* Clear Info */
RtlZeroMemory(Info, sizeof(FILE_PIPE_REMOTE_INFORMATION)); RtlZeroMemory(Info, sizeof(FILE_PIPE_REMOTE_INFORMATION));
/* Return Info */ /* Return Info */
Info->MaximumCollectionCount = Pipe->InboundQuota; Info->MaximumCollectionCount = Fcb->InboundQuota;
Info->CollectDataTime = Pipe->TimeOut; Info->CollectDataTime = Fcb->TimeOut;
/* Return success */ /* Return success */
*BufferLength -= sizeof(FILE_PIPE_REMOTE_INFORMATION); *BufferLength -= sizeof(FILE_PIPE_REMOTE_INFORMATION);
@ -118,21 +118,21 @@ NpfsQueryLocalPipeInformation(PDEVICE_OBJECT DeviceObject,
PFILE_PIPE_LOCAL_INFORMATION Info, PFILE_PIPE_LOCAL_INFORMATION Info,
PULONG BufferLength) PULONG BufferLength)
{ {
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
DPRINT("NpfsQueryLocalPipeInformation()\n"); DPRINT("NpfsQueryLocalPipeInformation()\n");
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
RtlZeroMemory(Info, RtlZeroMemory(Info,
sizeof(FILE_PIPE_LOCAL_INFORMATION)); sizeof(FILE_PIPE_LOCAL_INFORMATION));
Info->NamedPipeType = Pipe->PipeType; Info->NamedPipeType = Fcb->PipeType;
Info->NamedPipeConfiguration = Pipe->PipeConfiguration; Info->NamedPipeConfiguration = Fcb->PipeConfiguration;
Info->MaximumInstances = Pipe->MaximumInstances; Info->MaximumInstances = Fcb->MaximumInstances;
Info->CurrentInstances = Pipe->CurrentInstances; Info->CurrentInstances = Fcb->CurrentInstances;
Info->InboundQuota = Pipe->InboundQuota; Info->InboundQuota = Fcb->InboundQuota;
Info->OutboundQuota = Pipe->OutboundQuota; Info->OutboundQuota = Fcb->OutboundQuota;
Info->NamedPipeState = Ccb->PipeState; Info->NamedPipeState = Ccb->PipeState;
Info->NamedPipeEnd = Ccb->PipeEnd; Info->NamedPipeEnd = Ccb->PipeEnd;
@ -160,8 +160,8 @@ NpfsQueryInformation(PDEVICE_OBJECT DeviceObject,
FILE_INFORMATION_CLASS FileInformationClass; FILE_INFORMATION_CLASS FileInformationClass;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_DEVICE_EXTENSION DeviceExtension; PNPFS_DEVICE_EXTENSION DeviceExtension;
PNPFS_FCB Fcb;
PNPFS_CCB Ccb; PNPFS_CCB Ccb;
PNPFS_PIPE Pipe;
PVOID SystemBuffer; PVOID SystemBuffer;
ULONG BufferLength; ULONG BufferLength;
NTSTATUS Status; NTSTATUS Status;
@ -173,12 +173,12 @@ NpfsQueryInformation(PDEVICE_OBJECT DeviceObject,
DeviceExtension = DeviceObject->DeviceExtension; DeviceExtension = DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject; FileObject = IoStack->FileObject;
Ccb = (PNPFS_CCB)FileObject->FsContext2; Ccb = (PNPFS_CCB)FileObject->FsContext2;
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
SystemBuffer = Irp->AssociatedIrp.SystemBuffer; SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
BufferLength = IoStack->Parameters.QueryFile.Length; BufferLength = IoStack->Parameters.QueryFile.Length;
DPRINT("Pipe name: %wZ\n", &Pipe->PipeName); DPRINT("Pipe name: %wZ\n", &Fcb->PipeName);
DPRINT("FileInformationClass %d\n", FileInformationClass); DPRINT("FileInformationClass %d\n", FileInformationClass);
DPRINT("SystemBuffer %p\n", SystemBuffer); DPRINT("SystemBuffer %p\n", SystemBuffer);
DPRINT("BufferLength %lu\n", BufferLength); DPRINT("BufferLength %lu\n", BufferLength);
@ -229,8 +229,8 @@ NpfsSetInformation(PDEVICE_OBJECT DeviceObject,
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
FILE_INFORMATION_CLASS FileInformationClass; FILE_INFORMATION_CLASS FileInformationClass;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_FCB Fcb;
PNPFS_CCB Ccb; PNPFS_CCB Ccb;
PNPFS_PIPE Pipe;
PVOID SystemBuffer; PVOID SystemBuffer;
ULONG BufferLength; ULONG BufferLength;
NTSTATUS Status; NTSTATUS Status;
@ -241,12 +241,12 @@ NpfsSetInformation(PDEVICE_OBJECT DeviceObject,
FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass; FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
FileObject = IoStack->FileObject; FileObject = IoStack->FileObject;
Ccb = (PNPFS_CCB)FileObject->FsContext2; Ccb = (PNPFS_CCB)FileObject->FsContext2;
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
SystemBuffer = Irp->AssociatedIrp.SystemBuffer; SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
BufferLength = IoStack->Parameters.QueryFile.Length; BufferLength = IoStack->Parameters.QueryFile.Length;
DPRINT("Pipe name: %wZ\n", &Pipe->PipeName); DPRINT("Pipe name: %wZ\n", &Fcb->PipeName);
DPRINT("FileInformationClass %d\n", FileInformationClass); DPRINT("FileInformationClass %d\n", FileInformationClass);
DPRINT("SystemBuffer %p\n", SystemBuffer); DPRINT("SystemBuffer %p\n", SystemBuffer);
DPRINT("BufferLength %lu\n", BufferLength); DPRINT("BufferLength %lu\n", BufferLength);

68
reactos/drivers/filesystems/np/fsctrl.c
View file

@ -25,14 +25,14 @@ NpfsListeningCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
Waiter = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext; Waiter = (PNPFS_WAITER_ENTRY)&Irp->Tail.Overlay.DriverContext;
DPRINT1("NpfsListeningCancelRoutine() called for <%wZ>\n", DPRINT1("NpfsListeningCancelRoutine() called for <%wZ>\n",
&Waiter->Ccb->Pipe->PipeName); &Waiter->Ccb->Fcb->PipeName);
IoReleaseCancelSpinLock(Irp->CancelIrql); IoReleaseCancelSpinLock(Irp->CancelIrql);
KeLockMutex(&Waiter->Ccb->Pipe->CcbListLock); KeLockMutex(&Waiter->Ccb->Fcb->CcbListLock);
RemoveEntryList(&Waiter->Entry); RemoveEntryList(&Waiter->Entry);
KeUnlockMutex(&Waiter->Ccb->Pipe->CcbListLock); KeUnlockMutex(&Waiter->Ccb->Fcb->CcbListLock);
Irp->IoStatus.Status = STATUS_CANCELLED; Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
@ -51,17 +51,17 @@ NpfsAddListeningServerInstance(PIRP Irp,
Entry->Ccb = Ccb; Entry->Ccb = Ccb;
KeLockMutex(&Ccb->Pipe->CcbListLock); KeLockMutex(&Ccb->Fcb->CcbListLock);
IoMarkIrpPending(Irp); IoMarkIrpPending(Irp);
InsertTailList(&Ccb->Pipe->WaiterListHead, &Entry->Entry); InsertTailList(&Ccb->Fcb->WaiterListHead, &Entry->Entry);
IoAcquireCancelSpinLock(&oldIrql); IoAcquireCancelSpinLock(&oldIrql);
if (!Irp->Cancel) if (!Irp->Cancel)
{ {
(void)IoSetCancelRoutine(Irp, NpfsListeningCancelRoutine); (void)IoSetCancelRoutine(Irp, NpfsListeningCancelRoutine);
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
KeUnlockMutex(&Ccb->Pipe->CcbListLock); KeUnlockMutex(&Ccb->Fcb->CcbListLock);
return STATUS_PENDING; return STATUS_PENDING;
} }
IoReleaseCancelSpinLock(oldIrql); IoReleaseCancelSpinLock(oldIrql);
@ -71,7 +71,7 @@ NpfsAddListeningServerInstance(PIRP Irp,
Irp->IoStatus.Status = STATUS_CANCELLED; Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
KeUnlockMutex(&Ccb->Pipe->CcbListLock); KeUnlockMutex(&Ccb->Fcb->CcbListLock);
return STATUS_CANCELLED; return STATUS_CANCELLED;
} }
@ -81,8 +81,8 @@ static NTSTATUS
NpfsConnectPipe(PIRP Irp, NpfsConnectPipe(PIRP Irp,
PNPFS_CCB Ccb) PNPFS_CCB Ccb)
{ {
PNPFS_PIPE Pipe;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PNPFS_FCB Fcb;
PNPFS_CCB ClientCcb; PNPFS_CCB ClientCcb;
NTSTATUS Status; NTSTATUS Status;
@ -99,13 +99,13 @@ NpfsConnectPipe(PIRP Irp,
DPRINT("Waiting for connection...\n"); DPRINT("Waiting for connection...\n");
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
/* search for a listening client fcb */ /* search for a listening client fcb */
KeLockMutex(&Pipe->CcbListLock); KeLockMutex(&Fcb->CcbListLock);
current_entry = Pipe->ClientCcbListHead.Flink; current_entry = Fcb->ClientCcbListHead.Flink;
while (current_entry != &Pipe->ClientCcbListHead) while (current_entry != &Fcb->ClientCcbListHead)
{ {
ClientCcb = CONTAINING_RECORD(current_entry, ClientCcb = CONTAINING_RECORD(current_entry,
NPFS_CCB, NPFS_CCB,
@ -133,7 +133,7 @@ NpfsConnectPipe(PIRP Irp,
Ccb->PipeState = FILE_PIPE_CONNECTED_STATE; Ccb->PipeState = FILE_PIPE_CONNECTED_STATE;
ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE; ClientCcb->PipeState = FILE_PIPE_CONNECTED_STATE;
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
/* FIXME: create and initialize data queues */ /* FIXME: create and initialize data queues */
@ -155,7 +155,7 @@ NpfsConnectPipe(PIRP Irp,
Status = NpfsAddListeningServerInstance(Irp, Ccb); Status = NpfsAddListeningServerInstance(Irp, Ccb);
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
DPRINT("NpfsConnectPipe() done (Status %lx)\n", Status); DPRINT("NpfsConnectPipe() done (Status %lx)\n", Status);
@ -167,14 +167,14 @@ static NTSTATUS
NpfsDisconnectPipe(PNPFS_CCB Ccb) NpfsDisconnectPipe(PNPFS_CCB Ccb)
{ {
NTSTATUS Status; NTSTATUS Status;
PNPFS_FCB Fcb;
PNPFS_CCB OtherSide; PNPFS_CCB OtherSide;
PNPFS_PIPE Pipe;
BOOLEAN Server; BOOLEAN Server;
DPRINT("NpfsDisconnectPipe()\n"); DPRINT("NpfsDisconnectPipe()\n");
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
KeLockMutex(&Pipe->CcbListLock); KeLockMutex(&Fcb->CcbListLock);
if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE) if (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE)
{ {
@ -225,8 +225,8 @@ NpfsDisconnectPipe(PNPFS_CCB Ccb)
BOOLEAN Complete = FALSE; BOOLEAN Complete = FALSE;
PIRP Irp = NULL; PIRP Irp = NULL;
Entry = Ccb->Pipe->WaiterListHead.Flink; Entry = Ccb->Fcb->WaiterListHead.Flink;
while (Entry != &Ccb->Pipe->WaiterListHead) while (Entry != &Ccb->Fcb->WaiterListHead)
{ {
WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry); WaitEntry = CONTAINING_RECORD(Entry, NPFS_WAITER_ENTRY, Entry);
if (WaitEntry->Ccb == Ccb) if (WaitEntry->Ccb == Ccb)
@ -259,7 +259,7 @@ NpfsDisconnectPipe(PNPFS_CCB Ccb)
{ {
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
} }
KeUnlockMutex(&Pipe->CcbListLock); KeUnlockMutex(&Fcb->CcbListLock);
return Status; return Status;
} }
@ -268,8 +268,8 @@ static NTSTATUS
NpfsWaitPipe(PIRP Irp, NpfsWaitPipe(PIRP Irp,
PNPFS_CCB Ccb) PNPFS_CCB Ccb)
{ {
PNPFS_PIPE Pipe;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PNPFS_FCB Fcb;
PNPFS_CCB ServerCcb; PNPFS_CCB ServerCcb;
PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe; PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe;
NTSTATUS Status; NTSTATUS Status;
@ -277,7 +277,7 @@ NpfsWaitPipe(PIRP Irp,
DPRINT("NpfsWaitPipe\n"); DPRINT("NpfsWaitPipe\n");
WaitPipe = (PFILE_PIPE_WAIT_FOR_BUFFER)Irp->AssociatedIrp.SystemBuffer; WaitPipe = (PFILE_PIPE_WAIT_FOR_BUFFER)Irp->AssociatedIrp.SystemBuffer;
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
if (Ccb->PipeState != 0) if (Ccb->PipeState != 0)
{ {
@ -286,8 +286,8 @@ NpfsWaitPipe(PIRP Irp,
} }
/* search for listening server */ /* search for listening server */
current_entry = Pipe->ServerCcbListHead.Flink; current_entry = Fcb->ServerCcbListHead.Flink;
while (current_entry != &Pipe->ServerCcbListHead) while (current_entry != &Fcb->ServerCcbListHead)
{ {
ServerCcb = CONTAINING_RECORD(current_entry, ServerCcb = CONTAINING_RECORD(current_entry,
NPFS_CCB, NPFS_CCB,
@ -339,8 +339,8 @@ NpfsPeekPipe(PIRP Irp,
PIO_STACK_LOCATION IoStack) PIO_STACK_LOCATION IoStack)
{ {
ULONG OutputBufferLength; ULONG OutputBufferLength;
PNPFS_PIPE Pipe;
PFILE_PIPE_PEEK_BUFFER Reply; PFILE_PIPE_PEEK_BUFFER Reply;
PNPFS_FCB Fcb;
PNPFS_CCB Ccb; PNPFS_CCB Ccb;
NTSTATUS Status; NTSTATUS Status;
@ -358,7 +358,7 @@ NpfsPeekPipe(PIRP Irp,
Ccb = IoStack->FileObject->FsContext2; Ccb = IoStack->FileObject->FsContext2;
Reply = (PFILE_PIPE_PEEK_BUFFER)Irp->AssociatedIrp.SystemBuffer; Reply = (PFILE_PIPE_PEEK_BUFFER)Irp->AssociatedIrp.SystemBuffer;
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
Reply->NamedPipeState = Ccb->PipeState; Reply->NamedPipeState = Ccb->PipeState;
@ -389,7 +389,7 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
NTSTATUS Status; NTSTATUS Status;
PNPFS_DEVICE_EXTENSION DeviceExt; PNPFS_DEVICE_EXTENSION DeviceExt;
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
PNPFS_CCB Ccb; PNPFS_CCB Ccb;
DPRINT("NpfsFileSystemContol(DeviceObject %p Irp %p)\n", DeviceObject, Irp); DPRINT("NpfsFileSystemContol(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
@ -401,9 +401,9 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
DPRINT("FileObject: %p\n", FileObject); DPRINT("FileObject: %p\n", FileObject);
Ccb = FileObject->FsContext2; Ccb = FileObject->FsContext2;
DPRINT("CCB: %p\n", Ccb); DPRINT("CCB: %p\n", Ccb);
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
DPRINT("Pipe: %p\n", Pipe); DPRINT("Pipe: %p\n", Fcb);
DPRINT("PipeName: %wZ\n", &Pipe->PipeName); DPRINT("PipeName: %wZ\n", &Fcb->PipeName);
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
@ -415,17 +415,17 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
break; break;
case FSCTL_PIPE_DISCONNECT: case FSCTL_PIPE_DISCONNECT:
DPRINT("Disconnecting pipe %wZ\n", &Pipe->PipeName); DPRINT("Disconnecting pipe %wZ\n", &Fcb->PipeName);
Status = NpfsDisconnectPipe(Ccb); Status = NpfsDisconnectPipe(Ccb);
break; break;
case FSCTL_PIPE_LISTEN: case FSCTL_PIPE_LISTEN:
DPRINT("Connecting pipe %wZ\n", &Pipe->PipeName); DPRINT("Connecting pipe %wZ\n", &Fcb->PipeName);
Status = NpfsConnectPipe(Irp, Ccb); Status = NpfsConnectPipe(Irp, Ccb);
break; break;
case FSCTL_PIPE_PEEK: case FSCTL_PIPE_PEEK:
DPRINT("Peeking pipe %wZ\n", &Pipe->PipeName); DPRINT("Peeking pipe %wZ\n", &Fcb->PipeName);
Status = NpfsPeekPipe(Irp, (PIO_STACK_LOCATION)IoStack); Status = NpfsPeekPipe(Irp, (PIO_STACK_LOCATION)IoStack);
break; break;
@ -442,7 +442,7 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
break; break;
case FSCTL_PIPE_WAIT: case FSCTL_PIPE_WAIT:
DPRINT("Waiting for pipe %wZ\n", &Pipe->PipeName); DPRINT("Waiting for pipe %wZ\n", &Fcb->PipeName);
Status = NpfsWaitPipe(Irp, Ccb); Status = NpfsWaitPipe(Irp, Ccb);
break; break;

7
reactos/drivers/filesystems/np/npfs.h
View file

@ -15,8 +15,9 @@ typedef struct _NPFS_DEVICE_EXTENSION
ULONG MaxQuota; ULONG MaxQuota;
} NPFS_DEVICE_EXTENSION, *PNPFS_DEVICE_EXTENSION; } NPFS_DEVICE_EXTENSION, *PNPFS_DEVICE_EXTENSION;
typedef struct _NPFS_PIPE typedef struct _NPFS_FCB
{ {
FSRTL_COMMON_FCB_HEADER RFCB;
UNICODE_STRING PipeName; UNICODE_STRING PipeName;
LIST_ENTRY PipeListEntry; LIST_ENTRY PipeListEntry;
KMUTEX CcbListLock; KMUTEX CcbListLock;
@ -34,14 +35,14 @@ typedef struct _NPFS_PIPE
ULONG InboundQuota; ULONG InboundQuota;
ULONG OutboundQuota; ULONG OutboundQuota;
LARGE_INTEGER TimeOut; LARGE_INTEGER TimeOut;
} NPFS_PIPE, *PNPFS_PIPE; } NPFS_FCB, *PNPFS_FCB;
typedef struct _NPFS_CCB typedef struct _NPFS_CCB
{ {
LIST_ENTRY CcbListEntry; LIST_ENTRY CcbListEntry;
struct _NPFS_CCB* OtherSide; struct _NPFS_CCB* OtherSide;
struct ETHREAD *Thread; struct ETHREAD *Thread;
PNPFS_PIPE Pipe; PNPFS_FCB Fcb;
KEVENT ConnectEvent; KEVENT ConnectEvent;
KEVENT ReadEvent; KEVENT ReadEvent;
KEVENT WriteEvent; KEVENT WriteEvent;

18
reactos/drivers/filesystems/np/rw.c
View file

@ -414,7 +414,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&Ccb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
} }
if (Information > 0 && if (Information > 0 &&
(Ccb->Pipe->ReadMode != FILE_PIPE_BYTE_STREAM_MODE || (Ccb->Fcb->ReadMode != FILE_PIPE_BYTE_STREAM_MODE ||
Ccb->PipeState != FILE_PIPE_CONNECTED_STATE)) Ccb->PipeState != FILE_PIPE_CONNECTED_STATE))
{ {
break; break;
@ -430,13 +430,13 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
{ {
/* Wait for ReadEvent to become signaled */ /* Wait for ReadEvent to become signaled */
DPRINT("Waiting for readable data (%wZ)\n", &Ccb->Pipe->PipeName); DPRINT("Waiting for readable data (%wZ)\n", &Ccb->Fcb->PipeName);
Status = KeWaitForSingleObject(&Ccb->ReadEvent, Status = KeWaitForSingleObject(&Ccb->ReadEvent,
UserRequest, UserRequest,
KernelMode, KernelMode,
FALSE, FALSE,
NULL); NULL);
DPRINT("Finished waiting (%wZ)! Status: %x\n", &Ccb->Pipe->PipeName, Status); DPRINT("Finished waiting (%wZ)! Status: %x\n", &Ccb->Fcb->PipeName, Status);
ExAcquireFastMutex(&Ccb->DataListLock); ExAcquireFastMutex(&Ccb->DataListLock);
} }
else else
@ -455,7 +455,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
} }
} }
ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL); ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
if (Ccb->Pipe->ReadMode == FILE_PIPE_BYTE_STREAM_MODE) if (Ccb->Fcb->ReadMode == FILE_PIPE_BYTE_STREAM_MODE)
{ {
DPRINT("Byte stream mode\n"); DPRINT("Byte stream mode\n");
/* Byte stream mode */ /* Byte stream mode */
@ -603,9 +603,9 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
{ {
PIO_STACK_LOCATION IoStack; PIO_STACK_LOCATION IoStack;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PNPFS_FCB Fcb = NULL;
PNPFS_CCB Ccb = NULL; PNPFS_CCB Ccb = NULL;
PNPFS_CCB ReaderCcb; PNPFS_CCB ReaderCcb;
PNPFS_PIPE Pipe = NULL;
PUCHAR Buffer; PUCHAR Buffer;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
ULONG Length; ULONG Length;
@ -623,7 +623,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
Ccb = FileObject->FsContext2; Ccb = FileObject->FsContext2;
ReaderCcb = Ccb->OtherSide; ReaderCcb = Ccb->OtherSide;
Pipe = Ccb->Pipe; Fcb = Ccb->Fcb;
Length = IoStack->Parameters.Write.Length; Length = IoStack->Parameters.Write.Length;
Offset = IoStack->Parameters.Write.ByteOffset.u.LowPart; Offset = IoStack->Parameters.Write.ByteOffset.u.LowPart;
@ -680,13 +680,13 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
} }
ExReleaseFastMutex(&ReaderCcb->DataListLock); ExReleaseFastMutex(&ReaderCcb->DataListLock);
DPRINT("Waiting for buffer space (%S)\n", Pipe->PipeName.Buffer); DPRINT("Waiting for buffer space (%S)\n", Fcb->PipeName.Buffer);
Status = KeWaitForSingleObject(&Ccb->WriteEvent, Status = KeWaitForSingleObject(&Ccb->WriteEvent,
UserRequest, UserRequest,
KernelMode, KernelMode,
FALSE, FALSE,
NULL); NULL);
DPRINT("Finished waiting (%S)! Status: %x\n", Pipe->PipeName.Buffer, Status); DPRINT("Finished waiting (%S)! Status: %x\n", Fcb->PipeName.Buffer, Status);
ExAcquireFastMutex(&ReaderCcb->DataListLock); ExAcquireFastMutex(&ReaderCcb->DataListLock);
/* /*
@ -702,7 +702,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
} }
} }
if (Pipe->WriteMode == FILE_PIPE_BYTE_STREAM_MODE) if (Fcb->WriteMode == FILE_PIPE_BYTE_STREAM_MODE)
{ {
DPRINT("Byte stream mode\n"); DPRINT("Byte stream mode\n");
while (Length > 0 && ReaderCcb->WriteQuotaAvailable > 0) while (Length > 0 && ReaderCcb->WriteQuotaAvailable > 0)