storage.proto

syntax = "proto2";

package NCloud.NFileStore.NProto;

import "cloud/filestore/public/api/protos/node.proto";
import "cloud/storage/core/protos/authorization_mode.proto";
import "cloud/storage/core/protos/certificate.proto";
import "cloud/storage/core/protos/config_dispatcher_settings.proto";

option go_package = "github.com/ydb-platform/nbs/cloud/filestore/config";

////////////////////////////////////////////////////////////////////////////////

enum EBlobIndexOpsPriority
{
    BIOP_CLEANUP_FIRST = 0;
    BIOP_COMPACTION_FIRST = 1;
    BIOP_FAIR = 2;
}

enum EGuestCachingType
{
    // No caching is allowed, every CreateHandle forces a guest page cache
    // invalidation
    GCT_NONE = 0;
    // The second RDONLY open call will be allowed not to invalidate the guest
    // page cache if there are no other write handles and mtime of the file
    // has not been changed since the last cache invalidation within a given
    // session
    GCT_SECOND_READ = 1;
    // Same as GCT_SECOND_READ but the first RDONLY open call is also allowed
    // to use the cache if the conditions regarding the write handles and
    // mtime are met
    GCT_ANY_READ = 2;
}

enum EShardBalancerPolicy
{
    // Shard balancer will use round robin policy and periodically reset the
    // round robin pointer to the least loaded shard.
    SBP_ROUND_ROBIN = 0;

    // Shard balancer will randomly select a shard from the list of shards
    // that have enough free space for a new file.
    SBP_RANDOM = 1;

    // Shard balancer will randomly select a shard from the list of shards
    // that have enough free space for a new file. The probability of
    // selecting a shard is proportional to the amount of free space
    // available on the shard.
    SBP_WEIGHTED_RANDOM = 2;

    // Shard balancer prefers shards with more free space
    // and operates deterministically.
    SBP_WEIGHTED_DETERMINISTIC = 3;
}

////////////////////////////////////////////////////////////////////////////////
//
//  !!!IMPORTANT!!!
//  Even though StorageConfig is usually stored in textual format, it may be
//  overridden for some tablets and in this case it's stored in binary format
//  in the tablet's localdb. So binary backward-compatibility should be
//  maintained.
//
////////////////////////////////////////////////////////////////////////////////

