cloud/blockstore/libs/endpoints_vhost/vhost_server.cpp - main - githubmirror/nbs

cloud/blockstore/libs/endpoints_vhost/vhost_server.cpp
153 строки5 KB
Grigoriy Yurgin
[Blockstore] Drop discard requests when needed (fixed version of #5626) (#5771)
20 апр 2026, 21:54
20 апр 2026, 21:54d7d8036
#include "vhost_server.h"

#include <cloud/blockstore/libs/client/session.h>
#include <cloud/blockstore/libs/common/constants.h>
#include <cloud/blockstore/libs/endpoints/endpoint_listener.h>
#include <cloud/blockstore/libs/vhost/server.h>
#include <cloud/storage/core/libs/common/media.h>

namespace NCloud::NBlockStore::NServer {

using namespace NThreading;

namespace {

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

class TVhostEndpointListener final
    : public IEndpointListener
{
private:
    const NVhost::IServerPtr Server;
    const NProto::TChecksumFlags ChecksumFlags;
    const bool VhostDiscardEnabled;
    const bool VhostWriteZeroesEnabled;
    const bool DropDiscardRequests;
    const ui32 MaxZeroBlocksSubRequestSize;
    const ui32 OptimalIoSize;

public:
    TVhostEndpointListener(
            NVhost::IServerPtr server,
            NProto::TChecksumFlags checksumFlags,
            bool vhostDiscardEnabled,
            bool vhostWriteZeroesEnabled,
            bool dropDiscardRequests,
            ui32 maxZeroBlocksSubRequestSize,
            ui32 optimalIoSize)
        : Server(std::move(server))
        , ChecksumFlags(std::move(checksumFlags))
        , VhostDiscardEnabled(vhostDiscardEnabled)
        , VhostWriteZeroesEnabled(vhostWriteZeroesEnabled)
        , DropDiscardRequests(dropDiscardRequests)
        , MaxZeroBlocksSubRequestSize(maxZeroBlocksSubRequestSize)
        , OptimalIoSize(optimalIoSize)
    {}

    TFuture<NProto::TError> StartEndpoint(
        const NProto::TStartEndpointRequest& request,
        const NProto::TVolume& volume,
        NClient::ISessionPtr session) override
    {
        NVhost::TStorageOptions options;
        options.DeviceName = request.GetDeviceName();
        options.DiskId = request.GetDiskId();
        options.ClientId = request.GetClientId();
        options.BlockSize = volume.GetBlockSize();
        options.BlocksCount = volume.GetBlocksCount();
        options.VhostQueuesCount = request.GetVhostQueuesCount();
        options.UnalignedRequestsDisabled = request.GetUnalignedRequestsDisabled();
        options.StorageMediaKind = volume.GetStorageMediaKind();
        options.DiscardEnabled =
            ShouldEnableVhostDiscardForVolume(VhostDiscardEnabled, volume);
        options.WriteZeroesEnabled =
            VhostWriteZeroesEnabled && !IsDiskRegistryMediaKind(volume.GetStorageMediaKind());
        options.DropDiscardRequests =
            ShouldDropDiscardRequestsForVolume(DropDiscardRequests, volume);
        options.MaxZeroBlocksSubRequestSize = MaxZeroBlocksSubRequestSize;
        options.OptimalIoSize = OptimalIoSize;

        return Server->StartEndpoint(
            request.GetUnixSocketPath(),
            std::move(session),
            options);
    }

    TFuture<NProto::TError> AlterEndpoint(
        const NProto::TStartEndpointRequest& request,
        const NProto::TVolume& volume,
        NClient::ISessionPtr session) override
    {
        Y_UNUSED(request, volume, session);

        return MakeFuture<NProto::TError>();
    }

    TFuture<NProto::TError> StopEndpoint(
        const TString& socketPath) override
    {
        return Server->StopEndpoint(socketPath);
    }

    NProto::TError RefreshEndpoint(
        const TString& socketPath,
        const NProto::TVolume& volume) override
    {
        return Server->UpdateEndpoint(socketPath, volume.GetBlocksCount());
    }

    TFuture<NProto::TError> SwitchEndpoint(
        const NProto::TStartEndpointRequest& request,
        const NProto::TVolume& volume,
        NClient::ISessionPtr session) override
    {
        Y_UNUSED(request);
        Y_UNUSED(volume);
        Y_UNUSED(session);
        return MakeFuture<NProto::TError>();
    }
};

}   // namespace

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

bool ShouldEnableVhostDiscardForVolume(
    bool vhostDiscardEnabled,
    const NProto::TVolume& volume)
{
    return (vhostDiscardEnabled || volume.GetVhostDiscardEnabled()) &&
           !IsDiskRegistryMediaKind(volume.GetStorageMediaKind());
}

bool ShouldDropDiscardRequestsForVolume(
    bool dropDiscardRequests,
    const NProto::TVolume& volume)
{
    // It is not safe to use ZeroBlocks as the implementation of discard
    // for disk registry based disks.
    return dropDiscardRequests ||
           volume.GetTags().contains(DropDiscardRequestsTagName) ||
           IsDiskRegistryMediaKind(volume.GetStorageMediaKind());
}

IEndpointListenerPtr CreateVhostEndpointListener(
    NVhost::IServerPtr server,
    const NProto::TChecksumFlags& checksumFlags,
    bool vhostDiscardEnabled,
    bool vhostWriteZeroesEnabled,
    bool dropDiscardRequests,
    ui32 maxZeroBlocksSubRequestSize,
    ui32 optimalIoSize)
{
    return std::make_shared<TVhostEndpointListener>(
        std::move(server),
        checksumFlags,
        vhostDiscardEnabled,
        vhostWriteZeroesEnabled,
        dropDiscardRequests,
        maxZeroBlocksSubRequestSize,
        optimalIoSize);
}

}   // namespace NCloud::NBlockStore::NServer