/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    pfsvc.h

Abstract:

    This module contains private declarations for the prefetcher
    service responsible for maintaining prefetch scenario files.

Author:

    Stuart Sechrest (stuartse)
    Cenk Ergan (cenke)
    Chuck Leinzmeier (chuckl)

Environment:

    User Mode

--*/

#ifndef _PFSVC_H_
#define _PFSVC_H_

//
// This is the version of the prefetcher maintenance service. It does
// not have to be in sync with the the prefetcher PF_CURRENT_VERSION.
//

#define PFSVC_SERVICE_VERSION           15

//
// This is the maximum number of traces that will be acquired from the
// kernel and put on the list in the service waiting to be processed.
//

#define PFSVC_MAX_NUM_QUEUED_TRACES     100

//
// If the number of faults in a trace period falls below this, that
// marks the end of the trace for some scenario types.
//

#define PFSVC_MIN_FAULT_THRESHOLD       10

//
// What the rate of usage for the pages we prefetched should be
// greater than for us not to increase scenario sensitivity.
//

#define PFSVC_MIN_HIT_PERCENTAGE        90

//
// What the rate of usage for the pages we knew about but ignored
// should be less than for us not to decrease scenario sensitivity.
//

#define PFSVC_MAX_IGNORED_PERCENTAGE    30

//
// This is the number of launches after which we will set the
// MinReTraceTime and MinRePrefetchTime's on the scenario's header to
// limit prefetch activity if a scenario gets launched very
// frequently. This allows short training scenarios to be run before
// benchmarking after deleting the prefetch files.
//

#define PFSVC_MIN_LAUNCHES_FOR_LAUNCH_FREQ_CHECK     10

//
// This is the default time in 100ns that has to pass from the last
// launch of a scenario before we prefetch it again.
//

#define PFSVC_DEFAULT_MIN_REPREFETCH_TIME            (1i64 * 120 * 1000 * 1000 * 10)

//
// This is the default time in 100ns that has to pass from the last
// launch of a scenario before we prefetch it again.
//

#define PFSVC_DEFAULT_MIN_RETRACE_TIME               (1i64 * 120 * 1000 * 1000 * 10) 

//
// This is the maximum number of prefetch scenario files we'll have in 
// the prefetch directory. Once we reach this amount we won't create 
// new scenario files until we clean up the old ones.
//

#if DBG
#define PFSVC_MAX_PREFETCH_FILES                     12
#else // DBG
#define PFSVC_MAX_PREFETCH_FILES                     128
#endif // DBG

//
// Path to the registry key and name of the value that specifies the
// file the defragger uses to determine optimal layout of files on the
// disk.
//

#define PFSVC_OPTIMAL_LAYOUT_REG_KEY_PATH       \
    L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\OptimalLayout"
#define PFSVC_OPTIMAL_LAYOUT_REG_VALUE_NAME     \
    L"LayoutFilePath"
#define PFSVC_OPTIMAL_LAYOUT_FILE_DEFAULT_NAME  \
    L"Layout.ini"
#define PFSVC_OPTIMAL_LAYOUT_ENABLE_VALUE_NAME  \
    L"EnableAutoLayout"

//
// Path to the registry key under which we store various service data,
// e.g. version, last time the defragger was run successfully to
// update layout etc.
//

#define PFSVC_SERVICE_DATA_KEY                  \
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Prefetcher"

//
// These are the value names under PFSVC_SERVICE_DATA_KEY in which we
// store various prefetcher service data.
//

#define PFSVC_VERSION_VALUE_NAME                \
    L"Version"

#define PFSVC_START_TIME_VALUE_NAME             \
    L"StartTime"

#define PFSVC_EXIT_TIME_VALUE_NAME              \
    L"ExitTime"

#define PFSVC_EXIT_CODE_VALUE_NAME              \
    L"ExitCode"

#define PFSVC_LAST_DISK_LAYOUT_TIME_STRING_VALUE_NAME  \
    L"LastDiskLayoutTimeString"

#define PFSVC_TRACES_PROCESSED_VALUE_NAME       \
    L"TracesProcessed"

#define PFSVC_TRACES_SUCCESSFUL_VALUE_NAME      \
    L"TracesSuccessful"

#define PFSVC_LAST_TRACE_FAILURE_VALUE_NAME     \
    L"LastTraceFailure"

#define PFSVC_BOOT_FILES_OPTIMIZED_VALUE_NAME   \
    L"BootFilesOptimized"

#define PFSVC_MIN_RELAYOUT_HOURS_VALUE_NAME     \
    L"MinRelayoutHours"

//
// This is the value name under PFSVC_SERVICE_DATA_KEY in which we
// store the last time the defragger was run successfully to update
// layout.
//

#define PFSVC_LAST_DISK_LAYOUT_TIME_VALUE_NAME  \
    L"LastDiskLayoutTime"

//
// This is the registry path to the NLS configuration key.
//

#define PFSVC_NLS_REG_KEY_PATH                  \
    L"SYSTEM\\CurrentControlSet\\Control\\Nls"

//
// This is the name of the named manual-reset event that can be set to
// override waiting for system to be idle before processing traces.
//

#define PFSVC_OVERRIDE_IDLE_EVENT_NAME       L"PrefetchOverrideIdle"

//
// This is the name of the named manual-reset event that will be set
// when there are no traces left to process.
//

#define PFSVC_PROCESSING_COMPLETE_EVENT_NAME L"PrefetchProcessingComplete"

//
// When we have run the defragger for all drives after a setup / upgrade,
// we set the build status registry value to this string:
//

#define PFSVC_DEFRAG_DRIVES_DONE             L"DefragDone"

//
// Number of 100ns in an hour.
//

#define PFSVC_NUM_100NS_IN_AN_HOUR           (1i64 * 60 * 60 * 1000 * 1000 * 10)

//
// This is how many 100ns have to pass since last disk layout for us to do
// another one, if we are not being explicitly run.
//

#define PFSVC_MIN_TIME_BEFORE_DISK_RELAYOUT  (1i64 * 3 * 24 * PFSVC_NUM_100NS_IN_AN_HOUR)

//
// Allocation granularity for trace buffers.
//

#define ROUND_TRACE_BUFFER_SIZE(_required) (((_required) + 16384 - 1) & ~(16384 - 1))

