reactos/ntoskrnl/io/iomgr.c

   1 /* $Id: iomgr.c,v 1.32 2003/05/13 21:28:26 chorns Exp $
   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 ULONG        EXPORTED IoReadOperationCount = 0; /* FIXME: unknown type */
  34 ULONG        EXPORTED IoReadTransferCount = 0;  /* FIXME: unknown type */
  35 ULONG        EXPORTED IoWriteOperationCount = 0; /* FIXME: unknown type */
  36 ULONG        EXPORTED IoWriteTransferCount = 0; /* FIXME: unknown type */
  37 ULONG        EXPORTED IoStatisticsLock = 0;     /* FIXME: unknown type */
  38
  39 static GENERIC_MAPPING IopFileMapping = {FILE_GENERIC_READ,
  40                                          FILE_GENERIC_WRITE,
  41                                          FILE_GENERIC_EXECUTE,
  42                                          FILE_ALL_ACCESS};
  43
  44 /* FUNCTIONS ****************************************************************/
  45
  46 VOID STDCALL
  47 IopCloseFile(PVOID ObjectBody,
  48              ULONG HandleCount)
  49 {
  50    PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
  51    PIRP Irp;
  52    PIO_STACK_LOCATION StackPtr;
  53    NTSTATUS Status;
  54
  55    DPRINT("IopCloseFile()\n");
  56
  57    if (HandleCount > 0 || FileObject->DeviceObject == NULL)
  58      {
  59         return;
  60      }
  61
  62    ObReferenceObjectByPointer(FileObject,
  63                               STANDARD_RIGHTS_REQUIRED,
  64                               IoFileObjectType,
  65                               UserMode);
  66    KeResetEvent( &FileObject->Event );
  67
  68    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_CLEANUP,
  69                                       FileObject->DeviceObject,
  70                                       NULL,
  71                                       0,
  72                                       NULL,
  73                                       NULL,
  74                                       NULL);
  75    StackPtr = IoGetNextIrpStackLocation(Irp);
  76    StackPtr->FileObject = FileObject;
  77
  78    Status = IoCallDriver(FileObject->DeviceObject, Irp);
  79    if (Status == STATUS_PENDING)
  80    {
  81       KeWaitForSingleObject(&FileObject->Event, Executive, KernelMode, FALSE, NULL);
  82    }
  83 }
  84
  85 VOID STDCALL
  86 IopDeleteFile(PVOID ObjectBody)
  87 {
  88    PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
  89    PIRP Irp;
  90    PIO_STACK_LOCATION StackPtr;
  91    NTSTATUS Status;
  92
  93    DPRINT("IopDeleteFile()\n");
  94
  95    if (FileObject->DeviceObject)
  96    {
  97      ObReferenceObjectByPointer(ObjectBody,
  98                                 STANDARD_RIGHTS_REQUIRED,
  99                                 IoFileObjectType,
 100                                 UserMode);
 101
 102      KeResetEvent( &FileObject->Event );
 103      Irp = IoBuildSynchronousFsdRequest(IRP_MJ_CLOSE,
 104                                         FileObject->DeviceObject,
 105                                         NULL,
 106                                         0,
 107                                         NULL,
 108                                         NULL,
 109                                         NULL);
 110      StackPtr = IoGetNextIrpStackLocation(Irp);
 111      StackPtr->FileObject = FileObject;
 112
 113      Status = IoCallDriver(FileObject->DeviceObject, Irp);
 114      if (Status == STATUS_PENDING)
 115      {
 116         KeWaitForSingleObject(&FileObject->Event, Executive, KernelMode, FALSE, NULL);
 117      }
 118    }
 119
 120    if (FileObject->FileName.Buffer != NULL)
 121      {
 122         ExFreePool(FileObject->FileName.Buffer);
 123         FileObject->FileName.Buffer = 0;
 124      }
 125 }
 126
 127
 128 VOID IoInit (VOID)
 129 {
 130   OBJECT_ATTRIBUTES ObjectAttributes;
 131   UNICODE_STRING DirName;
 132   UNICODE_STRING LinkName;
 133   HANDLE Handle;
 134
 135   IopInitDriverImplementation();
 136
 137   /*
 138    * Register iomgr types: DeviceObjectType
 139    */
 140   IoDeviceObjectType = ExAllocatePool (NonPagedPool,
 141                                        sizeof (OBJECT_TYPE));
 142
 143   IoDeviceObjectType->Tag = TAG_DEVICE_TYPE;
 144   IoDeviceObjectType->TotalObjects = 0;
 145   IoDeviceObjectType->TotalHandles = 0;
 146   IoDeviceObjectType->MaxObjects = ULONG_MAX;
 147   IoDeviceObjectType->MaxHandles = ULONG_MAX;
 148   IoDeviceObjectType->PagedPoolCharge = 0;
 149   IoDeviceObjectType->NonpagedPoolCharge = sizeof (DEVICE_OBJECT);
 150   IoDeviceObjectType->Mapping = &IopFileMapping;
 151   IoDeviceObjectType->Dump = NULL;
 152   IoDeviceObjectType->Open = NULL;
 153   IoDeviceObjectType->Close = NULL;
 154   IoDeviceObjectType->Delete = NULL;
 155   IoDeviceObjectType->Parse = NULL;
 156   IoDeviceObjectType->Security = NULL;
 157   IoDeviceObjectType->QueryName = NULL;
 158   IoDeviceObjectType->OkayToClose = NULL;
 159   IoDeviceObjectType->Create = IopCreateDevice;
 160   IoDeviceObjectType->DuplicationNotify = NULL;
 161
 162   RtlInitUnicodeStringFromLiteral(&IoDeviceObjectType->TypeName, L"Device");
 163
 164   /*
 165    * Register iomgr types: FileObjectType
 166    * (alias DriverObjectType)
 167    */
 168   IoFileObjectType = ExAllocatePool (NonPagedPool, sizeof (OBJECT_TYPE));
 169
 170   IoFileObjectType->Tag = TAG_FILE_TYPE;
 171   IoFileObjectType->TotalObjects = 0;
 172   IoFileObjectType->TotalHandles = 0;
 173   IoFileObjectType->MaxObjects = ULONG_MAX;
 174   IoFileObjectType->MaxHandles = ULONG_MAX;
 175   IoFileObjectType->PagedPoolCharge = 0;
 176   IoFileObjectType->NonpagedPoolCharge = sizeof(FILE_OBJECT);
 177   IoFileObjectType->Mapping = &IopFileMapping;
 178   IoFileObjectType->Dump = NULL;
 179   IoFileObjectType->Open = NULL;
 180   IoFileObjectType->Close = IopCloseFile;
 181   IoFileObjectType->Delete = IopDeleteFile;
 182   IoFileObjectType->Parse = NULL;
 183   IoFileObjectType->Security = NULL;
 184   IoFileObjectType->QueryName = NULL;
 185   IoFileObjectType->OkayToClose = NULL;
 186   IoFileObjectType->Create = IopCreateFile;
 187   IoFileObjectType->DuplicationNotify = NULL;
 188
 189   RtlInitUnicodeStringFromLiteral(&IoFileObjectType->TypeName, L"File");
 190
 191   /*
 192    * Create the '\Driver' object directory
 193    */
 194   RtlInitUnicodeStringFromLiteral(&DirName, L"\\Driver");
 195   InitializeObjectAttributes(&ObjectAttributes,
 196                              &DirName,
 197                              0,
 198                              NULL,
 199                              NULL);
 200   NtCreateDirectoryObject(&Handle,
 201                           0,
 202                           &ObjectAttributes);
 203
 204   /*
 205    * Create the '\FileSystem' object directory
 206    */
 207   RtlInitUnicodeStringFromLiteral(&DirName,
 208                        L"\\FileSystem");
 209   InitializeObjectAttributes(&ObjectAttributes,
 210                              &DirName,
 211                              0,
 212                              NULL,
 213                              NULL);
 214   NtCreateDirectoryObject(&Handle,
 215                           0,
 216                           &ObjectAttributes);
 217
 218   /*
 219    * Create the '\Device' directory
 220    */
 221   RtlInitUnicodeStringFromLiteral(&DirName,
 222                        L"\\Device");
 223   InitializeObjectAttributes(&ObjectAttributes,
 224                              &DirName,
 225                              0,
 226                              NULL,
 227                              NULL);
 228   ZwCreateDirectoryObject(&Handle,
 229                           0,
 230                           &ObjectAttributes);
 231
 232   /*
 233    * Create the '\??' directory
 234    */
 235   RtlInitUnicodeStringFromLiteral(&DirName,
 236                        L"\\??");
 237   InitializeObjectAttributes(&ObjectAttributes,
 238                              &DirName,
 239                              0,
 240                              NULL,
 241                              NULL);
 242   ZwCreateDirectoryObject(&Handle,
 243                           0,
 244                           &ObjectAttributes);
 245
 246   /*
 247    * Create the '\ArcName' directory
 248    */
 249   RtlInitUnicodeStringFromLiteral(&DirName,
 250                        L"\\ArcName");
 251   InitializeObjectAttributes(&ObjectAttributes,
 252                              &DirName,
 253                              0,
 254                              NULL,
 255                              NULL);
 256   ZwCreateDirectoryObject(&Handle,
 257                           0,
 258                           &ObjectAttributes);
 259
 260   /*
 261    * Initialize remaining subsubsystem
 262    */
 263   IoInitCancelHandling();
 264   IoInitFileSystemImplementation();
 265   IoInitVpbImplementation();
 266   IoInitShutdownNotification();
 267
 268   /*
 269    * Create link from '\DosDevices' to '\??' directory
 270    */
 271   RtlInitUnicodeStringFromLiteral(&LinkName,
 272                        L"\\DosDevices");
 273   RtlInitUnicodeStringFromLiteral(&DirName,
 274                        L"\\??");
 275   IoCreateSymbolicLink(&LinkName,
 276                        &DirName);
 277
 278   /*
 279    * Initialize PnP manager
 280    */
 281   PnpInit();
 282 }
 283
 284 VOID IoInit2(VOID)
 285 {
 286   PDEVICE_NODE DeviceNode;
 287   NTSTATUS Status;
 288
 289   /* Initialize raw filesystem driver */
 290
 291   /* Use IopRootDeviceNode for now */
 292   Status = IopCreateDeviceNode(IopRootDeviceNode,
 293     NULL,
 294     &DeviceNode);
 295   if (!NT_SUCCESS(Status))
 296     {
 297       CPRINT("IopCreateDeviceNode() failed with status (%x)\n", Status);
 298       return;
 299     }
 300
 301   Status = IopInitializeDriver(RawFsDriverEntry,
 302     DeviceNode,
 303     TRUE);
 304   if (!NT_SUCCESS(Status))
 305     {
 306       IopFreeDeviceNode(DeviceNode);
 307       CPRINT("IopInitializeDriver() failed with status (%x)\n", Status);
 308       return;
 309     }
 310 }
 311
 312 PGENERIC_MAPPING STDCALL
 313 IoGetFileObjectGenericMapping(VOID)
 314 {
 315   return(&IopFileMapping);
 316 }
 317
 318 /* EOF */