drivers/filesystems/ext2/src/volinfo.c

   1 /*
   2  * COPYRIGHT:        See COPYRIGHT.TXT
   3  * PROJECT:          Ext2 File System Driver for WinNT/2K/XP
   4  * FILE:             volinfo.c
   5  * PROGRAMMER:       Matt Wu <mattwu@163.com>
   6  * HOMEPAGE:         http://www.ext2fsd.com
   7  * UPDATE HISTORY:
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include "ext2fs.h"
  13
  14 /* GLOBALS ***************************************************************/
  15
  16 extern PEXT2_GLOBAL Ext2Global;
  17
  18 /* DEFINITIONS *************************************************************/
  19
  20 #ifdef ALLOC_PRAGMA
  21 #pragma alloc_text(PAGE, Ext2QueryVolumeInformation)
  22 #pragma alloc_text(PAGE, Ext2SetVolumeInformation)
  23 #endif
  24
  25
  26 NTSTATUS
  27 Ext2QueryVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext)
  28 {
  29     PDEVICE_OBJECT          DeviceObject;
  30     PEXT2_VCB               Vcb = NULL;
  31     PIRP                    Irp = NULL;
  32     PIO_STACK_LOCATION      IoStackLocation = NULL;
  33     PVOID                   Buffer;
  34     ULONG                   Length;
  35     NTSTATUS                Status = STATUS_UNSUCCESSFUL;
  36     FS_INFORMATION_CLASS    FsInformationClass;
  37     BOOLEAN                 VcbResourceAcquired = FALSE;
  38
  39     _SEH2_TRY {
  40
  41         ASSERT(IrpContext != NULL);
  42         ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
  43                (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
  44
  45         DeviceObject = IrpContext->DeviceObject;
  46
  47         //
  48         // This request is not allowed on the main device object
  49         //
  50         if (IsExt2FsDevice(DeviceObject)) {
  51             Status = STATUS_INVALID_DEVICE_REQUEST;
  52             _SEH2_LEAVE;
  53         }
  54
  55         Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
  56         ASSERT(Vcb != NULL);
  57         ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
  58                (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
  59
  60         if (!IsMounted(Vcb)) {
  61             Status = STATUS_VOLUME_DISMOUNTED;
  62             _SEH2_LEAVE;
  63         }
  64
  65         if (!ExAcquireResourceSharedLite(
  66                     &Vcb->MainResource,
  67                     IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)
  68                 )) {
  69
  70             Status = STATUS_PENDING;
  71             _SEH2_LEAVE;
  72         }
  73         VcbResourceAcquired = TRUE;
  74
  75         Irp = IrpContext->Irp;
  76         IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
  77         FsInformationClass =
  78             IoStackLocation->Parameters.QueryVolume.FsInformationClass;
  79
  80         Length = IoStackLocation->Parameters.QueryVolume.Length;
  81         Buffer = Irp->AssociatedIrp.SystemBuffer;
  82
  83         RtlZeroMemory(Buffer, Length);
  84
  85         switch (FsInformationClass) {
  86
  87         case FileFsVolumeInformation:
  88         {
  89             PFILE_FS_VOLUME_INFORMATION FsVolInfo;
  90             ULONG                       VolumeLabelLength;
  91             ULONG                       RequiredLength;
  92
  93             if (Length < sizeof(FILE_FS_VOLUME_INFORMATION)) {
  94                 Status = STATUS_BUFFER_OVERFLOW;
  95                 _SEH2_LEAVE;
  96             }
  97
  98             FsVolInfo = (PFILE_FS_VOLUME_INFORMATION) Buffer;
  99             FsVolInfo->VolumeCreationTime.QuadPart = 0;
 100             FsVolInfo->VolumeSerialNumber = Vcb->Vpb->SerialNumber;
 101             VolumeLabelLength = Vcb->Vpb->VolumeLabelLength;
 102             FsVolInfo->VolumeLabelLength = VolumeLabelLength;
 103             /* We don't support ObjectId */
 104             FsVolInfo->SupportsObjects = FALSE;
 105
 106             RequiredLength = sizeof(FILE_FS_VOLUME_INFORMATION)
 107                              + VolumeLabelLength - sizeof(WCHAR);
 108
 109             if (Length < RequiredLength) {
 110                 Irp->IoStatus.Information =
 111                     sizeof(FILE_FS_VOLUME_INFORMATION);
 112                 Status = STATUS_BUFFER_OVERFLOW;
 113                 _SEH2_LEAVE;
 114             }
 115
 116             RtlCopyMemory(FsVolInfo->VolumeLabel, Vcb->Vpb->VolumeLabel, Vcb->Vpb->VolumeLabelLength);
 117
 118             Irp->IoStatus.Information = RequiredLength;
 119             Status = STATUS_SUCCESS;
 120         }
 121         break;
 122
 123         case FileFsSizeInformation:
 124         {
 125             PFILE_FS_SIZE_INFORMATION FsSizeInfo;
 126
 127             if (Length < sizeof(FILE_FS_SIZE_INFORMATION)) {
 128                 Status = STATUS_BUFFER_OVERFLOW;
 129                 _SEH2_LEAVE;
 130             }
 131
 132             FsSizeInfo = (PFILE_FS_SIZE_INFORMATION) Buffer;
 133             FsSizeInfo->TotalAllocationUnits.QuadPart =
 134                 ext3_blocks_count(SUPER_BLOCK);
 135             FsSizeInfo->AvailableAllocationUnits.QuadPart =
 136                 ext3_free_blocks_count(SUPER_BLOCK);
 137             FsSizeInfo->SectorsPerAllocationUnit =
 138                 Vcb->BlockSize / Vcb->DiskGeometry.BytesPerSector;
 139             FsSizeInfo->BytesPerSector =
 140                 Vcb->DiskGeometry.BytesPerSector;
 141
 142             Irp->IoStatus.Information = sizeof(FILE_FS_SIZE_INFORMATION);
 143             Status = STATUS_SUCCESS;
 144         }
 145         break;
 146
 147         case FileFsDeviceInformation:
 148         {
 149             PFILE_FS_DEVICE_INFORMATION FsDevInfo;
 150
 151             if (Length < sizeof(FILE_FS_DEVICE_INFORMATION)) {
 152                 Status = STATUS_BUFFER_OVERFLOW;
 153                 _SEH2_LEAVE;
 154             }
 155
 156             FsDevInfo = (PFILE_FS_DEVICE_INFORMATION) Buffer;
 157             FsDevInfo->DeviceType =
 158                 Vcb->TargetDeviceObject->DeviceType;
 159
 160             if (FsDevInfo->DeviceType != FILE_DEVICE_DISK) {
 161                 DbgBreak();
 162             }
 163
 164             FsDevInfo->Characteristics =
 165                 Vcb->TargetDeviceObject->Characteristics;
 166
 167             if (IsVcbReadOnly(Vcb)) {
 168                 SetFlag( FsDevInfo->Characteristics,
 169                          FILE_READ_ONLY_DEVICE   );
 170             }
 171
 172             Irp->IoStatus.Information = sizeof(FILE_FS_DEVICE_INFORMATION);
 173             Status = STATUS_SUCCESS;
 174         }
 175         break;
 176
 177         case FileFsAttributeInformation:
 178         {
 179             PFILE_FS_ATTRIBUTE_INFORMATION  FsAttrInfo;
 180             ULONG                           RequiredLength;
 181
 182             if (Length < sizeof(FILE_FS_ATTRIBUTE_INFORMATION)) {
 183                 Status = STATUS_BUFFER_OVERFLOW;
 184                 _SEH2_LEAVE;
 185             }
 186
 187             FsAttrInfo =
 188                 (PFILE_FS_ATTRIBUTE_INFORMATION) Buffer;
 189             FsAttrInfo->FileSystemAttributes = FILE_SUPPORTS_HARD_LINKS |
 190                 FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES |
 191                 FILE_SUPPORTS_REPARSE_POINTS | FILE_SUPPORTS_EXTENDED_ATTRIBUTES;
 192             if (IsVcbReadOnly(Vcb)) {
 193                 FsAttrInfo->FileSystemAttributes |= FILE_READ_ONLY_VOLUME;
 194             }
 195             FsAttrInfo->MaximumComponentNameLength = EXT2_NAME_LEN;
 196             FsAttrInfo->FileSystemNameLength = 8;
 197
 198             RequiredLength = sizeof(FILE_FS_ATTRIBUTE_INFORMATION) +
 199                              8 - sizeof(WCHAR);
 200
 201             if (Length < RequiredLength) {
 202                 Irp->IoStatus.Information =
 203                     sizeof(FILE_FS_ATTRIBUTE_INFORMATION);
 204                 Status = STATUS_BUFFER_OVERFLOW;
 205                 _SEH2_LEAVE;
 206             }
 207
 208             if (IsFlagOn(SUPER_BLOCK->s_feature_incompat, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
 209                 RtlCopyMemory(FsAttrInfo->FileSystemName,  L"EXT4\0", 10);
 210             } else if (Vcb->IsExt3fs) {
 211                 RtlCopyMemory(FsAttrInfo->FileSystemName,  L"EXT3\0", 10);
 212             } else {
 213                 RtlCopyMemory(FsAttrInfo->FileSystemName,  L"EXT2\0", 10);
 214             }
 215
 216             Irp->IoStatus.Information = RequiredLength;
 217             Status = STATUS_SUCCESS;
 218         }
 219         break;
 220
 221 #if (_WIN32_WINNT >= 0x0500)
 222
 223         case FileFsFullSizeInformation:
 224         {
 225             PFILE_FS_FULL_SIZE_INFORMATION PFFFSI;
 226
 227             if (Length < sizeof(FILE_FS_FULL_SIZE_INFORMATION)) {
 228                 Status = STATUS_BUFFER_OVERFLOW;
 229                 _SEH2_LEAVE;
 230             }
 231
 232             PFFFSI = (PFILE_FS_FULL_SIZE_INFORMATION) Buffer;
 233
 234             /*
 235                             typedef struct _FILE_FS_FULL_SIZE_INFORMATION {
 236                                 LARGE_INTEGER   TotalAllocationUnits;
 237                                 LARGE_INTEGER   CallerAvailableAllocationUnits;
 238                                 LARGE_INTEGER   ActualAvailableAllocationUnits;
 239                                 ULONG           SectorsPerAllocationUnit;
 240                                 ULONG           BytesPerSector;
 241                             } FILE_FS_FULL_SIZE_INFORMATION, *PFILE_FS_FULL_SIZE_INFORMATION;
 242             */
 243
 244             {
 245                 PFFFSI->TotalAllocationUnits.QuadPart =
 246                     ext3_blocks_count(SUPER_BLOCK);
 247
 248                 PFFFSI->CallerAvailableAllocationUnits.QuadPart =
 249                     ext3_free_blocks_count(SUPER_BLOCK);
 250
 251                 /* - Vcb->SuperBlock->s_r_blocks_count; */
 252                 PFFFSI->ActualAvailableAllocationUnits.QuadPart =
 253                     ext3_free_blocks_count(SUPER_BLOCK);
 254             }
 255
 256             PFFFSI->SectorsPerAllocationUnit =
 257                 Vcb->BlockSize / Vcb->DiskGeometry.BytesPerSector;
 258
 259             PFFFSI->BytesPerSector = Vcb->DiskGeometry.BytesPerSector;
 260
 261             Irp->IoStatus.Information = sizeof(FILE_FS_FULL_SIZE_INFORMATION);
 262             Status = STATUS_SUCCESS;
 263         }
 264         break;
 265
 266 #endif // (_WIN32_WINNT >= 0x0500)
 267
 268         default:
 269             Status = STATUS_INVALID_INFO_CLASS;
 270             break;
 271         }
 272
 273     } _SEH2_FINALLY {
 274
 275         if (VcbResourceAcquired) {
 276             ExReleaseResourceLite(&Vcb->MainResource);
 277         }
 278
 279         if (!IrpContext->ExceptionInProgress) {
 280             if (Status == STATUS_PENDING) {
 281                 Ext2QueueRequest(IrpContext);
 282             } else {
 283                 Ext2CompleteIrpContext(IrpContext, Status);
 284             }
 285         }
 286     } _SEH2_END;
 287
 288     return Status;
 289 }
 290
 291 NTSTATUS
 292 Ext2SetVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext)
 293 {
 294     PDEVICE_OBJECT          DeviceObject;
 295     NTSTATUS                Status = STATUS_UNSUCCESSFUL;
 296     PEXT2_VCB               Vcb = NULL;
 297     PIRP                    Irp;
 298     PIO_STACK_LOCATION      IoStackLocation;
 299     FS_INFORMATION_CLASS    FsInformationClass;
 300     BOOLEAN                 VcbResourceAcquired = FALSE;
 301
 302     _SEH2_TRY {
 303
 304         ASSERT(IrpContext != NULL);
 305
 306         ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
 307                (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 308
 309         DeviceObject = IrpContext->DeviceObject;
 310
 311         //
 312         // This request is not allowed on the main device object
 313         //
 314         if (IsExt2FsDevice(DeviceObject)) {
 315             Status = STATUS_INVALID_DEVICE_REQUEST;
 316             _SEH2_LEAVE;
 317         }
 318
 319         Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
 320         ASSERT(Vcb != NULL);
 321         ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
 322                (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 323         ASSERT(IsMounted(Vcb));
 324
 325         if (IsVcbReadOnly(Vcb)) {
 326             Status = STATUS_MEDIA_WRITE_PROTECTED;
 327             _SEH2_LEAVE;
 328         }
 329
 330         if (!ExAcquireResourceExclusiveLite(
 331                     &Vcb->MainResource, TRUE)) {
 332             Status = STATUS_PENDING;
 333             _SEH2_LEAVE;
 334         }
 335         VcbResourceAcquired = TRUE;
 336
 337         Ext2VerifyVcb(IrpContext, Vcb);
 338
 339         Irp = IrpContext->Irp;
 340         IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
 341
 342         //Notes: SetVolume is not defined in ntddk.h of win2k ddk,
 343         //       But it's same to QueryVolume ....
 344         FsInformationClass =
 345             IoStackLocation->Parameters./*SetVolume*/QueryVolume.FsInformationClass;
 346
 347         switch (FsInformationClass) {
 348
 349         case FileFsLabelInformation:
 350         {
 351             PFILE_FS_LABEL_INFORMATION      VolLabelInfo = NULL;
 352             ULONG                           VolLabelLen;
 353             UNICODE_STRING                  LabelName  ;
 354
 355             OEM_STRING                      OemName;
 356
 357             VolLabelInfo = (PFILE_FS_LABEL_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
 358             VolLabelLen = VolLabelInfo->VolumeLabelLength;
 359
 360             if (VolLabelLen > (16 * sizeof(WCHAR))) {
 361                 Status = STATUS_INVALID_VOLUME_LABEL;
 362                 _SEH2_LEAVE;
 363             }
 364
 365             RtlCopyMemory( Vcb->Vpb->VolumeLabel,
 366                            VolLabelInfo->VolumeLabel,
 367                            VolLabelLen );
 368
 369             RtlZeroMemory(Vcb->SuperBlock->s_volume_name, 16);
 370             LabelName.Buffer = VolLabelInfo->VolumeLabel;
 371             LabelName.MaximumLength = (USHORT)16 * sizeof(WCHAR);
 372             LabelName.Length = (USHORT)VolLabelLen;
 373
 374             OemName.Buffer = SUPER_BLOCK->s_volume_name;
 375             OemName.Length  = 0;
 376             OemName.MaximumLength = 16;
 377
 378             Ext2UnicodeToOEM(Vcb, &OemName, &LabelName);
 379             Vcb->Vpb->VolumeLabelLength = (USHORT) VolLabelLen;
 380
 381             if (Ext2SaveSuper(IrpContext, Vcb)) {
 382                 Status = STATUS_SUCCESS;
 383             }
 384
 385             Irp->IoStatus.Information = 0;
 386         }
 387         break;
 388
 389         default:
 390             Status = STATUS_INVALID_INFO_CLASS;
 391         }
 392
 393     } _SEH2_FINALLY {
 394
 395         if (VcbResourceAcquired) {
 396             ExReleaseResourceLite(&Vcb->MainResource);
 397         }
 398
 399         if (!IrpContext->ExceptionInProgress) {
 400             if (Status == STATUS_PENDING) {
 401                 Ext2QueueRequest(IrpContext);
 402             } else {
 403                 Ext2CompleteIrpContext(IrpContext, Status);
 404             }
 405         }
 406     } _SEH2_END;
 407
 408     return Status;
 409 }