//
// Define useful macros. As with all macros, must be careful of parameter
// reevalation. Don't use expressions as macro parameters.
//

#define PFSVC_ALLOC(NumBytes)          (HeapAlloc(GetProcessHeap(),0,(NumBytes)))
#define PFSVC_REALLOC(Buffer,NumBytes) (HeapReAlloc(GetProcessHeap(),0,(Buffer),(NumBytes)))
#define PFSVC_FREE(Buffer)             (HeapFree(GetProcessHeap(),0,(Buffer)))

//
// This magic is used to mark free'd memory in chunk allocator.
//

#define PFSVC_CHUNK_ALLOCATOR_FREED_MAGIC  0xFEEDCEED

//
// This magic is used to mark free'd memory in chunk allocator.
//

#define PFSVC_STRING_ALLOCATOR_FREED_MAGIC 0xFEED

//
// This is the max size for the strings allocated from the string
// allocator that will be allocated from the preallocated buffer, so we 
// can save the size of the allocation with the header in a USHORT.
// 

#define PFSVC_STRING_ALLOCATOR_MAX_BUFFER_ALLOCATION_SIZE 60000

//
// These macros are used to acquire/release a mutex.
//

#define PFSVC_ACQUIRE_LOCK(Lock)                                                        \
    DBGPR((PFID,PFLOCK,"PFSVC: AcquireLock-Begin(%s,%d,%s)\n",#Lock,__LINE__,__FILE__));\
    WaitForSingleObject((Lock), INFINITE);                                              \
    DBGPR((PFID,PFLOCK,"PFSVC: AcquireLock-End(%s,%d,%s)\n",#Lock,__LINE__,__FILE__));  \

#define PFSVC_RELEASE_LOCK(Lock)                                                        \
    ReleaseMutex((Lock));                                                               \
    DBGPR((PFID,PFLOCK,"PFSVC: ReleaseLock(%s,%d,%s)\n",#Lock,__LINE__,__FILE__));      \

//
// Internal type and constant definitions: Entries in the trace and in
// the existing scenario file are put into these structures for easier
// manipulation and policy implementation.
//

typedef struct _PFSVC_SECTION_NODE {
   
    union {

        //
        // Link in the scenarios list of section nodes.
        //

        LIST_ENTRY SectionLink;

        //
        // These fields are used to sort section nodes by first
        // access.
        //

        struct {
            struct _PFSVC_SECTION_NODE *LeftChild;
            struct _PFSVC_SECTION_NODE *RightChild;
        };
    };

    //
    // Filesystem index number for this section is saved here if it is
    // retrieved. If the section node is for the MFT for the volume we
    // save the number of pages to prefetch from it here.
    //

    union {
        LARGE_INTEGER FileIndexNumber;
        ULONG MFTNumPagesToPrefetch;  
    };

    //
    // This is the section record that we will setup and save in the
    // scenario file.
    //

    PF_SECTION_RECORD SectionRecord;

    //
    // File path for this section.
    //

    WCHAR *FilePath;
    
    //
    // List of page nodes belonging to this section.
    //

    LIST_ENTRY PageList;

    //
    // This is the index of the section in the new trace file when
    // ordered by first access [i.e. page fault].
    //
    
    ULONG NewSectionIndex;

    //
    // This is the index of the section in the original scenario file.
    //

    ULONG OrgSectionIndex;

    //
    // Link in the volume's list of section nodes.
    //

    LIST_ENTRY SectionVolumeLink;

} PFSVC_SECTION_NODE, *PPFSVC_SECTION_NODE;

//
// This structure contains a path and is used with the path list below.
//

typedef struct _PFSVC_PATH {

    //
    // Link in the path list sorted by insertion order.
    //

    LIST_ENTRY InOrderLink;

    //
    // Link in the path list sorted lexically.
    //

    LIST_ENTRY SortedLink;

    //
    // Number of characters in the path excluding terminating NUL.
    //

    ULONG Length;

    //
    // NUL terminated path.
    //

    WCHAR Path[1];

} PFSVC_PATH, *PPFSVC_PATH;

//
// This structure holds a list paths. You should manipulate the
// list or walk through paths in it only using the PathList APIs
// (e.g. GetNextPathInOrder).
//

//
// Wrapper around section records.
//

typedef struct _PFSVC_PATH_LIST {

    //
    // The list of paths sorted by insertion order.
    //

    LIST_ENTRY InOrderList;
    
    //
    // The list of paths sorted lexically.
    //

    LIST_ENTRY SortedList;

    //
    // If non NULL, we will make allocations for new entries from it
    // instead of hitting the heap.
    //

    struct _PFSVC_STRING_ALLOCATOR *Allocator;

    //
    // Number of paths in the list.
    //

    ULONG NumPaths;
    
    //
    // Total length of the paths in the list excluding NULs.
    //

    ULONG TotalLength;

    //
    // Whether list will be case sensitive or not.
    //

    BOOLEAN CaseSensitive;

} PFSVC_PATH_LIST, *PPFSVC_PATH_LIST;

//
// This structure is used to divide sections in a scenario to
// different disk volumes (i.e. c:, d:) they are on.
//

typedef struct _PFSVC_VOLUME_NODE {

    //
    // Link in the scenario's list of volume nodes.
    //

    LIST_ENTRY VolumeLink;

    //
    // Volume path and length in number of characters excluding NUL.
    //

    WCHAR *VolumePath;
    ULONG VolumePathLength;
    
    //
    // List of sections that are on this volume that will be prefetched.
    //

    LIST_ENTRY SectionList;
    ULONG NumSections;

    //
    // This is the total number of sections on this volume, including
    // those that won't be prefetched.
    //

    ULONG NumAllSections;

    //
    // List of directories accessed on this volume.
    //
    
    PFSVC_PATH_LIST DirectoryList;

    //
    // Serial Number/Creation time for this volume. This is retrieved
    // either from a new trace or from the existing scenarion file
    // (both should match or the scenario file gets discarded.)
    //

    LARGE_INTEGER CreationTime;
    ULONG SerialNumber;

    //
    // Pointer to section node for the MFT for this volume (if there is one).
    //

    PPFSVC_SECTION_NODE MFTSectionNode;

} PFSVC_VOLUME_NODE, *PPFSVC_VOLUME_NODE;

//
// Wrapper around page records.
//

typedef struct _PFSVC_PAGE_NODE {

    //
    // Link in the section node's list of pages.
    //

    LIST_ENTRY PageLink;

    //
    // Page record from previous scenario instructions or a new one
    // initialized for a trace log entry.
    //

    PF_PAGE_RECORD PageRecord;

} PFSVC_PAGE_NODE, *PPFSVC_PAGE_NODE;

//
// This structure is used to make a single big allocation and give it away
// in small chunks to be used as strings. It is very simple and will not reclaim 
// freed memory for future allocs. The whole allocation will be freed in cleanup. 
// There is no synchronization.
//

typedef struct _PFSVC_STRING_ALLOCATOR {

    //
    // Actual allocation to be divided up and given away in small chunks.
    //

    PCHAR Buffer;

    //
    // End of buffer. If FreePointer is equal to beyond this we can't give
    // away more from this buffer.
    //

    PCHAR BufferEnd;

    //
    // Pointer to start of free memory in Buffer.
    //

    PCHAR FreePointer;

    //
    // Number of times we had to hit the heap because we ran out of space
    // and the current outstanding such allocations.
    //

    ULONG MaxHeapAllocs;
    ULONG NumHeapAllocs;

    //
    // Size of the last allocation that was made from the buffer.
    //

    USHORT LastAllocationSize;

    //
    // Whether user has passed in Buffer (so we don't free it when
    // cleaning up.
    //

    ULONG UserSpecifiedBuffer:1;

} PFSVC_STRING_ALLOCATOR, *PPFSVC_STRING_ALLOCATOR;

//
// This structure comes before allocations from the string allocator buffer.
//

typedef struct _PFSVC_STRING_ALLOCATION_HEADER {

    union {

        //
        // This structure contains the actual fields.
        //

        struct {

            //
            // Size of the preceding allocation.
            //

            USHORT PrecedingAllocationSize;

            //
            // Size of this allocation.
            //

            USHORT AllocationSize;

        };

        //
        // Require pointer alignment for this structure, so allocations
        // from the string allocator end up pointer aligned.
        //

        PVOID FieldToRequirePointerAlignment;
    };

} PFSVC_STRING_ALLOCATION_HEADER, *PPFSVC_STRING_ALLOCATION_HEADER;

//
// This structure is used to make a single big allocation and give it away
// to be used as page nodes, sections nodes etc in small chunks. It is very 
// simple and will not reclaim freed small chunks for future allocs. The whole
// allocation will be freed in cleanup. The chunk size and max allocs to satisfy
// is fixed at initialization. There is no synchronization.
//

typedef struct _PFSVC_CHUNK_ALLOCATOR {

    //
    // Actual allocation to be divided up and given away in small chunks.
    //

    PCHAR Buffer;

    //
    // End of buffer. If FreePointer is equal to beyond this we can't give
    // away more from this buffer.
    //

    PCHAR BufferEnd;

    //
    // Pointer to start of free memory in Buffer.
    //

    PCHAR FreePointer;

    //
    // How big each chunk will be in bytes.
    //

    ULONG ChunkSize;

    //
    // Number of times we had to hit the heap because we ran out of space
    // and the current outstanding such allocations.
    //

    ULONG MaxHeapAllocs;
    ULONG NumHeapAllocs;

    //
    // Whether user has passed in Buffer (so we don't free it when
    // cleaning up.
    //

    ULONG UserSpecifiedBuffer:1;

} PFSVC_CHUNK_ALLOCATOR, *PPFSVC_CHUNK_ALLOCATOR;

//
// Wrapper around a scenario structure.
//

typedef struct _PFSVC_SCENARIO_INFO {

    //
    // Header information for the scenario instructions in preparation.
    //

    PF_SCENARIO_HEADER ScenHeader;

    //
    // Allocators used to make allocations for scenario processing efficient.
    //

    PVOID OneBigAllocation;
    PFSVC_CHUNK_ALLOCATOR SectionNodeAllocator;
    PFSVC_CHUNK_ALLOCATOR PageNodeAllocator;
    PFSVC_CHUNK_ALLOCATOR VolumeNodeAllocator;
    PFSVC_STRING_ALLOCATOR PathAllocator;

    //
    // Container for the sections in this scenario.
    //

    LIST_ENTRY SectionList;

    //
    // List of disk volumes that the scenario's sections are on. This
    // list is sorted lexically.
    //

    LIST_ENTRY VolumeList;

    //
    // Various statistics acquired from the trace information and used
    // in applying prefetch policy.
    //

    ULONG NewPages;
    ULONG HitPages;
    ULONG MissedOpportunityPages;
    ULONG IgnoredPages;
    ULONG PrefetchedPages;

} PFSVC_SCENARIO_INFO, *PPFSVC_SCENARIO_INFO;

//
// This is a priority queue used for sorting section nodes by first
// access.
//

typedef struct _PFSV_SECTNODE_PRIORITY_QUEUE {

    //
    // Think of this priority queue as a Head node and a binary sorted
    // tree at the right child of the Head node. The left child of the
    // Head node always stays NULL. If we need to add a new node
    // smaller than Head, the new node becames the new Head. This way
    // we always have binary sorted tree rooted at Head as well.
    //

    PPFSVC_SECTION_NODE Head;

} PFSV_SECTNODE_PRIORITY_QUEUE, *PPFSV_SECTNODE_PRIORITY_QUEUE;

//
// A list of these may be used to convert the prefix of a path from NT
// to DOS style. [e.g. \Device\HarddiskVolume1 to C:]
//

typedef struct _NTPATH_TRANSLATION_ENTRY {
    
    //
    // Link in a list of translation entries.
    //

    LIST_ENTRY Link;

    //
    // NT path prefix to convert and its length in number of
    // characters excluding NUL.
    //
    
    WCHAR *NtPrefix;
    ULONG NtPrefixLength;
    
    //
    // A DOS path prefix that the NT Path translates to. Note that
    // this not the only possible DOS name translation as a volume may
    // be mounted anywhere.
    //

    WCHAR *DosPrefix;
    ULONG DosPrefixLength;

    //
    // This is the volume string returned by FindNextVolume.
    //

    WCHAR *VolumeName;
    ULONG VolumeNameLength;

} NTPATH_TRANSLATION_ENTRY, *PNTPATH_TRANSLATION_ENTRY;

typedef LIST_ENTRY NTPATH_TRANSLATION_LIST;
typedef NTPATH_TRANSLATION_LIST *PNTPATH_TRANSLATION_LIST;

//
// Define structure that wraps traces from the kernel.
//

typedef struct _PFSVC_TRACE_BUFFER {
    
    //
    // Traces are saved on the list via this link.
    //

    LIST_ENTRY TracesLink;
    
    //
    // The real trace from kernel starts here and extends for traces
    // size.
    //

    PF_TRACE_HEADER Trace;

} PFSVC_TRACE_BUFFER, *PPFSVC_TRACE_BUFFER;

//
// Define the globals structure.
//

typedef struct _PFSVC_GLOBALS {

    //
    // Prefetch parameters. These won't be initialized when globals are 
    // initialized and have to be explicitly acquired from the kernel.
    // Use PrefetchRoot below instead of RootDirPath in this structure.  
    //

    PF_SYSTEM_PREFETCH_PARAMETERS Parameters;

    //
    // OS Version information.
    //

    OSVERSIONINFOEXW OsVersion;

    //
    // An array of path suffices to recognize files we don't want to prefetch 
    // for boot. It is UPCASE and sorted lexically going from last character 
    // to first.
    //

    WCHAR **FilesToIgnoreForBoot;
    ULONG NumFilesToIgnoreForBoot;
    ULONG *FileSuffixLengths;
    
    //
    // This manual reset event gets set when the prefetcher service is
    // asked to go away.
    //
    
    HANDLE TerminateServiceEvent;

    //
    // This is the list of traces acquired from the kernel that have
    // to be processed, number of them and the lock to protect the
    // list.
    //

    LIST_ENTRY Traces;
    ULONG NumTraces;
    HANDLE TracesLock;
    
    //
    // This auto-clearing event is set when new traces are put on the
    // list.
    //

    HANDLE NewTracesToProcessEvent;
    
    //
    // This auto-clearing event is set when we had max number of
    // queued traces and we process one. It signifies that we should
    // check for any traces we could not pick up because the queue was
    // maxed.
    //
    
    HANDLE CheckForMissedTracesEvent;

    //
    // This named manual-reset event is set to force the prefetcher
    // service to process the traces without waiting for an idle
    // system.
    //

    HANDLE OverrideIdleProcessingEvent;

    //
    // This named manual-reset event is set when processing of the
    // currently available traces are done.
    //

    HANDLE ProcessingCompleteEvent;

    //
    // This is the path to the directory where prefetch files are
    // kept and the lock to protect it.
    //
    
    WCHAR PrefetchRoot[MAX_PATH + 1];
    HANDLE PrefetchRootLock;

    //
    // Number of prefetch files in the prefetch directory. This is an estimate
    // (i.e. may not be exact) used to make sure the prefetch directory does
    // not grow too big.
    //

    ULONG NumPrefetchFiles;

    //
    // This is a registry handle to the data key under which some
    // prefetch service data is stored.
    //

    HKEY ServiceDataKey;

    //
    // This is the number of total traces we attempted to process. 
    //

    ULONG NumTracesProcessed;

    //
    // This is the number of traces processed successfully.
    //

    ULONG NumTracesSuccessful;

    //
    // This is the last error code with which we failed processing a
    // trace.
    //

    DWORD LastTraceFailure;

    //
    // Did the defragger crash last time we ran it?
    //

    DWORD DefraggerErrorCode;

    //
    // Whether we are asked not to run the defragger in the registry.
    //

    DWORD DontRunDefragger;

    //
    // Pointer to path where CSC (client side caching) files are stored.
    //

    WCHAR *CSCRootPath;

} PFSVC_GLOBALS, *PPFSVC_GLOBALS;

//
// This describes a worker function called when it is time for an idle
// task to run.
//

typedef 
DWORD 
(*PFSVC_IDLE_TASK_WORKER_FUNCTION) (
    struct _PFSVC_IDLE_TASK *Task
    );

//
// This structure is used to keep context for a registered idle task.
//

typedef struct _PFSVC_IDLE_TASK {

    //
    // Parameters filled in by RegisterIdleTask call.
    //

    HANDLE ItHandle;
    HANDLE StartEvent;
    HANDLE StopEvent;

    //
    // Handle for the registered wait.
    //

    HANDLE WaitHandle;

    //
    // The registered callback function that will be called when the start
    // event is signaled.
    //

    WAITORTIMERCALLBACK Callback;

    //
    // If the common callback function is specified, it calls this function
    // to do the actual work.
    //

    PFSVC_IDLE_TASK_WORKER_FUNCTION DoWorkFunction;

    //
    // This is a manual reset event that will be set when the wait/callback
    // on the start event is fully unregistered.
    //

    HANDLE WaitUnregisteredEvent;

    //
    // This manual reset event gets reset when a callback starts running and
    // gets signaled when the callback stops running. Signaling of this event
    // is not protected so you can't purely rely on it. It is useful as a
    // shortcut.
    //

    HANDLE CallbackStoppedEvent;

    //
    // This manual reset event gets signaled when somebody starts unregistering.
    //

    HANDLE StartedUnregisteringEvent;

    //
    // This manual reset event gets signaled when somebody completes unregistering.
    //

    HANDLE CompletedUnregisteringEvent;
    
    //
    // The first one to interlocked set this from 0 to an integer is responsible 
    // for unregistering the wait & task and cleaning up.
    //

    LONG Unregistering;

    //
    // This is interlocked set from 0 to 1 when a callback is running, or when
    // the main thread is unregistering.
    //

    LONG CallbackRunning;

    //
    // Whether this task is registered (i.e. and has to be unregistered.)
    //

    BOOLEAN Registered;

    //
    // Whether this task has been initialized, used as a sanity check.
    //

    BOOLEAN Initialized;

} PFSVC_IDLE_TASK, *PPFSVC_IDLE_TASK;

//
// Values for the Unregistering field of PFSVC_IDLE_TASK.
//

typedef enum _PFSVC_TASK_UNREGISTERING_VALUES {
    PfSvcNotUnregisteringTask = 0,
    PfSvcUnregisteringTaskFromCallback,
    PfSvcUnregisteringTaskFromMainThread,
    PfSvcUnregisteringTaskMaxValue
} PFSVC_TASK_UNREGISTERING_VALUES, *PPFSVC_TASK_UNREGISTERING_VALUES;

//
// Values for the CallbackRunning field of PFSVC_IDLE_TASK.
//

typedef enum _PFSVC_TASK_CALLBACKRUNNING_VALUES {
    PfSvcTaskCallbackNotRunning = 0,
    PfSvcTaskCallbackRunning,
    PfSvcTaskCallbackDisabled,
    PfSvcTaskCallbackMaxValue
} PFSVC_TASK_CALLBACKRUNNING_VALUES, *PPFSVC_TASK_CALLBACKRUNNING_VALUES;


//
// Information on a scenario file's age, number of launches etc. used in 
// discarding old scenario files in the prefetch directory.
//

typedef struct _PFSVC_SCENARIO_AGE_INFO {

    //
    // Weight calculated based on the launch information. Larger weight is 
    // better. We'd rather discrad scenario with smaller weight.
    //

    ULONG Weight;

    //
    // Scenario file path.
    //

    WCHAR *FilePath;   

} PFSVC_SCENARIO_AGE_INFO, *PPFSVC_SCENARIO_AGE_INFO;

//
// This structure is used to enumerate through the scenario files
// in the prefetch directory. None of the fields of this function
// should be modified outside the file cursor routines.
//

typedef struct _PFSVC_SCENARIO_FILE_CURSOR {

    //
    // Data returned from FindFile calls for the current prefetch file.
    //

    WIN32_FIND_DATA FileData;

    //
    // The current prefetch file's full path.
    //

    WCHAR *FilePath;

    //
    // File name & path length in number of characters excluding NUL.
    //

    ULONG FileNameLength;
    ULONG FilePathLength;

    //
    // Index of the current file.
    //

    ULONG CurrentFileIdx;

    //
    // The fields below are used privately by the scenario file cursor
    // functions.
    //

    //
    // FindFile handle.
    //

    HANDLE FindFileHandle;

    //
    // Where we are looking for prefetch files.
    //

    WCHAR *PrefetchRoot;
    ULONG PrefetchRootLength;

    //
    // This is the maximum length string the allocated FilePath can store.
    //

    ULONG FilePathMaxLength;

    //
    // This is where the file name starts in the file path. The base of
    // the file path does not change (i.e. PrefetchRoot) and we copy
    // the new enumerated file name starting at FilePath+FileNameStart.
    //

    ULONG FileNameStart;
    
} PFSVC_SCENARIO_FILE_CURSOR, *PPFSVC_SCENARIO_FILE_CURSOR;

//
// Return values from CompareSuffix.
//

typedef enum _PFSV_SUFFIX_COMPARISON_RESULT {
    PfSvSuffixIdentical,
    PfSvSuffixLongerThan,
    PfSvSuffixLessThan,
    PfSvSuffixGreaterThan
} PFSV_SUFFIX_COMPARISON_RESULT, *PPFSV_SUFFIX_COMPARISON_RESULT;

//
// Return values from ComparePrefix.
//

typedef enum _PFSV_PREFIX_COMPARISON_RESULT {
    PfSvPrefixIdentical,
    PfSvPrefixLongerThan,
    PfSvPrefixLessThan,
    PfSvPrefixGreaterThan
} PFSV_PREFIX_COMPARISON_RESULT, *PPFSV_PREFIX_COMPARISON_RESULT;

//
// Return values from SectionNodeComparisonRoutine.
//

typedef enum _PFSV_SECTION_NODE_COMPARISON_RESULT {
    PfSvSectNode1LessThanSectNode2 = -1,
    PfSvSectNode1EqualToSectNode2 = 0,
    PfSvSectNode1GreaterThanSectNode2 = 1,
} PFSV_SECTION_NODE_COMPARISON_RESULT, *PPFSV_SECTION_NODE_COMPARISON_RESULT;

//
// Local function prototypes:
//

//
// Exposed routines:
//

DWORD 
WINAPI
PfSvcMainThread(
    VOID *Param
    );


//
// Internal service routines:
//

//
// Thread routines:
//

DWORD 
WINAPI
PfSvProcessTraceThread(
    VOID *Param
    );

DWORD 
WINAPI
PfSvPollShellReadyWorker(
    VOID *Param
    );

//
// Routines called by the main prefetcher thread.
//

DWORD 
PfSvGetRawTraces(
    VOID
    );

DWORD
PfSvInitializeGlobals(
    VOID
    );

VOID
PfSvCleanupGlobals(
    VOID
    );

DWORD
PfSvGetCSCRootPath (
    WCHAR *CSCRootPath,
    ULONG CSCRootPathMaxChars
    );
    
DWORD
PfSvGetDontRunDefragger(
    DWORD *DontRunDefragger
    );

DWORD
PfSvSetPrefetchParameters(
    PPF_SYSTEM_PREFETCH_PARAMETERS Parameters
    );

DWORD
PfSvQueryPrefetchParameters(
    PPF_SYSTEM_PREFETCH_PARAMETERS Parameters
    );

DWORD
PfSvInitializePrefetchDirectory(
    WCHAR *PathFromSystemRoot
    );

DWORD
PfSvCountFilesInDirectory(
    WCHAR *DirectoryPath,
    WCHAR *MatchExpression,
    PULONG NumFiles
    );

//
// Routines to process acquired traces:
//

DWORD
PfSvProcessTrace(
    PPF_TRACE_HEADER Trace
    );

VOID
PfSvInitializeScenarioInfo (
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PPF_SCENARIO_ID ScenarioId,
    PF_SCENARIO_TYPE ScenarioType
    );

VOID 
PfSvCleanupScenarioInfo(
    PPFSVC_SCENARIO_INFO ScenarioInfo
    );

DWORD
PfSvScenarioOpen (
    IN PWCHAR FilePath,
    IN PPF_SCENARIO_ID ScenarioId,
    IN PF_SCENARIO_TYPE ScenarioType,
    OUT PPF_SCENARIO_HEADER *Scenario
    );

DWORD
PfSvScenarioGetFilePath(
    OUT PWCHAR FilePath,
    IN ULONG FilePathMaxChars,
    IN PPF_SCENARIO_ID ScenarioId
    );

DWORD
PfSvScenarioInfoPreallocate(
    IN PPFSVC_SCENARIO_INFO ScenarioInfo,
    OPTIONAL IN PPF_SCENARIO_HEADER Scenario,
    IN PPF_TRACE_HEADER Trace
    );

DWORD
PfSvAddExistingScenarioInfo(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PPF_SCENARIO_HEADER Scenario
    );

DWORD
PfSvVerifyVolumeMagics(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PPF_TRACE_HEADER Trace 
    );

DWORD
PfSvAddTraceInfo(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PPF_TRACE_HEADER Trace 
    );

PPFSVC_SECTION_NODE 
PfSvGetSectionRecord(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    WCHAR *FilePath,
    ULONG FilePathLength
    );

DWORD 
PfSvAddFaultInfoToSection(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PPF_LOG_ENTRY LogEntry,
    PPFSVC_SECTION_NODE SectionNode
    );

DWORD
PfSvApplyPrefetchPolicy(
    PPFSVC_SCENARIO_INFO ScenarioInfo
    );

ULONG 
PfSvGetNumTimesUsed(
    ULONG UsageHistory,
    ULONG UsageHistorySize
    );

ULONG 
PfSvGetTraceEndIdx(
    PPF_TRACE_HEADER Trace
    );

//
// Routines to write updated scenario instructions to the scenario
// file.
//

DWORD
PfSvWriteScenario(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PWCHAR ScenarioFilePath
    );

DWORD
PfSvPrepareScenarioDump(
    IN PPFSVC_SCENARIO_INFO ScenarioInfo,
    OUT PPF_SCENARIO_HEADER *ScenarioPtr
    );

//
// Routines to maintain the optimal disk layout file and update disk
// layout.
//

DWORD
PfSvUpdateOptimalLayout(
    PPFSVC_IDLE_TASK Task
    );

DWORD
PfSvUpdateLayout (
    PPFSVC_PATH_LIST CurrentLayout,
    PPFSVC_PATH_LIST OptimalLayout,
    PBOOLEAN LayoutChanged
    );

DWORD
PfSvDetermineOptimalLayout (
    PPFSVC_IDLE_TASK Task,
    PPFSVC_PATH_LIST OptimalLayout,
    BOOL *BootScenarioProcessed
    );

DWORD
PfSvUpdateLayoutForScenario (
    PPFSVC_PATH_LIST OptimalLayout,
    WCHAR *ScenarioFilePath,
    PNTPATH_TRANSLATION_LIST TranslationList,
    PWCHAR *DosPathBuffer,
    PULONG DosPathBufferSize
    );

DWORD
PfSvReadLayout(
    IN WCHAR *FilePath,
    OUT PPFSVC_PATH_LIST Layout,
    OUT FILETIME *LastWriteTime
    );

DWORD
PfSvSaveLayout(
    IN WCHAR *FilePath,
    IN PPFSVC_PATH_LIST Layout,
    OUT FILETIME *LastWriteTime
    );

DWORD
PfSvGetLayoutFilePath(
    PWCHAR *FilePathBuffer,
    PULONG FilePathBufferSize
    );

//
// Routines to defrag the disks once after setup when the system is idle.
//

DWORD
PfSvDefragDisks(
    PPFSVC_IDLE_TASK Task
    );

DWORD
PfSvLaunchDefragger(
    PPFSVC_IDLE_TASK Task,
    BOOLEAN ForLayoutOptimization,
    PWCHAR TargetDrive
    );

DWORD
PfSvGetBuildDefragStatusValueName (
    OSVERSIONINFOEXW *OsVersion,
    PWCHAR *ValueName
    );

DWORD
PfSvSetBuildDefragStatus(
    OSVERSIONINFOEXW *OsVersion,
    PWCHAR BuildDefragStatus,
    ULONG Size
    );

DWORD
PfSvGetBuildDefragStatus(
    OSVERSIONINFOEXW *OsVersion,
    PWCHAR *BuildDefragStatus,
    PULONG ReturnSize
    );

//
// Routines to cleanup old scenario files in the prefetch directory.
//

DWORD
PfSvCleanupPrefetchDirectory(
    PPFSVC_IDLE_TASK Task
    );

int
__cdecl 
PfSvCompareScenarioAgeInfo(
    const void *Param1,
    const void *Param2
    );

//
// Routines to enumerate scenario files.
//

VOID
PfSvInitializeScenarioFileCursor (
    PPFSVC_SCENARIO_FILE_CURSOR FileCursor
    );

VOID
PfSvCleanupScenarioFileCursor(
    PPFSVC_SCENARIO_FILE_CURSOR FileCursor
    );

DWORD
PfSvStartScenarioFileCursor(
    PPFSVC_SCENARIO_FILE_CURSOR FileCursor,
    WCHAR *PrefetchRoot
    );

DWORD
PfSvGetNextScenarioFileInfo(
    PPFSVC_SCENARIO_FILE_CURSOR FileCursor
    );

//
// File I/O utility routines.
//

DWORD
PfSvGetViewOfFile(
    IN WCHAR *FilePath,
    OUT PVOID *BasePointer,
    OUT PULONG FileSize
    );

DWORD
PfSvWriteBuffer(
    PWCHAR FilePath,
    PVOID Buffer,
    ULONG Length
    );

DWORD
PfSvGetLastWriteTime (
    WCHAR *FilePath,
    PFILETIME LastWriteTime
    );

DWORD
PfSvReadLine (
    FILE *File,
    WCHAR **LineBuffer,
    ULONG *LineBufferMaxChars,
    ULONG *LineLength
    );

DWORD
PfSvGetFileBasicInformation (
    WCHAR *FilePath,
    PFILE_BASIC_INFORMATION FileInformation
    );

DWORD
PfSvGetFileIndexNumber(
    WCHAR *FilePath,
    PLARGE_INTEGER FileIndexNumber
    );

//
// String utility routines.
//

PFSV_SUFFIX_COMPARISON_RESULT
PfSvCompareSuffix(
    WCHAR *String,
    ULONG StringLength,
    WCHAR *Suffix,
    ULONG SuffixLength,
    BOOLEAN CaseSensitive
    );

PFSV_PREFIX_COMPARISON_RESULT
PfSvComparePrefix(
    WCHAR *String,
    ULONG StringLength,
    WCHAR *Prefix,
    ULONG PrefixLength,
    BOOLEAN CaseSensitive
    );

VOID
FASTCALL
PfSvRemoveEndOfLineChars (
    WCHAR *Line,
    ULONG *LineLength
    );

PWCHAR
PfSvcAnsiToUnicode(
    PCHAR str
    );

PCHAR
PfSvcUnicodeToAnsi(
    PWCHAR wstr
    );

VOID 
PfSvcFreeString(
    PVOID String
    );

//
// Routines that deal with information in the registry.
//

DWORD
PfSvSaveStartInfo (
    HKEY ServiceDataKey
    );

DWORD
PfSvSaveExitInfo (
    HKEY ServiceDataKey,
    DWORD ExitCode
    );

DWORD
PfSvSaveTraceProcessingStatistics (
    HKEY ServiceDataKey
    );

DWORD
PfSvGetLastDiskLayoutTime(
    FILETIME *LastDiskLayoutTime
    );

DWORD
PfSvSetLastDiskLayoutTime(
    FILETIME *LastDiskLayoutTime
    );

BOOLEAN
PfSvAllowedToRunDefragger(
    BOOLEAN CheckRegistry
    );

//
// Routines that deal with security.
//

BOOL 
PfSvSetPrivilege(
    HANDLE hToken,
    LPCTSTR lpszPrivilege,
    ULONG ulPrivilege,
    BOOL bEnablePrivilege
    );

DWORD
PfSvSetAdminOnlyPermissions(
    WCHAR *ObjectPath,
    HANDLE ObjectHandle,
    SE_OBJECT_TYPE ObjectType
    );

DWORD
PfSvGetPrefetchServiceThreadPrivileges (
    VOID
    );

//
// Routines that deal with volume node structures.
//

DWORD
PfSvCreateVolumeNode (
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    WCHAR *VolumePath,
    ULONG VolumePathLength,
    PLARGE_INTEGER CreationTime,
    ULONG SerialNumber
    );

PPFSVC_VOLUME_NODE
PfSvGetVolumeNode (
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    WCHAR *FilePath,
    ULONG FilePathLength
    );

VOID
PfSvCleanupVolumeNode(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PPFSVC_VOLUME_NODE VolumeNode
    );
    
DWORD
PfSvAddParentDirectoriesToList(
    PPFSVC_PATH_LIST DirectoryList,
    ULONG VolumePathLength,
    WCHAR *FilePath,
    ULONG FilePathLength
    );

//
// Routines used to allocate / free section & page nodes etc. efficiently.
//

VOID
PfSvChunkAllocatorInitialize (
    PPFSVC_CHUNK_ALLOCATOR Allocator
    );

DWORD
PfSvChunkAllocatorStart (
    PPFSVC_CHUNK_ALLOCATOR Allocator,
    PVOID Buffer,
    ULONG ChunkSize,
    ULONG MaxChunks
    );

PVOID
PfSvChunkAllocatorAllocate (
    PPFSVC_CHUNK_ALLOCATOR Allocator
    );

VOID
PfSvChunkAllocatorFree (
    PPFSVC_CHUNK_ALLOCATOR Allocator,
    PVOID Allocation
    );

VOID
PfSvChunkAllocatorCleanup (
    PPFSVC_CHUNK_ALLOCATOR Allocator
    );

//
// Routines used to allocate / free file / directory / volume paths fast.
//

VOID
PfSvStringAllocatorInitialize (
    PPFSVC_STRING_ALLOCATOR Allocator
    );

DWORD
PfSvStringAllocatorStart (
    PPFSVC_STRING_ALLOCATOR Allocator,
    PVOID Buffer,
    ULONG MaxSize
    );

PVOID
PfSvStringAllocatorAllocate (
    PPFSVC_STRING_ALLOCATOR Allocator,
    ULONG NumBytes
    );

VOID
PfSvStringAllocatorFree (
    PPFSVC_STRING_ALLOCATOR Allocator,
    PVOID Allocation
    );

VOID
PfSvStringAllocatorCleanup (
    PPFSVC_STRING_ALLOCATOR Allocator
    );

//
// Routines that deal with section node structures.
//

VOID
PfSvCleanupSectionNode(
    PPFSVC_SCENARIO_INFO ScenarioInfo,
    PPFSVC_SECTION_NODE SectionNode
    );

//
// Routines used to sort scenario's section nodes.
//

DWORD
PfSvSortSectionNodesByFirstAccess(
    PLIST_ENTRY SectionNodeList
    );

PFSV_SECTION_NODE_COMPARISON_RESULT 
FASTCALL
PfSvSectionNodeComparisonRoutine(
    PPFSVC_SECTION_NODE Element1, 
    PPFSVC_SECTION_NODE Element2 
    );

//
// Routines that implement a priority queue used to sort section nodes
// for a scenario.
//

VOID
PfSvInitializeSectNodePriorityQueue(
    PPFSV_SECTNODE_PRIORITY_QUEUE PriorityQueue
    );

VOID
PfSvInsertSectNodePriorityQueue(
    PPFSV_SECTNODE_PRIORITY_QUEUE PriorityQueue,
    PPFSVC_SECTION_NODE NewElement
    );

PPFSVC_SECTION_NODE
PfSvRemoveMinSectNodePriorityQueue(
    PPFSV_SECTNODE_PRIORITY_QUEUE PriorityQueue
    );

//
// Implementation of the Nt path to Dos path translation API.
//

DWORD
PfSvBuildNtPathTranslationList(
    PNTPATH_TRANSLATION_LIST *NtPathTranslationList
    );

VOID
PfSvFreeNtPathTranslationList(
    PNTPATH_TRANSLATION_LIST TranslationList
    );

DWORD 
PfSvTranslateNtPath(
    PNTPATH_TRANSLATION_LIST TranslationList,
    WCHAR *NtPath,
    ULONG NtPathLength,
    PWCHAR *DosPathBuffer,
    PULONG DosPathBufferSize
    );
    
//
// Path list API.
//

VOID
PfSvInitializePathList(
    PPFSVC_PATH_LIST PathList,
    PPFSVC_STRING_ALLOCATOR PathAllocator,
    BOOLEAN CaseSensitive
    );

VOID
PfSvCleanupPathList(
    PPFSVC_PATH_LIST PathList
    );

BOOLEAN
PfSvIsInPathList(
    PPFSVC_PATH_LIST PathList,
    WCHAR *Path,
    ULONG PathLength
    );

DWORD
PfSvAddToPathList(
    PPFSVC_PATH_LIST PathList,
    WCHAR *Path,
    ULONG PathLength
    );

PPFSVC_PATH
PfSvGetNextPathSorted (
    PPFSVC_PATH_LIST PathList,
    PPFSVC_PATH CurrentPath
    );

PPFSVC_PATH
PfSvGetNextPathInOrder (
    PPFSVC_PATH_LIST PathList,
    PPFSVC_PATH CurrentPath
    );

//
// Routines to build the list of files accessed by the boot loader.
//

DWORD
PfSvBuildBootLoaderFilesList (
    PPFSVC_PATH_LIST PathList
    );

DWORD 
PfSvAddBootImageAndImportsToList(
    PPFSVC_PATH_LIST PathList,
    WCHAR *FilePath,
    ULONG FilePathLength
    );

DWORD
PfSvLocateBootServiceFile(
    IN WCHAR *FileName,
    IN ULONG FileNameLength,
    OUT WCHAR *FullPathBuffer,
    IN ULONG FullPathBufferLength,
    OUT PULONG RequiredLength   
    );

DWORD
PfSvGetBootServiceFullPath(
    IN WCHAR *ServiceName,
    IN WCHAR *BinaryPathName,
    OUT WCHAR *FullPathBuffer,
    IN ULONG FullPathBufferLength,
    OUT PULONG RequiredLength
    );

DWORD 
PfSvGetBootLoaderNlsFileNames (
    PPFSVC_PATH_LIST PathList
    );

DWORD 
PfSvLocateNlsFile(
    WCHAR *FileName,
    WCHAR *FilePathBuffer,
    ULONG FilePathBufferLength,
    ULONG *RequiredLength
    );

DWORD
PfSvQueryNlsFileName (
    HKEY Key,
    WCHAR *ValueName,
    WCHAR *FileNameBuffer,
    ULONG FileNameBufferSize,
    ULONG *RequiredSize
    );

//
// Routines to manage / run idle tasks.
//

VOID
PfSvInitializeTask (
    PPFSVC_IDLE_TASK Task
    );

DWORD
PfSvRegisterTask (
    PPFSVC_IDLE_TASK Task,
    IT_IDLE_TASK_ID TaskId,
    WAITORTIMERCALLBACK Callback,
    PFSVC_IDLE_TASK_WORKER_FUNCTION DoWorkFunction
    );

DWORD
PfSvUnregisterTask (
    PPFSVC_IDLE_TASK Task,
    BOOLEAN CalledFromCallback
    );

VOID
PfSvCleanupTask (
    PPFSVC_IDLE_TASK Task
    );

BOOL
PfSvStartTaskCallback(
    PPFSVC_IDLE_TASK Task
    );

VOID
PfSvStopTaskCallback(
    PPFSVC_IDLE_TASK Task
    );

VOID 
CALLBACK 
PfSvCommonTaskCallback(
    PVOID lpParameter,
    BOOLEAN TimerOrWaitFired
    );

DWORD
PfSvContinueRunningTask(
    PPFSVC_IDLE_TASK Task
    );

//
// ProcessIdleTasks notify routine and its dependencies.
//

VOID
PfSvProcessIdleTasksCallback(
    VOID
    );

DWORD
PfSvForceWMIProcessIdleTasks(
    VOID
    );

BOOL 
PfSvWaitForServiceToStart (
    LPTSTR ServiceName, 
    DWORD MaxWait
    );

//
// Wrappers around verify routines.
//

BOOLEAN
PfSvVerifyScenarioBuffer(
    PPF_SCENARIO_HEADER Scenario,
    ULONG BufferSize,
    PULONG FailedCheck
    );

//
// Debug definitions.
//

#if DBG
#ifndef PFSVC_DBG
#define PFSVC_DBG
#endif // !PFSVC_DBG
#endif // DBG

#ifdef PFSVC_DBG

//
// Define the component ID we use.
//

#define PFID       DPFLTR_PREFETCHER_ID

//
// Define DbgPrintEx levels.
//

#define PFERR      DPFLTR_ERROR_LEVEL
#define PFWARN     DPFLTR_WARNING_LEVEL
#define PFTRC      DPFLTR_TRACE_LEVEL
#define PFINFO     DPFLTR_INFO_LEVEL

//
// DbgPrintEx levels 4 - 19 are reserved for the kernel mode component.
//

#define PFSTRC     20
#define PFWAIT     21
#define PFLOCK     22
#define PFPATH     23
#define PFNTRC     24
#define PFTASK     25

//
//  This may help you determine what to set the DbgPrintEx mask.
//
//  3 3 2 2  2 2 2 2  2 2 2 2  1 1 1 1   1 1 1 1  1 1 0 0  0 0 0 0  0 0 0 0
//  1 0 9 8  7 6 5 4  3 2 1 0  9 8 7 6   5 4 3 2  1 0 9 8  7 6 5 4  3 2 1 0
//  _ _ _ _  _ _ _ _  _ _ _ _  _ _ _ _   _ _ _ _  _ _ _ _  _ _ _ _  _ _ _ _
//

NTSYSAPI
VOID
NTAPI
RtlAssert(
    PVOID FailedAssertion,
    PVOID FileName,
    ULONG LineNumber,
    PCHAR Message
    );

#define DBGPR(x) DbgPrintEx x
#define PFSVC_ASSERT(x) if (!(x)) RtlAssert(#x, __FILE__, __LINE__, NULL )

//
// Variables used when saving traces acquired from the kernel. The
// traces are saved in the prefetch directory by appending the trace
// number % max number of saved traces to the base trace name.
//

WCHAR *PfSvcDbgTraceBaseName = L"PrefetchTrace";
LONG PfSvcDbgTraceNumber = 0;
LONG PfSvcDbgMaxNumSavedTraces = 20;

#else // PFSVC_DBG

#define DBGPR(x)
#define PFSVC_ASSERT(x)

#endif // PFSVC_DBG

#endif // _PFSVC_H_