reactos/ntoskrnl/io/file.c

   1 /* $Id: file.c,v 1.13 2001/03/06 23:34:39 cnettel Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            ntoskrnl/io/file.c
   6  * PURPOSE:         Graceful system shutdown if a bug is detected
   7  * PROGRAMMER:      David Welch (welch@mcmail.com)
   8  * UPDATE HISTORY:
   9  *                  Created 22/05/98
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <ddk/ntddk.h>
  15 #include <internal/io.h>
  16
  17 #define NDEBUG
  18 #include <internal/debug.h>
  19
  20 /* FUNCTIONS *****************************************************************/
  21
  22 NTSTATUS STDCALL internalQueryFileInfo (
  23         IN      PFILE_OBJECT            FileObject,
  24         IN      FILE_INFORMATION_CLASS  FileInformationClass,
  25         PIO_STATUS_BLOCK        IoStatusBlock,
  26         IN      ULONG                   Length,
  27         OUT     PVOID                   FileInformation,
  28         OUT     PULONG                  ReturnedLength  // FIXME: ReturnedLength not implemented
  29         )
  30 {
  31    //This code is taken from old NtQueryInformationFile, now shared with IoQueryFileInformation
  32    PIRP Irp;
  33    PDEVICE_OBJECT DeviceObject;
  34    NTSTATUS Status;
  35    KEVENT Event;
  36    PIO_STACK_LOCATION StackPtr;
  37
  38
  39    KeInitializeEvent(&Event,NotificationEvent,FALSE);
  40    DeviceObject = FileObject->DeviceObject;
  41
  42    Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
  43    if (Irp==NULL)
  44      {
  45         ObDereferenceObject(FileObject);
  46         return STATUS_UNSUCCESSFUL;
  47      }
  48
  49    Irp->UserIosb = IoStatusBlock;
  50    Irp->UserEvent = &Event;
  51    Irp->UserBuffer=FileInformation;
  52
  53    StackPtr = IoGetNextIrpStackLocation(Irp);
  54    StackPtr->MajorFunction = IRP_MJ_QUERY_INFORMATION;
  55    StackPtr->MinorFunction = 0;
  56    StackPtr->Flags = 0;
  57    StackPtr->Control = 0;
  58    StackPtr->DeviceObject = DeviceObject;
  59    StackPtr->FileObject = FileObject;
  60
  61    StackPtr->Parameters.QueryFile.FileInformationClass =
  62      FileInformationClass;
  63    StackPtr->Parameters.QueryFile.Length = Length;
  64
  65    Status = IoCallDriver(FileObject->DeviceObject,Irp);
  66    if (Status==STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
  67      {
  68         KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL);
  69         Status = Irp->IoStatus.Status;
  70      }
  71
  72    return Status;
  73 }
  74
  75 NTSTATUS
  76 STDCALL
  77 NtQueryInformationFile (
  78         HANDLE                  FileHandle,
  79         PIO_STATUS_BLOCK        IoStatusBlock,
  80         PVOID                   FileInformation,
  81         ULONG                   Length,
  82         FILE_INFORMATION_CLASS  FileInformationClass
  83         )
  84 {
  85    PFILE_OBJECT FileObject;
  86    NTSTATUS Status;
  87
  88    DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
  89           FileHandle,
  90           IoStatusBlock,
  91           FileInformation,
  92           Length,
  93           FileInformationClass);
  94
  95    Status = ObReferenceObjectByHandle(FileHandle,
  96                                       FILE_READ_ATTRIBUTES,
  97                                       IoFileObjectType,
  98                                       UserMode,
  99                                       (PVOID *)&FileObject,
 100                                       NULL);
 101    if (!NT_SUCCESS(Status))
 102      {
 103         return(Status);
 104      }
 105    DPRINT("FileObject %x\n", FileObject);
 106    Status = internalQueryFileInfo(FileObject, FileInformationClass, IoStatusBlock, Length, FileInformation, NULL);
 107
 108 //   ObDereferenceObject(FileObject); FIXME: Why will a Dereference here make the OS impossible to boot. Incorrect deferring somewhere else?
 109    return(Status);
 110 }
 111
 112
 113
 114 NTSTATUS
 115 STDCALL
 116 IoQueryFileInformation (
 117         IN      PFILE_OBJECT            FileObject,
 118         IN      FILE_INFORMATION_CLASS  FileInformationClass,
 119         IN      ULONG                   Length,
 120         OUT     PVOID                   FileInformation,
 121         OUT     PULONG                  ReturnedLength  // FIXME: ReturnedLength not implemented
 122         )
 123 {
 124    NTSTATUS Status;
 125
 126    Status = ObReferenceObjectByPointer(FileObject,
 127                                       FILE_READ_ATTRIBUTES,
 128                                       IoFileObjectType,
 129                                       KernelMode); // FIXME: Is KernelMode the correct choice here?
 130    if (!NT_SUCCESS(Status))
 131      {
 132         return(Status);
 133      }
 134
 135 //   ObDereferenceObject(FileObject); For some reason, ObDereference is NOT a good thing here... wish I knew why
 136    return internalQueryFileInfo(FileObject,FileInformationClass,NULL,Length,FileInformation,ReturnedLength);
 137 }
 138
 139
 140 NTSTATUS
 141 STDCALL
 142 NtSetInformationFile (
 143         HANDLE                  FileHandle,
 144         PIO_STATUS_BLOCK        IoStatusBlock,
 145         PVOID                   FileInformation,
 146         ULONG                   Length,
 147         FILE_INFORMATION_CLASS  FileInformationClass
 148         )
 149 {
 150         NTSTATUS                Status;
 151         PFILE_OBJECT            FileObject;
 152         PIRP                    Irp;
 153         PIO_STACK_LOCATION      StackPtr;
 154         KEVENT                  Event;
 155
 156         DPRINT(
 157                 "NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
 158                 FileHandle,
 159                 IoStatusBlock,
 160                 FileInformation,
 161                 Length,
 162                 FileInformationClass
 163                 );
 164
 165         /*  Get the file object from the file handle  */
 166         Status = ObReferenceObjectByHandle(
 167                         FileHandle,
 168                         FILE_WRITE_ATTRIBUTES,
 169                         IoFileObjectType,
 170                         UserMode,
 171                         (PVOID *) & FileObject,
 172                         NULL
 173                         );
 174         if (!NT_SUCCESS(Status))
 175         {
 176                 return Status;
 177         }
 178
 179         DPRINT("FileObject %x\n", FileObject);
 180
 181         /*
 182          * Initialize an event object to wait
 183          * on for the request.
 184          */
 185         KeInitializeEvent(
 186                 & Event,
 187                 NotificationEvent,
 188                 FALSE
 189                 );
 190         /*
 191          * Build the IRP to be sent to the driver
 192          * for the request.
 193          */
 194         Irp = IoBuildSynchronousFsdRequest(
 195                 IRP_MJ_SET_INFORMATION,
 196                 FileObject->DeviceObject,
 197                 FileInformation,
 198                 Length,
 199                 0,
 200                 & Event,
 201                 IoStatusBlock
 202                 );
 203
 204         StackPtr = IoGetNextIrpStackLocation(Irp);
 205         StackPtr->FileObject = FileObject;
 206         StackPtr->Parameters.SetFile.Length = Length;
 207         StackPtr->Parameters.SetFile.FileInformationClass =
 208                 FileInformationClass;
 209
 210         /*
 211          * Pass the IRP to the FSD (and wait for
 212          * it if required)
 213          */
 214         DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject);
 215         Status = IoCallDriver(
 216                         FileObject->DeviceObject,
 217                         Irp
 218                         );
 219         if (    (Status == STATUS_PENDING)
 220                 && (FileObject->Flags & FO_SYNCHRONOUS_IO)
 221                 )
 222         {
 223                 KeWaitForSingleObject(
 224                         & Event,
 225                         Executive,
 226                         KernelMode,
 227                         FALSE,
 228                         NULL
 229                         );
 230                 Status = Irp->IoStatus.Status;
 231         }
 232
 233         return Status;
 234 }
 235
 236
 237 NTSTATUS
 238 STDCALL
 239 NtQueryAttributesFile (
 240         IN      POBJECT_ATTRIBUTES      ObjectAttributes,
 241         IN      PVOID   Buffer
 242         )
 243 {
 244         UNIMPLEMENTED;
 245 }
 246
 247
 248 NTSTATUS
 249 STDCALL
 250 NtQueryFullAttributesFile (
 251         IN      HANDLE  FileHandle,
 252         IN      PVOID   Attributes
 253         )
 254 {
 255         UNIMPLEMENTED;
 256 }
 257
 258
 259 NTSTATUS
 260 STDCALL
 261 NtQueryEaFile (
 262         IN      HANDLE                  FileHandle,
 263         OUT     PIO_STATUS_BLOCK        IoStatusBlock,
 264         OUT     PVOID                   Buffer,
 265         IN      ULONG                   Length,
 266         IN      BOOLEAN                 ReturnSingleEntry,
 267         IN      PVOID                   EaList                  OPTIONAL,
 268         IN      ULONG                   EaListLength,
 269         IN      PULONG                  EaIndex                 OPTIONAL,
 270         IN      BOOLEAN                 RestartScan
 271         )
 272 {
 273         UNIMPLEMENTED;
 274 }
 275
 276
 277 NTSTATUS
 278 STDCALL
 279 NtSetEaFile (
 280         IN      HANDLE                  FileHandle,
 281         IN      PIO_STATUS_BLOCK        IoStatusBlock,
 282                 PVOID                   EaBuffer,
 283                 ULONG                   EaBufferSize
 284                 )
 285 {
 286         UNIMPLEMENTED;
 287 }
 288
 289
 290 /* EOF */