ntoskrnl/io/iomgr.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:            See COPYING in the top level directory
   4  * PROJECT:              ReactOS kernel
   5  * FILE:                 ntoskrnl/io/iomgr.c
   6  * PURPOSE:              Initializes the io manager
   7  * PROGRAMMER:           David Welch (welch@mcmail.com)
   8  * REVISION HISTORY:
   9  *             29/07/98: Created
  10  */
  11
  12 /* INCLUDES ****************************************************************/
  13
  14 #include <limits.h>
  15 #include <ddk/ntddk.h>
  16 #include <internal/ob.h>
  17 #include <internal/io.h>
  18 #include <internal/pool.h>
  19
  20 #define NDEBUG
  21 #include <internal/debug.h>
  22
  23 /* GLOBALS *******************************************************************/
  24
  25 #define TAG_DEVICE_TYPE     TAG('D', 'E', 'V', 'T')
  26 #define TAG_FILE_TYPE       TAG('F', 'I', 'L', 'E')
  27
  28 /* DATA ********************************************************************/
  29
  30
  31 POBJECT_TYPE EXPORTED IoDeviceObjectType = NULL;
  32 POBJECT_TYPE EXPORTED IoFileObjectType = NULL;
  33 #ifndef LIBCAPTIVE
  34 ULONG        EXPORTED IoReadOperationCount = 0; /* FIXME: unknown type */
  35 ULONG        EXPORTED IoReadTransferCount = 0;  /* FIXME: unknown type */
  36 ULONG        EXPORTED IoWriteOperationCount = 0; /* FIXME: unknown type */
  37 ULONG        EXPORTED IoWriteTransferCount = 0; /* FIXME: unknown type */
  38 ULONG        EXPORTED IoStatisticsLock = 0;     /* FIXME: unknown type */
  39 #endif /* LIBCAPTIVE */
  40
  41 static GENERIC_MAPPING IopFileMapping = {FILE_GENERIC_READ,
  42                                          FILE_GENERIC_WRITE,
  43                                          FILE_GENERIC_EXECUTE,
  44                                          FILE_ALL_ACCESS};
  45
  46 /* FUNCTIONS ****************************************************************/
  47
  48 extern BOOLEAN IoCreateStreamFileObjectLite_is_owner(FILE_OBJECT *FileObject);
  49
  50 VOID STDCALL
  51 IopCloseFile(PVOID ObjectBody,
  52              ULONG HandleCount)
  53 {
  54    PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
  55    PIRP Irp;
  56    PIO_STACK_LOCATION StackPtr;
  57    NTSTATUS Status;
  58
  59    DPRINT("IopCloseFile()\n");
  60
  61    if (HandleCount > 0 || FileObject->DeviceObject == NULL)
  62      {
  63         return;
  64      }
  65
  66    ObReferenceObjectByPointer(FileObject,
  67                               STANDARD_RIGHTS_REQUIRED,
  68                               IoFileObjectType,
  69                               UserMode);
  70    KeResetEvent( &FileObject->Event );
  71
  72    if (IoCreateStreamFileObjectLite_is_owner(FileObject))
  73      {
  74         return;
  75      }
  76
  77    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_CLEANUP,
  78                                       FileObject->DeviceObject,
  79                                       NULL,
  80                                       0,
  81                                       NULL,
  82                                       NULL,
  83                                       NULL);
  84    StackPtr = IoGetNextIrpStackLocation(Irp);
  85    StackPtr->FileObject = FileObject;
  86
  87    Status = IoCallDriver(FileObject->DeviceObject, Irp);
  88    if (Status == STATUS_PENDING)
  89    {
  90       KeWaitForSingleObject(&FileObject->Event, Executive, KernelMode, FALSE, NULL);
  91    }
  92 }
  93
  94 extern BOOLEAN IoCreateStreamFileObjectLite_is_owner(FILE_OBJECT *FileObject);
  95 extern void IoCreateStreamFileObjectLite_remove(FILE_OBJECT *FileObject);
  96
  97 VOID STDCALL
  98 IopDeleteFile(PVOID ObjectBody)
  99 {
 100    PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
 101    PIRP Irp;
 102    PIO_STACK_LOCATION StackPtr;
 103    NTSTATUS Status;
 104
 105    DPRINT("IopDeleteFile()\n");
 106
 107    if (FileObject->DeviceObject)
 108    {
 109      ObReferenceObjectByPointer(ObjectBody,
 110                                 STANDARD_RIGHTS_REQUIRED,
 111                                 IoFileObjectType,
 112                                 UserMode);
 113
 114      KeResetEvent( &FileObject->Event );
 115      Irp = IoBuildSynchronousFsdRequest(IRP_MJ_CLOSE,
 116                                         FileObject->DeviceObject,
 117                                         NULL,
 118                                         0,
 119                                         NULL,
 120                                         NULL,
 121                                         NULL);
 122      StackPtr = IoGetNextIrpStackLocation(Irp);
 123      StackPtr->FileObject = FileObject;
 124
 125      Status = IoCallDriver(FileObject->DeviceObject, Irp);
 126      if (Status == STATUS_PENDING)
 127      {
 128         KeWaitForSingleObject(&FileObject->Event, Executive, KernelMode, FALSE, NULL);
 129      }
 130    }
 131
 132    if (FileObject->FileName.Buffer != NULL)
 133      {
 134         ExFreePool(FileObject->FileName.Buffer);
 135         FileObject->FileName.Buffer = 0;
 136      }
 137
 138    if (IoCreateStreamFileObjectLite_is_owner(FileObject))
 139      {
 140         IoCreateStreamFileObjectLite_remove(FileObject);
 141      }
 142 }
 143
 144
 145 VOID IoInit (VOID)
 146 {
 147   OBJECT_ATTRIBUTES ObjectAttributes;
 148   UNICODE_STRING DirName;
 149 #ifndef LIBCAPTIVE
 150   UNICODE_STRING LinkName;
 151 #endif /* LIBCAPTIVE */
 152   HANDLE Handle;
 153
 154 #ifndef LIBCAPTIVE
 155   IopInitDriverImplementation();
 156 #endif /* LIBCAPTIVE */
 157
 158   /*
 159    * Register iomgr types: DeviceObjectType
 160    */
 161   IoDeviceObjectType = ExAllocatePool (NonPagedPool,
 162                                        sizeof (OBJECT_TYPE));
 163
 164   IoDeviceObjectType->Tag = TAG_DEVICE_TYPE;
 165   IoDeviceObjectType->TotalObjects = 0;
 166   IoDeviceObjectType->TotalHandles = 0;
 167   IoDeviceObjectType->MaxObjects = ULONG_MAX;
 168   IoDeviceObjectType->MaxHandles = ULONG_MAX;
 169   IoDeviceObjectType->PagedPoolCharge = 0;
 170   IoDeviceObjectType->NonpagedPoolCharge = sizeof (DEVICE_OBJECT);
 171   IoDeviceObjectType->Mapping = &IopFileMapping;
 172   IoDeviceObjectType->Dump = NULL;
 173   IoDeviceObjectType->Open = NULL;
 174   IoDeviceObjectType->Close = NULL;
 175   IoDeviceObjectType->Delete = NULL;
 176   IoDeviceObjectType->Parse = NULL;
 177   IoDeviceObjectType->Security = NULL;
 178   IoDeviceObjectType->QueryName = NULL;
 179   IoDeviceObjectType->OkayToClose = NULL;
 180   IoDeviceObjectType->Create = IopCreateDevice;
 181   IoDeviceObjectType->DuplicationNotify = NULL;
 182
 183   RtlInitUnicodeStringFromLiteral(&IoDeviceObjectType->TypeName, REACTOS_UCS2(L"Device"));
 184
 185   /*
 186    * Register iomgr types: FileObjectType
 187    * (alias DriverObjectType)
 188    */
 189   IoFileObjectType = ExAllocatePool (NonPagedPool, sizeof (OBJECT_TYPE));
 190
 191   IoFileObjectType->Tag = TAG_FILE_TYPE;
 192   IoFileObjectType->TotalObjects = 0;
 193   IoFileObjectType->TotalHandles = 0;
 194   IoFileObjectType->MaxObjects = ULONG_MAX;
 195   IoFileObjectType->MaxHandles = ULONG_MAX;
 196   IoFileObjectType->PagedPoolCharge = 0;
 197   IoFileObjectType->NonpagedPoolCharge = sizeof(FILE_OBJECT);
 198   IoFileObjectType->Mapping = &IopFileMapping;
 199   IoFileObjectType->Dump = NULL;
 200   IoFileObjectType->Open = NULL;
 201   IoFileObjectType->Close = IopCloseFile;
 202   IoFileObjectType->Delete = IopDeleteFile;
 203   IoFileObjectType->Parse = NULL;
 204   IoFileObjectType->Security = NULL;
 205   IoFileObjectType->QueryName = NULL;
 206   IoFileObjectType->OkayToClose = NULL;
 207   IoFileObjectType->Create = IopCreateFile;
 208   IoFileObjectType->DuplicationNotify = NULL;
 209
 210   RtlInitUnicodeStringFromLiteral(&IoFileObjectType->TypeName, REACTOS_UCS2(L"File"));
 211
 212   /*
 213    * Create the '\Driver' object directory
 214    */
 215   RtlInitUnicodeStringFromLiteral(&DirName, REACTOS_UCS2(L"\\Driver"));
 216   InitializeObjectAttributes(&ObjectAttributes,
 217                              &DirName,
 218                              0,
 219                              NULL,
 220                              NULL);
 221   NtCreateDirectoryObject(&Handle,
 222                           0,
 223                           &ObjectAttributes);
 224
 225   /*
 226    * Create the '\FileSystem' object directory
 227    */
 228   RtlInitUnicodeStringFromLiteral(&DirName,
 229                        REACTOS_UCS2(L"\\FileSystem"));
 230   InitializeObjectAttributes(&ObjectAttributes,
 231                              &DirName,
 232                              0,
 233                              NULL,
 234                              NULL);
 235   NtCreateDirectoryObject(&Handle,
 236                           0,
 237                           &ObjectAttributes);
 238
 239   /*
 240    * Create the '\Device' directory
 241    */
 242   RtlInitUnicodeStringFromLiteral(&DirName,
 243                        REACTOS_UCS2(L"\\Device"));
 244   InitializeObjectAttributes(&ObjectAttributes,
 245                              &DirName,
 246                              0,
 247                              NULL,
 248                              NULL);
 249   ZwCreateDirectoryObject(&Handle,
 250                           0,
 251                           &ObjectAttributes);
 252
 253 #ifndef LIBCAPTIVE
 254   /*
 255    * Create the '\??' directory
 256    */
 257   RtlInitUnicodeStringFromLiteral(&DirName,
 258                        REACTOS_UCS2(L"\\??"));
 259   InitializeObjectAttributes(&ObjectAttributes,
 260                              &DirName,
 261                              0,
 262                              NULL,
 263                              NULL);
 264   ZwCreateDirectoryObject(&Handle,
 265                           0,
 266                           &ObjectAttributes);
 267
 268   /*
 269    * Create the '\ArcName' directory
 270    */
 271   RtlInitUnicodeStringFromLiteral(&DirName,
 272                        REACTOS_UCS2(L"\\ArcName"));
 273   InitializeObjectAttributes(&ObjectAttributes,
 274                              &DirName,
 275                              0,
 276                              NULL,
 277                              NULL);
 278   ZwCreateDirectoryObject(&Handle,
 279                           0,
 280                           &ObjectAttributes);
 281
 282   /*
 283    * Initialize remaining subsubsystem
 284    */
 285 #endif /* LIBCAPTIVE */
 286   IoInitCancelHandling();
 287 #ifndef LIBCAPTIVE
 288   IoInitSymbolicLinkImplementation();
 289 #endif /* LIBCAPTIVE */
 290   IoInitFileSystemImplementation();
 291   IoInitVpbImplementation();
 292   IoInitShutdownNotification();
 293
 294   /*
 295    * Create link from '\DosDevices' to '\??' directory
 296    */
 297 #ifndef LIBCAPTIVE
 298   RtlInitUnicodeStringFromLiteral(&LinkName,
 299                        L"\\DosDevices");
 300   RtlInitUnicodeStringFromLiteral(&DirName,
 301                        L"\\??");
 302   IoCreateSymbolicLink(&LinkName,
 303                        &DirName);
 304
 305   /*
 306    * Initialize PnP manager
 307    */
 308   PnpInit();
 309 #endif /* LIBCAPTIVE */
 310 }
 311
 312
 313 PGENERIC_MAPPING STDCALL
 314 IoGetFileObjectGenericMapping(VOID)
 315 {
 316   return(&IopFileMapping);
 317 }
 318
 319 /* EOF */