1241 lines
45 KiB
C++
1241 lines
45 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1991 - 2000.
|
|
//
|
|
// File: PARAMS.HXX
|
|
//
|
|
// Contents: Default content index parameters
|
|
//
|
|
// History: 25-Mar-92 BartoszM Created.
|
|
// 04-Jan-94 DwightKr Added MAX_PERSIST_DEL_RECORDS
|
|
// 19-Oct-98 SundarA Added IS_ENUM_ALLOWED
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include <ciintf.h>
|
|
|
|
const BOOL CI_GENERATE_RELEVANT_WORDS_DEFAULT = FALSE;
|
|
const BOOL CI_FFILTER_FILES_WITH_UNKNOWN_EXTENSIONS_DEFAULT = TRUE;
|
|
const BOOL CI_FILTER_CONTENTS_DEFAULT = TRUE;
|
|
|
|
//
|
|
// Maximum time spent creating a clustering.
|
|
// Units: seconds
|
|
// Note: this isn't currenly used anywhere.
|
|
//
|
|
|
|
const ULONG CI_CLUSTERINGTIME_DEFAULT = 500;
|
|
const ULONG CI_CLUSTERINGTIME_MIN = 100;
|
|
const ULONG CI_CLUSTERINGTIME_MAX = 10000;
|
|
|
|
//
|
|
// Minimum number of idle threads kept alive to process
|
|
// incoming queries.
|
|
//
|
|
|
|
const ULONG CI_MIN_IDLE_QUERY_THREADS_DEFAULT = 1;
|
|
const ULONG CI_MIN_IDLE_QUERY_THREADS_MIN = 0;
|
|
const ULONG CI_MIN_IDLE_QUERY_THREADS_MAX = 1000;
|
|
|
|
//
|
|
// Maximum number of query threads. This caps the number of concurrently
|
|
// processed asynchronous queries.
|
|
//
|
|
|
|
const ULONG CI_MAX_ACTIVE_QUERY_THREADS_DEFAULT = 2;
|
|
const ULONG CI_MAX_ACTIVE_QUERY_THREADS_MIN = 1;
|
|
const ULONG CI_MAX_ACTIVE_QUERY_THREADS_MAX = 1000;
|
|
|
|
//
|
|
// Minimum number of idle request threads kept alive to process
|
|
// incoming query requests.
|
|
//
|
|
|
|
const ULONG CI_MIN_IDLE_REQUEST_THREADS_DEFAULT = 1;
|
|
const ULONG CI_MIN_IDLE_REQUEST_THREADS_MIN = 0;
|
|
const ULONG CI_MIN_IDLE_REQUEST_THREADS_MAX = 1000;
|
|
|
|
//
|
|
// Maximum number of request threads. This caps the number of concurrently
|
|
// processed synchronous queries.
|
|
//
|
|
|
|
const ULONG CI_MAX_ACTIVE_REQUEST_THREADS_DEFAULT = 2;
|
|
const ULONG CI_MAX_ACTIVE_REQUEST_THREADS_MIN = 1;
|
|
const ULONG CI_MAX_ACTIVE_REQUEST_THREADS_MAX = 1000;
|
|
|
|
//
|
|
// Maximum number of simultaneous query/catalog request connections
|
|
// (pipe instances).
|
|
//
|
|
|
|
const ULONG CI_MAX_SIMULTANEOUS_REQUESTS_DEFAULT = 100;
|
|
const ULONG CI_MAX_SIMULTANEOUS_REQUESTS_MIN = 1;
|
|
const ULONG CI_MAX_SIMULTANEOUS_REQUESTS_MAX = 20000;
|
|
|
|
//
|
|
// Maximum number of cached pipe instances
|
|
//
|
|
|
|
const ULONG CI_MAX_CACHED_PIPES_DEFAULT = 3;
|
|
const ULONG CI_MAX_CACHED_PIPES_MIN = 0;
|
|
const ULONG CI_MAX_CACHED_PIPES_MAX = 1000;
|
|
|
|
//
|
|
// Timeout (in milleseconds) for clients trying to obtain a pipe instance
|
|
// when all available pipe instances are busy.
|
|
//
|
|
|
|
const ULONG CI_REQUEST_TIMEOUT_DEFAULT = 10000;
|
|
const ULONG CI_REQUEST_TIMEOUT_MIN = 0;
|
|
const ULONG CI_REQUEST_TIMEOUT_MAX = 1000000000;
|
|
|
|
//
|
|
// Minimum idle time a client can enjoy. After this expires, it can be
|
|
// kicked out on the server's discretion to allow newer clients.
|
|
// This is in seconds.
|
|
//
|
|
|
|
const ULONG CI_MIN_CLIENT_IDLE_TIME = 600; // 10 minutes. Is this a reasonable default?
|
|
|
|
//
|
|
// W3 Server Instance #
|
|
//
|
|
|
|
const ULONG CI_W3SVC_INSTANCE_DEFAULT = 1;
|
|
const ULONG CI_W3SVC_INSTANCE_MIN = 1;
|
|
const ULONG CI_W3SVC_INSTANCE_MAX = ~0;
|
|
|
|
//
|
|
// NNTP Server Instance #
|
|
//
|
|
|
|
const ULONG CI_NNTPSVC_INSTANCE_DEFAULT = 1;
|
|
const ULONG CI_NNTPSVC_INSTANCE_MIN = 1;
|
|
const ULONG CI_NNTPSVC_INSTANCE_MAX = ~0;
|
|
|
|
//
|
|
// IMAP Server Instance #
|
|
//
|
|
|
|
const ULONG CI_IMAPSVC_INSTANCE_DEFAULT = 1;
|
|
const ULONG CI_IMAPSVC_INSTANCE_MIN = 1;
|
|
const ULONG CI_IMAPSVC_INSTANCE_MAX = ~0;
|
|
|
|
//
|
|
// Whether to trim working set when idle
|
|
//
|
|
|
|
const BOOL CI_MINIMIZE_WORKINGSET_DEFAULT = 0;
|
|
|
|
//
|
|
// Maximum amount of time to execute a query in a single time-slice.
|
|
// If more asynchronous queries are active than allowed query threads,
|
|
// then a query is put back on the pending queue after this time interval.
|
|
// Timeslicing is done only after a matching row is found, so the time
|
|
// spent in a timeslice may overrun this and a considerable number of
|
|
// rows may be examined in the time slice.
|
|
//
|
|
// Units: milliseconds of CPU time
|
|
//
|
|
|
|
const ULONG CI_MAX_QUERY_TIMESLICE_DEFAULT = 50;
|
|
const ULONG CI_MAX_QUERY_TIMESLICE_MIN = 1;
|
|
const ULONG CI_MAX_QUERY_TIMESLICE_MAX = 1000;
|
|
|
|
//
|
|
// Maximum execution time of a query. If a query takes more than this
|
|
// amount of CPU time, processing of it will be stopped and an error
|
|
// status indicated.
|
|
// A special value of 0 means no timeout or timeout specified by the client
|
|
//
|
|
// Units: milliseconds of CPU time
|
|
//
|
|
|
|
const ULONG CI_MAX_QUERY_EXECUTION_TIME_DEFAULT = 10*1000;
|
|
const ULONG CI_MAX_QUERY_EXECUTION_TIME_MIN = 0;
|
|
const ULONG CI_MAX_QUERY_EXECUTION_TIME_MAX = ~0;
|
|
|
|
|
|
//++++++++++++++++++++++++++++++++++++
|
|
//+ Content index parameters +
|
|
//++++++++++++++++++++++++++++++++++++
|
|
|
|
//
|
|
// Sleep time between merges. Content index wakes up this often to determine
|
|
// if a merge is necessary. Usually an annealing merge, but may be a shadow
|
|
// or master merge.
|
|
//
|
|
// Units: minutes
|
|
//
|
|
const ULONG CI_MAX_MERGE_INTERVAL_DEFAULT = 10;
|
|
const ULONG CI_MAX_MERGE_INTERVAL_MIN = 1;
|
|
const ULONG CI_MAX_MERGE_INTERVAL_MAX = 60;
|
|
|
|
//
|
|
// Priority class of the filter process. Priority within class is always
|
|
// above normal.
|
|
//
|
|
|
|
const int CI_THREAD_CLASS_FILTER_DEFAULT = IDLE_PRIORITY_CLASS;
|
|
const int CI_THREAD_CLASS_FILTER_MIN = NORMAL_PRIORITY_CLASS;
|
|
const int CI_THREAD_CLASS_FILTER_MAX = HIGH_PRIORITY_CLASS;
|
|
|
|
//
|
|
// Maximum number of word lists that can exists at one time.
|
|
//
|
|
|
|
const ULONG CI_MAX_WORDLISTS_DEFAULT = 25;
|
|
const ULONG CI_MAX_WORDLISTS_MIN = 10;
|
|
const ULONG CI_MAX_WORDLISTS_MAX = 2000;
|
|
|
|
//
|
|
// Minimum combined size of wordlists which will force shadow merge.
|
|
// Units: 4k pages.
|
|
//
|
|
|
|
const ULONG CI_MIN_SIZE_MERGE_WORDLISTS_DEFAULT = 256;
|
|
const ULONG CI_MIN_SIZE_MERGE_WORDLISTS_MIN = 16;
|
|
const ULONG CI_MIN_SIZE_MERGE_WORDLISTS_MAX = ~0;
|
|
|
|
//
|
|
// Minimum free memory for wordlist creation.
|
|
// Units: MBytes
|
|
//
|
|
|
|
const ULONG CI_MIN_WORDLIST_MEMORY_DEFAULT = 5;
|
|
const ULONG CI_MIN_WORDLIST_MEMORY_MIN = 1;
|
|
const ULONG CI_MIN_WORDLIST_MEMORY_MAX = 100;
|
|
|
|
//
|
|
// Milliseconds after system boot until CI starts scanning/filtering
|
|
// Units: Milliseconds
|
|
//
|
|
|
|
const ULONG CI_STARTUP_DELAY_DEFAULT = 1000 * 60 * 8; // 8 minutes
|
|
const ULONG CI_STARTUP_DELAY_MIN = 0;
|
|
const ULONG CI_STARTUP_DELAY_MAX = ~0;
|
|
|
|
//
|
|
// More than this amount of I/O results in a delay before
|
|
// creating a word list.
|
|
// Units: KB/Sec
|
|
//
|
|
|
|
const ULONG CI_MAX_WORDLIST_IO_MIN = 100;
|
|
const ULONG CI_MAX_WORDLIST_IO_MAX = ~0;
|
|
const ULONG CI_MAX_WORDLIST_IO_DEFAULT = 410; // ~ 2 Mb / 5 Seconds
|
|
|
|
//
|
|
// More than this amount of I/O results in a delay before creating a
|
|
// word list. FSCI-specific, and only enabled if DiskPerf counters are
|
|
// enabled.
|
|
// Units: % Disk in use.
|
|
//
|
|
|
|
const ULONG CI_MAX_WORDLIST_IO_DISKPERF_MIN = 1; // 0% doesn't make any sense. We'd never run.
|
|
const ULONG CI_MAX_WORDLIST_IO_DISKPERF_MAX = 100;
|
|
const ULONG CI_MAX_WORDLIST_IO_DISKPERF_DEFAULT = 10;
|
|
|
|
//
|
|
// Interval at which resource limitations such as low memory and
|
|
// heavy [user] I/O will be checked. This is the minimum unit of
|
|
// time devoted to wordlist creation.
|
|
// Units: Seconds
|
|
//
|
|
|
|
const ULONG CI_WORDLIST_RESOURCE_CHECK_INTERVAL_MIN = 5;
|
|
const ULONG CI_WORDLIST_RESOURCE_CHECK_INTERVAL_MAX = ~0;
|
|
const ULONG CI_WORDLIST_RESOURCE_CHECK_INTERVAL_DEFAULT = 60;
|
|
|
|
//
|
|
// Maximum fresh list entries--forces master merge
|
|
// Each fresh entry takes up 8 bytes.
|
|
//
|
|
|
|
const ULONG CI_MAX_FRESHCOUNT_DEFAULT = 60000;
|
|
const ULONG CI_MAX_FRESHCOUNT_MIN = 1000;
|
|
const ULONG CI_MAX_FRESHCOUNT_MAX = ~0;
|
|
|
|
//
|
|
// Maximum number of delete entries in fresh list before a
|
|
// delete merge is forced.
|
|
//
|
|
|
|
const ULONG CI_MAX_FRESH_DELETES_DEFAULT = 5000;
|
|
const ULONG CI_MAX_FRESH_DELETES_MIN = 10;
|
|
const ULONG CI_MAX_FRESH_DELETES_MAX = ~0;
|
|
|
|
//
|
|
// Maximum amount of data which can be gernated from a single file, based
|
|
// on its size. This value is a multiplier. 8 means that a file can generate
|
|
// up to 8 times it size in content index data.
|
|
//
|
|
|
|
const ULONG CI_MAX_FILESIZE_MULTIPLIER_DEFAULT = 8;
|
|
const ULONG CI_MAX_FILESIZE_MULTIPLIER_MIN = 4;
|
|
const ULONG CI_MAX_FILESIZE_MULTIPLIER_MAX = ~0;
|
|
|
|
//
|
|
// Time at which master merge will occur. This is stored as the number of
|
|
// minutes after midnight.
|
|
// Units: minutes
|
|
//
|
|
|
|
const ULONG CI_MASTER_MERGE_TIME_DEFAULT = 60;
|
|
const ULONG CI_MASTER_MERGE_TIME_MIN = 0;
|
|
const ULONG CI_MASTER_MERGE_TIME_MAX = 1439;
|
|
|
|
//
|
|
// Maximum number of indices considered acceptable in a well-tuned system.
|
|
// When the number of indices climbs above this number and the system is
|
|
// idle then an 'annealing' merge will take place to bring the total count
|
|
// of indices under this number.
|
|
//
|
|
|
|
const ULONG CI_MAX_IDEAL_INDEXES_DEFAULT = 5;
|
|
const ULONG CI_MAX_IDEAL_INDEXES_MIN = 2;
|
|
const ULONG CI_MAX_IDEAL_INDEXES_MAX = 100;
|
|
|
|
//
|
|
// If average system idle time for the last merge check period is greater
|
|
// than this value, then we may perform an annealing merge.
|
|
// Units: Percentage of total CPU time.
|
|
//
|
|
|
|
const ULONG CI_MIN_MERGE_IDLE_TIME_DEFAULT = 90;
|
|
const ULONG CI_MIN_MERGE_IDLE_TIME_MIN = 10;
|
|
const ULONG CI_MIN_MERGE_IDLE_TIME_MAX = 100;
|
|
|
|
|
|
//
|
|
// Time interval between forced scans on network shares with no notifications.
|
|
// Units: minutes
|
|
//
|
|
|
|
const ULONG CI_FORCED_NETPATH_SCAN_DEFAULT = 120;
|
|
const ULONG CI_FORCED_NETPATH_SCAN_MIN = 10;
|
|
const ULONG CI_FORCED_NETPATH_SCAN_MAX = 0x00FFFFFF;
|
|
|
|
//
|
|
// Maximum # of catalogs that can be opened at once.
|
|
// Units: count of catalogs
|
|
//
|
|
|
|
const ULONG CI_MAX_CATALOGS_DEFAULT = 33; // enough to fit in 1 perfmon shared-memory page
|
|
const ULONG CI_MAX_CATALOGS_MIN = 1;
|
|
const ULONG CI_MAX_CATALOGS_MAX = 1000;
|
|
|
|
//
|
|
// Default value for _fIsEnumAllowed is TRUE
|
|
//
|
|
|
|
const BOOL CI_IS_ENUM_ALLOWED_DEFAULT = TRUE;
|
|
|
|
//
|
|
// Default value for _fIsReadOnly is FALSE
|
|
//
|
|
|
|
const BOOL CI_IS_READ_ONLY_DEFAULT = FALSE;
|
|
|
|
//
|
|
// Number of megabytes to leave on disk
|
|
// If there is less than this amount of space on disk then fail attempts to
|
|
// extend files.
|
|
//
|
|
const ULONG CI_MIN_DISK_SPACE_TO_LEAVE_DEFAULT = 20;
|
|
const ULONG CI_MIN_DISK_SPACE_TO_LEAVE_MIN = 0;
|
|
const ULONG CI_MIN_DISK_SPACE_TO_LEAVE_MAX = ~0;
|
|
|
|
//++++++++++++++++++++++++++++++++++++++
|
|
//+ IDQ ISAPI extension parameters +
|
|
//++++++++++++++++++++++++++++++++++++++
|
|
|
|
//
|
|
// Maximum total number of rows to fetch for a single query.
|
|
//
|
|
const ULONG IS_MAX_ROWS_IN_RESULT_DEFAULT = 0;
|
|
const ULONG IS_MAX_ROWS_IN_RESULT_MIN = 0;
|
|
const ULONG IS_MAX_ROWS_IN_RESULT_MAX = 1000000;
|
|
|
|
//
|
|
// Only fetch and sort this number of rows in a single query.
|
|
//
|
|
const ULONG IS_FIRST_ROWS_IN_RESULT_DEFAULT = 0;
|
|
const ULONG IS_FIRST_ROWS_IN_RESULT_MIN = 0;
|
|
const ULONG IS_FIRST_ROWS_IN_RESULT_MAX = 1000000;
|
|
|
|
//
|
|
// Maximum number of cached queries.
|
|
//
|
|
const ULONG IS_MAX_ENTRIES_IN_CACHE_DEFAULT = 10;
|
|
const ULONG IS_MAX_ENTRIES_IN_CACHE_MIN = 0;
|
|
const ULONG IS_MAX_ENTRIES_IN_CACHE_MAX = 100;
|
|
|
|
//
|
|
// Time interval a query cache entry will remain live.
|
|
// Units: Minutes
|
|
//
|
|
const ULONG IS_QUERY_CACHE_PURGE_INTERVAL_DEFAULT = 5;
|
|
const ULONG IS_QUERY_CACHE_PURGE_INTERVAL_MIN = 1;
|
|
const ULONG IS_QUERY_CACHE_PURGE_INTERVAL_MAX = 120;
|
|
|
|
//
|
|
// Default IS catalog directory
|
|
extern const WCHAR * IS_DEFAULT_CATALOG_DIRECTORY;
|
|
|
|
//
|
|
// # of web query requests to queue at most when busy with
|
|
// other queries
|
|
// Units: Count
|
|
//
|
|
const ULONG IS_QUERY_REQUEST_QUEUE_SIZE_DEFAULT = 16;
|
|
const ULONG IS_QUERY_REQUEST_QUEUE_SIZE_MIN = 0;
|
|
const ULONG IS_QUERY_REQUEST_QUEUE_SIZE_MAX = 100000;
|
|
|
|
|
|
//
|
|
// # of threads per processor beyond which query requests are queued.
|
|
// Units: Count of threads per processor
|
|
//
|
|
const ULONG IS_QUERY_REQUEST_THRESHOLD_FACTOR_DEFAULT = 3;
|
|
const ULONG IS_QUERY_REQUEST_THRESHOLD_FACTOR_MIN = 1;
|
|
const ULONG IS_QUERY_REQUEST_THRESHOLD_FACTOR_MAX = 100000;
|
|
|
|
//
|
|
// Date/Time formatting settings for IDQ
|
|
// 0 -- user default locale (slow) (half of all time spent formatting date/time)
|
|
// 1 -- system default locale (ok) (default)
|
|
// 2 -- hard-coded formatting (fast)
|
|
//
|
|
const ULONG IS_QUERY_DATETIME_FORMATTING_DEFAULT = 1;
|
|
const ULONG IS_QUERY_DATETIME_FORMATTING_MIN = 0;
|
|
const ULONG IS_QUERY_DATETIME_FORMATTING_MAX = 2;
|
|
|
|
//
|
|
// Date/Time local/gmt settings for IDQ
|
|
// 0 -- GMT (default)
|
|
// 1 -- Local system time
|
|
//
|
|
const ULONG IS_QUERY_DATETIME_LOCAL_DEFAULT = 0;
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
//+ Internal parameters (not exposed outside registry) +
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
//
|
|
// maximum number of updates passed by the catalog
|
|
// update to content index in a single batch
|
|
//
|
|
|
|
const ULONG CI_MAX_UPDATES_DEFAULT = 100;
|
|
const ULONG CI_MAX_UPDATES_MIN = 50;
|
|
const ULONG CI_MAX_UPDATES_MAX = 200;
|
|
|
|
//
|
|
// Maximum size (in 4k pages) of wordlist at which new documents
|
|
// can still be added to wordlist.
|
|
//
|
|
|
|
const ULONG CI_MAX_WORDLIST_SIZE_DEFAULT = 20;
|
|
const ULONG CI_MAX_WORDLIST_SIZE_MIN = 10;
|
|
const ULONG CI_MAX_WORDLIST_SIZE_MAX = 262144;
|
|
|
|
//
|
|
// Time to wait after low resource conditions before retrying operation.
|
|
// Units: seconds
|
|
//
|
|
|
|
const ULONG CI_LOW_RESOURCE_SLEEP_DEFAULT = 180;
|
|
const ULONG CI_LOW_RESOURCE_SLEEP_MIN = 5;
|
|
const ULONG CI_LOW_RESOURCE_SLEEP_MAX = 1200; // 20 minutes
|
|
|
|
//
|
|
// Maximum memory load for wordlist creation
|
|
// Units: percentage of total memory
|
|
//
|
|
|
|
const ULONG CI_MAX_WORDLIST_MEMORY_LOAD_DEFAULT = 95;
|
|
const ULONG CI_MAX_WORDLIST_MEMORY_LOAD_MIN = 80;
|
|
const ULONG CI_MAX_WORDLIST_MEMORY_LOAD_MAX = 95;
|
|
|
|
//
|
|
// Number of chunks allowed in the in-memory copy of the change list.
|
|
// Units: chunks
|
|
//
|
|
|
|
const ULONG CI_MAX_QUEUE_CHUNKS_DEFAULT = 20;
|
|
const ULONG CI_MAX_QUEUE_CHUNKS_MIN = 10;
|
|
const ULONG CI_MAX_QUEUE_CHUNKS_MAX = 30;
|
|
|
|
//
|
|
// Number of kilobytes to process before checkpointing during master merge
|
|
// Units: Kbytes
|
|
//
|
|
|
|
const ULONG CI_MASTER_MERGE_CHECKPOINT_INTERVAL_DEFAULT = 0x0800;
|
|
const ULONG CI_MASTER_MERGE_CHECKPOINT_INTERVAL_MIN = 0x0100;
|
|
const ULONG CI_MASTER_MERGE_CHECKPOINT_INTERVAL_MAX = 0x1000;
|
|
|
|
//
|
|
// Maximum number of indexes. Normally, a shadow merge will merge all
|
|
// existing wordlists into a new shadow index. When the total number of
|
|
// indexes climbs beyond this count, then existing shadow indexes will
|
|
// participate in a shadow merge.
|
|
//
|
|
|
|
const ULONG CI_MAX_INDEXES_DEFAULT = 25;
|
|
const ULONG CI_MAX_INDEXES_MIN = 10;
|
|
const ULONG CI_MAX_INDEXES_MAX = 150;
|
|
|
|
|
|
//
|
|
// Memory buffer size used for CI filter to communicate between
|
|
// server and kernel space.
|
|
// Units: KBytes
|
|
//
|
|
|
|
const ULONG CI_FILTER_BUFFER_SIZE_DEFAULT = 128;
|
|
const ULONG CI_FILTER_BUFFER_SIZE_MIN = 64;
|
|
const ULONG CI_FILTER_BUFFER_SIZE_MAX = 1024;
|
|
|
|
#if 0
|
|
//
|
|
// Time in minutes between polling the system for new OFS drives to start
|
|
// filtering.
|
|
// Units: minutes
|
|
//
|
|
|
|
const ULONG CI_CHANGE_NOTIFICATION_INTERVAL_DEFAULT = 15;
|
|
const ULONG CI_CHANGE_NOTIFICATION_INTERVAL_MIN = 1;
|
|
const ULONG CI_CHANGE_NOTIFICATION_INTERVAL_MAX = 20;
|
|
#endif
|
|
|
|
//
|
|
// Number of attempts to filter a document.
|
|
//
|
|
//
|
|
|
|
const ULONG CI_FILTER_RETRIES_DEFAULT = 4;
|
|
const ULONG CI_FILTER_RETRIES_MIN = 1;
|
|
const ULONG CI_FILTER_RETRIES_MAX = 10;
|
|
|
|
//
|
|
// Number of attempts to filter a document in secondary Q.
|
|
//
|
|
//
|
|
|
|
const ULONG CI_SECQ_FILTER_RETRIES_DEFAULT = 10;
|
|
const ULONG CI_SECQ_FILTER_RETRIES_MIN = 0;
|
|
const ULONG CI_SECQ_FILTER_RETRIES_MAX = 32000; // long enough
|
|
|
|
//
|
|
// Interval between retries for filtering "open" documents.
|
|
// Units: minutes
|
|
//
|
|
const ULONG CI_FILTER_RETRY_INTERVAL_DEFAULT = 5;
|
|
const ULONG CI_FILTER_RETRY_INTERVAL_MIN = 1;
|
|
const ULONG CI_FILTER_RETRY_INTERVAL_MAX = 240;
|
|
|
|
//
|
|
// Filtering delay in case there are very few documents to be filtered. This
|
|
// will allow filtering more documents per call rather than 1 per call.
|
|
// Units: seconds
|
|
//
|
|
const ULONG CI_FILTER_DELAY_INTERVAL_DEFAULT = 20;
|
|
const ULONG CI_FILTER_DELAY_INTERVAL_MIN = 0;
|
|
const ULONG CI_FILTER_DELAY_INTERVAL_MAX = 600;
|
|
|
|
//
|
|
// If the number of un-filtered documents is below this threshold, a filtering
|
|
// delay will be introduced.
|
|
//
|
|
const ULONG CI_FILTER_REMAINING_THRESHOLD_DEFAULT = 32;
|
|
const ULONG CI_FILTER_REMAINING_THRESHOLD_MIN = 0;
|
|
const ULONG CI_FILTER_REMAINING_THRESHOLD_MAX = 320;
|
|
|
|
//
|
|
// If a filter has not been used in the below time, the daemon will ask if
|
|
// it can unload its DLL.
|
|
// Units: milliseconds
|
|
//
|
|
const ULONG CI_FILTER_IDLE_TIMEOUT_DEFAULT = 15 * 60 * 1000;
|
|
const ULONG CI_FILTER_IDLE_TIMEOUT_MIN = 0;
|
|
const ULONG CI_FILTER_IDLE_TIMEOUT_MAX = ~0;
|
|
|
|
//
|
|
// Min disk space available before a master merge is forced, thus freeing
|
|
// up disk space.
|
|
// Units: percentage of disk size
|
|
//
|
|
|
|
const ULONG CI_MIN_DISKFREE_FORCE_MERGE_DEFAULT = 15;
|
|
const ULONG CI_MIN_DISKFREE_FORCE_MERGE_MIN = 5;
|
|
const ULONG CI_MIN_DISKFREE_FORCE_MERGE_MAX = 25;
|
|
|
|
//
|
|
// Max disk free space consumed by shadow indexes before a master merge
|
|
// is forced, thus freeing up a significant portion of shadow index
|
|
// disk space.
|
|
// Units: percentage of disk free space
|
|
//
|
|
|
|
const ULONG CI_MAX_SHADOW_FREE_FORCE_MERGE_DEFAULT = 20;
|
|
const ULONG CI_MAX_SHADOW_FREE_FORCE_MERGE_MIN = 5;
|
|
const ULONG CI_MAX_SHADOW_FREE_FORCE_MERGE_MAX = ~0;
|
|
|
|
//
|
|
// Max combined size of shadow indexes before a master merge is forced.
|
|
// Units: percentage of disk space
|
|
//
|
|
|
|
const ULONG CI_MAX_SHADOW_INDEX_SIZE_DEFAULT = 15;
|
|
const ULONG CI_MAX_SHADOW_INDEX_SIZE_MIN = 5;
|
|
const ULONG CI_MAX_SHADOW_INDEX_SIZE_MAX = 25;
|
|
|
|
//
|
|
// Time to wait for a response from the CI daemon on a query status
|
|
// call.
|
|
// Units: minutes
|
|
//
|
|
const ULONG CI_DAEMON_RESPONSE_TIMEOUT_DEFAULT = 5;
|
|
const ULONG CI_DAEMON_RESPONSE_TIMEOUT_MIN = 1;
|
|
const ULONG CI_DAEMON_RESPONSE_TIMEOUT_MAX = 120;
|
|
|
|
//
|
|
// Maximum number of documents pending filtering before considering
|
|
// CI out-of-date for property queries.
|
|
// Units: documents
|
|
//
|
|
|
|
const ULONG CI_MAX_PENDING_DOCUMENTS_DEFAULT = 32;
|
|
const ULONG CI_MAX_PENDING_DOCUMENTS_MIN = 1;
|
|
const ULONG CI_MAX_PENDING_DOCUMENTS_MAX = 50000;
|
|
|
|
//
|
|
// Whether or not characterizations are generated and stored by default
|
|
// in the ci, and the max size in wide characters if they are generated.
|
|
//
|
|
|
|
const ULONG CI_MAX_CHARACTERIZATION_DEFAULT = 160;
|
|
const ULONG CI_MAX_CHARACTERIZATION_MIN = 0;
|
|
const ULONG CI_MAX_CHARACTERIZATION_MAX = 500;
|
|
|
|
//
|
|
// Determines whether characterizations should be generated at all. (Default: TRUE)
|
|
//
|
|
|
|
const ULONG CI_GENERATE_CHARACTERIZATION_DEFAULT = 1;
|
|
const ULONG CI_GENERATE_CHARACTERIZATION_MIN = 0;
|
|
const ULONG CI_GENERATE_CHARACTERIZATION_MAX = 1;
|
|
|
|
//
|
|
// Size of the property store mapped large pages cache (in physical storage)
|
|
// Units: pages
|
|
//
|
|
|
|
const ULONG CI_PROPERTY_STORE_MAPPED_CACHE_DEFAULT = 4;
|
|
const ULONG CI_PROPERTY_STORE_MAPPED_CACHE_MIN = 0;
|
|
const ULONG CI_PROPERTY_STORE_MAPPED_CACHE_MAX = ~0;
|
|
|
|
//
|
|
// The mode for backing off on scans
|
|
// 0 -- no backing off -- the original behavior
|
|
// 1 -- moderate backoff
|
|
// 10 -- aggressive backoff
|
|
// 11-20 -- reserved for special cases like battery power
|
|
|
|
const ULONG CI_SCAN_BACKOFF_DEFAULT = 3;
|
|
const ULONG CI_SCAN_BACKOFF_MIN = 0;
|
|
const ULONG CI_SCAN_BACKOFF_MAX_RANGE = 10;
|
|
const ULONG CI_SCAN_BACKOFF_MAX = 20;
|
|
|
|
//
|
|
// Number of OS pages to be backed up in the backup page
|
|
// Min filesize is 128 KB and max is 2 GB
|
|
//
|
|
|
|
#if defined (_X86_)
|
|
|
|
const ULONG CI_PROPERTY_STORE_BACKUP_SIZE_DEFAULT = 1024;
|
|
const ULONG CI_PROPERTY_STORE_BACKUP_SIZE_MIN = 32;
|
|
const ULONG CI_PROPERTY_STORE_BACKUP_SIZE_MAX = 500000;
|
|
|
|
;///////////////////// RISC ////////////////
|
|
#else
|
|
|
|
const ULONG CI_PROPERTY_STORE_BACKUP_SIZE_DEFAULT = 512;
|
|
const ULONG CI_PROPERTY_STORE_BACKUP_SIZE_MIN = 16;
|
|
const ULONG CI_PROPERTY_STORE_BACKUP_SIZE_MAX = 250000;
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// Maximum number of expanded restriction nodes in a single query
|
|
//
|
|
|
|
const ULONG CI_MAX_RESTRICTION_NODES_DEFAULT = 5000;
|
|
const ULONG CI_MAX_RESTRICTION_NODES_MIN = 1;
|
|
const ULONG CI_MAX_RESTRICTION_NODES_MAX = ~0;
|
|
|
|
//
|
|
// Whether CI should auto-alias (add fixups for net shares). (default TRUE)
|
|
//
|
|
|
|
const BOOL CI_IS_AUTO_ALIAS_DEFAULT = 1;
|
|
|
|
//
|
|
// Maximum refresh frequency for alias checks
|
|
// Units: Minutes
|
|
//
|
|
|
|
const ULONG CI_MAX_AUTO_ALIAS_REFRESH_DEFAULT = 15;
|
|
const ULONG CI_MAX_AUTO_ALIAS_REFRESH_MIN = 0;
|
|
const ULONG CI_MAX_AUTO_ALIAS_REFRESH_MAX = 10080; // 1 week
|
|
|
|
//
|
|
// Force path fixups in query results, default is FALSE
|
|
//
|
|
|
|
const ULONG CI_FORCE_PATH_ALIAS_DEFAULT = 0;
|
|
|
|
//
|
|
// Whether CI should index w3 vroots (default TRUE)
|
|
//
|
|
|
|
const BOOL CI_IS_INDEXING_W3_ROOTS_DEFAULT = 1;
|
|
|
|
//
|
|
// Whether CI should index nntp vroots (default FALSE)
|
|
//
|
|
|
|
const ULONG CI_IS_INDEXING_NNTP_ROOTS_DEFAULT = 0;
|
|
|
|
//
|
|
// Whether CI should index imap vroots (default FALSE)
|
|
//
|
|
|
|
const ULONG CI_IS_INDEXING_IMAP_ROOTS_DEFAULT = 0;
|
|
|
|
//
|
|
// Wether to auto-mount catalogs on the roots of removable drives (TRUE)
|
|
//
|
|
|
|
const ULONG CI_AUTO_MOUNT_CATALOGS_DEFAULT = 1;
|
|
|
|
//
|
|
// Whether directories should be filtered and returned in queries by default
|
|
//
|
|
const ULONG CI_FILTER_DIRECTORIES_DEFAULT = 1;
|
|
|
|
//
|
|
// Whether files with unknown extensions should be filtered by default
|
|
//
|
|
const ULONG CI_FILTER_FILES_WITH_UNKNOWN_EXTENSIONS_DEFAULT = 1;
|
|
|
|
//
|
|
// Flags that control type of events that are logged.
|
|
//
|
|
const ULONG CI_EVTLOG_FLAGS_UNKNOWN_CLASS = 0x00000001;
|
|
const ULONG CI_EVTLOG_FLAGS_FAILED_EMBEDDING = 0x00000002;
|
|
|
|
const ULONG CI_EVTLOG_FLAGS_DEFAULT = 0x00000002;
|
|
|
|
//
|
|
// Usn log parameters
|
|
//
|
|
const CI_MAX_USN_LOG_SIZE_DEFAULT = 0x800000; // Max size of usn log in bytes
|
|
const CI_USN_LOG_ALLOCATION_DELTA_DEFAULT = 0x100000; // Allocation/deallocation size in bytes
|
|
|
|
//
|
|
// Usn Log timeout. Wait until buffer is full or this many seconds since call.
|
|
//
|
|
|
|
const ULONG CI_USN_READ_TIMEOUT_DEFAULT = 1 * 60; // 1 minute
|
|
const ULONG CI_USN_READ_TIMEOUT_MIN = 0;
|
|
const ULONG CI_USN_READ_TIMEOUT_MAX = 12 * 60 * 60; // 12 hours
|
|
|
|
//
|
|
// Usn Log minimum read size. Wait until at least this many bytes in the log
|
|
// before returning.
|
|
//
|
|
|
|
const ULONG CI_USN_READ_MIN_SIZE_DEFAULT = 4 * 1024;
|
|
const ULONG CI_USN_READ_MIN_SIZE_MIN = 1;
|
|
const ULONG CI_USN_READ_MIN_SIZE_MAX = 512 * 1024;
|
|
|
|
//
|
|
// Determines whether USN read should be delayed when machine is busy. Default: TRUE
|
|
//
|
|
|
|
const BOOL CI_DELAY_USN_READ_ON_LOW_RESOURCE_DEFAULT = TRUE;
|
|
|
|
//
|
|
// Files with last access times older than this don't have their last access times modified
|
|
// by the filter daemon. This is parameterized becuase there is a cost, both in terms
|
|
// of extra downlevel notifications and extra USN records when last access time is reset
|
|
// by the daemon.
|
|
// Units: Days
|
|
//
|
|
|
|
const ULONG CI_STOMP_LAST_ACCESS_DELAY_DEFAULT = 7;
|
|
const ULONG CI_STOMP_LAST_ACCESS_DELAY_MIN = 0;
|
|
const ULONG CI_STOMP_LAST_ACCESS_DELAY_MAX = 1000000000; // Don't overflow 64-bit FILETIME
|
|
|
|
//
|
|
// Minimim amount of battery life required to keep filtering running.
|
|
// Units: Percent of battery life remaining. 0 --> Always run.
|
|
//
|
|
|
|
const ULONG CI_MIN_WORDLIST_BATTERY_DEFAULT = 100; // Never filter on batteries
|
|
const ULONG CI_MIN_WORDLIST_BATTERY_MIN = 0;
|
|
const ULONG CI_MIN_WORDLIST_BATTERY_MAX = 100;
|
|
|
|
//
|
|
// User idle time required to keep filtering running.
|
|
// Units: seconds 0 --> Always run.
|
|
//
|
|
|
|
const ULONG CI_WORDLIST_USER_IDLE_DEFAULT = 120;
|
|
const ULONG CI_WORDLIST_USER_IDLE_MIN = 0;
|
|
const ULONG CI_WORDLIST_USER_IDLE_MAX = 1200;
|
|
|
|
//
|
|
// Maximum amount of pagefile space consumed by out-of-process filter daemon.
|
|
// Allocations beyond this limit will fail.
|
|
// Units: KB
|
|
//
|
|
|
|
const ULONG CI_MAX_DAEMON_VM_USE_DEFAULT = 40 * 1024; // Big, but shouldn't kill the machine
|
|
const ULONG CI_MAX_DAEMON_VM_USE_MIN = 10 * 1024; // 10 Mb
|
|
const ULONG CI_MAX_DAEMON_VM_USE_MAX = 0x3FFFFF; // Avoid overflow when converted to bytes
|
|
|
|
//
|
|
// Flags for miscellaneous use - internal only.
|
|
//
|
|
const ULONG CI_MISC_FLAGS_DONT_FILTER = 0x00000001;
|
|
const ULONG CI_MISC_FLAGS_NO_QUERIES = 0x00000002;
|
|
|
|
const ULONG CI_MISC_FLAGS_DEFAULT = 0x00000000;
|
|
|
|
//
|
|
// Maximum portion of a file with a well-known extenstion the text filter
|
|
// will index. Default is 25 meg.
|
|
//
|
|
|
|
const ULONG CI_MAX_TEXT_FILTER_BYTES_DEFAULT = 1024 * 1024 * 25;
|
|
const ULONG CI_MAX_TEXT_FILTER_BYTES_MIN = 1;
|
|
const ULONG CI_MAX_TEXT_FILTER_BYTES_MAX = ~0;
|
|
|
|
//
|
|
// Flags for Content Index Use
|
|
//
|
|
|
|
//
|
|
// Set this flag to turn off notifications on all remote roots.
|
|
//
|
|
const ULONG CI_FLAGS_NO_REMOTE_NOTIFY = 0x00000001;
|
|
|
|
//
|
|
// Set this flag to turn off notifications on all local roots.
|
|
//
|
|
const ULONG CI_FLAGS_NO_LOCAL_NOTIFY = 0x00000002;
|
|
|
|
const ULONG CI_FLAGS_DEFAULT = 0x00000000;
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
//+ Internal parameters (not even in registry) +
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
//
|
|
// Priority of the filter daemon and merge thread. Only class of
|
|
// filter daemon is controlled via registry.
|
|
//
|
|
|
|
const int CI_THREAD_PRIORITY_FILTER_DEFAULT = THREAD_PRIORITY_ABOVE_NORMAL;
|
|
const int CI_THREAD_PRIORITY_MERGE_DEFAULT = THREAD_BASE_PRIORITY_MIN;
|
|
|
|
//
|
|
// Maximum number of documents to be filtered at once and put
|
|
// into a single wordlist. Cannot be > 16 given current
|
|
// wordlist compression scheme.
|
|
//
|
|
|
|
const ULONG CI_MAX_DOCS_IN_WORDLIST = 16;
|
|
|
|
//
|
|
// Content index version. Increment both current_index_version and
|
|
// fsci_version when a change is made that will affect all framework
|
|
// client, but increment fsci_version only when changes are made to
|
|
// data structures such as property store that are used only by the
|
|
// File System client. Site Server Search also uses these, but they
|
|
// are not always using the same versions as the fsci is.
|
|
//
|
|
// For example, FSCI moved to a two-level store in Dec '97 but Site
|
|
// Server Search will remain with the older single level store for the
|
|
// 3.0 release.
|
|
//
|
|
|
|
//
|
|
// INDEX_VERSION HISTORY:
|
|
//
|
|
// Version Date Change
|
|
// ------- -------- ----------------------------------------------------------
|
|
// 1 Original
|
|
// 10 06/11/97 USN Support
|
|
// 11 07/01/97 Parent WorkId
|
|
// 30 07/18/97 Property Store Backup
|
|
// 31 08/06/97 64-bit file ids
|
|
// 32 09/21/97 File id hash function change
|
|
// 33 09/29/97 Scope checking fix
|
|
// 34 12/16/97 Size/Performance changes
|
|
// 35 01/26/98 Added signatures at beginning/end of index pages.
|
|
// 36 02/26/98 Changed directory format to fit count in 1 byte
|
|
// 37 04/14/98 Added SecondaryQ Retry Count for documents
|
|
// 38 05/27/98 Added checksums to all recoverable stream records
|
|
// 39 06/23/98 Changed the way variable records are written
|
|
// 3A 08/11/98 Changed .dir files to support ro catalogs during MM
|
|
// 3B 01/04/99 dlee Changed cicat.hsh and cicat.fid hash chaining
|
|
|
|
//
|
|
// FSCI_VERSION HISTORY:
|
|
//
|
|
// Version Date Change
|
|
// ------- -------- ----------------------------------------------------------
|
|
// 34 12/02/97 2 level property store
|
|
// 35 12/16/97 Size/Performance changes
|
|
// 36 12/30/97 Lean primary store
|
|
// 37 01/08/98 Move file index to primary store
|
|
// 38 02/02/98 Move attrib to primary store
|
|
// 39 04/10/98 Track volume id for NTFS v5 volumes
|
|
// 3A 05/27/98 Added checksums to all recoverable stream records
|
|
// 3B 06/01/98 Changed the way variable records are written
|
|
// 3C 08/11/98 Changed .dir files to support ro catalogs during MM
|
|
// 3D 01/04/99 dlee Changed cicat.hsh and cicat.fid hash chaining
|
|
//
|
|
|
|
const ULONG CURRENT_INDEX_VERSION = 0x3B; // PLEASE CHANGE HISTORY ABOVE
|
|
const ULONG CURRENT_FSCI_VERSION = 0x3D; // PLEASE CHANGE HISTORY ABOVE
|
|
|
|
const ULONG CURRENT_VERSION_STAMP = (CURRENT_INDEX_VERSION << 16);
|
|
const ULONG FSCI_VERSION_STAMP = (CURRENT_FSCI_VERSION << 16);
|
|
|
|
//
|
|
// 64K common page size for memory mapped streams
|
|
//
|
|
|
|
const ULONG COMMON_PAGE_SIZE = 0x10000L;
|
|
|
|
// This is 4 Kb == 2^12
|
|
const ULONG CI_PAGE_SIZE = 0x1000;
|
|
const ULONG CI_PAGE_SHIFT = 12;
|
|
|
|
//
|
|
// Size of page in DWORDs. Missing two DWORDs for signatures.
|
|
//
|
|
|
|
const ULONG SMARTBUF_PAGE_SIZE_IN_DWORDS = CI_PAGE_SIZE / sizeof(DWORD) - 2;
|
|
const ULONG SMARTBUF_PAGE_SIZE_IN_BITS = SMARTBUF_PAGE_SIZE_IN_DWORDS * 8 * sizeof(DWORD);
|
|
|
|
// This is 64 b == 2^6
|
|
//const ULONG CI_PAGE_SIZE = 64; // For testing
|
|
//const ULONG CI_PAGE_SHIFT = 6; // For testing
|
|
|
|
const ULONG PAGES_PER_COMMON_PAGE = (COMMON_PAGE_SIZE/CI_PAGE_SIZE);
|
|
|
|
//
|
|
// Maximum file size for which the contents will be filtered. Files
|
|
// larger than this will have only their properities included in the CI.
|
|
// Units: KBytes
|
|
//
|
|
|
|
const ULONG CI_MAX_FILESIZE_FILTERED_DEFAULT = 256;
|
|
|
|
//
|
|
// Use Cairo/Daytona for binding
|
|
//
|
|
|
|
const BOOL CI_USE_OLE_DEFAULT = TRUE;
|
|
|
|
|
|
//
|
|
// Default IP address for the default virtual server.
|
|
//
|
|
const CI_DEFAULT_IP_ADDRESS = ~0;
|
|
|
|
//
|
|
// Default is a catalog is active
|
|
//
|
|
|
|
const ULONG CI_CATALOG_INACTIVE_DEFAULT = 0;
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CCiRegVars
|
|
//
|
|
// Purpose: Registry variables used by CI
|
|
//
|
|
// Notes: Does not include registry params used by IDQ, Webhits or
|
|
// other client-side only functionality.
|
|
//
|
|
// History 10-11-96 dlee Created from user+kernel params
|
|
// 02-04-98 kitmanh Added _fIsReadOnly
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CCiRegVars
|
|
{
|
|
|
|
public:
|
|
|
|
void SetDefault();
|
|
|
|
ULONG _maxMergeInterval; // Sleep time between merges
|
|
int _threadPriorityMerge; // Priority of merge thread
|
|
ULONG _maxUpdates; // Max # of updates passed by catalog
|
|
ULONG _maxWordlists; // Max # of word lists that can exist
|
|
ULONG _minSizeMergeWordlist; // Min combined size of wordlists
|
|
ULONG _maxWordlistSize; // Max size at which docs can be added
|
|
ULONG _minWordlistMemory; // Min free mem for wordlist creation
|
|
ULONG _maxWordlistIo; // User I/O has to be below this for wordlist creation
|
|
ULONG _maxWordlistIoDiskPerf; // User I/O has to be below this for wordlist creation
|
|
ULONG _minWordlistBattery; // Min remaining batter for wordlist creation
|
|
ULONG _WordlistUserIdle; // User idle time for wordlist creation
|
|
ULONG _ResourceCheckInterval; // Low memory / high I/O are checked at most this often.
|
|
ULONG _maxFreshDeletes; // Max # of uncommitted deletes in fresh list
|
|
ULONG _lowResourceSleep; // Time to wait after low resource condition
|
|
ULONG _maxWordlistMemoryLoad; // Max mem load for wordlist creation
|
|
ULONG _maxFreshCount; // Max fresh list entries before mmerge
|
|
ULONG _maxQueueChunks; // # of chunks in in-memory change list
|
|
ULONG _masterMergeCheckpointInterval; // # of bytes to process before Checkpointing
|
|
ULONG _filterRetries; // # of attempts to filter a document
|
|
ULONG _secQFilterRetries; // # of attempts to filter a document in Sec. Q
|
|
ULONG _filterRetryInterval; // # of minutes between retrying an open doc
|
|
ULONG _maxShadowIndexSize; // Max combined size of shadow indexes
|
|
ULONG _minDiskFreeForceMerge; // Min disk free before a mmerge is forced
|
|
ULONG _maxShadowFreeForceMerge; // Max space for shadow indexes (% free space)
|
|
ULONG _maxIndexes; // Maximum number of indexes (persistent or wordlist)
|
|
ULONG _maxIdealIndexes; // Maximum number of indexes in an 'ideal' system.
|
|
ULONG _minMergeIdleTime; // Minumum idle time to perform annealing merge.
|
|
ULONG _maxPendingDocuments; // Max pending docs for property queries
|
|
ULONG _minIdleQueryThreads; // Min number of idle query threads to maintain
|
|
ULONG _maxActiveQueryThreads; // Maximum number of query threads to allow
|
|
ULONG _maxQueryTimeslice; // Query timeslice (if waiting queries)
|
|
ULONG _maxQueryExecutionTime; // Maximum query execution time (if waiting queries)
|
|
ULONG _evtLogFlags; // Flags for event log
|
|
ULONG _miscCiFlags; // Miscellaneous CI Flags
|
|
ULONG _ciCatalogFlags; // CI external flags
|
|
ULONG _maxRestrictionNodes; // Maximum normalized restriction nodes
|
|
ULONG _minIdleRequestThreads; // Min number of idle request threads to maintain
|
|
ULONG _minClientIdleTime; // Minimum client idle time after which it can be disconnected.
|
|
ULONG _maxActiveRequestThreads; // Maximum number of request threads to allow
|
|
ULONG _maxSimultaneousRequests; // Maximum number of simultaneous client/server connections
|
|
ULONG _maxCachedPipes; // Maximum number of cached pipe instances
|
|
ULONG _requestTimeout; // Milliseconds after which clients timeout
|
|
BOOL _fIsAutoAlias; // TRUE if fixups should be automatically added for net shares
|
|
ULONG _maxAutoAliasRefresh; // Time between net share polls
|
|
ULONG _W3SvcInstance; // W3SVC Instance ID
|
|
ULONG _NNTPSvcInstance; // NNTP Instance ID
|
|
ULONG _IMAPSvcInstance; // IMAP Instance ID
|
|
BOOL _fIsIndexingW3Roots; // TRUE if should index w3 vroots
|
|
BOOL _fIsIndexingNNTPRoots; // TRUE if should index nntp vroots
|
|
BOOL _fIsIndexingIMAPRoots; // TRUE if should index imap vroots
|
|
BOOL _fMinimizeWorkingSet; // if TRUE, minimize WS when idle
|
|
BOOL _fIsReadOnly; // Catalogs are in read-only mode
|
|
BOOL _fIsEnumAllowed; // Flag to perform enumeration
|
|
BOOL _fForcePathAlias; // If TRUE, query result paths are fixed up
|
|
ULONG _minDiskSpaceToLeave; // Number of megabytes to leave on disk
|
|
|
|
BOOL _useOle; // Use OLE for filtering
|
|
ULONG _filterBufferSize; // Buffer size for filtering
|
|
BOOL _filterContents; // Should the daemon filter contents?
|
|
ULONG _filterDelayInterval; // Number of seconds the filter should delay
|
|
// in case there are few documents.
|
|
ULONG _filterRemainingThreshold;
|
|
// The number of unfiltered documents below
|
|
// which a delay will be introduced.
|
|
ULONG _maxFilesizeFiltered; // Maximum filesize filtered
|
|
ULONG _masterMergeTime; // Time for queue master merge
|
|
ULONG _maxFilesizeMultiplier; // Largest amount of data from single file
|
|
int _threadPriorityFilter; // Priority of update/filter thread
|
|
int _threadClassFilter; // Priority class of update/filter thread
|
|
ULONG _daemonResponseTimeout; // Timeout waiting for response
|
|
ULONG _maxCharacterization; // Max size in cwc of a characterization
|
|
BOOL _fFilterDirectories; // Should queries return directories?
|
|
BOOL _fFilterFilesWithUnknownExtensions; // Should files with unknown(to IFilter) extensions be filtered ?
|
|
BOOL _fCatalogInactive; // TRUE if the catalog shouldn't be auto-loaded
|
|
ULONG _maxPropertyStoreMappedCache; // # of mapped large pages cached in primary
|
|
ULONG _maxPropertyStoreBackupSize; // # of backed up OS pages in primary
|
|
ULONG _maxSecPropertyStoreMappedCache; // # of mapped large pages cached in secondary
|
|
ULONG _maxSecPropertyStoreBackupSize; // # of backed up OS pages in secondary
|
|
ULONG _forcedNetPathScanInterval; // Number of minutes for forced net path scans
|
|
ULONG _maxUsnLogSize; // Max size of usn log in bytes
|
|
ULONG _usnLogAllocationDelta; // Allocation/deallocation size in bytes
|
|
ULONG _ulScanBackoff; // Mode for backing off on scans
|
|
ULONG _ulStartupDelay; // Delay in MS after boot
|
|
ULONG _ulUsnReadTimeout; // Max wait in MS for Usn log data
|
|
ULONG _ulUsnReadMinSize; // Wait until timeout or this many bytes
|
|
ULONG _fDelayUsnReadOnLowResource; // TRUE --> Don't read USN Journal during high i/o, low memory
|
|
ULONG _maxDaemonVmUse; // Max amount of pagefile used by OOP daemon
|
|
ULONG _ulStompLastAccessDelay; // Files accessed more recently than this delta are not reset
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CCiRegParams
|
|
//
|
|
// Purpose: Registry variables used by CI
|
|
//
|
|
// History 10-11-96 dlee Created from user+kernel params
|
|
// 02-04-98 kitmanh Added IsReadOnly()
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CRegAccess;
|
|
|
|
class CCiRegParams : public CCiRegVars
|
|
{
|
|
public :
|
|
|
|
CCiRegParams( const WCHAR * pwcName = 0 );
|
|
|
|
void Refresh( ICiAdminParams * pICiAdminParams = 0,
|
|
BOOL fUseDefaultsOnFailure = FALSE );
|
|
|
|
const BOOL UseOle() { return _useOle; }
|
|
const BOOL FilterContents() { return _filterContents; }
|
|
const ULONG GetMasterMergeTime() { return _masterMergeTime; }
|
|
const ULONG GetMaxFilesizeMultiplier() { return _maxFilesizeMultiplier; }
|
|
|
|
const int GetThreadPriorityFilter() { return _threadPriorityFilter; }
|
|
const int GetThreadClassFilter() { return _threadClassFilter; }
|
|
const ULONG GetDaemonResponseTimeout() { return _daemonResponseTimeout; }
|
|
|
|
const BOOL GetGenerateCharacterization() { return (0 != _maxCharacterization); }
|
|
const ULONG GetMaxCharacterization() { return _maxCharacterization; }
|
|
const BOOL IsAutoAlias() { return _fIsAutoAlias; }
|
|
const ULONG MaxAutoAliasRefresh() { return _maxAutoAliasRefresh; }
|
|
|
|
const BOOL IsIndexingW3Roots() { return _fIsIndexingW3Roots; }
|
|
const BOOL IsIndexingIMAPRoots() { return _fIsIndexingIMAPRoots; }
|
|
const BOOL IsIndexingNNTPRoots() { return _fIsIndexingNNTPRoots; }
|
|
const BOOL IsReadOnly() { return _fIsReadOnly; }
|
|
|
|
const BOOL IsEnumAllowed() { return _fIsEnumAllowed; }
|
|
const BOOL FilterDirectories() { return _fFilterDirectories; }
|
|
const BOOL FilterFilesWithUnknownExtensions() { return _fFilterFilesWithUnknownExtensions; }
|
|
const ULONG GetPrimaryStoreMappedCache() { return _maxPropertyStoreMappedCache; }
|
|
|
|
const ULONG GetSecondaryStoreMappedCache() { return _maxSecPropertyStoreMappedCache; }
|
|
const ULONG GetMaxFilesizeFiltered() { return _maxFilesizeFiltered; }
|
|
const ULONG GetPrimaryStoreBackupSize() { return _maxPropertyStoreBackupSize; }
|
|
const ULONG GetSecondaryStoreBackupSize() { return _maxSecPropertyStoreBackupSize; }
|
|
|
|
void SetPrimaryStoreMappedCache(ULONG ulVal) { _maxPropertyStoreMappedCache = ulVal; }
|
|
void SetPrimaryStoreBackupSize(ULONG ulVal) { _maxPropertyStoreBackupSize = ulVal; }
|
|
void SetSecondaryStoreMappedCache(ULONG ulVal) { _maxPropertyStoreMappedCache = ulVal; }
|
|
void SetSecondaryStoreBackupSize(ULONG ulVal) { _maxSecPropertyStoreBackupSize = ulVal; }
|
|
|
|
const BOOL GetCatalogInactive() { return _fCatalogInactive; }
|
|
const BOOL GetForcePathAlias() const { return _fForcePathAlias; }
|
|
const ULONG GetForcedNetPathScanInterval() { return _forcedNetPathScanInterval; }
|
|
const ULONG GetFilterDelayInterval() { return _filterDelayInterval; }
|
|
const ULONG GetFilterRemainingThreshold() { return _filterRemainingThreshold; }
|
|
|
|
const ULONG GetMaxMergeInterval() { return _maxMergeInterval; }
|
|
const int GetThreadPriorityMerge() { return _threadPriorityMerge; }
|
|
const ULONG GetMaxUpdates() { return _maxUpdates; }
|
|
const ULONG GetMaxWordlists() { return _maxWordlists; }
|
|
|
|
const ULONG GetMinSizeMergeWordlist() { return _minSizeMergeWordlist; }
|
|
const ULONG GetMaxWordlistSize() { return _maxWordlistSize; }
|
|
const ULONG GetMinWordlistMemory() { return _minWordlistMemory; }
|
|
const ULONG GetMaxWordlistIo() { return _maxWordlistIo; }
|
|
|
|
const ULONG GetMaxWordlistIoDiskPerf() { return _maxWordlistIoDiskPerf; }
|
|
const ULONG GetMinWordlistBattery() { return _minWordlistBattery; }
|
|
const ULONG GetWordlistUserIdle() { return _WordlistUserIdle; }
|
|
const ULONG GetResourceCheckInterval() { return _ResourceCheckInterval; }
|
|
|
|
const ULONG GetMaxFreshDeletes() { return _maxFreshDeletes; }
|
|
const ULONG GetLowResourceSleep() { return _lowResourceSleep; }
|
|
const ULONG GetMaxWordlistMemoryLoad() { return _maxWordlistMemoryLoad; }
|
|
const ULONG GetMaxFreshCount() { return _maxFreshCount; }
|
|
|
|
const ULONG GetMaxQueueChunks() { return _maxQueueChunks; }
|
|
const ULONG GetMasterMergeCheckpointInterval() { return _masterMergeCheckpointInterval; }
|
|
const ULONG GetFilterBufferSize() { return _filterBufferSize; }
|
|
const ULONG GetFilterRetries() { return _filterRetries; }
|
|
|
|
const ULONG GetSecQFilterRetries() { return _secQFilterRetries; }
|
|
const ULONG GetFilterRetryInterval() { return _filterRetryInterval; }
|
|
const ULONG GetMaxShadowIndexSize() { return _maxShadowIndexSize; }
|
|
const ULONG GetMinDiskFreeForceMerge() { return _minDiskFreeForceMerge; }
|
|
|
|
const ULONG GetMaxShadowFreeForceMerge() { return _maxShadowFreeForceMerge; }
|
|
const ULONG GetMaxIndexes() { return _maxIndexes; }
|
|
const ULONG GetMaxIdealIndexes() { return _maxIdealIndexes; }
|
|
const ULONG GetMinMergeIdleTime() { return _minMergeIdleTime; }
|
|
|
|
const ULONG GetMaxPendingDocuments() { return _maxPendingDocuments; }
|
|
const ULONG GetMinIdleQueryThreads() { return _minIdleQueryThreads; }
|
|
const ULONG GetMaxActiveQueryThreads() { return _maxActiveQueryThreads; }
|
|
const ULONG GetMaxQueryTimeslice() { return _maxQueryTimeslice; }
|
|
|
|
const ULONG GetMaxQueryExecutionTime() { return _maxQueryExecutionTime; }
|
|
const ULONG GetMinIdleRequestThreads() { return _minIdleRequestThreads; }
|
|
const ULONG GetMinClientIdleTime() { return _minClientIdleTime; }
|
|
const ULONG GetMaxActiveRequestThreads() { return _maxActiveRequestThreads; }
|
|
|
|
const ULONG GetMaxSimultaneousRequests() { return _maxSimultaneousRequests; }
|
|
const ULONG GetMaxCachedPipes() { return _maxCachedPipes; }
|
|
const ULONG GetRequestTimeout() { return _requestTimeout; }
|
|
const ULONG GetW3SvcInstance() { return _W3SvcInstance; }
|
|
|
|
const ULONG GetNNTPSvcInstance() { return _NNTPSvcInstance; }
|
|
const ULONG GetIMAPSvcInstance() { return _IMAPSvcInstance; }
|
|
const BOOL GetMinimizeWorkingSet() { return _fMinimizeWorkingSet; }
|
|
const ULONG GetEventLogFlags() { return _evtLogFlags; }
|
|
|
|
const ULONG GetMiscCiFlags() { return _miscCiFlags; }
|
|
const ULONG GetCiCatalogFlags() { return _ciCatalogFlags; }
|
|
const ULONG GetMaxRestrictionNodes() { return _maxRestrictionNodes; }
|
|
const ULONG GetMaxUsnLogSize() { return _maxUsnLogSize; }
|
|
|
|
const ULONG GetUsnLogAllocationDelta() { return _usnLogAllocationDelta; }
|
|
const ULONG GetScanBackoff() { return _ulScanBackoff; }
|
|
const ULONG GetStartupDelay() { return _ulStartupDelay; }
|
|
const ULONG GetUsnReadTimeout() { return _ulUsnReadTimeout; }
|
|
|
|
const ULONG GetUsnReadMinSize() { return _ulUsnReadMinSize; }
|
|
const BOOL DelayUsnReadOnLowResource() { return _fDelayUsnReadOnLowResource; }
|
|
const ULONG GetMaxDaemonVmUse() { return _maxDaemonVmUse; }
|
|
const ULONG GetStompLastAccessDelay() { return _ulStompLastAccessDelay; }
|
|
const ULONG GetMinDiskSpaceToLeave() {return _minDiskSpaceToLeave; }
|
|
|
|
private:
|
|
|
|
void _ReadValues( CRegAccess & reg, CCiRegVars & vars );
|
|
void _ReadAndOverrideValues( CRegAccess & reg );
|
|
void _StoreCIValues ( CCiRegVars & vars, ICiAdminParams * pICiAdminParams );
|
|
void _StoreNewValues( CCiRegVars & vars );
|
|
void _OverrideForCatalog();
|
|
|
|
static void _CheckNamedValues();
|
|
|
|
CMutexSem _mutex; // Used to serialize access
|
|
XArray<WCHAR> _xOverrideName;
|
|
static const CI_ADMIN_PARAMS _aParamNames[CI_AP_MAX_VAL];
|
|
};
|
|
|
|
void BuildRegistryScopesKey( XArray<WCHAR> & xKey, WCHAR const *pwcName );
|
|
void BuildRegistryPropertiesKey( XArray<WCHAR> & xKey, WCHAR const *pwcName );
|
|
|
|
ULONG GetMaxCatalogs();
|
|
|