message TStorageConfig
{
    // Schemeshard directory for tablets.
    optional string SchemeShardDir = 1;

    // Number of reties before pipe client reports failure.
    optional uint32 PipeClientRetryCount = 2;

    // Minimum timeout before pipe client reconnect attempt.
    optional uint32 PipeClientMinRetryTime = 3;

    // Maximum timeout before pipe client reconnect attempt.
    optional uint32 PipeClientMaxRetryTime = 4;

    // Timeout before automatically removing session.
    optional uint32 IdleSessionTimeout = 5;

    // Timeout for establishing session.
    optional uint32 EstablishSessionTimeout = 6;

    // Obsolete.
    optional bool WriteBatchEnabled = 7 [deprecated = true];

    // Obsolete.
    optional uint32 WriteBatchTimeout = 8 [deprecated = true];

    // Minimum write request size (in bytes) that lets us write the data
    // directly to blobstorage (as a mixed/merged blob).
    optional uint32 WriteBlobThreshold = 9;

    // The size of data (in bytes) in the fresh blocks table that triggers
    // flushing.
    optional uint32 FlushThreshold = 10;

    // Thresholds for background ops.
    optional uint32 CleanupThreshold = 11;
    optional uint32 CompactionThreshold = 12;
    optional uint32 CollectGarbageThreshold = 13;

    // The size of data (in bytes) in the fresh bytes table that triggers
    // flushing.
    optional uint64 FlushBytesThreshold = 14;

    // Size of allocation unit for HDD drives (in GiB).
    optional uint32 AllocationUnitHDD = 15;

    // Size of allocation unit for SSD drives (in GiB).
    optional uint32 AllocationUnitSSD = 16;

    // Channel configuration for HDD.
    optional string HDDSystemChannelPoolKind = 17;
    optional string HDDLogChannelPoolKind = 18;
    optional string HDDIndexChannelPoolKind = 19;
    optional string HDDFreshChannelPoolKind = 20;
    optional string HDDMixedChannelPoolKind = 21;

    // Channel configuration for SSD.
    optional string SSDSystemChannelPoolKind = 22;
    optional string SSDLogChannelPoolKind = 23;
    optional string SSDIndexChannelPoolKind = 24;
    optional string SSDFreshChannelPoolKind = 25;
    optional string SSDMixedChannelPoolKind = 26;

    // Performance per allocation unit for HDD.
    optional uint32 HDDUnitReadBandwidth = 27;    // in MiB/s
    optional uint32 HDDUnitWriteBandwidth = 28;   // in MiB/s
    optional uint32 HDDMaxReadBandwidth = 29;     // in MiB/s
    optional uint32 HDDMaxWriteBandwidth = 30;    // in MiB/s
    optional uint32 HDDUnitReadIops = 31;
    optional uint32 HDDUnitWriteIops = 32;
    optional uint32 HDDMaxReadIops = 33;
    optional uint32 HDDMaxWriteIops = 34;

    // Performance per allocation unit for SSD.
    optional uint32 SSDUnitReadBandwidth = 35;    // in MiB/s
    optional uint32 SSDUnitWriteBandwidth = 36;   // in MiB/s
    optional uint32 SSDMaxReadBandwidth = 37;     // in MiB/s
    optional uint32 SSDMaxWriteBandwidth = 38;    // in MiB/s
    optional uint32 SSDUnitReadIops = 39;
    optional uint32 SSDUnitWriteIops = 40;
    optional uint32 SSDMaxReadIops = 41;
    optional uint32 SSDMaxWriteIops = 42;

    // Minumal channels count for the tablet configuration.
    optional uint32 MinChannelCount = 43;

    // Maximum number of bytes in response.
    optional uint32 MaxResponseBytes = 44;

    // Channel configuration for Hybrid.
    optional string HybridSystemChannelPoolKind = 45;
    optional string HybridLogChannelPoolKind = 46;
    optional string HybridIndexChannelPoolKind = 47;
    optional string HybridFreshChannelPoolKind = 48;
    optional string HybridMixedChannelPoolKind = 49;

    // Override storage media kind for too slow HDD.
    optional uint32 HDDMediaKindOverride = 50;

    // Nodes limit & ratio for the filesystem.
    optional uint32 DefaultNodesLimit = 51;
    optional uint32 SizeToNodesRatio = 52;

    // Do not allow to start tablets on specific nodes.
    optional bool DisableLocalService = 53;

    // Number of last request ids kept per session for deduplicate cache.
    optional uint32 DupCacheEntryCount = 54;

    // Process no more than this number of new/garbage blobs per one
    // DeleteGarbage tx.
    optional uint32 MaxDeleteGarbageBlobsPerTx = 55;

    // Do run CollectGarbage at start.
    optional bool EnableCollectGarbageAtStart = 56;

    // Enables persistent backup for tablet boot infos.
    optional string TabletBootInfoBackupFilePath = 57;
    // In fallback mode, all requests to Hive are served from cache.
    optional bool HiveProxyFallbackMode = 58;

    // Thresholds which enable backpressure.
    optional uint32 FlushThresholdForBackpressure = 59;
    optional uint32 CleanupThresholdForBackpressure = 60;
    optional uint32 CompactionThresholdForBackpressure = 61;
    optional uint64 FlushBytesThresholdForBackpressure = 62;

    // Threshold for blob size in bytes.
    optional uint32 MaxBlobSize = 63;

    // Enable file system throttling.
    optional bool ThrottlingEnabled = 64;

    // Max blocks count for a single truncate tx.
    optional uint32 MaxBlocksPerTruncateTx = 65;
    optional uint32 MaxTruncateTxInflight = 66;

    // Maximum number of entries in response.
    optional uint32 MaxResponseEntries = 67;

    // Performance profile configuration for SSD.
    optional bool SSDThrottlingEnabled = 68;
    optional uint32 SSDBoostTime = 69;         // in ms
    optional uint32 SSDBoostRefillTime = 70;   // in ms
    optional uint32 SSDUnitBoost = 71;
    optional uint32 SSDBurstPercentage = 72;
    optional uint32 SSDDefaultPostponedRequestWeight = 73;
    optional uint32 SSDMaxPostponedWeight = 74;
    optional uint32 SSDMaxWriteCostMultiplier = 75;
    optional uint32 SSDMaxPostponedTime = 76;   // in ms
    optional uint32 SSDMaxPostponedCount = 77;

    // Performance profile configuration for HDD.
    optional bool HDDThrottlingEnabled = 78;
    optional uint32 HDDBoostTime = 79;         // in ms
    optional uint32 HDDBoostRefillTime = 80;   // in ms
    optional uint32 HDDUnitBoost = 81;
    optional uint32 HDDBurstPercentage = 82;
    optional uint32 HDDDefaultPostponedRequestWeight = 83;
    optional uint32 HDDMaxPostponedWeight = 84;
    optional uint32 HDDMaxWriteCostMultiplier = 85;
    optional uint32 HDDMaxPostponedTime = 86;   // in ms
    optional uint32 HDDMaxPostponedCount = 87;

    // Timeout in between forced range compaction attempts.
    optional uint32 CompactionRetryTimeout = 88;   // in ms

    // Min percentage of reassignable channels after which reassign requests
    // are sent.
    optional uint32 ReassignChannelsPercentageThreshold = 89;

    optional uint32 CpuLackThreshold = 90;

    optional NCloud.NProto.EAuthorizationMode AuthorizationMode = 91;

    // FolderId of this NFS instance. Used for authorization.
    optional string FolderId = 92;

    // Number of last sessions kept in storage
    optional uint32 SessionHistoryEntryCount = 93;

    // Tenant hive tablet id different from root to be used by hive proxy.
    // Should be configured once and for the lifetime of the cluster.
    optional uint64 TenantHiveTabletId = 329;

    // Max number of compaction ranges loaded per 1 compaction state load
    // iteration.
    optional uint32 LoadedCompactionRangesPerTx = 330;

    // Enables DescribeData + ReadBlob instead of ReadData for reading.
    optional bool TwoStageReadEnabled = 331;

    // Enables runtime config update tool.
    optional bool ConfigsDispatcherServiceEnabled = 332;

    // Max inflight for out of order compaction map load requests.
    optional uint32 MaxOutOfOrderCompactionMapLoadRequestsInQueue = 333;

    // IndexTabletActor will suicide (and thus reboot) after observing this
    // number of backpressure errors. Needed to automatically recover after
    // various races that may happen during index tablet startup due to bugs.
    optional uint32 MaxBackpressureErrorsBeforeSuicide = 334;

    // Params that are passed to filestore-vhost via TCreateSessionResponse via
    // TFilestore::Features. They do not have any effect on the tablet itself.
    optional uint32 EntryTimeout = 335;
    optional uint32 NegativeEntryTimeout = 336;
    optional uint32 AttrTimeout = 337;

    // Threshold for the number of garbage blocks in a compaction range that
    // triggers automatic compaction.
    optional uint32 GarbageCompactionThreshold = 338;
    // Threshold for average CompactionScore for the whole FS.
    optional uint32 CompactionThresholdAverage = 339;
    // Threshold for average GarbageCompactionScore for the whole FS.
    optional uint32 GarbageCompactionThresholdAverage = 340;
    // Enables 3 aforementioned thresholds.
    optional bool NewCompactionEnabled = 341;

    // Threshold for average CleanupScore for the whole FS.
    optional uint32 CleanupThresholdAverage = 342;
    // Enables the aforementioned threshold.
    optional bool NewCleanupEnabled = 343;

    // Enables GenerateBlobIds + WriteBlob + AddData instead of WriteBlob
    // for writing.
    optional bool ThreeStageWriteEnabled = 344;

    // When issuing blob ids, the tablet acquires a collect barrier. In order
    // to release it in case of a client disconnect, this timeout is used.
    optional uint32 GenerateBlobIdsReleaseCollectBarrierTimeout = 345;

    // If ThreeStageWriteEnabled is true, writes that exceed this threshold
    // will use the three-stage write path. Similar to WriteBlobThreshold
    optional uint32 ThreeStageWriteThreshold = 346;

    // ReadAhead cache params. Used upon DescribeData requests.
    // If ReadAheadCacheRangeSize is not 0 the requested ranges may be widened
    // to this value and the results will be cached to serve future describe
    // requests. The requested range is widened if the previous 32 DescribeData
    // requests represent a pattern which is similar to sequential. The similar
    // part is controlled by the ReadAheadMaxGapPercentage parameter which
    // regulates the maximum number of skipped bytes in an otherwise sequential
    // pattern.
    optional uint32 ReadAheadCacheMaxNodes = 347;
    optional uint32 ReadAheadCacheMaxResultsPerNode = 348;
    optional uint32 ReadAheadCacheRangeSize = 349;
    optional uint32 ReadAheadMaxGapPercentage = 350;
    optional uint32 ReadAheadCacheMaxHandlesPerNode = 351;

    optional bool NewLocalDBCompactionPolicyEnabled = 352 [deprecated = true];

    optional uint32 NodeIndexCacheMaxNodes = 353 [deprecated = true];

    // By default, the blocksize, provided by the GetNodeAttr request, is set to
    // the filestore blocksize. Due to the fact that every 64 blocks are stored in
    // the same range, it may be beneficial to increase the reported blocksize x-fold.
    // This numeric value is that x.
    optional uint32 PreferredBlockSizeMultiplier = 354;

    optional bool MultiTabletForwardingEnabled = 355 [deprecated = true];

    // Controls BlobIndexOps' priority over each other.
    optional EBlobIndexOpsPriority BlobIndexOpsPriority = 356;

    // Allow to destroy filestore with active sessions
    optional bool AllowFileStoreForceDestroy = 357;

    optional bool GetNodeAttrBatchEnabled = 358 [deprecated = true];

    // Max number of items to delete during TrimBytes.
    optional uint64 TrimBytesItemCount = 359;

    // auth token for node registration via ydb discovery api.
    optional string NodeRegistrationToken = 360;

    // Node type.
    optional string NodeType = 361;

    // TLS node registration details.
    optional string NodeRegistrationRootCertsFile = 362;
    optional NCloud.NProto.TCertificate NodeRegistrationCert = 363;

    // Blob compression experiment params.
    optional uint32 BlobCompressionRate = 364;
    optional string BlobCompressionCodec = 365;

    // Enables ThreeStageWrite for unaligned requests.
    optional bool UnalignedThreeStageWriteEnabled = 366;

    // Number of ranges with zero compaction stats to delete per tx.
    optional uint32 MaxZeroCompactionRangesToDeletePerTx = 367;

    // Mapping allowing for multiple fs ids to point to the same fs
    message TFilestoreAliasEntry
    {
        optional string Alias = 1;
        optional string FsId = 2;
    }
    message TFilestoreAliases
    {
        repeated TFilestoreAliasEntry Entries = 1;
    }
    optional TFilestoreAliases FilestoreAliases = 368;

    // Channel free space threshold - used for write request balancing.
    optional uint32 ChannelFreeSpaceThreshold = 369;
    // Channel min free space - used for write request balancing.
    optional uint32 ChannelMinFreeSpace = 370;

    // Enables in-memory index cache for all index-related requests
    optional bool InMemoryIndexCacheEnabled = 371;
    // Capacity of in-memory index cache, in number of entries per each table
    optional uint64 InMemoryIndexCacheNodesCapacity = 372;
    // Ratio of maximal number of nodes in the fs to the in-memory index cache
    // capacity. I. e., if there are max 1000 nodes and ratio is set to 10,
    // then there can be max 100 entries in cache. If both capacity and ratio
    // are set, the greater value is used.
    optional uint64 InMemoryIndexCacheNodesToNodesCapacityRatio = 373;
    optional uint64 InMemoryIndexCacheNodeAttrsCapacity = 374;
    optional uint64 InMemoryIndexCacheNodesToNodeAttrsCapacityRatio = 375;
    optional uint64 InMemoryIndexCacheNodeRefsCapacity = 376;
    optional uint64 InMemoryIndexCacheNodesToNodeRefsCapacityRatio = 377;
    // In addition to the per-table isExhaustive flag, it is possible to have a
    // per-node isExhaustive flag, which can be set upon exhaustive ListNodes
    // requests. The number of the per-node flags is limited by this value.
    optional uint64 InMemoryIndexCacheNodeRefsExhaustivenessCapacity = 437;

    // Used to send non-network metrics as network ones to HIVE,
    // while we use them for load balancing
    optional uint32 NonNetworkMetricsBalancingFactor = 378;

    // Async processing of destroy handle requests.
    optional bool AsyncDestroyHandleEnabled = 379;

    // Polling period when the async handle operations queue is empty, in ms.
    optional uint32 AsyncHandleOperationIdlePeriod = 380;

    // Dynamic node registration params.
    optional uint32 NodeRegistrationMaxAttempts = 381;
    optional uint32 NodeRegistrationTimeout = 382;   // in ms
    optional uint32 NodeRegistrationErrorTimeout = 383;  // in ms

    // Max block count per file.
    // uint32 is chosen deliberately - using values that exceed 2^32 - 1 or even
    // 2^31 (which is 8TiB for a 4KiB block) should be thoroughly tested anyway
    optional uint32 MaxFileBlocks = 384;
    // Enables the usage of large deletion markers (needed for efficient
    // truncate ops on large files).
    optional bool LargeDeletionMarkersEnabled = 385;
    // Sets max block count per single large deletion marker.
    optional uint64 LargeDeletionMarkerBlocks = 386;
    // Truncate and allocate ops that exceed this threshold will lead to large
    // deletion marker generation.
    optional uint64 LargeDeletionMarkersThreshold = 387;
    // If the number of blocks marked for deletion via large deletion markers
    // exceeds this threshold, Cleanup will be triggered.
    optional uint64 LargeDeletionMarkersCleanupThreshold = 388;

    // Throttle DescribeData and GenerateBlobIds requests
    optional bool MultipleStageRequestThrottlingEnabled = 389;

    // Prioritize background operations whose optimization targets are close
    // to their backpressure thresholds.
    optional uint32 BackpressureThresholdPercentageForBackgroundOpsPriority = 390;

    // If enabled, GarbageCompactionThresholdAverage will be compared to the
    // difference between MixedBlocks and UsedBlocks instead of the difference
    // between alive blocks and UsedBlocks. This actually should be the default
    // behaviour but is implemented via this flag in order not to cause
    // uncontrollable behaviour change for production systems. TODO: gradually
    // enable this flag everywhere and make this behaviour the new default.
    optional bool UseMixedBlocksInsteadOfAliveBlocksInCompaction = 391;

    // IndexTabletActor will suicide (and thus reboot) after observing
    // consecutive backpressure errors for this period of time. Needed to
    // automatically recover after various races that may happen during index
    // tablet startup due to bugs.
    optional uint32 MaxBackpressurePeriodBeforeSuicide = 392;   // in ms

    // settings for ydb config dispatcher service.
    optional NCloud.NProto.TConfigDispatcherSettings ConfigDispatcherSettings = 393;

    // If the number of blocks marked for deletion via large deletion markers
    // exceeds this threshold, large truncate-like operations will be rejected.
    optional uint64 LargeDeletionMarkersThresholdForBackpressure = 394;

    // Enables persistent backup for tablet path descriptions.
    optional string PathDescriptionBackupFilePath = 395;

    // Server will reject all requests to destroy filestores in the provided
    // list
    repeated string DestroyFilestoreDenyList = 396;

    // In fallback mode, all requests to SchemeShard are served from backup.
    optional bool SSProxyFallbackMode = 397;

    // Enables index cache loading on tablet startup. Enables ListNodes
    // responses from cache.
    optional bool InMemoryIndexCacheLoadOnTabletStart = 398;
    optional uint64 InMemoryIndexCacheLoadOnTabletStartRowsPerTx = 399;

    // Blob is divided into chunks of a certain size (in bytes) and each chunk
    // is compressed separately.
    optional uint32 BlobCompressionChunkSize = 400;

    // If Compaction encounters a range which contains <= garbage than set via
    // these fields and whose blobs' average size is >= that set via these
    // fields, it just marks this range as 'compacted' and moves on without
    // rewriting the data belonging to this range.
    optional uint32 CompactRangeGarbagePercentageThreshold = 401;
    optional uint32 CompactRangeAverageBlobSizeThreshold = 402;

    // Disables ThreeStageWrite for HDD filesystems.
    optional bool ThreeStageWriteDisabledForHDD = 403;

    // Disables TwoStageRead for HDD filesystems.
    optional bool TwoStageReadDisabledForHDD = 404;

    // Enables automatic shard creation for new filesystems upon create/resize
    // operations. Shard count is calculated based on FS size. If this flag is
    // enabled, new filesystems will have this feature enabled and will create
    // extra shards upon resize if needed. Existing filesystems are not
    // affected. Filesystems created with this flag enabled will maintain the
    // autosharding feature even if this flag is disabled in the global storage
    // config.
    optional bool AutomaticShardCreationEnabled = 405;
    // Affects shard count calculation if AutomaticShardCreationEnabled is on.
    optional uint64 ShardAllocationUnit = 406;

    // Enable write-back cache on guest (FUSE client)
    optional bool GuestWriteBackCacheEnabled = 407;

    // Ignore orphan sessions upon filestore sessions check during destruction
    // attempts.
    optional bool AllowFileStoreDestroyWithOrphanSessions = 408;

    // Automatically created shards will be of this size.
    optional uint64 AutomaticallyCreatedShardSize = 409;

    // Forbids session creation (forces E_REJECTED) if filesystem shard count
    // calculated based on the filesystem's size is too small.
    // We can't enable this logic by default yet since we need to maintain
    // backward compatibility during the update which enables automatic
    // sharding.
    optional bool EnforceCorrectFileSystemShardCountUponSessionCreation = 410;

    // Enables ShardId selection in Leader for CreateNode and CreateHandle
    // requests. ShardIds selected in Leader have priority over ShardIds
    // selected at the StorageServiceActor level.
    //
    // Obsolete.
    // TODO(#5431): remove
    optional bool ShardIdSelectionInLeaderEnabled = 411 [deprecated = true];

    // Shard balancer will prefer shards which have at least this amount of
    // free space in bytes.
    optional uint64 ShardBalancerDesiredFreeSpaceReserve = 412;

    // Shard balancer will not select shards which have less than this amount of
    // free space in bytes.
    optional uint64 ShardBalancerMinFreeSpaceReserve = 413;

    // Enables directory creation in shards (by default directories are created
    // only in the main tablet).
    optional bool DirectoryCreationInShardsEnabled = 414;

    // Mixed blocks map are  stored in memory only for actively used ranges.
    // Additionally MixedBlocksOffloadedRangesCapacity ranges that are not
    // actively used are also stored in memory. Their memory footprint is
    // proportional to the aforementioned value multiplied my the size of
    // TRange
    optional uint64 MixedBlocksOffloadedRangesCapacity = 415;

    optional bool YdbViewerServiceEnabled = 416;

    // During the InMemoryIndexCache load, the time between the batches loading
    optional uint32 InMemoryIndexCacheLoadSchedulePeriod = 417;  // in ms

    // Guest (FUSE client) will use direct IO for read/write requests
    // regardless of whether file is opened with O_DIRECT or not
    optional bool GuestPageCacheDisabled = 418;

    // Don't support extended attributes
    optional bool ExtendedAttributesDisabled = 419;

    // Enable write-back cache on FUSE server
    optional bool ServerWriteBackCacheEnabled = 420;

    // If enabled, GarbageCompactionThresholdAverage in Cleanup will be compared
    // to the scaled ratio of DeletionMarkersCount to UsedBlocksCount instead of
    // UsedRangesCount.
    optional bool CalculateCleanupScoreBasedOnUsedBlocksCount = 421;

    // Use SSL for dynamic node registration.
    optional bool NodeRegistrationUseSsl = 422;

    // If set to true, in some cases the client is allowed not to invalidate the
    // guest page cache associated with the inode. It is allowed only for
    // handles to nodes that are not being edited and are already opened
    // within a given session
    optional bool GuestKeepCacheAllowed = 423;

    optional EGuestCachingType GuestCachingType = 424;

    // In addition to the actively opened handles the tablet will also keep
    // in memory at most this number of the most recently used nodes
    optional uint64 SessionHandleOffloadedStatsCapacity = 425;

    // Limit CPU consumption by Cleanup when a massive amount
    // of deletion markers is to be cleaned up after changing configuration.
    // (for example after changing cleanup threshold or other parameters)
    optional uint32 CleanupCpuThrottlingThresholdPercentage = 426;

    // EnqueueBlobIndexOpIfNeeded will be called with this interval
    // if background operations should run but have been throttled.
    // (e.g. cleanup operation due to CleanupCpuThrottlingThresholdPercentage)
    optional uint32 EnqueueBlobIndexOpIfNeededScheduleInterval = 427; // in ms

    // Specifies the shard balancer policy to be used for the shard balancing.
    // Has no effect if ShardBalancerEnabled is false.
    optional EShardBalancerPolicy ShardBalancerPolicy = 428;

    // The amount of data entries in the fresh bytes table that triggers
    // flushing
    optional uint32 FlushBytesItemCountThreshold = 429;

    // Enable triggering FlushBytes by reaching FlushBytesItemCountThreshold
    optional bool FlushBytesByItemCountEnabled = 430;

    // Retry policy when unable to get configs from CMS, in ms
    optional uint32 LoadConfigsFromCmsRetryMinDelay = 431;
    optional uint32 LoadConfigsFromCmsRetryMaxDelay = 432;
    optional uint32 LoadConfigsFromCmsTotalTimeout = 433;

    // If this flag is enabled all the files will be created without parents.
    // Meaning that the NodeRefs table will be empty for these files.
    // None of these files will be observable using the ListNodes request
    // and the only way to access them is to use the node's NodeId
    //
    // This alters the default behavior:
    // - CreateNode will not create a NodeRef for the file and this node will
    //   be found only in the Nodes table of a shard (or in the main tablet if
    //   there are no shards). This means that the passed filename will not be
    //   used at all.
    // - UnlinkNode will be possible to perform using only the file's NodeId
    //   and it will not require the parent directory's NodeId.
    optional bool ParentlessFilesOnly = 434;

    // If set to true, the filestore will allow handleless read requests.
    // Meaning that one will not need to open a file handle to read or write
    // data.
    optional bool AllowHandlelessIO = 435;

    // This flag enables tracking of XAttrs. If it's true and a new filesystem
    // is created, TFileSystemStats::HasXAttrs is set to EHasXAttrs::False and
    // changes to EHasXAttrs::True when the first XAttr is set. If it's false,
    // filesystem behaves as if it has XAttrs. Knowledge about XAttrs presence
    // allows to reply early to GetNodeXAttr and ListNodeXAttr queries.
    optional bool LazyXAttrsEnabled = 436;

    // Limits max requests allowed at a time.
    optional uint32 MaxBackground = 438;

    // Limits max threads used in fuse loop per mount (vhost frontend queues)
    optional uint32 MaxFuseLoopThreads = 439;

    // If this flag is on, shards store ids of all other shards. Counters
    // AggregateUsedBytesCount and AggregateUsedNodesCount are calculated for
    // all the shards. These counters are used to strictly enforce the
    // filesystem size.
    optional bool StrictFileSystemSizeEnforcementEnabled = 440;

    // Enable zero-copy for write operations in the VFS FUSE layer
    optional bool ZeroCopyWriteEnabled = 441;

    // When enabled, the backup in stored in binary proto format instead of
    // prototxt.
    optional bool UseBinaryFormatForTabletBootInfoBackup = 442;

    // Enable zero-copy for read operations in the VFS FUSE layer
    optional bool ZeroCopyReadEnabled = 443;

    // Allows to set node's priority for system (tenant) tablets (hive,
    // schemeshard, etc.). Lower value means lower priority.
    // NOTE: can be negative.
    optional int32 SystemTabletsPriority = 464;

    // Disable fsync queue which is used to synchronize data/metadata ops during fsync
    optional bool FSyncQueueDisabled = 465;

    // Enable directory handles storage functionality.
    optional bool DirectoryHandlesStorageEnabled = 466;

    // Capacity for DirectoryHandles persistent table.
    optional uint64 DirectoryHandlesTableSize = 467;

    // Enable FUSE_HANDLE_KILLPRIV_V2 on guest (FUSE client)
    optional bool GuestHandleKillPrivV2Enabled = 468;

    // Multiplier for MaxBytes when calculating upper bound in ClampVal
    // for BytesToPrecharge in ListNodes transaction
    optional uint32 MaxBytesMultiplier = 469;

    // Allow SysViewProcessor and StatisticsAggregator tablets for compatibility
    // with newer versions of ydb (24-2 and older)
    optional bool AllowAdditionalSystemTablets = 470;

    // If TwoStageReadEnabled is true, reads that exceed this threshold will use
    // the two-stage read path.
    optional uint32 TwoStageReadThreshold = 471;

    // Enables checksum calculation for all blocks upon IO requests and
    // background requests like Compaction and Cleanup. Checksums are logged
    // to profile log.
    optional bool BlockChecksumsInProfileLogEnabled = 472;

    // MaxShardCount used to be hardcoded and equal to 254.
    // Now it is configurable with the default == 254
    optional uint32 MaxShardCount = 473;

    // These 2 parameters convert ReadBlob and WriteBlob ops to no-op. These
    // parameters are supposed to be used only for testing purposes - to test
    // fuse / service / tablet layer performance without direct blobstorage
    // reads / writes. Tablet local DB still continues to use blobstorage.
    optional bool ReadBlobDisabled = 474;
    optional bool WriteBlobDisabled = 475;

    // Entry timeout for regular entries. See EntryTimeout
    // Passed to filestore-vhost and do not have effect on the tablet
    optional uint32 RegularFileEntryTimeout = 476;

    // If CpuLack goes over this threshold, tablets will start setting the
    // IsOverloaded flag in their responses.
    optional uint32 CpuLackOverloadThreshold = 477;

    // Maximum step value for the tablet. This
    // parameter is supposed to be used only for testing purposes.
    optional uint32 MaxTabletStep = 478;

    // Enables “fake” DescribeData responses, meaning the responses are not
    // related to real blobs and are used solely for performance modeling and
    // testing purposes
    optional bool FakeDescribeDataEnabled = 479;
    optional uint32 FakeDescribeDataLatencyUs = 480;

    // If enabled, if the S_ISGID is set on the directory, its gid will be
    // propagated to newly created files (including directories, symlinks, etc.)
    // inside that directory.
    optional bool GidPropagationEnabled = 481;

    // If tablet actor CPU usage goes over this threshold, tablets will start
    // setting the IsOverloaded flag in their responses.
    optional uint32 TabletActorCpuUsageOverloadThreshold = 482;

    // If enabled, auto-precharge is disabled for the NodeRefs table. This is
    // equivalent to setting NoAutoPrecharge option in the NodeRefs schema with
    // the difference that flag allows this option to be set in runtime and
    // not compile time.
    optional bool NodeRefsNoAutoPrecharge = 483;

    // Mode for calculating byte size in ListNodes when applying MaxBytes limit.
    // TODO(#5148): consider other size calculation modes
    optional EListNodesSizeMode ListNodesSizeMode = 484;

    // Tablet ResponseLogEntry TTL in ms before it gets deleted by a regular
    // tablet operation.
    optional uint32 ResponseLogEntryTTL = 485;

    // Frequency of tablet regular task runs (e.g. ResponseLogEntry cleanup).
    optional uint32 TabletRegularTasksSchedulePeriod = 486;

    // Allow to destroy filestore with active sessions
    // with size less than threshold(in bytes)
    optional uint64 ForceDestroySizeThreshold = 487;

    // Enable adding unconfirmed data for write operations
    optional bool AddingUnconfirmedDataEnabled = 488;

    // Limits unconfirmed (and confirmed but not added to the index) data count.
    optional uint32 UnconfirmedDataCountHardLimit = 489;

    // Reject writes when FlushBytesItemCount >= threshold
    optional uint64 FlushBytesItemCountThresholdForBackpressure = 490;

    // Set this to see file name hashes instead of the actual names in the
    // tablet's directory viewer.
    optional bool HideFileNamesInTabletDirectoryViewer = 491;

    // Enable FUSE_POSIX_ACL on guest (FUSE client)
    optional bool GuestPosixAclEnabled = 492;

    // Shard balancer will round free space per shard to a multiple of this
    // number in bytes.
    optional uint64 ShardBalancerPrecisionBytes = 493;

    // Use ListNodesInternal API for internal ListNodes calls.
    optional bool UseListNodesInternal = 494;

    // Thresholds which enable backpressure - part 2.
    optional uint64 CollectGarbageThresholdForBackpressure = 495;

    // These flags turn NodeRefs cache into a btree_map without capacity limits.
    optional bool UseUnlimitedBTreeNodeRefsCacheInMainTablet = 496;
    optional bool UseUnlimitedBTreeNodeRefsCacheInShards = 497;

    // Use custom protobuf parser for TReadDataResponse
    // to optimize TReadDataActor performance.
    optional bool UseCustomReadDataResponseParser = 498 [deprecated = true];

    // If true, describes will be done using SchemeCache instead of TxProxy.
    optional bool UseSchemeCache = 499;

    // Similar to `InMemoryIndexCacheLoadOnTabletStart`, but applies only to
    // the node refs table in filesystem shards. If
    // `InMemoryIndexCacheLoadOnTabletStart` is also set, it takes precedence.
    optional bool InMemoryIndexCacheNodeRefsLoadOnTabletStartInShards = 500;

    // Restart index tablet on destroy with active sessions only if tablet
    // uptime is greater than this threshold. Zero disables restarts.
    optional uint32 RestartTabletUptimeThresholdDuringDestroy = 501;

    // Maximum serialized size of one persistent handle.
    optional uint64 DirectoryHandlesPersistentHandleMaxSize = 502;

    // Enable the silk-based fastshard TCP server. When enabled, adapter-
    // mode tablets register their IFileSystemShard with this server,
    // allowing direct TCP access to shard operations.
    optional uint32 FastShardServerPort = 503;

    // If this flag is on, new filesystems are created with CompressNodeRef.
    optional bool EnableNodeRefCompression = 504;

    // Feature flag and soft thresholds for backpressure throttling.
    optional bool SoftBackpressureEnabled = 505;
    optional uint32 FlushThresholdForBackpressureSoft = 506;
    optional uint32 CleanupThresholdForBackpressureSoft = 507;
    optional uint32 CompactionThresholdForBackpressureSoft = 508;
    optional uint64 FlushBytesThresholdForBackpressureSoft = 509;
    optional uint64 FlushBytesItemCountThresholdForBackpressureSoft = 510;
    optional uint64 CollectGarbageThresholdForBackpressureSoft = 511;

    // Makes tablet's CreateHandle op handler reply before the tx is committed.
    optional bool TabletUnsafeAsyncReadOnlyCreateHandleEnabled = 512;

    // Makes tablet's DestroyHandle op handler reply before the tx is committed.
    optional bool TabletUnsafeAsyncDestroyHandleEnabled = 513;

    // Allows flushing WriteData requests to the underlying storage in parallel.
    // This significantly improves flushing performance but an external reader
    // may observe the effects of newer writes before older ones.
    // With parallel writes off, only sequential writes will be optimized.
    optional bool ServerWriteBackCacheFlushWritesInParallelEnabled = 514;

    // Limit max number in-flight requests to create/configure/destroy shards.
    // Zero means unlimited.
    optional uint32 MaxShardManagementRequestsInFlight = 515;

    // Cache TTL that is used by TStorageServiceActor::HandleStatFileStore.
    optional uint32 StatFileStoreCacheTTL = 516; // in ms

    // Pass data buffer from the tablet as a message payload
    optional bool ExternalReadDataPayload = 517;

    // Throttling configuration for backpressure usecase, when global throttler is disabled
    optional uint32 SoftBackpressureMaxWriteBandwidth = 518;   // in MiB/s
    optional uint32 SoftBackpressureMaxReadBandwidth = 519;    // in MiB/s
    optional uint32 SoftBackpressureMaxWriteIops = 520;
    optional uint32 SoftBackpressureMaxReadIops = 521;

    // Sets the minimum shard count that each filesystem would have regardless
    // of its size.
    optional uint32 MinShardCount = 522;

    // If enabled, tablet overload is ignored when deciding whether to use
    // the unconfirmed data flow.
    optional bool AllowTabletOverload = 523;

    // Enables the RDMA side channel for tablet-proxied requests in
    // filestore-server and filestore-vhost.
    optional bool TabletDirectRdmaEnabled = 524;

    // Async processing of destroy handle requests only for read only handles.
    optional bool AsyncDestroyReadOnlyHandleEnabled = 525;

    // Pass data buffer to the tablet as a message payload
    optional bool ExternalWriteDataPayloadEnabled = 526;

    // Enables injecting of errors in TIndexTabletDatabase. Must be only used in tests!
    optional double FakeTxPageFaultsProbability = 527;

    // When this flag is enabled, TAggregateStatsActor does not poll all shards.
    // Instead, it requests aggregate statistics only from the main tablet.
    optional bool FanoutStatsCollectionInShardsDisabled = 528;

    // Enable silk regardless of other config parameters. Required for
    // persistent fastshard to work.
    optional bool FastShardRuntimeEnabled = 529;

    // Limits the number of session handles destroyed by a single ResetSession
    // or DestroySession transaction. Sessions with more handles are cleaned
    // up by a chain of transactions. 0 means no limit.
    optional uint32 MaxDeleteSessionHandlesPerTx = 530;

    // Enables various self diagnostics/validation.
    optional bool FastShardExtendedVerificationEnabled = 531;

    // Async processing of read-only create handle requests.
    optional bool AsyncCreateHandleEnabled = 532;

    // Allow to create load actor.
    optional bool EnableLoadActor = 533;

    // Limits the number of entries when tracking the most accessed nodes per tablet.
    optional uint32 MaxNodeDiagnosticEntries = 534;

    // Sets the time after which access count will decrease by half.
    optional uint32 NodeAccessCountHalfLife = 535; // measured in ms

    // Time after a tablet start during which an operation on an unknown handle
    // returns a retriable error instead of E_FS_BADHANDLE, so that a client can
    // recover a handle lost by a tablet restart via its queued
    // ConfirmCreateHandle. 0 disables the grace window. In ms.
    optional uint32 UnconfirmedCreateHandleGraceTimeout = 536;

    // Limits the number of entries when tracking
    // the slowest nodes + request tuples per tablet.
    optional uint32 MaxSlowestRequestsEntries = 537;

    // Sets the time after which latency of a node + request tuple will decrease by half.
    optional uint32 NodeLatencyHalfLife = 538; // measured in ms

    // Enables the per-client filesystem availability tracking on the guest.
    optional bool AvailabilityTrackingEnabled = 539;

    // Availability interval duration (in ms); 0 means the default.
    optional uint32 AvailabilityTrackingInterval = 540;

    // Delay between processing entries in the async handle operations queue,
    // in ms.
    optional uint32 AsyncHandleOperationDrainPeriod = 541;
}