reactos/drivers/filesystems/ffs/src/cmcb.c

   1 /*
   2  * FFS File System Driver for Windows
   3  *
   4  * cmcb.c
   5  *
   6  * 2004.5.6 ~
   7  *
   8  * Lee Jae-Hong, http://www.pyrasis.com
   9  *
  10  * See License.txt
  11  *
  12  */
  13
  14 #include "ntifs.h"
  15 #include "ffsdrv.h"
  16
  17 /* Globals */
  18
  19 extern PFFS_GLOBAL FFSGlobal;
  20
  21 /* Definitions */
  22
  23 #ifdef ALLOC_PRAGMA
  24 #pragma alloc_text(PAGE, FFSAcquireForLazyWrite)
  25 #pragma alloc_text(PAGE, FFSReleaseFromLazyWrite)
  26 #pragma alloc_text(PAGE, FFSAcquireForReadAhead)
  27 #pragma alloc_text(PAGE, FFSReleaseFromReadAhead)
  28 #pragma alloc_text(PAGE, FFSNoOpAcquire)
  29 #pragma alloc_text(PAGE, FFSNoOpRelease)
  30 #endif
  31
  32
  33 __drv_mustHoldCriticalRegion
  34 BOOLEAN NTAPI
  35 FFSAcquireForLazyWrite(
  36         IN PVOID    Context,
  37         IN BOOLEAN  Wait)
  38 {
  39         //
  40         // On a readonly filesystem this function still has to exist but it
  41         // doesn't need to do anything.
  42
  43         PFFS_FCB     Fcb;
  44
  45     PAGED_CODE();
  46
  47         Fcb = (PFFS_FCB)Context;
  48
  49         ASSERT(Fcb != NULL);
  50
  51         ASSERT((Fcb->Identifier.Type == FFSFCB) &&
  52                         (Fcb->Identifier.Size == sizeof(FFS_FCB)));
  53
  54         FFSPrint((DBG_INFO, "FFSAcquireForLazyWrite: %s %s %s\n",
  55                                 FFSGetCurrentProcessName(),
  56                                 "ACQUIRE_FOR_LAZY_WRITE",
  57                                 Fcb->AnsiFileName.Buffer));
  58
  59
  60         if (!IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY))
  61         {
  62                 FFSPrint((DBG_INFO, "FFSAcquireForLazyWrite: Inode=%xh %S\n",
  63                                         Fcb->FFSMcb->Inode, Fcb->FFSMcb->ShortName.Buffer));
  64
  65                 if(!ExAcquireResourceSharedLite(
  66                                         &Fcb->PagingIoResource, Wait))
  67                 {
  68                         return FALSE;
  69                 }
  70         }
  71
  72         ASSERT(IoGetTopLevelIrp() == NULL);
  73
  74         IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
  75
  76         return TRUE;
  77 }
  78
  79
  80 __drv_mustHoldCriticalRegion
  81 VOID NTAPI
  82 FFSReleaseFromLazyWrite(
  83         IN PVOID Context)
  84 {
  85         //
  86         // On a readonly filesystem this function still has to exist but it
  87         // doesn't need to do anything.
  88         PFFS_FCB Fcb;
  89
  90     PAGED_CODE();
  91
  92         Fcb = (PFFS_FCB)Context;
  93
  94         ASSERT(Fcb != NULL);
  95
  96         ASSERT((Fcb->Identifier.Type == FFSFCB) &&
  97                         (Fcb->Identifier.Size == sizeof(FFS_FCB)));
  98
  99         FFSPrint((DBG_INFO, "FFSReleaseFromLazyWrite: %s %s %s\n",
 100                                 FFSGetCurrentProcessName(),
 101                                 "RELEASE_FROM_LAZY_WRITE",
 102                                 Fcb->AnsiFileName.Buffer));
 103
 104         if (!IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY))
 105         {
 106                 FFSPrint((DBG_INFO, "FFSReleaseFromLazyWrite: Inode=%xh %S\n",
 107                                         Fcb->FFSMcb->Inode, Fcb->FFSMcb->ShortName.Buffer));
 108
 109                 ExReleaseResourceLite(&Fcb->PagingIoResource);
 110         }
 111
 112         ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 113
 114         IoSetTopLevelIrp(NULL);
 115
 116 }
 117
 118
 119 __drv_mustHoldCriticalRegion
 120 BOOLEAN NTAPI
 121 FFSAcquireForReadAhead(
 122         IN PVOID    Context,
 123         IN BOOLEAN  Wait)
 124 {
 125         PFFS_FCB    Fcb;
 126
 127     PAGED_CODE();
 128
 129         Fcb = (PFFS_FCB)Context;
 130
 131         ASSERT(Fcb != NULL);
 132
 133         ASSERT((Fcb->Identifier.Type == FFSFCB) &&
 134                         (Fcb->Identifier.Size == sizeof(FFS_FCB)));
 135
 136         FFSPrint((DBG_INFO, "FFSAcquireForReadAhead: Inode=%xh %S\n",
 137                                 Fcb->FFSMcb->Inode, Fcb->FFSMcb->ShortName.Buffer));
 138
 139         if (!ExAcquireResourceSharedLite(
 140                                 &Fcb->MainResource, Wait))
 141                 return FALSE;
 142
 143         ASSERT(IoGetTopLevelIrp() == NULL);
 144
 145         IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 146
 147         return TRUE;
 148 }
 149
 150
 151 __drv_mustHoldCriticalRegion
 152 VOID NTAPI
 153 FFSReleaseFromReadAhead(
 154         IN PVOID Context)
 155 {
 156         PFFS_FCB Fcb;
 157
 158     PAGED_CODE();
 159
 160         Fcb = (PFFS_FCB)Context;
 161
 162         ASSERT(Fcb != NULL);
 163
 164         ASSERT((Fcb->Identifier.Type == FFSFCB) &&
 165                         (Fcb->Identifier.Size == sizeof(FFS_FCB)));
 166
 167         FFSPrint((DBG_INFO, "FFSReleaseFromReadAhead: Inode=%xh %S\n",
 168                                 Fcb->FFSMcb->Inode, Fcb->FFSMcb->ShortName.Buffer));
 169
 170         IoSetTopLevelIrp(NULL);
 171
 172         ExReleaseResourceLite(&Fcb->MainResource);
 173 }
 174
 175
 176 BOOLEAN NTAPI
 177 FFSNoOpAcquire(
 178         IN PVOID Fcb,
 179         IN BOOLEAN Wait)
 180 {
 181         UNREFERENCED_PARAMETER(Fcb);
 182         UNREFERENCED_PARAMETER(Wait);
 183
 184         //
 185         //  This is a kludge because Cc is really the top level.  We it
 186         //  enters the file system, we will think it is a resursive call
 187         //  and complete the request with hard errors or verify.  It will
 188         //  have to deal with them, somehow....
 189         //
 190
 191     PAGED_CODE();
 192
 193         ASSERT(IoGetTopLevelIrp() == NULL);
 194
 195         IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 196
 197         return TRUE;
 198 }
 199
 200
 201 VOID NTAPI
 202 FFSNoOpRelease(
 203         IN PVOID Fcb)
 204 {
 205         //
 206         //  Clear the kludge at this point.
 207         //
 208
 209     PAGED_CODE();
 210
 211         ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 212
 213         IoSetTopLevelIrp(NULL);
 214
 215         UNREFERENCED_PARAMETER(Fcb);
 216
 217         return;
 218 }