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             _SEH2_TRY
  95             {
  96                 CcInitializeCacheMap(FileObject,
  97                     &FileSizes,
  98                     FALSE,
  99                     &(CdfsGlobalData->CacheMgrCallbacks),
 100                     Fcb);
 101             }
 102             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 103             {
 104                 return _SEH2_GetExceptionCode();
 105             }
 106             _SEH2_END;
 107         }
 108
 109         FileOffset.QuadPart = (LONGLONG)ReadOffset;
 110         _SEH2_TRY
 111         {
 112             CcCopyRead(FileObject,
 113                 &FileOffset,
 114                 ToRead,
 115                 TRUE,
 116                 Buffer,
 117                 &IoStatus);
 118         }
 119         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 120         {
 121             IoStatus.Information = 0;
 122             IoStatus.Status = _SEH2_GetExceptionCode();
 123         }
 124         _SEH2_END;
 125         *LengthRead = IoStatus.Information;
 126
 127         Status = IoStatus.Status;
 128     }
 129     else
 130     {
 131         ULONG ActualReadOffset = ROUND_DOWN(ReadOffset, BLOCKSIZE);
 132         ULONG nBlocks = (ROUND_UP(ReadOffset + ToRead, BLOCKSIZE) - ActualReadOffset) / BLOCKSIZE;
 133         PUCHAR PageBuf;
 134         BOOLEAN bFreeBuffer = FALSE;
 135         if ((ReadOffset % BLOCKSIZE) != 0 || (ToRead % BLOCKSIZE) != 0)
 136         {
 137             PageBuf = ExAllocatePoolWithTag(NonPagedPool,
 138                                             nBlocks * BLOCKSIZE,
 139                                             CDFS_TAG);
 140             if (!PageBuf)
 141             {
 142                 return STATUS_NO_MEMORY;
 143             }
 144             bFreeBuffer = TRUE;
 145         }
 146         else
 147         {
 148             PageBuf = Buffer;
 149         }
 150         Status = CdfsReadSectors(DeviceExt->StorageDevice,
 151             Fcb->Entry.ExtentLocationL + (ActualReadOffset / BLOCKSIZE),
 152             nBlocks,
 153             (PVOID)PageBuf,
 154             FALSE);
 155
 156         if(NT_SUCCESS(Status))
 157         {
 158             *LengthRead = ToRead;
 159             if(bFreeBuffer)
 160             {
 161                 /* Copy what we've got */
 162                 RtlCopyMemory(Buffer, PageBuf + (ReadOffset - ActualReadOffset), ToRead);
 163             }
 164             /* Zero out the rest */
 165             if(ToRead != Length)
 166                 RtlZeroMemory(Buffer + ToRead, Length - ToRead);
 167         }
 168
 169         if(bFreeBuffer)
 170             ExFreePoolWithTag(PageBuf, CDFS_TAG);
 171     }
 172
 173     return Status;
 174 }
 175
 176
 177 NTSTATUS NTAPI
 178 CdfsRead(PDEVICE_OBJECT DeviceObject,
 179          PIRP Irp)
 180 {
 181     PDEVICE_EXTENSION DeviceExt;
 182     PIO_STACK_LOCATION Stack;
 183     PFILE_OBJECT FileObject;
 184     PVOID Buffer = NULL;
 185     ULONG ReadLength;
 186     LARGE_INTEGER ReadOffset;
 187     ULONG ReturnedReadLength = 0;
 188     NTSTATUS Status = STATUS_SUCCESS;
 189
 190     DPRINT("CdfsRead(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
 191
 192     DeviceExt = DeviceObject->DeviceExtension;
 193     Stack = IoGetCurrentIrpStackLocation(Irp);
 194     FileObject = Stack->FileObject;
 195
 196     ReadLength = Stack->Parameters.Read.Length;
 197     ReadOffset = Stack->Parameters.Read.ByteOffset;
 198     if (ReadLength) Buffer = MmGetSystemAddressForMdl(Irp->MdlAddress);
 199
 200     Status = CdfsReadFile(DeviceExt,
 201         FileObject,
 202         Buffer,
 203         ReadLength,
 204         ReadOffset.u.LowPart,
 205         Irp->Flags,
 206         &ReturnedReadLength);
 207     if (NT_SUCCESS(Status))
 208     {
 209         if (FileObject->Flags & FO_SYNCHRONOUS_IO)
 210         {
 211             FileObject->CurrentByteOffset.QuadPart =
 212                 ReadOffset.QuadPart + ReturnedReadLength;
 213         }
 214         Irp->IoStatus.Information = ReturnedReadLength;
 215     }
 216     else
 217     {
 218         Irp->IoStatus.Information = 0;
 219     }
 220
 221     Irp->IoStatus.Status = Status;
 222     IoCompleteRequest(Irp,IO_NO_INCREMENT);
 223
 224     return(Status);
 225 }
 226
 227
 228 NTSTATUS NTAPI
 229 CdfsWrite(PDEVICE_OBJECT DeviceObject,
 230           PIRP Irp)
 231 {
 232     DPRINT("CdfsWrite(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 233
 234     Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 235     Irp->IoStatus.Information = 0;
 236     return(STATUS_NOT_SUPPORTED);
 237 }
 238
 239 /* EOF */