reactos/drivers/filesystems/cdfs/rw.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 /*
  20  * COPYRIGHT:        See COPYING in the top level directory
  21  * PROJECT:          ReactOS kernel
  22  * FILE:             drivers/fs/cdfs/rw.c
  23  * PURPOSE:          CDROM (ISO 9660) filesystem driver
  24  * PROGRAMMER:       Art Yerkes
  25  *                   Eric Kohl
  26  */
  27
  28 /* INCLUDES *****************************************************************/
  29
  30 #include "cdfs.h"
  31
  32 #define NDEBUG
  33 #include <debug.h>
  34
  35 /* FUNCTIONS ****************************************************************/
  36
  37 #define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
  38 #define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
  39
  40
  41 /* FUNCTIONS ****************************************************************/
  42
  43 static NTSTATUS
  44 CdfsReadFile(PDEVICE_EXTENSION DeviceExt,
  45              PFILE_OBJECT FileObject,
  46              PUCHAR Buffer,
  47              ULONG Length,
  48              ULONG ReadOffset,
  49              ULONG IrpFlags,
  50              PULONG LengthRead)
  51              /*
  52              * FUNCTION: Reads data from a file
  53              */
  54 {
  55     NTSTATUS Status = STATUS_SUCCESS;
  56     PFCB Fcb;
  57     ULONG ToRead = Length;
  58
  59     DPRINT("CdfsReadFile(ReadOffset %lu  Length %lu)\n", ReadOffset, Length);
  60
  61     *LengthRead = 0;
  62
  63     if (Length == 0)
  64         return(STATUS_SUCCESS);
  65
  66     Fcb = (PFCB)FileObject->FsContext;
  67
  68     if (ReadOffset >= Fcb->Entry.DataLengthL)
  69         return(STATUS_END_OF_FILE);
  70
  71     if (ReadOffset + Length > Fcb->Entry.DataLengthL)
  72         ToRead = Fcb->Entry.DataLengthL - ReadOffset;
  73
  74     DPRINT("Reading %u bytes at %u\n", Length, ReadOffset);
  75
  76     if (!(IrpFlags & (IRP_NOCACHE|IRP_PAGING_IO)))
  77     {
  78         LARGE_INTEGER FileOffset;
  79         IO_STATUS_BLOCK IoStatus;
  80         CC_FILE_SIZES FileSizes;
  81
  82         DPRINT("Using cache\n");
  83
  84         if (FileObject->PrivateCacheMap == NULL)
  85         {
  86             FileSizes.AllocationSize = Fcb->RFCB.AllocationSize;
  87             FileSizes.FileSize = Fcb->RFCB.FileSize;
  88             FileSizes.ValidDataLength = Fcb->RFCB.ValidDataLength;
  89
  90             DPRINT("Attach FCB to File: Size %08x%08x\n",
  91                 Fcb->RFCB.ValidDataLength.HighPart,
  92                 Fcb->RFCB.ValidDataLength.LowPart);
  93
  94             CcInitializeCacheMap(FileObject,
  95                 &FileSizes,
  96                 FALSE,
  97                 &(CdfsGlobalData->CacheMgrCallbacks),
  98                 Fcb);
  99         }
 100
 101         FileOffset.QuadPart = (LONGLONG)ReadOffset;
 102         CcCopyRead(FileObject,
 103             &FileOffset,
 104             ToRead,
 105             TRUE,
 106             Buffer,
 107             &IoStatus);
 108         *LengthRead = IoStatus.Information;
 109
 110         Status = IoStatus.Status;
 111     }
 112     else
 113     {
 114         ULONG ActualReadOffset = ROUND_DOWN(ReadOffset, BLOCKSIZE);
 115         ULONG nBlocks = (ROUND_UP(ReadOffset + ToRead, BLOCKSIZE) - ActualReadOffset) / BLOCKSIZE;
 116         PUCHAR PageBuf;
 117         BOOLEAN bFreeBuffer = FALSE;
 118         if ((ReadOffset % BLOCKSIZE) != 0 || (ToRead % BLOCKSIZE) != 0)
 119         {
 120             PageBuf = ExAllocatePool(NonPagedPool, nBlocks * BLOCKSIZE);
 121             if (!PageBuf)
 122             {
 123                 return STATUS_NO_MEMORY;
 124             }
 125             bFreeBuffer = TRUE;
 126         }
 127         else
 128         {
 129             PageBuf = Buffer;
 130         }
 131         Status = CdfsReadSectors(DeviceExt->StorageDevice,
 132             Fcb->Entry.ExtentLocationL + (ActualReadOffset / BLOCKSIZE),
 133             nBlocks,
 134             (PVOID)PageBuf,
 135             FALSE);
 136
 137         if(NT_SUCCESS(Status))
 138         {
 139             *LengthRead = ToRead;
 140             if(bFreeBuffer)
 141             {
 142                 /* Copy what we've got */
 143                 RtlCopyMemory(Buffer, PageBuf + (ReadOffset - ActualReadOffset), ToRead);
 144             }
 145             /* Zero out the rest */
 146             if(ToRead != Length)
 147                 RtlZeroMemory(Buffer + ToRead, Length - ToRead);
 148         }
 149
 150         if(bFreeBuffer)
 151             ExFreePool(PageBuf);
 152     }
 153
 154     return Status;
 155 }
 156
 157
 158 NTSTATUS NTAPI
 159 CdfsRead(PDEVICE_OBJECT DeviceObject,
 160          PIRP Irp)
 161 {
 162     PDEVICE_EXTENSION DeviceExt;
 163     PIO_STACK_LOCATION Stack;
 164     PFILE_OBJECT FileObject;
 165     PVOID Buffer = NULL;
 166     ULONG ReadLength;
 167     LARGE_INTEGER ReadOffset;
 168     ULONG ReturnedReadLength = 0;
 169     NTSTATUS Status = STATUS_SUCCESS;
 170
 171     DPRINT("CdfsRead(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
 172
 173     DeviceExt = DeviceObject->DeviceExtension;
 174     Stack = IoGetCurrentIrpStackLocation(Irp);
 175     FileObject = Stack->FileObject;
 176
 177     ReadLength = Stack->Parameters.Read.Length;
 178     ReadOffset = Stack->Parameters.Read.ByteOffset;
 179     if (ReadLength) Buffer = MmGetSystemAddressForMdl(Irp->MdlAddress);
 180
 181     Status = CdfsReadFile(DeviceExt,
 182         FileObject,
 183         Buffer,
 184         ReadLength,
 185         ReadOffset.u.LowPart,
 186         Irp->Flags,
 187         &ReturnedReadLength);
 188     if (NT_SUCCESS(Status))
 189     {
 190         if (FileObject->Flags & FO_SYNCHRONOUS_IO)
 191         {
 192             FileObject->CurrentByteOffset.QuadPart =
 193                 ReadOffset.QuadPart + ReturnedReadLength;
 194         }
 195         Irp->IoStatus.Information = ReturnedReadLength;
 196     }
 197     else
 198     {
 199         Irp->IoStatus.Information = 0;
 200     }
 201
 202     Irp->IoStatus.Status = Status;
 203     IoCompleteRequest(Irp,IO_NO_INCREMENT);
 204
 205     return(Status);
 206 }
 207
 208
 209 NTSTATUS NTAPI
 210 CdfsWrite(PDEVICE_OBJECT DeviceObject,
 211           PIRP Irp)
 212 {
 213     DPRINT("CdfsWrite(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 214
 215     Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 216     Irp->IoStatus.Information = 0;
 217     return(STATUS_NOT_SUPPORTED);
 218 }
 219
 220 /* EOF */