ntoskrnl/cache/copysup.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/cache/copysup.c
   5  * PURPOSE:         Logging and configuration routines
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #include "newcc.h"
  13 #include "section/newmm.h"
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 /* GLOBALS ********************************************************************/
  18
  19 ULONG CcFastMdlReadWait;
  20 ULONG CcFastMdlReadNotPossible;
  21 ULONG CcFastReadNotPossible;
  22 ULONG CcFastReadWait;
  23 ULONG CcFastReadNoWait;
  24 ULONG CcFastReadResourceMiss;
  25
  26 #define TAG_COPY_READ  TAG('C', 'o', 'p', 'y')
  27 #define TAG_COPY_WRITE TAG('R', 'i', 't', 'e')
  28
  29 /* FUNCTIONS ******************************************************************/
  30
  31 BOOLEAN
  32 NTAPI
  33 CcCopyRead(IN PFILE_OBJECT FileObject,
  34            IN PLARGE_INTEGER FileOffset,
  35            IN ULONG Length,
  36            IN BOOLEAN Wait,
  37            OUT PVOID Buffer,
  38            OUT PIO_STATUS_BLOCK IoStatus)
  39 {
  40     PCHAR ReadBuffer;
  41     ULONG ReadLen;
  42     PVOID Bcb;
  43     PCHAR BufferTarget = (PCHAR)Buffer;
  44     LARGE_INTEGER CacheOffset, EndOfExtent, NextOffset;
  45
  46     DPRINT
  47         ("CcCopyRead(%x,%x,%d,%d,%x)\n",
  48          FileObject,
  49          FileOffset->LowPart,
  50          Length,
  51          Wait,
  52          Buffer);
  53
  54     CacheOffset.QuadPart = FileOffset->QuadPart;
  55     EndOfExtent.QuadPart = FileOffset->QuadPart + Length;
  56
  57     while (CacheOffset.QuadPart < EndOfExtent.QuadPart)
  58     {
  59                 NextOffset.QuadPart = CacheOffset.QuadPart;
  60                 NextOffset.LowPart = (NextOffset.LowPart + CACHE_STRIPE) & ~(CACHE_STRIPE-1);
  61                 ReadLen = EndOfExtent.QuadPart - CacheOffset.QuadPart;
  62                 if (CacheOffset.QuadPart + ReadLen > NextOffset.QuadPart)
  63                 {
  64                         ReadLen = NextOffset.QuadPart - CacheOffset.QuadPart;
  65                 }
  66
  67                 DPRINT("Reading %d bytes in this go (at %08x%08x)\n", ReadLen, CacheOffset.HighPart, CacheOffset.LowPart);
  68
  69                 if (!CcPinRead
  70                         (FileObject,
  71                          &CacheOffset,
  72                          ReadLen,
  73                          Wait ? PIN_WAIT : PIN_IF_BCB,
  74                          &Bcb,
  75                          (PVOID*)&ReadBuffer))
  76                 {
  77                         IoStatus->Status = STATUS_UNSUCCESSFUL;
  78                         IoStatus->Information = 0;
  79                         DPRINT("Failed CcCopyRead\n");
  80                         return FALSE;
  81                 }
  82
  83                 DPRINT1("Copying %d bytes at %08x%08x\n", ReadLen, CacheOffset.HighPart, CacheOffset.LowPart);
  84                 RtlCopyMemory
  85                         (BufferTarget,
  86                          ReadBuffer,
  87                          ReadLen);
  88
  89                 BufferTarget += ReadLen;
  90
  91                 CacheOffset = NextOffset;
  92                 CcUnpinData(Bcb);
  93     }
  94
  95     IoStatus->Status = STATUS_SUCCESS;
  96     IoStatus->Information = Length;
  97
  98     DPRINT("Done with CcCopyRead\n");
  99
 100     return TRUE;
 101 }
 102
 103 VOID
 104 NTAPI
 105 CcFastCopyRead(IN PFILE_OBJECT FileObject,
 106                IN ULONG FileOffset,
 107                IN ULONG Length,
 108                IN ULONG PageCount,
 109                OUT PVOID Buffer,
 110                OUT PIO_STATUS_BLOCK IoStatus)
 111 {
 112     UNIMPLEMENTED;
 113     while (TRUE);
 114 }
 115
 116 BOOLEAN
 117 NTAPI
 118 CcCopyWrite(IN PFILE_OBJECT FileObject,
 119             IN PLARGE_INTEGER FileOffset,
 120             IN ULONG Length,
 121             IN BOOLEAN Wait,
 122             IN PVOID Buffer)
 123 {
 124         INT Count = 0;
 125         BOOLEAN Result;
 126         PNOCC_BCB Bcb;
 127         PVOID WriteBuf;
 128         ULONG WriteLen;
 129         LARGE_INTEGER CurrentOffset = *FileOffset;
 130         LARGE_INTEGER EndOffset;
 131         LARGE_INTEGER NextOffset;
 132
 133         EndOffset.QuadPart = CurrentOffset.QuadPart + Length;
 134
 135         DPRINT
 136                 ("CcCopyWrite(%x,%x,%d,%d,%x)\n",
 137                  FileObject,
 138                  FileOffset->LowPart,
 139                  Length,
 140                  Wait,
 141                  Buffer);
 142
 143         while (CurrentOffset.QuadPart < EndOffset.QuadPart)
 144         {
 145                 NextOffset.HighPart = CurrentOffset.HighPart;
 146                 NextOffset.LowPart = (CurrentOffset.LowPart + CACHE_STRIPE) & ~(CACHE_STRIPE - 1);
 147                 DPRINT("NextOffset %08x%08x\n", NextOffset.u.HighPart, NextOffset.u.LowPart);
 148                 WriteLen = MIN(NextOffset.QuadPart - CurrentOffset.QuadPart, Length);
 149                 DPRINT("Copying %x bytes from %08x%08x\n",
 150                                 WriteLen,
 151                                 CurrentOffset.u.HighPart, CurrentOffset.u.LowPart);
 152                 DPRINT("CcPreparePinWrite\n");
 153                 Result = CcPreparePinWrite
 154                         (FileObject, &CurrentOffset, WriteLen, FALSE, Wait ? PIN_WAIT : PIN_IF_BCB,
 155                          (PVOID *)&Bcb, &WriteBuf);
 156                 DPRINT("Result %s %x %x\n", Result ? "TRUE" : "FALSE", Bcb, WriteBuf);
 157                 if (!Result)
 158                 {
 159                         DPRINT1("CcPreparePinWrite Failed?\n");
 160                         if (Wait) RtlRaiseStatus(STATUS_NOT_MAPPED_DATA); else return FALSE;
 161                 }
 162                 DPRINT1("Copying actual memory to BCB#%x (@%x) (from buffer at %x)\n", Bcb - CcCacheSections, WriteBuf, Bcb->BaseAddress);
 163
 164                 //MiZeroFillSection(WriteBuf, &CurrentOffset, WriteLen);
 165                 RtlCopyMemory(WriteBuf, ((PCHAR)Buffer) + Count, WriteLen);
 166                 Count += WriteLen;
 167                 Length -= WriteLen;
 168                 CurrentOffset = NextOffset;
 169                 Bcb->Dirty = TRUE;
 170                 CcUnpinData(Bcb);
 171         }
 172
 173         DPRINT("Done with CcCopyWrite\n");
 174
 175         return TRUE;
 176 }
 177
 178 VOID
 179 NTAPI
 180 CcFastCopyWrite(IN PFILE_OBJECT FileObject,
 181                 IN ULONG FileOffset,
 182                 IN ULONG Length,
 183                 IN PVOID Buffer)
 184 {
 185     UNIMPLEMENTED;
 186     while (TRUE);
 187 }
 188
 189 BOOLEAN
 190 NTAPI
 191 CcCanIWrite(IN PFILE_OBJECT FileObject,
 192             IN ULONG BytesToWrite,
 193             IN BOOLEAN Wait,
 194             IN UCHAR Retrying)
 195 {
 196     UNIMPLEMENTED;
 197     while (TRUE);
 198     return FALSE;
 199 }
 200
 201 VOID
 202 NTAPI
 203 CcDeferWrite(IN PFILE_OBJECT FileObject,
 204              IN PCC_POST_DEFERRED_WRITE PostRoutine,
 205              IN PVOID Context1,
 206              IN PVOID Context2,
 207              IN ULONG BytesToWrite,
 208              IN BOOLEAN Retrying)
 209 {
 210     UNIMPLEMENTED;
 211     while (TRUE);
 212 }
 213
 214 /* EOF */