ReactOS Development > Doxygen

00001 /*
00002  * COPYRIGHT:  See COPYING in the top level directory
00003  * PROJECT:    ReactOS kernel
00004  * FILE:       drivers/filesystems/msfs/create.c
00005  * PURPOSE:    Mailslot filesystem
00006  * PROGRAMMER: Eric Kohl
00007  */
00008 
00009 /* INCLUDES ******************************************************************/
00010 
00011 #include "msfs.h"
00012 
00013 #define NDEBUG
00014 #include <debug.h>
00015 
00016 
00017 /* FUNCTIONS *****************************************************************/
00018 
00019 /* Creates the client side */
00020 NTSTATUS DEFAULTAPI
00021 MsfsCreate(PDEVICE_OBJECT DeviceObject,
00022            PIRP Irp)
00023 {
00024     PIO_STACK_LOCATION IoStack;
00025     PFILE_OBJECT FileObject;
00026     PMSFS_DEVICE_EXTENSION DeviceExtension;
00027     PMSFS_FCB Fcb;
00028     PMSFS_CCB Ccb;
00029     PMSFS_FCB current = NULL;
00030     PLIST_ENTRY current_entry;
00031     KIRQL oldIrql;
00032 
00033     DPRINT("MsfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
00034 
00035     IoStack = IoGetCurrentIrpStackLocation(Irp);
00036     DeviceExtension = DeviceObject->DeviceExtension;
00037     FileObject = IoStack->FileObject;
00038 
00039     DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);
00040 
00041     Ccb = ExAllocatePool(NonPagedPool, sizeof(MSFS_CCB));
00042     if (Ccb == NULL)
00043     {
00044         Irp->IoStatus.Status = STATUS_NO_MEMORY;
00045         Irp->IoStatus.Information = 0;
00046 
00047         IoCompleteRequest(Irp, IO_NO_INCREMENT);
00048         return STATUS_NO_MEMORY;
00049     }
00050 
00051     KeLockMutex(&DeviceExtension->FcbListLock);
00052     current_entry = DeviceExtension->FcbListHead.Flink;
00053     while (current_entry != &DeviceExtension->FcbListHead)
00054     {
00055         current = CONTAINING_RECORD(current_entry,
00056                                     MSFS_FCB,
00057                                     FcbListEntry);
00058 
00059         if (!RtlCompareUnicodeString(&FileObject->FileName, &current->Name, TRUE))
00060             break;
00061 
00062         current_entry = current_entry->Flink;
00063     }
00064 
00065     if (current_entry == &DeviceExtension->FcbListHead)
00066     {
00067         ExFreePool(Ccb);
00068         KeUnlockMutex(&DeviceExtension->FcbListLock);
00069 
00070         Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
00071         Irp->IoStatus.Information = 0;
00072 
00073         IoCompleteRequest(Irp, IO_NO_INCREMENT);
00074 
00075         return STATUS_UNSUCCESSFUL;
00076     }
00077 
00078     Fcb = current;
00079 
00080     KeAcquireSpinLock(&Fcb->CcbListLock, &oldIrql);
00081     InsertTailList(&Fcb->CcbListHead, &Ccb->CcbListEntry);
00082     KeReleaseSpinLock(&Fcb->CcbListLock, oldIrql);
00083 
00084     Fcb->ReferenceCount++;
00085 
00086     Ccb->Fcb = Fcb;
00087 
00088     KeUnlockMutex(&DeviceExtension->FcbListLock);
00089 
00090     FileObject->FsContext = Fcb;
00091     FileObject->FsContext2 = Ccb;
00092     FileObject->Flags |= FO_MAILSLOT;
00093 
00094     Irp->IoStatus.Status = STATUS_SUCCESS;
00095     Irp->IoStatus.Information = 0;
00096 
00097     IoCompleteRequest(Irp, IO_NO_INCREMENT);
00098 
00099     return STATUS_SUCCESS;
00100 }
00101 
00102 
00103 /* Creates the server side */
00104 NTSTATUS DEFAULTAPI
00105 MsfsCreateMailslot(PDEVICE_OBJECT DeviceObject,
00106                    PIRP Irp)
00107 {
00108     PEXTENDED_IO_STACK_LOCATION IoStack;
00109     PFILE_OBJECT FileObject;
00110     PMSFS_DEVICE_EXTENSION DeviceExtension;
00111     PMSFS_FCB Fcb;
00112     PMSFS_CCB Ccb;
00113     KIRQL oldIrql;
00114     PLIST_ENTRY current_entry;
00115     PMSFS_FCB current = NULL;
00116     PMAILSLOT_CREATE_PARAMETERS Buffer;
00117 
00118     DPRINT("MsfsCreateMailslot(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
00119 
00120     IoStack = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp);
00121     DeviceExtension = DeviceObject->DeviceExtension;
00122     FileObject = IoStack->FileObject;
00123     Buffer = IoStack->Parameters.CreateMailslot.Parameters;
00124 
00125     DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);
00126 
00127     Fcb = ExAllocatePool(NonPagedPool, sizeof(MSFS_FCB));
00128     if (Fcb == NULL)
00129     {
00130         Irp->IoStatus.Status = STATUS_NO_MEMORY;
00131         Irp->IoStatus.Information = 0;
00132 
00133         IoCompleteRequest(Irp, IO_NO_INCREMENT);
00134 
00135         return STATUS_NO_MEMORY;
00136     }
00137 
00138     Fcb->Name.Length = FileObject->FileName.Length;
00139     Fcb->Name.MaximumLength = Fcb->Name.Length + sizeof(UNICODE_NULL);
00140     Fcb->Name.Buffer = ExAllocatePool(NonPagedPool, Fcb->Name.MaximumLength);
00141     if (Fcb->Name.Buffer == NULL)
00142     {
00143         ExFreePool(Fcb);
00144 
00145         Irp->IoStatus.Status = STATUS_NO_MEMORY;
00146         Irp->IoStatus.Information = 0;
00147 
00148         IoCompleteRequest(Irp, IO_NO_INCREMENT);
00149 
00150         return STATUS_NO_MEMORY;
00151     }
00152 
00153     RtlCopyUnicodeString(&Fcb->Name, &FileObject->FileName);
00154 
00155     Ccb = ExAllocatePool(NonPagedPool, sizeof(MSFS_CCB));
00156     if (Ccb == NULL)
00157     {
00158         ExFreePool(Fcb->Name.Buffer);
00159         ExFreePool(Fcb);
00160 
00161         Irp->IoStatus.Status = STATUS_NO_MEMORY;
00162         Irp->IoStatus.Information = 0;
00163 
00164         IoCompleteRequest(Irp, IO_NO_INCREMENT);
00165 
00166         return STATUS_NO_MEMORY;
00167     }
00168 
00169     Fcb->ReferenceCount = 0;
00170     InitializeListHead(&Fcb->CcbListHead);
00171     KeInitializeSpinLock(&Fcb->CcbListLock);
00172 
00173     Fcb->MaxMessageSize = Buffer->MaximumMessageSize;
00174     Fcb->MessageCount = 0;
00175     Fcb->TimeOut = Buffer->ReadTimeout;
00176     KeInitializeEvent(&Fcb->MessageEvent,
00177                       NotificationEvent,
00178                       FALSE);
00179 
00180     InitializeListHead(&Fcb->MessageListHead);
00181     KeInitializeSpinLock(&Fcb->MessageListLock);
00182 
00183     KeLockMutex(&DeviceExtension->FcbListLock);
00184     current_entry = DeviceExtension->FcbListHead.Flink;
00185     while (current_entry != &DeviceExtension->FcbListHead)
00186     {
00187         current = CONTAINING_RECORD(current_entry,
00188                                     MSFS_FCB,
00189                                     FcbListEntry);
00190 
00191         if (!RtlCompareUnicodeString(&Fcb->Name, &current->Name, TRUE))
00192             break;
00193 
00194         current_entry = current_entry->Flink;
00195     }
00196 
00197     if (current_entry != &DeviceExtension->FcbListHead)
00198     {
00199         ExFreePool(Fcb->Name.Buffer);
00200         ExFreePool(Fcb);
00201         ExFreePool(Ccb);
00202 
00203         KeUnlockMutex(&DeviceExtension->FcbListLock);
00204 
00205         Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
00206         Irp->IoStatus.Information = 0;
00207 
00208         IoCompleteRequest(Irp, IO_NO_INCREMENT);
00209 
00210         return STATUS_UNSUCCESSFUL;
00211     }
00212     else
00213     {
00214         InsertTailList(&DeviceExtension->FcbListHead,
00215                        &Fcb->FcbListEntry);
00216     }
00217 
00218     KeAcquireSpinLock(&Fcb->CcbListLock, &oldIrql);
00219     InsertTailList(&Fcb->CcbListHead, &Ccb->CcbListEntry);
00220     KeReleaseSpinLock(&Fcb->CcbListLock, oldIrql);
00221 
00222     Fcb->ReferenceCount++;
00223     Fcb->ServerCcb = Ccb;
00224     Ccb->Fcb = Fcb;
00225 
00226     KeUnlockMutex(&DeviceExtension->FcbListLock);
00227 
00228     FileObject->FsContext = Fcb;
00229     FileObject->FsContext2 = Ccb;
00230     FileObject->Flags |= FO_MAILSLOT;
00231 
00232     Irp->IoStatus.Status = STATUS_SUCCESS;
00233     Irp->IoStatus.Information = 0;
00234 
00235     IoCompleteRequest(Irp, IO_NO_INCREMENT);
00236 
00237     return STATUS_SUCCESS;
00238 }
00239 
00240 
00241 NTSTATUS DEFAULTAPI
00242 MsfsClose(PDEVICE_OBJECT DeviceObject,
00243           PIRP Irp)
00244 {
00245     PIO_STACK_LOCATION IoStack;
00246     PFILE_OBJECT FileObject;
00247     PMSFS_DEVICE_EXTENSION DeviceExtension;
00248     PMSFS_FCB Fcb;
00249     PMSFS_CCB Ccb;
00250     PMSFS_MESSAGE Message;
00251     KIRQL oldIrql;
00252 
00253     DPRINT("MsfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
00254 
00255     IoStack = IoGetCurrentIrpStackLocation(Irp);
00256     DeviceExtension = DeviceObject->DeviceExtension;
00257     FileObject = IoStack->FileObject;
00258 
00259     KeLockMutex(&DeviceExtension->FcbListLock);
00260 
00261     if (DeviceExtension->FcbListHead.Flink == &DeviceExtension->FcbListHead)
00262     {
00263         KeUnlockMutex(&DeviceExtension->FcbListLock);
00264 
00265         Irp->IoStatus.Status = STATUS_SUCCESS;
00266         Irp->IoStatus.Information = 0;
00267 
00268         IoCompleteRequest(Irp, IO_NO_INCREMENT);
00269 
00270         return STATUS_SUCCESS;
00271     }
00272 
00273     Fcb = FileObject->FsContext;
00274     Ccb = FileObject->FsContext2;
00275 
00276     DPRINT("Mailslot name: %wZ\n", &Fcb->Name);
00277 
00278     Fcb->ReferenceCount--;
00279     if (Fcb->ServerCcb == Ccb)
00280     {
00281         /* delete all messages from message-list */
00282         KeAcquireSpinLock(&Fcb->MessageListLock, &oldIrql);
00283 
00284         while (Fcb->MessageListHead.Flink != &Fcb->MessageListHead)
00285         {
00286             Message = CONTAINING_RECORD(Fcb->MessageListHead.Flink,
00287                                         MSFS_MESSAGE,
00288                                         MessageListEntry);
00289             RemoveEntryList(Fcb->MessageListHead.Flink);
00290             ExFreePool(Message);
00291         }
00292 
00293         Fcb->MessageCount = 0;
00294 
00295         KeReleaseSpinLock(&Fcb->MessageListLock, oldIrql);
00296         Fcb->ServerCcb = NULL;
00297     }
00298 
00299     KeAcquireSpinLock(&Fcb->CcbListLock, &oldIrql);
00300     RemoveEntryList(&Ccb->CcbListEntry);
00301     KeReleaseSpinLock(&Fcb->CcbListLock, oldIrql);
00302     ExFreePool(Ccb);
00303     FileObject->FsContext2 = NULL;
00304 
00305     if (Fcb->ReferenceCount == 0)
00306     {
00307         DPRINT("ReferenceCount == 0: Deleting mailslot data\n");
00308         RemoveEntryList(&Fcb->FcbListEntry);
00309         ExFreePool(Fcb->Name.Buffer);
00310         ExFreePool(Fcb);
00311     }
00312 
00313     KeUnlockMutex(&DeviceExtension->FcbListLock);
00314 
00315     Irp->IoStatus.Status = STATUS_SUCCESS;
00316     Irp->IoStatus.Information = 0;
00317 
00318     IoCompleteRequest(Irp, IO_NO_INCREMENT);
00319 
00320     return STATUS_SUCCESS;
00321 }
00322 
00323 /* EOF */
Generated on Fri May 25 2012 04:15:16 for ReactOS by
1.7.6.1