reactos/drivers/filesystems/cdfs/common.c

   1 /*
   2 *  ReactOS kernel
   3 *  Copyright (C) 2002, 2003 ReactOS Team
   4 *
   5 *  This program is free software; you can redistribute it and/or modify
   6 *  it under the terms of the GNU General Public License as published by
   7 *  the Free Software Foundation; either version 2 of the License, or
   8 *  (at your option) any later version.
   9 *
  10 *  This program is distributed in the hope that it will be useful,
  11 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 *  GNU General Public License for more details.
  14 *
  15 *  You should have received a copy of the GNU General Public License along
  16 *  with this program; if not, write to the Free Software Foundation, Inc.,
  17 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19 /* $Id: common.c 55057 2012-01-21 22:16:46Z cgutman $
  20 *
  21 * COPYRIGHT:        See COPYING in the top level directory
  22 * PROJECT:          ReactOS kernel
  23 * FILE:             drivers/fs/cdfs/common.c
  24 * PURPOSE:          CDROM (ISO 9660) filesystem driver
  25 * PROGRAMMER:       Art Yerkes
  26 *                   Eric Kohl
  27 */
  28
  29 /* INCLUDES *****************************************************************/
  30
  31 #include "cdfs.h"
  32
  33 #define NDEBUG
  34 #include <debug.h>
  35
  36 /* FUNCTIONS ****************************************************************/
  37
  38 NTSTATUS
  39 CdfsReadSectors(IN PDEVICE_OBJECT DeviceObject,
  40                 IN ULONG DiskSector,
  41                 IN ULONG SectorCount,
  42                 IN OUT PUCHAR Buffer,
  43                 IN BOOLEAN Override)
  44 {
  45     PIO_STACK_LOCATION Stack;
  46     IO_STATUS_BLOCK IoStatus;
  47     LARGE_INTEGER Offset;
  48     ULONG BlockSize;
  49     KEVENT Event;
  50     PIRP Irp;
  51     NTSTATUS Status;
  52     BOOLEAN LastChance = FALSE;
  53
  54 again:
  55     KeInitializeEvent(&Event,
  56         NotificationEvent,
  57         FALSE);
  58
  59     Offset.u.LowPart = DiskSector << 11;
  60     Offset.u.HighPart = DiskSector >> 21;
  61
  62     BlockSize = BLOCKSIZE * SectorCount;
  63
  64     DPRINT("CdfsReadSectors(DeviceObject %x, DiskSector %d, Buffer %x)\n",
  65         DeviceObject, DiskSector, Buffer);
  66     DPRINT("Offset %I64x BlockSize %ld\n",
  67         Offset.QuadPart,
  68         BlockSize);
  69
  70     DPRINT("Building synchronous FSD Request...\n");
  71     Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
  72         DeviceObject,
  73         Buffer,
  74         BlockSize,
  75         &Offset,
  76         &Event,
  77         &IoStatus);
  78     if (Irp == NULL)
  79     {
  80         DPRINT("IoBuildSynchronousFsdRequest failed\n");
  81         return(STATUS_INSUFFICIENT_RESOURCES);
  82     }
  83
  84     if (Override)
  85     {
  86         Stack = IoGetNextIrpStackLocation(Irp);
  87         Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
  88     }
  89
  90     DPRINT("Calling IO Driver... with irp %x\n", Irp);
  91     Status = IoCallDriver(DeviceObject, Irp);
  92
  93     DPRINT("Waiting for IO Operation for %x\n", Irp);
  94     if (Status == STATUS_PENDING)
  95     {
  96         DPRINT("Operation pending\n");
  97         KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
  98         DPRINT("Getting IO Status... for %x\n", Irp);
  99         Status = IoStatus.Status;
 100     }
 101
 102     if (!NT_SUCCESS(Status))
 103     {
 104         if (Status == STATUS_VERIFY_REQUIRED)
 105         {
 106             PDEVICE_OBJECT DeviceToVerify;
 107
 108             DeviceToVerify = IoGetDeviceToVerify(PsGetCurrentThread());
 109             IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
 110
 111             Status = IoVerifyVolume(DeviceToVerify, FALSE);
 112
 113             if (NT_SUCCESS(Status) && !LastChance)
 114             {
 115                 DPRINT("Volume verify succeeded; trying request again\n");
 116                 LastChance = TRUE;
 117                 goto again;
 118             }
 119             else if (NT_SUCCESS(Status))
 120             {
 121                 DPRINT1("Failed to read after successful verify, aborting\n");
 122                 Status = STATUS_DEVICE_NOT_READY;
 123             }
 124             else
 125             {
 126                 DPRINT1("IoVerifyVolume() failed (Status %lx)\n", Status);
 127             }
 128         }
 129
 130         DPRINT("CdfsReadSectors() failed (Status %x)\n", Status);
 131         DPRINT("(DeviceObject %x, DiskSector %x, Buffer %x, Offset 0x%I64x)\n",
 132             DeviceObject, DiskSector, Buffer,
 133             Offset.QuadPart);
 134         return(Status);
 135     }
 136
 137     DPRINT("Block request succeeded for %x\n", Irp);
 138
 139     return(STATUS_SUCCESS);
 140 }
 141
 142
 143 NTSTATUS
 144 CdfsDeviceIoControl (IN PDEVICE_OBJECT DeviceObject,
 145                      IN ULONG CtlCode,
 146                      IN PVOID InputBuffer,
 147                      IN ULONG InputBufferSize,
 148                      IN OUT PVOID OutputBuffer,
 149                      IN OUT PULONG OutputBufferSize,
 150                      IN BOOLEAN Override)
 151 {
 152     PIO_STACK_LOCATION Stack;
 153     IO_STATUS_BLOCK IoStatus;
 154     KEVENT Event;
 155     PIRP Irp;
 156     NTSTATUS Status;
 157     BOOLEAN LastChance = FALSE;
 158
 159     DPRINT("CdfsDeviceIoControl(DeviceObject %x, CtlCode %x, "
 160         "InputBuffer %x, InputBufferSize %x, OutputBuffer %x, "
 161         "POutputBufferSize %x (%x)\n", DeviceObject, CtlCode,
 162         InputBuffer, InputBufferSize, OutputBuffer, OutputBufferSize,
 163         OutputBufferSize ? *OutputBufferSize : 0);
 164
 165 again:
 166     KeInitializeEvent (&Event, NotificationEvent, FALSE);
 167
 168     DPRINT("Building device I/O control request ...\n");
 169     Irp = IoBuildDeviceIoControlRequest(CtlCode,
 170         DeviceObject,
 171         InputBuffer,
 172         InputBufferSize,
 173         OutputBuffer,
 174         (OutputBufferSize != NULL) ? *OutputBufferSize : 0,
 175         FALSE,
 176         &Event,
 177         &IoStatus);
 178     if (Irp == NULL)
 179     {
 180         DPRINT("IoBuildDeviceIoControlRequest failed\n");
 181         return STATUS_INSUFFICIENT_RESOURCES;
 182     }
 183
 184     if (Override)
 185     {
 186         Stack = IoGetNextIrpStackLocation(Irp);
 187         Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
 188     }
 189
 190     DPRINT ("Calling IO Driver... with irp %x\n", Irp);
 191     Status = IoCallDriver(DeviceObject, Irp);
 192
 193     DPRINT ("Waiting for IO Operation for %x\n", Irp);
 194     if (Status == STATUS_PENDING)
 195     {
 196         DPRINT ("Operation pending\n");
 197         KeWaitForSingleObject (&Event, Suspended, KernelMode, FALSE, NULL);
 198         DPRINT ("Getting IO Status... for %x\n", Irp);
 199
 200         Status = IoStatus.Status;
 201     }
 202
 203     if (OutputBufferSize != NULL)
 204     {
 205         *OutputBufferSize = IoStatus.Information;
 206     }
 207
 208     if (Status == STATUS_VERIFY_REQUIRED)
 209     {
 210         PDEVICE_OBJECT DeviceToVerify;
 211
 212         DeviceToVerify = IoGetDeviceToVerify(PsGetCurrentThread());
 213         IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
 214
 215         if (DeviceToVerify)
 216         {
 217             Status = IoVerifyVolume(DeviceToVerify, FALSE);
 218             DPRINT("IoVerifyVolume() returned (Status %lx)\n", Status);
 219         }
 220
 221         if (NT_SUCCESS(Status) && !LastChance)
 222         {
 223             DPRINT1("Volume verify succeeded; trying request again\n");
 224             LastChance = TRUE;
 225             goto again;
 226         }
 227         else if (NT_SUCCESS(Status))
 228         {
 229             DPRINT1("Failed to read after successful verify, aborting\n");
 230             Status = STATUS_DEVICE_NOT_READY;
 231         }
 232         else
 233         {
 234             DPRINT1("IoVerifyVolume() failed (Status %lx)\n", Status);
 235         }
 236     }
 237
 238     DPRINT("Returning Status %x\n", Status);
 239
 240     return Status;
 241 }
 242
 243 /* EOF */