reactos/drivers/fs/ext2/blockdev.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             services/fs/ext2/blockdev.c
   5  * PURPOSE:          Temporary sector reading support
   6  * PROGRAMMER:       David Welch (welch@cwcom.net)
   7  * UPDATE HISTORY:
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include <ddk/ntddk.h>
  13
  14 //#define NDEBUG
  15 #include <debug.h>
  16
  17 #include "ext2fs.h"
  18
  19 /* FUNCTIONS ***************************************************************/
  20
  21 BOOLEAN
  22 Ext2ReadSectors(IN PDEVICE_OBJECT pDeviceObject,
  23                 IN ULONG DiskSector,
  24                 IN ULONG SectorCount,
  25                 IN PVOID Buffer)
  26 {
  27     LARGE_INTEGER   sectorNumber;
  28     PIRP            irp;
  29     IO_STATUS_BLOCK ioStatus;
  30     KEVENT          event;
  31     NTSTATUS        status;
  32     ULONG           sectorSize;
  33     int j;
  34
  35     DPRINT("VFATReadSector(pDeviceObject %x, DiskSector %d, Buffer %x)\n",
  36            pDeviceObject,DiskSector,Buffer);
  37
  38     sectorNumber.u.HighPart = 0;
  39     sectorNumber.u.LowPart = DiskSector * BLOCKSIZE;
  40
  41     DPRINT("DiskSector:%ld BLKSZ:%ld sectorNumber:%ld:%ld\n",
  42            (unsigned long) DiskSector,
  43            (unsigned long) BLOCKSIZE,
  44            (unsigned long) sectorNumber.u.HighPart,
  45            (unsigned long) sectorNumber.u.LowPart);
  46
  47     KeInitializeEvent(&event, NotificationEvent, FALSE);
  48
  49     sectorSize = BLOCKSIZE*SectorCount;
  50
  51
  52     DPRINT("Building synchronous FSD Request...\n");
  53     irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
  54                                        pDeviceObject,
  55                                        Buffer,
  56                                        sectorSize,
  57                                        &sectorNumber,
  58                                        &event,
  59                                        &ioStatus );
  60
  61     if (!irp)
  62      {
  63         DbgPrint("READ failed!!!\n");
  64         return FALSE;
  65      }
  66
  67     DPRINT("Calling IO Driver...\n");
  68     status = IoCallDriver(pDeviceObject, irp);
  69
  70     DPRINT("Waiting for IO Operation...\n");
  71     if (status == STATUS_PENDING)
  72      {
  73         KeWaitForSingleObject(&event,
  74                               Suspended,
  75                               KernelMode,
  76                               FALSE,
  77                               NULL);
  78         DPRINT("Getting IO Status...\n");
  79         status = ioStatus.Status;
  80      }
  81
  82    if (!NT_SUCCESS(status))
  83      {
  84         DbgPrint("IO failed!!! Error code: %d(%x)\n", status, status);
  85         return FALSE;
  86      }
  87
  88    return TRUE;
  89 }
  90
  91 BOOLEAN VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject,
  92                          IN ULONG       DiskSector,
  93                          IN ULONG       SectorCount,
  94                          IN UCHAR*      Buffer)
  95 {
  96     LARGE_INTEGER   sectorNumber;
  97     PIRP            irp;
  98     IO_STATUS_BLOCK ioStatus;
  99     KEVENT          event;
 100     NTSTATUS        status;
 101     ULONG           sectorSize;
 102     PULONG          mbr;
 103     int j;
 104
 105     DPRINT("VFATWriteSector(pDeviceObject %x, DiskSector %d, Buffer %x)\n",
 106            pDeviceObject,DiskSector,Buffer);
 107
 108     sectorNumber.u.HighPart = 0;
 109     sectorNumber.u.LowPart = DiskSector * BLOCKSIZE;
 110
 111     KeInitializeEvent(&event, NotificationEvent, FALSE);
 112
 113     sectorSize = BLOCKSIZE*SectorCount;
 114
 115
 116     DPRINT("Building synchronous FSD Request...\n");
 117     irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
 118                                        pDeviceObject,
 119                                        Buffer,
 120                                        sectorSize,
 121                                        &sectorNumber,
 122                                        &event,
 123                                        &ioStatus );
 124
 125     if (!irp) {
 126         DbgPrint("WRITE failed!!!\n");
 127         return FALSE;
 128     }
 129
 130     DPRINT("Calling IO Driver...\n");
 131     status = IoCallDriver(pDeviceObject,
 132                           irp);
 133
 134     DPRINT("Waiting for IO Operation...\n");
 135     if (status == STATUS_PENDING) {
 136         KeWaitForSingleObject(&event,
 137                               Suspended,
 138                               KernelMode,
 139                               FALSE,
 140                               NULL);
 141         DPRINT("Getting IO Status...\n");
 142         status = ioStatus.Status;
 143     }
 144
 145     if (!NT_SUCCESS(status)) {
 146         DbgPrint("IO failed!!! Error code: %d(%x)\n", status, status);
 147         return FALSE;
 148     }
 149
 150
 151     ExFreePool(mbr);
 152     DPRINT("Block request succeeded\n");
 153     return TRUE;
 154 }
 155