/* PROJECT: Alcyone  Kernel
* LICENSE: BSD Clause 3 
* PURPOSE: Cache Controller:: LOG Handler   
* NT KERNEL: 5.11.9360 
* COPYRIGHT: 2023-2029 Dibymartanda Samanta <>
*/    


#include <ntoskrnl.h>
#define NTDEBUG
#include <debug.h>
#include "ccinternal.hpp"
#include "ccloghandler.hpp"

extern "C"

LARGE_INTEGER
NTAPI
CcGetDirtyPages(IN PVOID LogHandle,
                IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,
                IN PVOID Context1,
                IN PVOID Context2)
{
    /* IMPLEMENTATION INCOMPLETE*/
}

LARGE_INTEGER
NTAPI
CcGetLsnForFileObject(IN PFILE_OBJECT FileObject,
                      OUT OPTIONAL PLARGE_INTEGER OldestLsn)
{    
     /* IMPLEMENTATION INCOMPLETE*/
}


Void NTAPI CcSetAdditionalCacheAttributes(
  In PFILE_OBJECT FileObject,
  In BOOLEAN      DisableReadAhead,
  In BOOLEAN      DisableWriteBehind
)
{

  PSHARED_CACHE_MAP SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
  KIRQL oldlock = KeAcquireQueuedSpinLock(LockQueueMasterLock);
  if ( DisableReadAhead )
    SharedCacheMap->Flags |= READAHEAD_FLAG;
  else
    SharedCacheMap->Flags &= ~READAHEAD_FLAG;
  if ( DisableWriteBehind )
    SharedCacheMap->Flags |= DISABLE_WRITE_FLAG;
  else
    SharedCacheMap->Flags &= ~ENABLE_WRITE_FLAG;
  KeReleaseQueuedSpinLock(LockQueueMasterLock, oldlock);

}
VOID NTAPI CcSetAdditionalCacheAttributesEx(PFILE_OBJECT FileObject, 
                                          UINT Flags)
{
    PSHARED_CACHE_MAP sharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
    KIRQL irqlDisableWriteBehind = {0};
    KLOCK_QUEUE_HANDLE lockQueueHandle = {0};
    BOOL disableReadAhead = (Flags & 2) != 0;
    if (sharedCacheMap == nullptr||!sharedCacheMap->OpenCount)
       DBGPRINT("Invalid Shared Cache Map or Open Count")
       return;

    
    if ((sharedCacheMap->Flags & 0x2000) == 0)
        CcSetAdditionalCacheAttributes(FileObject, disableReadAhead, (Flags & 4) != 0);

    
    KeAcquireInStackQueuedSpinLockAtDpcLevel(&sharedCacheMap->BcbLock, &lockQueueHandle);

    if ((Flags & 1) != 0)
        sharedCacheMap->Flags |= FLAG_DISABLE_WRITE_BEHIND;
    else
        sharedCacheMap->Flags &= ~FLAG_DISABLE_WRITE_BEHIND;

    if ((Flags & 8) != 0)
    {
        sharedCacheMap->Flags |= FLAG_DISABLE_LAZY_WRITER;
    }
    else
    {
        if ((sharedCacheMap->Flags & FLAG_DISABLE_LAZY_WRITER) != 0)
            sharedCacheMap->Flags |= FLAG_LAZY_WRITER_ACTIVE;
        sharedCacheMap->Flags &= ~FLAG_DISABLE_LAZY_WRITER;
    }

    if ((Flags & 0x10) != 0)
        sharedCacheMap->Flags |= FLAG_DISABLE_LAZY_WRITER_SCAN;
    else
        sharedCacheMap->Flags &= ~FLAG_DISABLE_LAZY_WRITER_SCAN;

    if ((Flags & 0x20) != 0)
        sharedCacheMap->Flags |= FLAG_DISABLE_METADATA_FLUSH;
    else
        sharedCacheMap->Flags &= ~FLAG_DISABLE_METADATA_FLUSH;

    KeReleaseInStackQueuedSpinLockFromDpcLevel(&lockQueueHandle);
    
}


VOID
NTAPI
CcSetLogHandleForFile(IN PFILE_OBJECT FileObject,
                      IN PVOID LogHandle,
                      IN PFLUSH_TO_LSN FlushToLsnRoutine)
{
  PSHARED_CACHE_MAP SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap
  SharedCacheMap->LogHandle = LogHandle;
  SharedCacheMap->FlushToLsnRoutine = FlushToLsnRoutine;
}