reactos/ntoskrnl/io/vpb.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/io/vpb.c
   5  * PURPOSE:         Volume Parameter Block managment
   6  * PROGRAMMER:      David Welch (welch@mcmail.com)
   7  * UPDATE HISTORY:
   8  *                  Created 22/05/98
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <ddk/ntddk.h>
  14 #include <string.h>
  15 #include <internal/string.h>
  16 #include <internal/ob.h>
  17
  18 #define NDEBUG
  19 #include <internal/debug.h>
  20
  21 /* FUNCTIONS *****************************************************************/
  22
  23 NTSTATUS IoAttachVpb(PDEVICE_OBJECT DeviceObject)
  24 {
  25    PVPB Vpb;
  26
  27    Vpb = ExAllocatePool(NonPagedPool,sizeof(VPB));
  28    if (Vpb==NULL)
  29      {
  30         return(STATUS_UNSUCCESSFUL);
  31      }
  32
  33    Vpb->Type = 0;
  34    Vpb->Size = sizeof(VPB) / sizeof(DWORD);
  35    Vpb->Flags = 0;
  36    Vpb->VolumeLabelLength = 0;
  37    Vpb->DeviceObject = NULL;
  38    Vpb->RealDevice = DeviceObject;
  39    Vpb->SerialNumber = 0;
  40    Vpb->ReferenceCount = 0;
  41    RtlZeroMemory(Vpb->VolumeLabel,sizeof(WCHAR)*MAXIMUM_VOLUME_LABEL_LENGTH);
  42
  43    DeviceObject->Vpb = Vpb;
  44
  45    return(STATUS_SUCCESS);
  46 }
  47
  48 PIRP IoBuildVolumeInformationIrp(ULONG MajorFunction,
  49                                  PFILE_OBJECT FileObject,
  50                                  PVOID FSInformation,
  51                                  ULONG Length,
  52                                  CINT FSInformationClass,
  53                                  PIO_STATUS_BLOCK IoStatusBlock,
  54                                  PKEVENT Event)
  55 {
  56    PIRP Irp;
  57    PIO_STACK_LOCATION StackPtr;
  58    PDEVICE_OBJECT DeviceObject;
  59
  60    DeviceObject = FileObject->DeviceObject;
  61
  62    Irp = IoAllocateIrp(DeviceObject->StackSize,TRUE);
  63    if (Irp==NULL)
  64      {
  65         return(NULL);
  66      }
  67
  68 //   Irp->AssociatedIrp.SystemBuffer = FSInformation;
  69    Irp->UserBuffer = FSInformation;
  70
  71    StackPtr = IoGetNextIrpStackLocation(Irp);
  72    StackPtr->MajorFunction = MajorFunction;
  73    StackPtr->MinorFunction = 0;
  74    StackPtr->Flags = 0;
  75    StackPtr->Control = 0;
  76    StackPtr->DeviceObject = DeviceObject;
  77    StackPtr->FileObject = FileObject;
  78    Irp->UserEvent = Event;
  79    Irp->UserIosb = IoStatusBlock;
  80
  81    switch (MajorFunction)
  82    {
  83       case IRP_MJ_SET_VOLUME_INFORMATION:
  84          StackPtr->Parameters.SetVolume.Length = Length;
  85          StackPtr->Parameters.SetVolume.FileInformationClass =
  86                      FSInformationClass;
  87          break;
  88
  89       case IRP_MJ_QUERY_VOLUME_INFORMATION:
  90          StackPtr->Parameters.QueryVolume.Length = Length;
  91          StackPtr->Parameters.QueryVolume.FileInformationClass =
  92                      FSInformationClass;
  93          break;
  94    }
  95    return(Irp);
  96 }
  97
  98 NTSTATUS
  99 STDCALL
 100 NtQueryVolumeInformationFile (
 101         IN      HANDLE                  FileHandle,
 102         OUT     PIO_STATUS_BLOCK        IoStatusBlock,
 103         OUT     PVOID                   FSInformation,
 104         IN      ULONG                   Length,
 105         IN      FS_INFORMATION_CLASS    FSInformationClass
 106         )
 107
 108 /*
 109  * FUNCTION: Queries the volume information
 110  * ARGUMENTS:
 111  *        FileHandle  = Handle to a file object on the target volume
 112  *        ReturnLength = DataWritten
 113  *        FSInformation = Caller should supply storage for the information
 114  *                        structure.
 115  *        Length = Size of the information structure
 116  *        FSInformationClass = Index to a information structure
 117  *
 118  *              FileFsVolumeInformation         FILE_FS_VOLUME_INFORMATION
 119  *              FileFsLabelInformation          FILE_FS_LABEL_INFORMATION
 120  *              FileFsSizeInformation           FILE_FS_SIZE_INFORMATION
 121  *              FileFsDeviceInformation         FILE_FS_DEVICE_INFORMATION
 122  *              FileFsAttributeInformation      FILE_FS_ATTRIBUTE_INFORMATION
 123  *              FileFsControlInformation
 124  *              FileFsQuotaQueryInformation     --
 125  *              FileFsQuotaSetInformation       --
 126  *              FileFsMaximumInformation
 127  *
 128  * RETURNS: Status
 129  */
 130 {
 131    PFILE_OBJECT FileObject;
 132    PDEVICE_OBJECT DeviceObject;
 133    PIRP Irp;
 134    KEVENT Event;
 135    NTSTATUS Status;
 136
 137    DPRINT("FSInformation %p\n", FSInformation);
 138
 139    Status = ObReferenceObjectByHandle(FileHandle,
 140                                       FILE_READ_ATTRIBUTES,
 141                                       NULL,
 142                                       UserMode,
 143                                       (PVOID*)&FileObject,
 144                                       NULL);
 145    if (Status != STATUS_SUCCESS)
 146      {
 147         return(Status);
 148      }
 149
 150    DeviceObject = FileObject->DeviceObject;
 151
 152    KeInitializeEvent(&Event,NotificationEvent,FALSE);
 153
 154    Irp = IoBuildVolumeInformationIrp(IRP_MJ_QUERY_VOLUME_INFORMATION,
 155                                      FileObject,
 156                                      FSInformation,
 157                                      Length,
 158                                      FSInformationClass,
 159                                      IoStatusBlock,
 160                                      &Event);
 161    Status = IoCallDriver(DeviceObject,Irp);
 162    if (Status == STATUS_PENDING)
 163      {
 164         KeWaitForSingleObject(&Event,UserRequest,KernelMode,FALSE,NULL);
 165         Status = IoStatusBlock->Status;
 166      }
 167    return(Status);
 168 }
 169
 170 NTSTATUS
 171 STDCALL
 172 NtSetVolumeInformationFile (
 173         IN      HANDLE  FileHandle,
 174         IN      CINT    VolumeInformationClass,
 175                 PVOID   VolumeInformation,
 176                 ULONG   Length
 177         )
 178 {
 179    PFILE_OBJECT FileObject;
 180    PDEVICE_OBJECT DeviceObject;
 181    PIRP Irp;
 182    KEVENT Event;
 183    NTSTATUS Status;
 184
 185    Status = ObReferenceObjectByHandle(FileHandle,
 186                                       FILE_WRITE_ATTRIBUTES,
 187                                       NULL,
 188                                       UserMode,
 189                                       (PVOID*)&FileObject,
 190                                       NULL);
 191    if (Status != STATUS_SUCCESS)
 192      {
 193         return(Status);
 194      }
 195
 196    DeviceObject = FileObject->DeviceObject;
 197
 198    KeInitializeEvent(&Event,NotificationEvent,FALSE);
 199
 200    Irp = IoBuildVolumeInformationIrp(IRP_MJ_SET_VOLUME_INFORMATION,
 201                                      FileObject,
 202                                      VolumeInformation,
 203                                      Length,
 204                                      VolumeInformationClass,
 205                                      NULL,
 206                                      &Event);
 207    Status = IoCallDriver(DeviceObject,Irp);
 208    if (Status == STATUS_PENDING)
 209      {
 210         KeWaitForSingleObject(&Event,UserRequest,KernelMode,FALSE,NULL);
 211      }
 212    return(Status);
 213 }