[#1678] adm: Fix frostfs-adm morph list-subjects & list-group-subjects

`include-names` for `list-subjects` returns error `invalid response subject struct`
because `ListSubjects` returns only subject addresses (see frostfs-contract).

Replace `include-names` with `extended` as now all subject info printed.

Signed-off-by: Dmitrii Stepanov <d.stepanov@yadro.com>

.golangci.yml

@@ -22,6 +22,11 @@ linters-settings:
     # 'default' case is present, even if all enum members aren't listed in the
     # switch
     default-signifies-exhaustive: true
+  gci:
+    sections:
+      - standard
+      - default
+    custom-order: true
   govet:
     # report about shadowed variables
     check-shadowing: false
@@ -72,6 +77,7 @@ linters:
     - durationcheck
     - exhaustive
     - copyloopvar
+    - gci
     - gofmt
     - goimports
     - misspell

cmd/frostfs-adm/internal/modules/morph/config/config.go

@@ -65,14 +65,14 @@ func dumpNetworkConfig(cmd *cobra.Command, _ []string) error {
 			nbuf := make([]byte, 8)
 			copy(nbuf[:], v)
 			n := binary.LittleEndian.Uint64(nbuf)
-			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%d (int)\n", k, n)))
+			_, _ = tw.Write(fmt.Appendf(nil, "%s:\t%d (int)\n", k, n))
 		case netmap.HomomorphicHashingDisabledKey, netmap.MaintenanceModeAllowedConfig:
 			if len(v) == 0 || len(v) > 1 {
 				return helper.InvalidConfigValueErr(k)
 			}
-			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%t (bool)\n", k, v[0] == 1)))
+			_, _ = tw.Write(fmt.Appendf(nil, "%s:\t%t (bool)\n", k, v[0] == 1))
 		default:
-			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%s (hex)\n", k, hex.EncodeToString(v))))
+			_, _ = tw.Write(fmt.Appendf(nil, "%s:\t%s (hex)\n", k, hex.EncodeToString(v)))
 		}
 	}
 

cmd/frostfs-adm/internal/modules/morph/contract/dump_hashes.go

@@ -219,8 +219,8 @@ func printContractInfo(cmd *cobra.Command, infos []contractDumpInfo) {
 		if info.version == "" {
 			info.version = "unknown"
 		}
-		_, _ = tw.Write([]byte(fmt.Sprintf("%s\t(%s):\t%s\n",
-			info.name, info.version, info.hash.StringLE())))
+		_, _ = tw.Write(fmt.Appendf(nil, "%s\t(%s):\t%s\n",
+			info.name, info.version, info.hash.StringLE()))
 	}
 	_ = tw.Flush()
 

cmd/frostfs-adm/internal/modules/morph/frostfsid/frostfsid.go

@@ -34,7 +34,7 @@ const (
 	subjectNameFlag    = "subject-name"
 	subjectKeyFlag     = "subject-key"
 	subjectAddressFlag = "subject-address"
-	includeNamesFlag   = "include-names"
+	extendedFlag       = "extended"
 	groupNameFlag      = "group-name"
 	groupIDFlag        = "group-id"
 
@@ -209,7 +209,7 @@ func initFrostfsIDListSubjectsCmd() {
 	Cmd.AddCommand(frostfsidListSubjectsCmd)
 	frostfsidListSubjectsCmd.Flags().StringP(commonflags.EndpointFlag, commonflags.EndpointFlagShort, "", commonflags.EndpointFlagDesc)
 	frostfsidListSubjectsCmd.Flags().String(namespaceFlag, "", "Namespace to list subjects")
-	frostfsidListSubjectsCmd.Flags().Bool(includeNamesFlag, false, "Whether include subject name (require additional requests)")
+	frostfsidListSubjectsCmd.Flags().Bool(extendedFlag, false, "Whether include subject info (require additional requests)")
 }
 
 func initFrostfsIDCreateGroupCmd() {
@@ -256,7 +256,7 @@ func initFrostfsIDListGroupSubjectsCmd() {
 	frostfsidListGroupSubjectsCmd.Flags().StringP(commonflags.EndpointFlag, commonflags.EndpointFlagShort, "", commonflags.EndpointFlagDesc)
 	frostfsidListGroupSubjectsCmd.Flags().String(namespaceFlag, "", "Namespace name")
 	frostfsidListGroupSubjectsCmd.Flags().Int64(groupIDFlag, 0, "Group id")
-	frostfsidListGroupSubjectsCmd.Flags().Bool(includeNamesFlag, false, "Whether include subject name (require additional requests)")
+	frostfsidListGroupSubjectsCmd.Flags().Bool(extendedFlag, false, "Whether include subject info (require additional requests)")
 }
 
 func initFrostfsIDSetKVCmd() {
@@ -336,7 +336,7 @@ func frostfsidDeleteSubject(cmd *cobra.Command, _ []string) {
 }
 
 func frostfsidListSubjects(cmd *cobra.Command, _ []string) {
-	includeNames, _ := cmd.Flags().GetBool(includeNamesFlag)
+	extended, _ := cmd.Flags().GetBool(extendedFlag)
 	ns := getFrostfsIDNamespace(cmd)
 	inv, _, hash := initInvoker(cmd)
 	reader := frostfsidrpclient.NewReader(inv, hash)
@@ -349,21 +349,19 @@ func frostfsidListSubjects(cmd *cobra.Command, _ []string) {
 	sort.Slice(subAddresses, func(i, j int) bool { return subAddresses[i].Less(subAddresses[j]) })
 
 	for _, addr := range subAddresses {
-		if !includeNames {
+		if !extended {
 			cmd.Println(address.Uint160ToString(addr))
 			continue
 		}
 
-		sessionID, it, err := reader.ListSubjects()
+		items, err := reader.GetSubject(addr)
 		commonCmd.ExitOnErr(cmd, "can't get subject: %w", err)
 
-		items, err := readIterator(inv, &it, sessionID)
-		commonCmd.ExitOnErr(cmd, "can't read iterator: %w", err)
-
 		subj, err := frostfsidclient.ParseSubject(items)
 		commonCmd.ExitOnErr(cmd, "can't parse subject: %w", err)
 
-		cmd.Printf("%s (%s)\n", address.Uint160ToString(addr), subj.Name)
+		printSubjectInfo(cmd, addr, subj)
+		cmd.Println()
 	}
 }
 
@@ -483,7 +481,7 @@ func frostfsidDeleteKV(cmd *cobra.Command, _ []string) {
 func frostfsidListGroupSubjects(cmd *cobra.Command, _ []string) {
 	ns := getFrostfsIDNamespace(cmd)
 	groupID := getFrostfsIDGroupID(cmd)
-	includeNames, _ := cmd.Flags().GetBool(includeNamesFlag)
+	extended, _ := cmd.Flags().GetBool(extendedFlag)
 	inv, cs, hash := initInvoker(cmd)
 	_, err := helper.NNSResolveHash(inv, cs.Hash, helper.DomainOf(constants.FrostfsIDContract))
 	commonCmd.ExitOnErr(cmd, "can't get netmap contract hash: %w", err)
@@ -501,7 +499,7 @@ func frostfsidListGroupSubjects(cmd *cobra.Command, _ []string) {
 	sort.Slice(subjects, func(i, j int) bool { return subjects[i].Less(subjects[j]) })
 
 	for _, subjAddr := range subjects {
-		if !includeNames {
+		if !extended {
 			cmd.Println(address.Uint160ToString(subjAddr))
 			continue
 		}
@@ -510,7 +508,8 @@ func frostfsidListGroupSubjects(cmd *cobra.Command, _ []string) {
 		commonCmd.ExitOnErr(cmd, "can't get subject: %w", err)
 		subj, err := frostfsidclient.ParseSubject(items)
 		commonCmd.ExitOnErr(cmd, "can't parse subject: %w", err)
-		cmd.Printf("%s (%s)\n", address.Uint160ToString(subjAddr), subj.Name)
+		printSubjectInfo(cmd, subjAddr, subj)
+		cmd.Println()
 	}
 }
 
@@ -600,3 +599,30 @@ func initInvoker(cmd *cobra.Command) (*invoker.Invoker, *state.Contract, util.Ui
 
 	return inv, cs, nmHash
 }
+
+func printSubjectInfo(cmd *cobra.Command, addr util.Uint160, subj *frostfsidclient.Subject) {
+	cmd.Printf("Address: %s\n", address.Uint160ToString(addr))
+	pk := "<nil>"
+	if subj.PrimaryKey != nil {
+		pk = subj.PrimaryKey.String()
+	}
+	cmd.Printf("Primary key: %s\n", pk)
+	cmd.Printf("Name: %s\n", subj.Name)
+	cmd.Printf("Namespace: %s\n", subj.Namespace)
+	if len(subj.AdditionalKeys) > 0 {
+		cmd.Printf("Additional keys:\n")
+		for _, key := range subj.AdditionalKeys {
+			k := "<nil>"
+			if key != nil {
+				k = key.String()
+			}
+			cmd.Printf("- %s\n", k)
+		}
+	}
+	if len(subj.KV) > 0 {
+		cmd.Printf("KV:\n")
+		for k, v := range subj.KV {
+			cmd.Printf("- %s: %s\n", k, v)
+		}
+	}
+}

cmd/frostfs-adm/internal/modules/morph/helper/netmap.go

@@ -3,6 +3,7 @@ package helper
 import (
 	"errors"
 	"fmt"
+	"slices"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
@@ -118,11 +119,8 @@ func MergeNetmapConfig(roInvoker *invoker.Invoker, md map[string]any) error {
 		return err
 	}
 	for k, v := range m {
-		for _, key := range NetmapConfigKeys {
-			if k == key {
-				md[k] = v
-				break
-			}
+		if slices.Contains(NetmapConfigKeys, k) {
+			md[k] = v
 		}
 	}
 	return nil

cmd/frostfs-adm/internal/modules/morph/initialize/initialize_transfer.go

@@ -22,15 +22,14 @@ import (
 )
 
 const (
-	gasInitialTotalSupply = 30000000 * native.GASFactor
 	// initialAlphabetGASAmount represents the amount of GAS given to each alphabet node.
 	initialAlphabetGASAmount = 10_000 * native.GASFactor
 	// initialProxyGASAmount represents the amount of GAS given to a proxy contract.
 	initialProxyGASAmount = 50_000 * native.GASFactor
 )
 
-func initialCommitteeGASAmount(c *helper.InitializeContext) int64 {
-	return (gasInitialTotalSupply - initialAlphabetGASAmount*int64(len(c.Wallets))) / 2
+func initialCommitteeGASAmount(c *helper.InitializeContext, initialGasDistribution int64) int64 {
+	return (initialGasDistribution - initialAlphabetGASAmount*int64(len(c.Wallets))) / 2
 }
 
 func transferFunds(c *helper.InitializeContext) error {
@@ -42,6 +41,11 @@ func transferFunds(c *helper.InitializeContext) error {
 		return err
 	}
 
+	version, err := c.Client.GetVersion()
+	if err != nil {
+		return err
+	}
+
 	var transfers []transferTarget
 	for _, acc := range c.Accounts {
 		to := acc.Contract.ScriptHash()
@@ -59,7 +63,7 @@ func transferFunds(c *helper.InitializeContext) error {
 		transferTarget{
 			Token:   gas.Hash,
 			Address: c.CommitteeAcc.Contract.ScriptHash(),
-			Amount:  initialCommitteeGASAmount(c),
+			Amount:  initialCommitteeGASAmount(c, int64(version.Protocol.InitialGasDistribution)),
 		},
 		transferTarget{
 			Token:   neo.Hash,
@@ -83,16 +87,23 @@ func transferFunds(c *helper.InitializeContext) error {
 // transferFundsFinished checks balances of accounts we transfer GAS to.
 // The stage is considered finished if the balance is greater than the half of what we need to transfer.
 func transferFundsFinished(c *helper.InitializeContext) (bool, error) {
-	acc := c.Accounts[0]
-
 	r := nep17.NewReader(c.ReadOnlyInvoker, gas.Hash)
-	res, err := r.BalanceOf(acc.Contract.ScriptHash())
-	if err != nil || res.Cmp(big.NewInt(initialAlphabetGASAmount/2)) != 1 {
+	res, err := r.BalanceOf(c.ConsensusAcc.ScriptHash())
+	if err != nil {
+		return false, err
+	}
+
+	version, err := c.Client.GetVersion()
+	if err != nil || res.Cmp(big.NewInt(int64(version.Protocol.InitialGasDistribution))) != -1 {
 		return false, err
 	}
 
 	res, err = r.BalanceOf(c.CommitteeAcc.ScriptHash())
-	return res != nil && res.Cmp(big.NewInt(initialCommitteeGASAmount(c)/2)) == 1, err
+	if err != nil {
+		return false, err
+	}
+
+	return res != nil && res.Cmp(big.NewInt(initialCommitteeGASAmount(c, int64(version.Protocol.InitialGasDistribution)))) == 1, err
 }
 
 func transferGASToProxy(c *helper.InitializeContext) error {

cmd/frostfs-adm/internal/modules/morph/policy/policy.go

@@ -80,9 +80,9 @@ func dumpPolicyCmd(cmd *cobra.Command, _ []string) error {
 	buf := bytes.NewBuffer(nil)
 	tw := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
 
-	_, _ = tw.Write([]byte(fmt.Sprintf("Execution Fee Factor:\t%d (int)\n", execFee)))
-	_, _ = tw.Write([]byte(fmt.Sprintf("Fee Per Byte:\t%d (int)\n", feePerByte)))
-	_, _ = tw.Write([]byte(fmt.Sprintf("Storage Price:\t%d (int)\n", storagePrice)))
+	_, _ = tw.Write(fmt.Appendf(nil, "Execution Fee Factor:\t%d (int)\n", execFee))
+	_, _ = tw.Write(fmt.Appendf(nil, "Fee Per Byte:\t%d (int)\n", feePerByte))
+	_, _ = tw.Write(fmt.Appendf(nil, "Storage Price:\t%d (int)\n", storagePrice))
 
 	_ = tw.Flush()
 	cmd.Print(buf.String())

cmd/frostfs-adm/internal/modules/storagecfg/config.go

@@ -40,8 +40,6 @@ morph:
     - address: wss://{{.}}/ws{{end}}
 {{if not .Relay }}
 storage:
-  shard_pool_size: 15  # size of per-shard worker pools used for PUT operations
-
   shard:
     default: # section with the default shard parameters
       metabase:

cmd/frostfs-adm/internal/modules/storagecfg/root.go

@@ -31,7 +31,6 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
 	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/wallet"
-
 	"github.com/spf13/cobra"
 )
 

cmd/frostfs-cli/internal/client/client.go

@@ -9,7 +9,6 @@ import (
 	"io"
 	"os"
 	"slices"
-	"strings"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/checksum"
@@ -77,9 +76,7 @@ func ListContainers(ctx context.Context, prm ListContainersPrm) (res ListContain
 // SortedIDList returns sorted list of identifiers of user's containers.
 func (x ListContainersRes) SortedIDList() []cid.ID {
 	list := x.cliRes.Containers()
-	slices.SortFunc(list, func(lhs, rhs cid.ID) int {
-		return strings.Compare(lhs.EncodeToString(), rhs.EncodeToString())
-	})
+	slices.SortFunc(list, cid.ID.Cmp)
 	return list
 }
 
@@ -687,9 +684,7 @@ func SearchObjects(ctx context.Context, prm SearchObjectsPrm) (*SearchObjectsRes
 		return nil, fmt.Errorf("read object list: %w", err)
 	}
 
-	slices.SortFunc(list, func(a, b oid.ID) int {
-		return strings.Compare(a.EncodeToString(), b.EncodeToString())
-	})
+	slices.SortFunc(list, oid.ID.Cmp)
 
 	return &SearchObjectsRes{
 		ids: list,

cmd/frostfs-cli/internal/commonflags/flags.go

@@ -28,7 +28,7 @@ const (
 	RPC          = "rpc-endpoint"
 	RPCShorthand = "r"
 	RPCDefault   = ""
-	RPCUsage     = "Remote node address (as 'multiaddr' or '<host>:<port>')"
+	RPCUsage     = "Remote node address ('<host>:<port>' or 'grpcs://<host>:<port>')"
 
 	Timeout          = "timeout"
 	TimeoutShorthand = "t"

cmd/frostfs-cli/modules/control/list_targets.go

@@ -62,7 +62,7 @@ func listTargets(cmd *cobra.Command, _ []string) {
 	tw := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
 	_, _ = tw.Write([]byte("#\tName\tType\n"))
 	for i, t := range targets {
-		_, _ = tw.Write([]byte(fmt.Sprintf("%s\t%s\t%s\n", strconv.Itoa(i), t.GetName(), t.GetType())))
+		_, _ = tw.Write(fmt.Appendf(nil, "%s\t%s\t%s\n", strconv.Itoa(i), t.GetName(), t.GetType()))
 	}
 	_ = tw.Flush()
 	cmd.Print(buf.String())

cmd/frostfs-cli/modules/control/locate.go

@@ -0,0 +1,117 @@
+package control
+
+import (
+	"bytes"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/commonflags"
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/key"
+	object "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/modules/object"
+	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
+	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/services/control"
+	rawclient "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/client"
+	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
+	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
+	"github.com/mr-tron/base58"
+	"github.com/spf13/cobra"
+)
+
+const (
+	FullInfoFlag      = "full"
+	FullInfoFlagUsage = "Print full ShardInfo."
+)
+
+var locateObjectCmd = &cobra.Command{
+	Use:   "locate-object",
+	Short: "List shards storing the object",
+	Long:  "List shards storing the object",
+	Run:   locateObject,
+}
+
+func initControlLocateObjectCmd() {
+	initControlFlags(locateObjectCmd)
+
+	flags := locateObjectCmd.Flags()
+
+	flags.String(commonflags.CIDFlag, "", commonflags.CIDFlagUsage)
+	_ = locateObjectCmd.MarkFlagRequired(commonflags.CIDFlag)
+
+	flags.String(commonflags.OIDFlag, "", commonflags.OIDFlagUsage)
+	_ = locateObjectCmd.MarkFlagRequired(commonflags.OIDFlag)
+
+	flags.Bool(commonflags.JSON, false, "Print shard info as a JSON array. Requires --full flag.")
+	flags.Bool(FullInfoFlag, false, FullInfoFlagUsage)
+}
+
+func locateObject(cmd *cobra.Command, _ []string) {
+	var cnr cid.ID
+	var obj oid.ID
+
+	_ = object.ReadObjectAddress(cmd, &cnr, &obj)
+
+	pk := key.Get(cmd)
+
+	body := new(control.ListShardsForObjectRequest_Body)
+	body.SetContainerId(cnr.EncodeToString())
+	body.SetObjectId(obj.EncodeToString())
+	req := new(control.ListShardsForObjectRequest)
+	req.SetBody(body)
+	signRequest(cmd, pk, req)
+
+	cli := getClient(cmd, pk)
+
+	var err error
+	var resp *control.ListShardsForObjectResponse
+	err = cli.ExecRaw(func(client *rawclient.Client) error {
+		resp, err = control.ListShardsForObject(client, req)
+		return err
+	})
+	commonCmd.ExitOnErr(cmd, "rpc error: %w", err)
+
+	verifyResponse(cmd, resp.GetSignature(), resp.GetBody())
+
+	shardIDs := resp.GetBody().GetShard_ID()
+
+	isFull, _ := cmd.Flags().GetBool(FullInfoFlag)
+	if !isFull {
+		for _, id := range shardIDs {
+			cmd.Println(base58.Encode(id))
+		}
+		return
+	}
+
+	// get full shard info
+	listShardsReq := new(control.ListShardsRequest)
+	listShardsReq.SetBody(new(control.ListShardsRequest_Body))
+	signRequest(cmd, pk, listShardsReq)
+	var listShardsResp *control.ListShardsResponse
+	err = cli.ExecRaw(func(client *rawclient.Client) error {
+		listShardsResp, err = control.ListShards(client, listShardsReq)
+		return err
+	})
+	commonCmd.ExitOnErr(cmd, "rpc error: %w", err)
+
+	verifyResponse(cmd, listShardsResp.GetSignature(), listShardsResp.GetBody())
+
+	shards := listShardsResp.GetBody().GetShards()
+	sortShardsByID(shards)
+	shards = filterShards(shards, shardIDs)
+
+	isJSON, _ := cmd.Flags().GetBool(commonflags.JSON)
+	if isJSON {
+		prettyPrintShardsJSON(cmd, shards)
+	} else {
+		prettyPrintShards(cmd, shards)
+	}
+}
+
+func filterShards(info []control.ShardInfo, ids [][]byte) []control.ShardInfo {
+	var res []control.ShardInfo
+	for _, id := range ids {
+		for _, inf := range info {
+			if bytes.Equal(inf.Shard_ID, id) {
+				res = append(res, inf)
+			}
+		}
+	}
+	return res
+}

cmd/frostfs-cli/modules/control/root.go

@@ -39,6 +39,7 @@ func init() {
 		listRulesCmd,
 		getRuleCmd,
 		listTargetsCmd,
+		locateObjectCmd,
 	)
 
 	initControlHealthCheckCmd()
@@ -52,4 +53,5 @@ func init() {
 	initControlListRulesCmd()
 	initControGetRuleCmd()
 	initControlListTargetsCmd()
+	initControlLocateObjectCmd()
 }

cmd/frostfs-cli/modules/object/delete.go

@@ -55,7 +55,7 @@ func deleteObject(cmd *cobra.Command, _ []string) {
 			commonCmd.ExitOnErr(cmd, "", fmt.Errorf("required flag \"%s\" not set", commonflags.OIDFlag))
 		}
 
-		objAddr = readObjectAddress(cmd, &cnr, &obj)
+		objAddr = ReadObjectAddress(cmd, &cnr, &obj)
 	}
 
 	pk := key.GetOrGenerate(cmd)

cmd/frostfs-cli/modules/object/get.go

@@ -46,7 +46,7 @@ func getObject(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := readObjectAddress(cmd, &cnr, &obj)
+	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
 
 	filename := cmd.Flag(fileFlag).Value.String()
 	out, closer := createOutWriter(cmd, filename)

cmd/frostfs-cli/modules/object/hash.go

@@ -52,7 +52,7 @@ func getObjectHash(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := readObjectAddress(cmd, &cnr, &obj)
+	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
 
 	ranges, err := getRangeList(cmd)
 	commonCmd.ExitOnErr(cmd, "", err)

cmd/frostfs-cli/modules/object/head.go

@@ -47,7 +47,7 @@ func getObjectHeader(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := readObjectAddress(cmd, &cnr, &obj)
+	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
 	pk := key.GetOrGenerate(cmd)
 
 	cli := internalclient.GetSDKClientByFlag(cmd, pk, commonflags.RPC)

cmd/frostfs-cli/modules/object/nodes.go

@@ -101,7 +101,7 @@ func initObjectNodesCmd() {
 func objectNodes(cmd *cobra.Command, _ []string) {
 	var cnrID cid.ID
 	var objID oid.ID
-	readObjectAddress(cmd, &cnrID, &objID)
+	ReadObjectAddress(cmd, &cnrID, &objID)
 
 	pk := key.GetOrGenerate(cmd)
 	cli := internalclient.GetSDKClientByFlag(cmd, pk, commonflags.RPC)

cmd/frostfs-cli/modules/object/patch.go

@@ -56,7 +56,7 @@ func patch(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := readObjectAddress(cmd, &cnr, &obj)
+	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
 
 	ranges, err := getRangeSlice(cmd)
 	commonCmd.ExitOnErr(cmd, "", err)

cmd/frostfs-cli/modules/object/range.go

@@ -47,7 +47,7 @@ func getObjectRange(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := readObjectAddress(cmd, &cnr, &obj)
+	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
 
 	ranges, err := getRangeList(cmd)
 	commonCmd.ExitOnErr(cmd, "", err)

cmd/frostfs-cli/modules/object/util.go

@@ -74,7 +74,7 @@ func parseXHeaders(cmd *cobra.Command) []string {
 	return xs
 }
 
-func readObjectAddress(cmd *cobra.Command, cnr *cid.ID, obj *oid.ID) oid.Address {
+func ReadObjectAddress(cmd *cobra.Command, cnr *cid.ID, obj *oid.ID) oid.Address {
 	readCID(cmd, cnr)
 	readOID(cmd, obj)
 

cmd/frostfs-cli/modules/tree/client.go

@@ -39,6 +39,7 @@ func _client() (tree.TreeServiceClient, error) {
 			tracing.NewStreamClientInterceptor(),
 		),
 		grpc.WithDefaultCallOptions(grpc.WaitForReady(true)),
+		grpc.WithDisableServiceConfig(),
 	}
 
 	if !strings.HasPrefix(netAddr.URIAddr(), "grpcs:") {

cmd/frostfs-lens/internal/meta/tui.go

@@ -2,13 +2,17 @@ package meta
 
 import (
 	"context"
+	"encoding/binary"
+	"errors"
 	"fmt"
 
 	common "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal"
+	schemaCommon "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/common"
 	schema "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/metabase"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/tui"
 	"github.com/rivo/tview"
 	"github.com/spf13/cobra"
+	"go.etcd.io/bbolt"
 )
 
 var tuiCMD = &cobra.Command{
@@ -27,6 +31,11 @@ Available search filters:
 
 var initialPrompt string
 
+var parserPerSchemaVersion = map[uint64]schemaCommon.Parser{
+	2: schema.MetabaseParserV2,
+	3: schema.MetabaseParserV3,
+}
+
 func init() {
 	common.AddComponentPathFlag(tuiCMD, &vPath)
 
@@ -49,12 +58,22 @@ func runTUI(cmd *cobra.Command) error {
 	}
 	defer db.Close()
 
+	schemaVersion, hasVersion := lookupSchemaVersion(cmd, db)
+	if !hasVersion {
+		return errors.New("couldn't detect schema version")
+	}
+
+	metabaseParser, ok := parserPerSchemaVersion[schemaVersion]
+	if !ok {
+		return fmt.Errorf("unknown schema version %d", schemaVersion)
+	}
+
 	// Need if app was stopped with Ctrl-C.
 	ctx, cancel := context.WithCancel(cmd.Context())
 	defer cancel()
 
 	app := tview.NewApplication()
-	ui := tui.NewUI(ctx, app, db, schema.MetabaseParser, nil)
+	ui := tui.NewUI(ctx, app, db, metabaseParser, nil)
 
 	_ = ui.AddFilter("cid", tui.CIDParser, "CID")
 	_ = ui.AddFilter("oid", tui.OIDParser, "OID")
@@ -69,3 +88,31 @@ func runTUI(cmd *cobra.Command) error {
 	app.SetRoot(ui, true).SetFocus(ui)
 	return app.Run()
 }
+
+var (
+	shardInfoBucket = []byte{5}
+	versionRecord   = []byte("version")
+)
+
+func lookupSchemaVersion(cmd *cobra.Command, db *bbolt.DB) (version uint64, ok bool) {
+	err := db.View(func(tx *bbolt.Tx) error {
+		bkt := tx.Bucket(shardInfoBucket)
+		if bkt == nil {
+			return nil
+		}
+		rec := bkt.Get(versionRecord)
+		if rec == nil {
+			return nil
+		}
+
+		version = binary.LittleEndian.Uint64(rec)
+		ok = true
+
+		return nil
+	})
+	if err != nil {
+		common.ExitOnErr(cmd, fmt.Errorf("couldn't lookup version: %w", err))
+	}
+
+	return
+}

cmd/frostfs-lens/internal/schema/metabase/buckets/parsers.go

@@ -80,10 +80,15 @@ var (
 		},
 	)
 
-	UserAttributeParser = NewUserAttributeKeyBucketParser(
+	UserAttributeParserV2 = NewUserAttributeKeyBucketParser(
 		NewUserAttributeValueBucketParser(records.UserAttributeRecordParser),
 	)
 
+	UserAttributeParserV3 = NewUserAttributeKeyBucketParserWithSpecificKeys(
+		NewUserAttributeValueBucketParser(records.UserAttributeRecordParser),
+		[]string{"FilePath", "S3-Access-Box-CRDT-Name"},
+	)
+
 	PayloadHashParser = NewPrefixContainerBucketParser(PayloadHash, records.PayloadHashRecordParser, Resolvers{
 		cidResolver: StrictResolver,
 		oidResolver: StrictResolver,
@@ -108,4 +113,14 @@ var (
 		cidResolver: StrictResolver,
 		oidResolver: LenientResolver,
 	})
+
+	ExpirationEpochToObjectParser = NewPrefixBucketParser(ExpirationEpochToObject, records.ExpirationEpochToObjectRecordParser, Resolvers{
+		cidResolver: LenientResolver,
+		oidResolver: LenientResolver,
+	})
+
+	ObjectToExpirationEpochParser = NewPrefixContainerBucketParser(ObjectToExpirationEpoch, records.ObjectToExpirationEpochRecordParser, Resolvers{
+		cidResolver: StrictResolver,
+		oidResolver: LenientResolver,
+	})
 )

cmd/frostfs-lens/internal/schema/metabase/buckets/prefix.go

@@ -22,27 +22,31 @@ const (
 	Split
 	ContainerCounters
 	ECInfo
+	ExpirationEpochToObject
+	ObjectToExpirationEpoch
 )
 
 var x = map[Prefix]string{
-	Graveyard:         "Graveyard",
-	Garbage:           "Garbage",
-	ToMoveIt:          "To Move It",
-	ContainerVolume:   "Container Volume",
-	Locked:            "Locked",
-	ShardInfo:         "Shard Info",
-	Primary:           "Primary",
-	Lockers:           "Lockers",
-	Tombstone:         "Tombstone",
-	Small:             "Small",
-	Root:              "Root",
-	Owner:             "Owner",
-	UserAttribute:     "User Attribute",
-	PayloadHash:       "Payload Hash",
-	Parent:            "Parent",
-	Split:             "Split",
-	ContainerCounters: "Container Counters",
-	ECInfo:            "EC Info",
+	Graveyard:               "Graveyard",
+	Garbage:                 "Garbage",
+	ToMoveIt:                "To Move It",
+	ContainerVolume:         "Container Volume",
+	Locked:                  "Locked",
+	ShardInfo:               "Shard Info",
+	Primary:                 "Primary",
+	Lockers:                 "Lockers",
+	Tombstone:               "Tombstone",
+	Small:                   "Small",
+	Root:                    "Root",
+	Owner:                   "Owner",
+	UserAttribute:           "User Attribute",
+	PayloadHash:             "Payload Hash",
+	Parent:                  "Parent",
+	Split:                   "Split",
+	ContainerCounters:       "Container Counters",
+	ECInfo:                  "EC Info",
+	ExpirationEpochToObject: "Exp. Epoch to Object",
+	ObjectToExpirationEpoch: "Object to Exp. Epoch",
 }
 
 func (p Prefix) String() string {

cmd/frostfs-lens/internal/schema/metabase/buckets/string.go

@@ -9,7 +9,7 @@ import (
 
 func (b *PrefixBucket) String() string {
 	return common.FormatSimple(
-		fmt.Sprintf("(%2d %-18s)", b.prefix, b.prefix), tcell.ColorLime,
+		fmt.Sprintf("(%2d %-20s)", b.prefix, b.prefix), tcell.ColorLime,
 	)
 }
 
@@ -17,7 +17,7 @@ func (b *PrefixContainerBucket) String() string {
 	return fmt.Sprintf(
 		"%s CID %s",
 		common.FormatSimple(
-			fmt.Sprintf("(%2d %-18s)", b.prefix, b.prefix), tcell.ColorLime,
+			fmt.Sprintf("(%2d %-20s)", b.prefix, b.prefix), tcell.ColorLime,
 		),
 		common.FormatSimple(b.id.String(), tcell.ColorAqua),
 	)
@@ -34,7 +34,7 @@ func (b *ContainerBucket) String() string {
 func (b *UserAttributeKeyBucket) String() string {
 	return fmt.Sprintf("%s CID %s ATTR-KEY %s",
 		common.FormatSimple(
-			fmt.Sprintf("(%2d %-18s)", b.prefix, b.prefix), tcell.ColorLime,
+			fmt.Sprintf("(%2d %-20s)", b.prefix, b.prefix), tcell.ColorLime,
 		),
 		common.FormatSimple(
 			fmt.Sprintf("%-44s", b.id), tcell.ColorAqua,

cmd/frostfs-lens/internal/schema/metabase/buckets/types.go

@@ -2,6 +2,7 @@ package buckets
 
 import (
 	"errors"
+	"slices"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/common"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
@@ -57,10 +58,11 @@ var (
 )
 
 var (
-	ErrNotBucket          = errors.New("not a bucket")
-	ErrInvalidKeyLength   = errors.New("invalid key length")
-	ErrInvalidValueLength = errors.New("invalid value length")
-	ErrInvalidPrefix      = errors.New("invalid prefix")
+	ErrNotBucket              = errors.New("not a bucket")
+	ErrInvalidKeyLength       = errors.New("invalid key length")
+	ErrInvalidValueLength     = errors.New("invalid value length")
+	ErrInvalidPrefix          = errors.New("invalid prefix")
+	ErrUnexpectedAttributeKey = errors.New("unexpected attribute key")
 )
 
 func NewPrefixBucketParser(prefix Prefix, next common.Parser, resolvers Resolvers) common.Parser {
@@ -132,6 +134,10 @@ func NewContainerBucketParser(next common.Parser, resolvers Resolvers) common.Pa
 }
 
 func NewUserAttributeKeyBucketParser(next common.Parser) common.Parser {
+	return NewUserAttributeKeyBucketParserWithSpecificKeys(next, nil)
+}
+
+func NewUserAttributeKeyBucketParserWithSpecificKeys(next common.Parser, keys []string) common.Parser {
 	return func(key, value []byte) (common.SchemaEntry, common.Parser, error) {
 		if value != nil {
 			return nil, nil, ErrNotBucket
@@ -147,6 +153,11 @@ func NewUserAttributeKeyBucketParser(next common.Parser) common.Parser {
 			return nil, nil, err
 		}
 		b.key = string(key[33:])
+
+		if len(keys) != 0 && !slices.Contains(keys, b.key) {
+			return nil, nil, ErrUnexpectedAttributeKey
+		}
+
 		return &b, next, nil
 	}
 }

cmd/frostfs-lens/internal/schema/metabase/parser.go

@@ -5,7 +5,30 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/metabase/buckets"
 )
 
-var MetabaseParser = common.WithFallback(
+var MetabaseParserV3 = common.WithFallback(
+	common.Any(
+		buckets.GraveyardParser,
+		buckets.GarbageParser,
+		buckets.ContainerVolumeParser,
+		buckets.LockedParser,
+		buckets.ShardInfoParser,
+		buckets.PrimaryParser,
+		buckets.LockersParser,
+		buckets.TombstoneParser,
+		buckets.SmallParser,
+		buckets.RootParser,
+		buckets.UserAttributeParserV3,
+		buckets.ParentParser,
+		buckets.SplitParser,
+		buckets.ContainerCountersParser,
+		buckets.ECInfoParser,
+		buckets.ExpirationEpochToObjectParser,
+		buckets.ObjectToExpirationEpochParser,
+	),
+	common.RawParser.ToFallbackParser(),
+)
+
+var MetabaseParserV2 = common.WithFallback(
 	common.Any(
 		buckets.GraveyardParser,
 		buckets.GarbageParser,
@@ -18,7 +41,7 @@ var MetabaseParser = common.WithFallback(
 		buckets.SmallParser,
 		buckets.RootParser,
 		buckets.OwnerParser,
-		buckets.UserAttributeParser,
+		buckets.UserAttributeParserV2,
 		buckets.PayloadHashParser,
 		buckets.ParentParser,
 		buckets.SplitParser,

cmd/frostfs-lens/internal/schema/metabase/records/detailed.go

@@ -63,3 +63,11 @@ func (r *ContainerCountersRecord) DetailedString() string {
 func (r *ECInfoRecord) DetailedString() string {
 	return spew.Sdump(*r)
 }
+
+func (r *ExpirationEpochToObjectRecord) DetailedString() string {
+	return spew.Sdump(*r)
+}
+
+func (r *ObjectToExpirationEpochRecord) DetailedString() string {
+	return spew.Sdump(*r)
+}

cmd/frostfs-lens/internal/schema/metabase/records/filter.go

@@ -143,3 +143,26 @@ func (r *ECInfoRecord) Filter(typ string, val any) common.FilterResult {
 		return common.No
 	}
 }
+
+func (r *ExpirationEpochToObjectRecord) Filter(typ string, val any) common.FilterResult {
+	switch typ {
+	case "cid":
+		id := val.(cid.ID)
+		return common.IfThenElse(r.cnt.Equals(id), common.Yes, common.No)
+	case "oid":
+		id := val.(oid.ID)
+		return common.IfThenElse(r.obj.Equals(id), common.Yes, common.No)
+	default:
+		return common.No
+	}
+}
+
+func (r *ObjectToExpirationEpochRecord) Filter(typ string, val any) common.FilterResult {
+	switch typ {
+	case "oid":
+		id := val.(oid.ID)
+		return common.IfThenElse(r.obj.Equals(id), common.Yes, common.No)
+	default:
+		return common.No
+	}
+}

cmd/frostfs-lens/internal/schema/metabase/records/parsers.go

@@ -249,3 +249,45 @@ func ECInfoRecordParser(key, value []byte) (common.SchemaEntry, common.Parser, e
 	}
 	return &r, nil, nil
 }
+
+func ExpirationEpochToObjectRecordParser(key, _ []byte) (common.SchemaEntry, common.Parser, error) {
+	if len(key) != 72 {
+		return nil, nil, ErrInvalidKeyLength
+	}
+
+	var (
+		r   ExpirationEpochToObjectRecord
+		err error
+	)
+
+	r.epoch = binary.BigEndian.Uint64(key[:8])
+	if err = r.cnt.Decode(key[8:40]); err != nil {
+		return nil, nil, err
+	}
+	if err = r.obj.Decode(key[40:]); err != nil {
+		return nil, nil, err
+	}
+
+	return &r, nil, nil
+}
+
+func ObjectToExpirationEpochRecordParser(key, value []byte) (common.SchemaEntry, common.Parser, error) {
+	if len(key) != 32 {
+		return nil, nil, ErrInvalidKeyLength
+	}
+	if len(value) != 8 {
+		return nil, nil, ErrInvalidValueLength
+	}
+
+	var (
+		r   ObjectToExpirationEpochRecord
+		err error
+	)
+
+	if err = r.obj.Decode(key); err != nil {
+		return nil, nil, err
+	}
+	r.epoch = binary.LittleEndian.Uint64(value)
+
+	return &r, nil, nil
+}

cmd/frostfs-lens/internal/schema/metabase/records/string.go

@@ -2,6 +2,7 @@ package records
 
 import (
 	"fmt"
+	"strconv"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/common"
 	"github.com/gdamore/tcell/v2"
@@ -133,3 +134,22 @@ func (r *ECInfoRecord) String() string {
 		len(r.ids),
 	)
 }
+
+func (r *ExpirationEpochToObjectRecord) String() string {
+	return fmt.Sprintf(
+		"exp. epoch %s %c CID %s OID %s",
+		common.FormatSimple(fmt.Sprintf("%-20d", r.epoch), tcell.ColorAqua),
+		tview.Borders.Vertical,
+		common.FormatSimple(fmt.Sprintf("%-44s", r.cnt), tcell.ColorAqua),
+		common.FormatSimple(fmt.Sprintf("%-44s", r.obj), tcell.ColorAqua),
+	)
+}
+
+func (r *ObjectToExpirationEpochRecord) String() string {
+	return fmt.Sprintf(
+		"OID %s %c exp. epoch %s",
+		common.FormatSimple(fmt.Sprintf("%-44s", r.obj), tcell.ColorAqua),
+		tview.Borders.Vertical,
+		common.FormatSimple(strconv.FormatUint(r.epoch, 10), tcell.ColorAqua),
+	)
+}

cmd/frostfs-lens/internal/schema/metabase/records/types.go

@@ -79,4 +79,15 @@ type (
 		id  oid.ID
 		ids []oid.ID
 	}
+
+	ExpirationEpochToObjectRecord struct {
+		epoch uint64
+		cnt   cid.ID
+		obj   oid.ID
+	}
+
+	ObjectToExpirationEpochRecord struct {
+		obj   oid.ID
+		epoch uint64
+	}
 )

cmd/frostfs-lens/internal/tui/input.go

@@ -1,6 +1,8 @@
 package tui
 
 import (
+	"slices"
+
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
@@ -26,7 +28,7 @@ func (f *InputFieldWithHistory) AddToHistory(s string) {
 
 	// Used history data for search prompt, so just make that data recent.
 	if f.historyPointer != len(f.history) && s == f.history[f.historyPointer] {
-		f.history = append(f.history[:f.historyPointer], f.history[f.historyPointer+1:]...)
+		f.history = slices.Delete(f.history, f.historyPointer, f.historyPointer+1)
 		f.history = append(f.history, s)
 	}
 

cmd/frostfs-node/config.go

@@ -33,6 +33,7 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/metrics"
 	internalNet "git.frostfs.info/TrueCloudLab/frostfs-node/internal/net"
+	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/qos"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/ape/chainbase"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/container"
 	frostfsidcore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/frostfsid"
@@ -69,6 +70,7 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/state"
 	"git.frostfs.info/TrueCloudLab/frostfs-observability/logging/lokicore"
 	"git.frostfs.info/TrueCloudLab/frostfs-observability/tracing"
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/limiting"
 	netmapV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
 	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
@@ -115,7 +117,6 @@ type applicationConfiguration struct {
 
 	EngineCfg struct {
 		errorThreshold uint32
-		shardPoolSize  uint32
 		shards         []shardCfg
 		lowMem         bool
 	}
@@ -134,6 +135,7 @@ type shardCfg struct {
 	refillMetabase             bool
 	refillMetabaseWorkersCount int
 	mode                       shardmode.Mode
+	limiter                    qos.Limiter
 
 	metaCfg struct {
 		path          string
@@ -247,45 +249,47 @@ func (a *applicationConfiguration) readConfig(c *config.Config) error {
 	// Storage Engine
 
 	a.EngineCfg.errorThreshold = engineconfig.ShardErrorThreshold(c)
-	a.EngineCfg.shardPoolSize = engineconfig.ShardPoolSize(c)
 	a.EngineCfg.lowMem = engineconfig.EngineLowMemoryConsumption(c)
 
 	return engineconfig.IterateShards(c, false, func(sc *shardconfig.Config) error { return a.updateShardConfig(c, sc) })
 }
 
-func (a *applicationConfiguration) updateShardConfig(c *config.Config, oldConfig *shardconfig.Config) error {
-	var newConfig shardCfg
+func (a *applicationConfiguration) updateShardConfig(c *config.Config, source *shardconfig.Config) error {
+	var target shardCfg
 
-	newConfig.refillMetabase = oldConfig.RefillMetabase()
-	newConfig.refillMetabaseWorkersCount = oldConfig.RefillMetabaseWorkersCount()
-	newConfig.mode = oldConfig.Mode()
-	newConfig.compress = oldConfig.Compress()
-	newConfig.estimateCompressibility = oldConfig.EstimateCompressibility()
-	newConfig.estimateCompressibilityThreshold = oldConfig.EstimateCompressibilityThreshold()
-	newConfig.uncompressableContentType = oldConfig.UncompressableContentTypes()
-	newConfig.smallSizeObjectLimit = oldConfig.SmallSizeLimit()
+	target.refillMetabase = source.RefillMetabase()
+	target.refillMetabaseWorkersCount = source.RefillMetabaseWorkersCount()
+	target.mode = source.Mode()
+	target.compress = source.Compress()
+	target.estimateCompressibility = source.EstimateCompressibility()
+	target.estimateCompressibilityThreshold = source.EstimateCompressibilityThreshold()
+	target.uncompressableContentType = source.UncompressableContentTypes()
+	target.smallSizeObjectLimit = source.SmallSizeLimit()
 
-	a.setShardWriteCacheConfig(&newConfig, oldConfig)
+	a.setShardWriteCacheConfig(&target, source)
 
-	a.setShardPiloramaConfig(c, &newConfig, oldConfig)
+	a.setShardPiloramaConfig(c, &target, source)
 
-	if err := a.setShardStorageConfig(&newConfig, oldConfig); err != nil {
+	if err := a.setShardStorageConfig(&target, source); err != nil {
 		return err
 	}
 
-	a.setMetabaseConfig(&newConfig, oldConfig)
+	a.setMetabaseConfig(&target, source)
 
-	a.setGCConfig(&newConfig, oldConfig)
+	a.setGCConfig(&target, source)
+	if err := a.setLimiter(&target, source); err != nil {
+		return err
+	}
 
-	a.EngineCfg.shards = append(a.EngineCfg.shards, newConfig)
+	a.EngineCfg.shards = append(a.EngineCfg.shards, target)
 
 	return nil
 }
 
-func (a *applicationConfiguration) setShardWriteCacheConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) {
-	writeCacheCfg := oldConfig.WriteCache()
+func (a *applicationConfiguration) setShardWriteCacheConfig(target *shardCfg, source *shardconfig.Config) {
+	writeCacheCfg := source.WriteCache()
 	if writeCacheCfg.Enabled() {
-		wc := &newConfig.writecacheCfg
+		wc := &target.writecacheCfg
 
 		wc.enabled = true
 		wc.path = writeCacheCfg.Path()
@@ -298,10 +302,10 @@ func (a *applicationConfiguration) setShardWriteCacheConfig(newConfig *shardCfg,
 	}
 }
 
-func (a *applicationConfiguration) setShardPiloramaConfig(c *config.Config, newConfig *shardCfg, oldConfig *shardconfig.Config) {
+func (a *applicationConfiguration) setShardPiloramaConfig(c *config.Config, target *shardCfg, source *shardconfig.Config) {
 	if config.BoolSafe(c.Sub("tree"), "enabled") {
-		piloramaCfg := oldConfig.Pilorama()
-		pr := &newConfig.piloramaCfg
+		piloramaCfg := source.Pilorama()
+		pr := &target.piloramaCfg
 
 		pr.enabled = true
 		pr.path = piloramaCfg.Path()
@@ -312,8 +316,8 @@ func (a *applicationConfiguration) setShardPiloramaConfig(c *config.Config, newC
 	}
 }
 
-func (a *applicationConfiguration) setShardStorageConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) error {
-	blobStorCfg := oldConfig.BlobStor()
+func (a *applicationConfiguration) setShardStorageConfig(target *shardCfg, source *shardconfig.Config) error {
+	blobStorCfg := source.BlobStor()
 	storagesCfg := blobStorCfg.Storages()
 
 	ss := make([]subStorageCfg, 0, len(storagesCfg))
@@ -347,13 +351,13 @@ func (a *applicationConfiguration) setShardStorageConfig(newConfig *shardCfg, ol
 		ss = append(ss, sCfg)
 	}
 
-	newConfig.subStorages = ss
+	target.subStorages = ss
 	return nil
 }
 
-func (a *applicationConfiguration) setMetabaseConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) {
-	metabaseCfg := oldConfig.Metabase()
-	m := &newConfig.metaCfg
+func (a *applicationConfiguration) setMetabaseConfig(target *shardCfg, source *shardconfig.Config) {
+	metabaseCfg := source.Metabase()
+	m := &target.metaCfg
 
 	m.path = metabaseCfg.Path()
 	m.perm = metabaseCfg.BoltDB().Perm()
@@ -361,12 +365,25 @@ func (a *applicationConfiguration) setMetabaseConfig(newConfig *shardCfg, oldCon
 	m.maxBatchSize = metabaseCfg.BoltDB().MaxBatchSize()
 }
 
-func (a *applicationConfiguration) setGCConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) {
-	gcCfg := oldConfig.GC()
-	newConfig.gcCfg.removerBatchSize = gcCfg.RemoverBatchSize()
-	newConfig.gcCfg.removerSleepInterval = gcCfg.RemoverSleepInterval()
-	newConfig.gcCfg.expiredCollectorBatchSize = gcCfg.ExpiredCollectorBatchSize()
-	newConfig.gcCfg.expiredCollectorWorkerCount = gcCfg.ExpiredCollectorWorkerCount()
+func (a *applicationConfiguration) setGCConfig(target *shardCfg, source *shardconfig.Config) {
+	gcCfg := source.GC()
+	target.gcCfg.removerBatchSize = gcCfg.RemoverBatchSize()
+	target.gcCfg.removerSleepInterval = gcCfg.RemoverSleepInterval()
+	target.gcCfg.expiredCollectorBatchSize = gcCfg.ExpiredCollectorBatchSize()
+	target.gcCfg.expiredCollectorWorkerCount = gcCfg.ExpiredCollectorWorkerCount()
+}
+
+func (a *applicationConfiguration) setLimiter(target *shardCfg, source *shardconfig.Config) error {
+	limitsConfig := source.Limits()
+	limiter, err := qos.NewLimiter(limitsConfig)
+	if err != nil {
+		return err
+	}
+	if target.limiter != nil {
+		target.limiter.Close()
+	}
+	target.limiter = limiter
+	return nil
 }
 
 // internals contains application-specific internals that are created
@@ -528,6 +545,8 @@ type cfgGRPC struct {
 	maxChunkSize     uint64
 	maxAddrAmount    uint64
 	reconnectTimeout time.Duration
+
+	limiter atomic.Pointer[limiting.SemaphoreLimiter]
 }
 
 func (c *cfgGRPC) append(e string, l net.Listener, s *grpc.Server) {
@@ -664,10 +683,6 @@ type cfgAccessPolicyEngine struct {
 }
 
 type cfgObjectRoutines struct {
-	putRemote *ants.Pool
-
-	putLocal *ants.Pool
-
 	replication *ants.Pool
 }
 
@@ -852,14 +867,14 @@ func initFrostfsID(appCfg *config.Config) cfgFrostfsID {
 	}
 }
 
-func initCfgGRPC() cfgGRPC {
+func initCfgGRPC() (cfg cfgGRPC) {
 	maxChunkSize := uint64(maxMsgSize) * 3 / 4  // 25% to meta, 75% to payload
 	maxAddrAmount := maxChunkSize / addressSize // each address is about 72 bytes
 
-	return cfgGRPC{
-		maxChunkSize:  maxChunkSize,
-		maxAddrAmount: maxAddrAmount,
-	}
+	cfg.maxChunkSize = maxChunkSize
+	cfg.maxAddrAmount = maxAddrAmount
+
+	return
 }
 
 func initCfgObject(appCfg *config.Config) cfgObject {
@@ -876,7 +891,6 @@ func (c *cfg) engineOpts() []engine.Option {
 	var opts []engine.Option
 
 	opts = append(opts,
-		engine.WithShardPoolSize(c.EngineCfg.shardPoolSize),
 		engine.WithErrorThreshold(c.EngineCfg.errorThreshold),
 		engine.WithLogger(c.log),
 		engine.WithLowMemoryConsumption(c.EngineCfg.lowMem),
@@ -916,6 +930,7 @@ func (c *cfg) getWriteCacheOpts(shCfg shardCfg) []writecache.Option {
 			writecache.WithMaxCacheCount(wcRead.countLimit),
 			writecache.WithNoSync(wcRead.noSync),
 			writecache.WithLogger(c.log),
+			writecache.WithQoSLimiter(shCfg.limiter),
 		)
 	}
 	return writeCacheOpts
@@ -1031,6 +1046,7 @@ func (c *cfg) getShardOpts(ctx context.Context, shCfg shardCfg) shardOptsWithID
 	}
 	if c.metricsCollector != nil {
 		mbOptions = append(mbOptions, meta.WithMetrics(lsmetrics.NewMetabaseMetrics(shCfg.metaCfg.path, c.metricsCollector.MetabaseMetrics())))
+		shCfg.limiter.SetMetrics(c.metricsCollector.QoSMetrics())
 	}
 
 	var sh shardOptsWithID
@@ -1055,6 +1071,7 @@ func (c *cfg) getShardOpts(ctx context.Context, shCfg shardCfg) shardOptsWithID
 
 			return pool
 		}),
+		shard.WithLimiter(shCfg.limiter),
 	}
 	return sh
 }
@@ -1166,21 +1183,7 @@ func initAccessPolicyEngine(ctx context.Context, c *cfg) {
 func initObjectPool(cfg *config.Config) (pool cfgObjectRoutines) {
 	var err error
 
-	optNonBlocking := ants.WithNonblocking(true)
-
-	putRemoteCapacity := objectconfig.Put(cfg).PoolSizeRemote()
-	pool.putRemote, err = ants.NewPool(putRemoteCapacity, optNonBlocking)
-	fatalOnErr(err)
-
-	putLocalCapacity := objectconfig.Put(cfg).PoolSizeLocal()
-	pool.putLocal, err = ants.NewPool(putLocalCapacity, optNonBlocking)
-	fatalOnErr(err)
-
 	replicatorPoolSize := replicatorconfig.PoolSize(cfg)
-	if replicatorPoolSize <= 0 {
-		replicatorPoolSize = putRemoteCapacity
-	}
-
 	pool.replication, err = ants.NewPool(replicatorPoolSize)
 	fatalOnErr(err)
 
@@ -1410,17 +1413,13 @@ func (c *cfg) getComponents(ctx context.Context, logPrm *logger.Prm) []dCmp {
 		components = append(components, dCmp{cmp.name, func() error { return cmp.reload(ctx) }})
 	}
 
+	components = append(components, dCmp{"rpc_limiter", func() error { return initRPCLimiter(c) }})
+
 	return components
 }
 
 func (c *cfg) reloadPools() error {
-	newSize := objectconfig.Put(c.appCfg).PoolSizeLocal()
-	c.reloadPool(c.cfgObject.pool.putLocal, newSize, "object.put.local_pool_size")
-
-	newSize = objectconfig.Put(c.appCfg).PoolSizeRemote()
-	c.reloadPool(c.cfgObject.pool.putRemote, newSize, "object.put.remote_pool_size")
-
-	newSize = replicatorconfig.PoolSize(c.appCfg)
+	newSize := replicatorconfig.PoolSize(c.appCfg)
 	c.reloadPool(c.cfgObject.pool.replication, newSize, "replicator.pool_size")
 
 	return nil

cmd/frostfs-node/config/configdir_test.go

@@ -12,13 +12,10 @@ import (
 func TestConfigDir(t *testing.T) {
 	dir := t.TempDir()
 
-	cfgFileName0 := path.Join(dir, "cfg_00.json")
-	cfgFileName1 := path.Join(dir, "cfg_01.yml")
+	cfgFileName := path.Join(dir, "cfg_01.yml")
 
-	require.NoError(t, os.WriteFile(cfgFileName0, []byte(`{"storage":{"shard_pool_size":15}}`), 0o777))
-	require.NoError(t, os.WriteFile(cfgFileName1, []byte("logger:\n  level: debug"), 0o777))
+	require.NoError(t, os.WriteFile(cfgFileName, []byte("logger:\n  level: debug"), 0o777))
 
 	c := New("", dir, "")
 	require.Equal(t, "debug", cast.ToString(c.Sub("logger").Value("level")))
-	require.EqualValues(t, 15, cast.ToUint32(c.Sub("storage").Value("shard_pool_size")))
 }

cmd/frostfs-node/config/engine/config.go

@@ -11,10 +11,6 @@ import (
 
 const (
 	subsection = "storage"
-
-	// ShardPoolSizeDefault is a default value of routine pool size per-shard to
-	// process object PUT operations in a storage engine.
-	ShardPoolSizeDefault = 20
 )
 
 // ErrNoShardConfigured is returned when at least 1 shard is required but none are found.
@@ -65,18 +61,6 @@ func IterateShards(c *config.Config, required bool, f func(*shardconfig.Config)
 	return nil
 }
 
-// ShardPoolSize returns the value of "shard_pool_size" config parameter from "storage" section.
-//
-// Returns ShardPoolSizeDefault if the value is not a positive number.
-func ShardPoolSize(c *config.Config) uint32 {
-	v := config.Uint32Safe(c.Sub(subsection), "shard_pool_size")
-	if v > 0 {
-		return v
-	}
-
-	return ShardPoolSizeDefault
-}
-
 // ShardErrorThreshold returns the value of "shard_ro_error_threshold" config parameter from "storage" section.
 //
 // Returns 0 if the the value is missing.

cmd/frostfs-node/config/engine/config_test.go

@@ -11,6 +11,7 @@ import (
 	blobovniczaconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/blobstor/blobovnicza"
 	fstreeconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/blobstor/fstree"
 	gcconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/gc"
+	limitsconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/limits"
 	piloramaconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/pilorama"
 	writecacheconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/writecache"
 	configtest "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/test"
@@ -53,7 +54,6 @@ func TestEngineSection(t *testing.T) {
 		require.False(t, handlerCalled)
 
 		require.EqualValues(t, 0, engineconfig.ShardErrorThreshold(empty))
-		require.EqualValues(t, engineconfig.ShardPoolSizeDefault, engineconfig.ShardPoolSize(empty))
 		require.EqualValues(t, mode.ReadWrite, shardconfig.From(empty).Mode())
 	})
 
@@ -63,7 +63,6 @@ func TestEngineSection(t *testing.T) {
 		num := 0
 
 		require.EqualValues(t, 100, engineconfig.ShardErrorThreshold(c))
-		require.EqualValues(t, 15, engineconfig.ShardPoolSize(c))
 
 		err := engineconfig.IterateShards(c, true, func(sc *shardconfig.Config) error {
 			defer func() {
@@ -76,6 +75,7 @@ func TestEngineSection(t *testing.T) {
 			ss := blob.Storages()
 			pl := sc.Pilorama()
 			gc := sc.GC()
+			limits := sc.Limits()
 
 			switch num {
 			case 0:
@@ -134,6 +134,75 @@ func TestEngineSection(t *testing.T) {
 				require.Equal(t, false, sc.RefillMetabase())
 				require.Equal(t, mode.ReadOnly, sc.Mode())
 				require.Equal(t, 100, sc.RefillMetabaseWorkersCount())
+
+				readLimits := limits.Read()
+				writeLimits := limits.Write()
+				require.Equal(t, 30*time.Second, readLimits.IdleTimeout)
+				require.Equal(t, int64(10_000), readLimits.MaxRunningOps)
+				require.Equal(t, int64(1_000), readLimits.MaxWaitingOps)
+				require.Equal(t, 45*time.Second, writeLimits.IdleTimeout)
+				require.Equal(t, int64(1_000), writeLimits.MaxRunningOps)
+				require.Equal(t, int64(100), writeLimits.MaxWaitingOps)
+				require.ElementsMatch(t, readLimits.Tags,
+					[]limitsconfig.IOTagConfig{
+						{
+							Tag:         "internal",
+							Weight:      toPtr(20),
+							ReservedOps: toPtr(1000),
+							LimitOps:    toPtr(0),
+						},
+						{
+							Tag:         "client",
+							Weight:      toPtr(70),
+							ReservedOps: toPtr(10000),
+						},
+						{
+							Tag:         "background",
+							Weight:      toPtr(5),
+							LimitOps:    toPtr(10000),
+							ReservedOps: toPtr(0),
+						},
+						{
+							Tag:      "writecache",
+							Weight:   toPtr(5),
+							LimitOps: toPtr(25000),
+						},
+						{
+							Tag:      "policer",
+							Weight:   toPtr(5),
+							LimitOps: toPtr(25000),
+						},
+					})
+				require.ElementsMatch(t, writeLimits.Tags,
+					[]limitsconfig.IOTagConfig{
+						{
+							Tag:         "internal",
+							Weight:      toPtr(200),
+							ReservedOps: toPtr(100),
+							LimitOps:    toPtr(0),
+						},
+						{
+							Tag:         "client",
+							Weight:      toPtr(700),
+							ReservedOps: toPtr(1000),
+						},
+						{
+							Tag:         "background",
+							Weight:      toPtr(50),
+							LimitOps:    toPtr(1000),
+							ReservedOps: toPtr(0),
+						},
+						{
+							Tag:      "writecache",
+							Weight:   toPtr(50),
+							LimitOps: toPtr(2500),
+						},
+						{
+							Tag:      "policer",
+							Weight:   toPtr(50),
+							LimitOps: toPtr(2500),
+						},
+					})
 			case 1:
 				require.Equal(t, "tmp/1/blob/pilorama.db", pl.Path())
 				require.Equal(t, fs.FileMode(0o644), pl.Perm())
@@ -188,6 +257,17 @@ func TestEngineSection(t *testing.T) {
 				require.Equal(t, true, sc.RefillMetabase())
 				require.Equal(t, mode.ReadWrite, sc.Mode())
 				require.Equal(t, shardconfig.RefillMetabaseWorkersCountDefault, sc.RefillMetabaseWorkersCount())
+
+				readLimits := limits.Read()
+				writeLimits := limits.Write()
+				require.Equal(t, limitsconfig.DefaultIdleTimeout, readLimits.IdleTimeout)
+				require.Equal(t, limitsconfig.NoLimit, readLimits.MaxRunningOps)
+				require.Equal(t, limitsconfig.NoLimit, readLimits.MaxWaitingOps)
+				require.Equal(t, limitsconfig.DefaultIdleTimeout, writeLimits.IdleTimeout)
+				require.Equal(t, limitsconfig.NoLimit, writeLimits.MaxRunningOps)
+				require.Equal(t, limitsconfig.NoLimit, writeLimits.MaxWaitingOps)
+				require.Equal(t, 0, len(readLimits.Tags))
+				require.Equal(t, 0, len(writeLimits.Tags))
 			}
 			return nil
 		})
@@ -201,3 +281,7 @@ func TestEngineSection(t *testing.T) {
 		configtest.ForEnvFileType(t, path, fileConfigTest)
 	})
 }
+
+func toPtr(v float64) *float64 {
+	return &v
+}

cmd/frostfs-node/config/engine/shard/boltdb/boltdb.go

@@ -37,10 +37,7 @@ func (x *Config) Perm() fs.FileMode {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchDelay() time.Duration {
 	d := config.DurationSafe((*config.Config)(x), "max_batch_delay")
-	if d < 0 {
-		d = 0
-	}
-	return d
+	return max(d, 0)
 }
 
 // MaxBatchSize returns the value of "max_batch_size" config parameter.
@@ -48,10 +45,7 @@ func (x *Config) MaxBatchDelay() time.Duration {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchSize() int {
 	s := int(config.IntSafe((*config.Config)(x), "max_batch_size"))
-	if s < 0 {
-		s = 0
-	}
-	return s
+	return max(s, 0)
 }
 
 // NoSync returns the value of "no_sync" config parameter.
@@ -66,8 +60,5 @@ func (x *Config) NoSync() bool {
 // Returns 0 if the value is not a positive number.
 func (x *Config) PageSize() int {
 	s := int(config.SizeInBytesSafe((*config.Config)(x), "page_size"))
-	if s < 0 {
-		s = 0
-	}
-	return s
+	return max(s, 0)
 }

cmd/frostfs-node/config/engine/shard/config.go

@@ -4,6 +4,7 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
 	blobstorconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/blobstor"
 	gcconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/gc"
+	limitsconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/limits"
 	metabaseconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/metabase"
 	piloramaconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/pilorama"
 	writecacheconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/writecache"
@@ -125,6 +126,14 @@ func (x *Config) GC() *gcconfig.Config {
 	)
 }
 
+// Limits returns "limits" subsection as a limitsconfig.Config.
+func (x *Config) Limits() *limitsconfig.Config {
+	return limitsconfig.From(
+		(*config.Config)(x).
+			Sub("limits"),
+	)
+}
+
 // RefillMetabase returns the value of "resync_metabase" config parameter.
 //
 // Returns false if the value is not a valid bool.

cmd/frostfs-node/config/engine/shard/limits/config.go

@@ -0,0 +1,130 @@
+package limits
+
+import (
+	"math"
+	"strconv"
+	"time"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
+	"github.com/spf13/cast"
+)
+
+const (
+	NoLimit            int64 = math.MaxInt64
+	DefaultIdleTimeout       = 5 * time.Minute
+)
+
+// From wraps config section into Config.
+func From(c *config.Config) *Config {
+	return (*Config)(c)
+}
+
+// Config is a wrapper over the config section
+// which provides access to Shard's limits configurations.
+type Config config.Config
+
+// Read returns the value of "read" limits config section.
+func (x *Config) Read() OpConfig {
+	return x.parse("read")
+}
+
+// Write returns the value of "write" limits config section.
+func (x *Config) Write() OpConfig {
+	return x.parse("write")
+}
+
+func (x *Config) parse(sub string) OpConfig {
+	c := (*config.Config)(x).Sub(sub)
+	var result OpConfig
+
+	if s := config.Int(c, "max_waiting_ops"); s > 0 {
+		result.MaxWaitingOps = s
+	} else {
+		result.MaxWaitingOps = NoLimit
+	}
+
+	if s := config.Int(c, "max_running_ops"); s > 0 {
+		result.MaxRunningOps = s
+	} else {
+		result.MaxRunningOps = NoLimit
+	}
+
+	if s := config.DurationSafe(c, "idle_timeout"); s > 0 {
+		result.IdleTimeout = s
+	} else {
+		result.IdleTimeout = DefaultIdleTimeout
+	}
+
+	result.Tags = tags(c)
+
+	return result
+}
+
+type OpConfig struct {
+	// MaxWaitingOps returns the value of "max_waiting_ops" config parameter.
+	//
+	// Equals NoLimit if the value is not a positive number.
+	MaxWaitingOps int64
+	// MaxRunningOps returns the value of "max_running_ops" config parameter.
+	//
+	// Equals NoLimit if the value is not a positive number.
+	MaxRunningOps int64
+	// IdleTimeout returns the value of "idle_timeout" config parameter.
+	//
+	// Equals DefaultIdleTimeout if the value is not a valid duration.
+	IdleTimeout time.Duration
+	// Tags returns the value of "tags" config parameter.
+	//
+	// Equals nil if the value is not a valid tags config slice.
+	Tags []IOTagConfig
+}
+
+type IOTagConfig struct {
+	Tag         string
+	Weight      *float64
+	LimitOps    *float64
+	ReservedOps *float64
+}
+
+func tags(c *config.Config) []IOTagConfig {
+	c = c.Sub("tags")
+	var result []IOTagConfig
+	for i := 0; ; i++ {
+		tag := config.String(c, strconv.Itoa(i)+".tag")
+		if tag == "" {
+			return result
+		}
+
+		var tagConfig IOTagConfig
+		tagConfig.Tag = tag
+
+		v := c.Value(strconv.Itoa(i) + ".weight")
+		if v != nil {
+			w, err := cast.ToFloat64E(v)
+			panicOnErr(err)
+			tagConfig.Weight = &w
+		}
+
+		v = c.Value(strconv.Itoa(i) + ".limit_ops")
+		if v != nil {
+			l, err := cast.ToFloat64E(v)
+			panicOnErr(err)
+			tagConfig.LimitOps = &l
+		}
+
+		v = c.Value(strconv.Itoa(i) + ".reserved_ops")
+		if v != nil {
+			r, err := cast.ToFloat64E(v)
+			panicOnErr(err)
+			tagConfig.ReservedOps = &r
+		}
+
+		result = append(result, tagConfig)
+	}
+}
+
+func panicOnErr(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

cmd/frostfs-node/config/engine/shard/pilorama/config.go

@@ -52,10 +52,7 @@ func (x *Config) NoSync() bool {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchDelay() time.Duration {
 	d := config.DurationSafe((*config.Config)(x), "max_batch_delay")
-	if d <= 0 {
-		d = 0
-	}
-	return d
+	return max(d, 0)
 }
 
 // MaxBatchSize returns the value of "max_batch_size" config parameter.
@@ -63,8 +60,5 @@ func (x *Config) MaxBatchDelay() time.Duration {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchSize() int {
 	s := int(config.IntSafe((*config.Config)(x), "max_batch_size"))
-	if s <= 0 {
-		s = 0
-	}
-	return s
+	return max(s, 0)
 }

cmd/frostfs-node/config/object/config.go

@@ -21,10 +21,6 @@ const (
 
 	putSubsection = "put"
 	getSubsection = "get"
-
-	// PutPoolSizeDefault is a default value of routine pool size to
-	// process object.Put requests in object service.
-	PutPoolSizeDefault = 10
 )
 
 // Put returns structure that provides access to "put" subsection of
@@ -35,30 +31,6 @@ func Put(c *config.Config) PutConfig {
 	}
 }
 
-// PoolSizeRemote returns the value of "remote_pool_size" config parameter.
-//
-// Returns PutPoolSizeDefault if the value is not a positive number.
-func (g PutConfig) PoolSizeRemote() int {
-	v := config.Int(g.cfg, "remote_pool_size")
-	if v > 0 {
-		return int(v)
-	}
-
-	return PutPoolSizeDefault
-}
-
-// PoolSizeLocal returns the value of "local_pool_size" config parameter.
-//
-// Returns PutPoolSizeDefault if the value is not a positive number.
-func (g PutConfig) PoolSizeLocal() int {
-	v := config.Int(g.cfg, "local_pool_size")
-	if v > 0 {
-		return int(v)
-	}
-
-	return PutPoolSizeDefault
-}
-
 // SkipSessionTokenIssuerVerification returns the value of "skip_session_token_issuer_verification" config parameter or `false“ if is not defined.
 func (g PutConfig) SkipSessionTokenIssuerVerification() bool {
 	return config.BoolSafe(g.cfg, "skip_session_token_issuer_verification")

cmd/frostfs-node/config/object/config_test.go

@@ -13,8 +13,6 @@ func TestObjectSection(t *testing.T) {
 	t.Run("defaults", func(t *testing.T) {
 		empty := configtest.EmptyConfig()
 
-		require.Equal(t, objectconfig.PutPoolSizeDefault, objectconfig.Put(empty).PoolSizeRemote())
-		require.Equal(t, objectconfig.PutPoolSizeDefault, objectconfig.Put(empty).PoolSizeLocal())
 		require.EqualValues(t, objectconfig.DefaultTombstoneLifetime, objectconfig.TombstoneLifetime(empty))
 		require.False(t, objectconfig.Put(empty).SkipSessionTokenIssuerVerification())
 	})
@@ -22,8 +20,6 @@ func TestObjectSection(t *testing.T) {
 	const path = "../../../../config/example/node"
 
 	fileConfigTest := func(c *config.Config) {
-		require.Equal(t, 100, objectconfig.Put(c).PoolSizeRemote())
-		require.Equal(t, 200, objectconfig.Put(c).PoolSizeLocal())
 		require.EqualValues(t, 10, objectconfig.TombstoneLifetime(c))
 		require.True(t, objectconfig.Put(c).SkipSessionTokenIssuerVerification())
 	}

cmd/frostfs-node/config/replicator/config.go

@@ -11,6 +11,8 @@ const (
 
 	// PutTimeoutDefault is a default timeout of object put request in replicator.
 	PutTimeoutDefault = 5 * time.Second
+	// PoolSizeDefault is a default pool size for put request in replicator.
+	PoolSizeDefault = 10
 )
 
 // PutTimeout returns the value of "put_timeout" config parameter
@@ -28,6 +30,13 @@ func PutTimeout(c *config.Config) time.Duration {
 
 // PoolSize returns the value of "pool_size" config parameter
 // from "replicator" section.
+//
+// Returns PoolSizeDefault if the value is non-positive integer.
 func PoolSize(c *config.Config) int {
-	return int(config.IntSafe(c.Sub(subsection), "pool_size"))
+	v := int(config.IntSafe(c.Sub(subsection), "pool_size"))
+	if v > 0 {
+		return v
+	}
+
+	return PoolSizeDefault
 }

cmd/frostfs-node/config/replicator/config_test.go

@@ -15,7 +15,7 @@ func TestReplicatorSection(t *testing.T) {
 		empty := configtest.EmptyConfig()
 
 		require.Equal(t, replicatorconfig.PutTimeoutDefault, replicatorconfig.PutTimeout(empty))
-		require.Equal(t, 0, replicatorconfig.PoolSize(empty))
+		require.Equal(t, replicatorconfig.PoolSizeDefault, replicatorconfig.PoolSize(empty))
 	})
 
 	const path = "../../../../config/example/node"

cmd/frostfs-node/config/rpc/config.go

@@ -0,0 +1,43 @@
+package rpcconfig
+
+import (
+	"strconv"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
+)
+
+const (
+	subsection       = "rpc"
+	limitsSubsection = "limits"
+)
+
+type LimitConfig struct {
+	Methods []string
+	MaxOps  int64
+}
+
+// Limits returns the "limits" config from "rpc" section.
+func Limits(c *config.Config) []LimitConfig {
+	c = c.Sub(subsection).Sub(limitsSubsection)
+
+	var limits []LimitConfig
+
+	for i := uint64(0); ; i++ {
+		si := strconv.FormatUint(i, 10)
+		sc := c.Sub(si)
+
+		methods := config.StringSliceSafe(sc, "methods")
+		if len(methods) == 0 {
+			break
+		}
+
+		maxOps := config.IntSafe(sc, "max_ops")
+		if maxOps == 0 {
+			panic("no max operations for method group")
+		}
+
+		limits = append(limits, LimitConfig{methods, maxOps})
+	}
+
+	return limits
+}

cmd/frostfs-node/config/rpc/config_test.go

@@ -0,0 +1,53 @@
+package rpcconfig
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
+	configtest "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/test"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRPCSection(t *testing.T) {
+	t.Run("defaults", func(t *testing.T) {
+		require.Empty(t, Limits(configtest.EmptyConfig()))
+	})
+
+	t.Run("correct config", func(t *testing.T) {
+		const path = "../../../../config/example/node"
+
+		fileConfigTest := func(c *config.Config) {
+			limits := Limits(c)
+			require.Len(t, limits, 2)
+
+			limit0 := limits[0]
+			limit1 := limits[1]
+
+			require.ElementsMatch(t, limit0.Methods, []string{"/neo.fs.v2.object.ObjectService/PutSingle", "/neo.fs.v2.object.ObjectService/Put"})
+			require.Equal(t, limit0.MaxOps, int64(1000))
+
+			require.ElementsMatch(t, limit1.Methods, []string{"/neo.fs.v2.object.ObjectService/Get"})
+			require.Equal(t, limit1.MaxOps, int64(10000))
+		}
+
+		configtest.ForEachFileType(path, fileConfigTest)
+
+		t.Run("ENV", func(t *testing.T) {
+			configtest.ForEnvFileType(t, path, fileConfigTest)
+		})
+	})
+
+	t.Run("no max operations", func(t *testing.T) {
+		const path = "testdata/node"
+
+		fileConfigTest := func(c *config.Config) {
+			require.Panics(t, func() { _ = Limits(c) })
+		}
+
+		configtest.ForEachFileType(path, fileConfigTest)
+
+		t.Run("ENV", func(t *testing.T) {
+			configtest.ForEnvFileType(t, path, fileConfigTest)
+		})
+	})
+}

cmd/frostfs-node/config/rpc/testdata/node.env

@@ -0,0 +1,3 @@
+FROSTFS_RPC_LIMITS_0_METHODS="/neo.fs.v2.object.ObjectService/PutSingle /neo.fs.v2.object.ObjectService/Put"
+FROSTFS_RPC_LIMITS_1_METHODS="/neo.fs.v2.object.ObjectService/Get"
+FROSTFS_RPC_LIMITS_1_MAX_OPS=10000

cmd/frostfs-node/config/rpc/testdata/node.json

@@ -0,0 +1,18 @@
+{
+  "rpc": {
+    "limits": [
+      {
+        "methods": [
+          "/neo.fs.v2.object.ObjectService/PutSingle",
+          "/neo.fs.v2.object.ObjectService/Put"
+        ]
+      },
+      {
+        "methods": [
+          "/neo.fs.v2.object.ObjectService/Get"
+        ],
+        "max_ops": 10000
+      }
+    ]
+  }
+}

cmd/frostfs-node/config/rpc/testdata/node.yaml

@@ -0,0 +1,8 @@
+rpc:
+  limits:
+    - methods:
+      - /neo.fs.v2.object.ObjectService/PutSingle
+      - /neo.fs.v2.object.ObjectService/Put
+    - methods:
+      - /neo.fs.v2.object.ObjectService/Get
+      max_ops: 10000

cmd/frostfs-node/grpc.go

@@ -4,14 +4,18 @@ import (
 	"context"
 	"crypto/tls"
 	"errors"
+	"fmt"
 	"net"
 	"time"
 
 	grpcconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/grpc"
+	rpcconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/rpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
+	qosInternal "git.frostfs.info/TrueCloudLab/frostfs-node/internal/qos"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/logger"
 	metrics "git.frostfs.info/TrueCloudLab/frostfs-observability/metrics/grpc"
 	tracing "git.frostfs.info/TrueCloudLab/frostfs-observability/tracing/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/limiting"
 	qos "git.frostfs.info/TrueCloudLab/frostfs-qos/tagging"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
@@ -134,11 +138,13 @@ func getGrpcServerOpts(ctx context.Context, c *cfg, sc *grpcconfig.Config) ([]gr
 			qos.NewUnaryServerInterceptor(),
 			metrics.NewUnaryServerInterceptor(),
 			tracing.NewUnaryServerInterceptor(),
+			qosInternal.NewMaxActiveRPCLimiterUnaryServerInterceptor(func() limiting.Limiter { return c.cfgGRPC.limiter.Load() }),
 		),
 		grpc.ChainStreamInterceptor(
 			qos.NewStreamServerInterceptor(),
 			metrics.NewStreamServerInterceptor(),
 			tracing.NewStreamServerInterceptor(),
+			qosInternal.NewMaxActiveRPCLimiterStreamServerInterceptor(func() limiting.Limiter { return c.cfgGRPC.limiter.Load() }),
 		),
 	}
 
@@ -227,3 +233,54 @@ func stopGRPC(ctx context.Context, name string, s *grpc.Server, l *logger.Logger
 
 	l.Info(ctx, logs.FrostFSNodeGRPCServerStoppedSuccessfully)
 }
+
+func initRPCLimiter(c *cfg) error {
+	var limits []limiting.KeyLimit
+	for _, l := range rpcconfig.Limits(c.appCfg) {
+		limits = append(limits, limiting.KeyLimit{Keys: l.Methods, Limit: l.MaxOps})
+	}
+
+	if err := validateRPCLimits(c, limits); err != nil {
+		return fmt.Errorf("validate RPC limits: %w", err)
+	}
+
+	limiter, err := limiting.NewSemaphoreLimiter(limits)
+	if err != nil {
+		return fmt.Errorf("create RPC limiter: %w", err)
+	}
+
+	c.cfgGRPC.limiter.Store(limiter)
+	return nil
+}
+
+func validateRPCLimits(c *cfg, limits []limiting.KeyLimit) error {
+	availableMethods := getAvailableMethods(c.cfgGRPC.servers)
+	for _, limit := range limits {
+		for _, method := range limit.Keys {
+			if _, ok := availableMethods[method]; !ok {
+				return fmt.Errorf("set limit on an unknown method %q", method)
+			}
+		}
+	}
+	return nil
+}
+
+func getAvailableMethods(servers []grpcServer) map[string]struct{} {
+	res := make(map[string]struct{})
+	for _, server := range servers {
+		for _, method := range getMethodsForServer(server.Server) {
+			res[method] = struct{}{}
+		}
+	}
+	return res
+}
+
+func getMethodsForServer(server *grpc.Server) []string {
+	var res []string
+	for service, info := range server.GetServiceInfo() {
+		for _, method := range info.Methods {
+			res = append(res, fmt.Sprintf("/%s/%s", service, method.Name))
+		}
+	}
+	return res
+}

cmd/frostfs-node/main.go

@@ -117,6 +117,8 @@ func initApp(ctx context.Context, c *cfg) {
 	initAndLog(ctx, c, "apemanager", initAPEManagerService)
 	initAndLog(ctx, c, "control", func(c *cfg) { initControlService(ctx, c) })
 
+	initAndLog(ctx, c, "RPC limiter", func(c *cfg) { fatalOnErr(initRPCLimiter(c)) })
+
 	initAndLog(ctx, c, "morph notifications", func(c *cfg) { listenMorphNotifications(ctx, c) })
 }
 

cmd/frostfs-node/object.go

@@ -326,7 +326,6 @@ func createPutSvc(c *cfg, keyStorage *util.KeyStorage, irFetcher *cachedIRFetche
 		c,
 		c.cfgNetmap.state,
 		irFetcher,
-		objectwriter.WithWorkerPools(c.cfgObject.pool.putRemote, c.cfgObject.pool.putLocal),
 		objectwriter.WithLogger(c.log),
 		objectwriter.WithVerifySessionTokenIssuer(!c.cfgObject.skipSessionTokenIssuerVerification),
 	)

cmd/frostfs-node/qos.go

@@ -47,7 +47,7 @@ func (s *cfgQoSService) AdjustIncomingTag(ctx context.Context, requestSignPublic
 	}
 	ioTag, err := qos.FromRawString(rawTag)
 	if err != nil {
-		s.logger.Warn(ctx, logs.FailedToParseIncomingIOTag, zap.Error(err))
+		s.logger.Debug(ctx, logs.FailedToParseIncomingIOTag, zap.Error(err))
 		return qosTagging.ContextWithIOTag(ctx, qos.IOTagClient.String())
 	}
 
@@ -70,6 +70,7 @@ func (s *cfgQoSService) AdjustIncomingTag(ctx context.Context, requestSignPublic
 				return ctx
 			}
 		}
+		s.logger.Debug(ctx, logs.FailedToValidateIncomingIOTag)
 		return qosTagging.ContextWithIOTag(ctx, qos.IOTagClient.String())
 	case qos.IOTagInternal:
 		for _, pk := range s.allowedInternalPubs {
@@ -87,9 +88,10 @@ func (s *cfgQoSService) AdjustIncomingTag(ctx context.Context, requestSignPublic
 				return ctx
 			}
 		}
+		s.logger.Debug(ctx, logs.FailedToValidateIncomingIOTag)
 		return qosTagging.ContextWithIOTag(ctx, qos.IOTagClient.String())
 	default:
-		s.logger.Warn(ctx, logs.NotSupportedIncomingIOTagReplacedWithClient, zap.Stringer("io_tag", ioTag))
+		s.logger.Debug(ctx, logs.NotSupportedIncomingIOTagReplacedWithClient, zap.Stringer("io_tag", ioTag))
 		return qosTagging.ContextWithIOTag(ctx, qos.IOTagClient.String())
 	}
 }

config/example/node.env

@@ -87,14 +87,16 @@ FROSTFS_REPLICATOR_POOL_SIZE=10
 FROSTFS_CONTAINER_LIST_STREAM_BATCH_SIZE=500
 
 # Object service section
-FROSTFS_OBJECT_PUT_REMOTE_POOL_SIZE=100
-FROSTFS_OBJECT_PUT_LOCAL_POOL_SIZE=200
 FROSTFS_OBJECT_PUT_SKIP_SESSION_TOKEN_ISSUER_VERIFICATION=true
 FROSTFS_OBJECT_DELETE_TOMBSTONE_LIFETIME=10
 FROSTFS_OBJECT_GET_PRIORITY="$attribute:ClusterName $attribute:UN-LOCODE"
 
+FROSTFS_RPC_LIMITS_0_METHODS="/neo.fs.v2.object.ObjectService/PutSingle /neo.fs.v2.object.ObjectService/Put"
+FROSTFS_RPC_LIMITS_0_MAX_OPS=1000
+FROSTFS_RPC_LIMITS_1_METHODS="/neo.fs.v2.object.ObjectService/Get"
+FROSTFS_RPC_LIMITS_1_MAX_OPS=10000
+
 # Storage engine section
-FROSTFS_STORAGE_SHARD_POOL_SIZE=15
 FROSTFS_STORAGE_SHARD_RO_ERROR_THRESHOLD=100
 ## 0 shard
 ### Flag to refill Metabase from BlobStor
@@ -154,6 +156,47 @@ FROSTFS_STORAGE_SHARD_0_GC_REMOVER_SLEEP_INTERVAL=2m
 FROSTFS_STORAGE_SHARD_0_GC_EXPIRED_COLLECTOR_BATCH_SIZE=1500
 #### Limit of concurrent workers collecting expired objects by the garbage collector
 FROSTFS_STORAGE_SHARD_0_GC_EXPIRED_COLLECTOR_WORKER_COUNT=15
+#### Limits config
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_MAX_RUNNING_OPS=10000
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_MAX_WAITING_OPS=1000
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_MAX_RUNNING_OPS=1000
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_MAX_WAITING_OPS=100
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_IDLE_TIMEOUT=45s
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_IDLE_TIMEOUT=30s
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_0_TAG=internal
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_0_WEIGHT=20
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_0_LIMIT_OPS=0
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_0_RESERVED_OPS=1000
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_1_TAG=client
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_1_WEIGHT=70
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_1_RESERVED_OPS=10000
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_2_TAG=background
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_2_WEIGHT=5
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_2_LIMIT_OPS=10000
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_2_RESERVED_OPS=0
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_3_TAG=writecache
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_3_WEIGHT=5
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_3_LIMIT_OPS=25000
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_4_TAG=policer
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_4_WEIGHT=5
+FROSTFS_STORAGE_SHARD_0_LIMITS_READ_TAGS_4_LIMIT_OPS=25000
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_0_TAG=internal
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_0_WEIGHT=200
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_0_LIMIT_OPS=0
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_0_RESERVED_OPS=100
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_1_TAG=client
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_1_WEIGHT=700
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_1_RESERVED_OPS=1000
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_2_TAG=background
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_2_WEIGHT=50
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_2_LIMIT_OPS=1000
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_2_RESERVED_OPS=0
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_3_TAG=writecache
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_3_WEIGHT=50
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_3_LIMIT_OPS=2500
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_4_TAG=policer
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_4_WEIGHT=50
+FROSTFS_STORAGE_SHARD_0_LIMITS_WRITE_TAGS_4_LIMIT_OPS=2500
 
 ## 1 shard
 ### Flag to refill Metabase from BlobStor

config/example/node.json

@@ -134,16 +134,30 @@
       "tombstone_lifetime": 10
     },
     "put": {
-      "remote_pool_size": 100,
-      "local_pool_size": 200,
       "skip_session_token_issuer_verification": true
     },
     "get": {
       "priority": ["$attribute:ClusterName", "$attribute:UN-LOCODE"]
     }
   },
+  "rpc": {
+    "limits": [
+      {
+        "methods": [
+          "/neo.fs.v2.object.ObjectService/PutSingle",
+          "/neo.fs.v2.object.ObjectService/Put"
+        ],
+        "max_ops": 1000
+      },
+      {
+        "methods": [
+          "/neo.fs.v2.object.ObjectService/Get"
+        ],
+        "max_ops": 10000
+      }
+    ]
+  },
   "storage": {
-    "shard_pool_size": 15,
     "shard_ro_error_threshold": 100,
     "shard": {
       "0": {
@@ -206,6 +220,76 @@
           "remover_sleep_interval": "2m",
           "expired_collector_batch_size": 1500,
           "expired_collector_worker_count": 15
+        },
+        "limits": {
+          "read": {
+            "max_running_ops": 10000,
+            "max_waiting_ops": 1000,
+            "idle_timeout": "30s",
+            "tags": [
+              {
+                "tag": "internal",
+                "weight": 20,
+                "limit_ops": 0,
+                "reserved_ops": 1000
+              },
+              {
+                "tag": "client",
+                "weight": 70,
+                "reserved_ops": 10000
+              },
+              {
+                "tag": "background",
+                "weight": 5,
+                "limit_ops": 10000,
+                "reserved_ops": 0
+              },
+              {
+                "tag": "writecache",
+                "weight": 5,
+                "limit_ops": 25000
+              },
+              {
+                "tag": "policer",
+                "weight": 5,
+                "limit_ops": 25000
+              }
+            ]
+          },
+          "write": {
+            "max_running_ops": 1000,
+            "max_waiting_ops": 100,
+            "idle_timeout": "45s",
+            "tags": [
+              {
+                "tag": "internal",
+                "weight": 200,
+                "limit_ops": 0,
+                "reserved_ops": 100
+              },
+              {
+                "tag": "client",
+                "weight": 700,
+                "reserved_ops": 1000
+              },
+              {
+                "tag": "background",
+                "weight": 50,
+                "limit_ops": 1000,
+                "reserved_ops": 0
+              },
+              {
+                "tag": "writecache",
+                "weight": 50,
+                "limit_ops": 2500
+              },
+              {
+                "tag": "policer",
+                "weight": 50,
+                "limit_ops": 2500
+              }
+            ]
+          }
         }
       },
       "1": {

config/example/node.yaml

@@ -117,17 +117,24 @@ object:
   delete:
     tombstone_lifetime: 10 # tombstone "local" lifetime in epochs
   put:
-    remote_pool_size: 100  # number of async workers for remote PUT operations
-    local_pool_size: 200  # number of async workers for local PUT operations
     skip_session_token_issuer_verification: true # session token issuer verification will be skipped if true
   get:
     priority:  # list of metrics of nodes for prioritization
       - $attribute:ClusterName
       - $attribute:UN-LOCODE
 
+rpc:
+  limits:
+    - methods:
+      - /neo.fs.v2.object.ObjectService/PutSingle
+      - /neo.fs.v2.object.ObjectService/Put
+      max_ops: 1000
+    - methods:
+      - /neo.fs.v2.object.ObjectService/Get
+      max_ops: 10000
+
 storage:
   # note: shard configuration can be omitted for relay node (see `node.relay`)
-  shard_pool_size: 15 # size of per-shard worker pools used for PUT operations
   shard_ro_error_threshold: 100 # amount of errors to occur before shard is made read-only (default: 0, ignore errors)
 
   shard:
@@ -219,6 +226,52 @@ storage:
         expired_collector_batch_size: 1500 # number of objects to be marked expired by the garbage collector
         expired_collector_worker_count: 15 # number of concurrent workers collecting expired objects by the garbage collector
 
+      limits:
+        read:
+          max_running_ops: 10000
+          max_waiting_ops: 1000
+          idle_timeout: 30s
+          tags:
+          - tag: internal
+            weight: 20
+            limit_ops: 0
+            reserved_ops: 1000
+          - tag: client
+            weight: 70
+            reserved_ops: 10000
+          - tag: background
+            weight: 5
+            limit_ops: 10000
+            reserved_ops: 0
+          - tag: writecache
+            weight: 5
+            limit_ops: 25000
+          - tag: policer
+            weight: 5
+            limit_ops: 25000
+        write:
+          max_running_ops: 1000
+          max_waiting_ops: 100
+          idle_timeout: 45s
+          tags:
+          - tag: internal
+            weight: 200
+            limit_ops: 0
+            reserved_ops: 100
+          - tag: client
+            weight: 700
+            reserved_ops: 1000
+          - tag: background
+            weight: 50
+            limit_ops: 1000
+            reserved_ops: 0
+          - tag: writecache
+            weight: 50
+            limit_ops: 2500
+          - tag: policer
+            weight: 50
+            limit_ops: 2500
+
     1:
       writecache:
         path: tmp/1/cache  # write-cache root directory

docs/storage-node-configuration.md

@@ -170,7 +170,6 @@ Local storage engine configuration.
 
 | Parameter                  | Type                              | Default value | Description                                                                                                      |
 |----------------------------|-----------------------------------|---------------|------------------------------------------------------------------------------------------------------------------|
-| `shard_pool_size`          | `int`                             | `20`          | Pool size for shard workers. Limits the amount of concurrent `PUT` operations on each shard.                     |
 | `shard_ro_error_threshold` | `int`                             | `0`           | Maximum amount of storage errors to encounter before shard automatically moves to `Degraded` or `ReadOnly` mode. |
 | `low_mem`                  | `bool`                            | `false`       | Reduce memory consumption by reducing performance.                                                               |
 | `shard`                    | [Shard config](#shard-subsection) |               | Configuration for separate shards.                                                                               |
@@ -195,6 +194,7 @@ The following table describes configuration for each shard.
 | `blobstor`                                       | [Blobstor config](#blobstor-subsection)     |               | Blobstor configuration.                                                                                                                                                                                           |
 | `small_object_size`                              | `size`                                      | `1M`          | Maximum size of an object stored in blobovnicza tree.                                                                                                                                                             |
 | `gc`                                             | [GC config](#gc-subsection)                 |               | GC configuration.                                                                                                                                                                                                 |
+| `limits`                                         | [Shard limits config](#limits-subsection)   |               | Shard limits configuration.                                                                                                                                                                                                 |
 
 ### `blobstor` subsection
 
@@ -301,6 +301,64 @@ writecache:
 | `flush_worker_count`        | `int`      | `20`          | Amount of background workers that move data from the writecache to the blobstor.                                              |
 | `max_flushing_objects_size` | `size`     | `512M`        | Max total size of background flushing objects.                                                                                |
 
+### `limits` subsection
+
+```yaml
+limits:
+  max_read_running_ops: 10000
+  max_read_waiting_ops: 1000
+  max_write_running_ops: 1000
+  max_write_waiting_ops: 100
+  read:
+    - tag: internal
+      weight: 20
+      limit_ops: 0
+      reserved_ops: 1000
+    - tag: client
+      weight: 70
+      reserved_ops: 10000
+    - tag: background
+      weight: 5
+      limit_ops: 10000
+      reserved_ops: 0
+    - tag: writecache
+      weight: 5
+      limit_ops: 25000
+    - tag: policer
+      weight: 5
+      limit_ops: 25000
+    write:
+    - tag: internal
+      weight: 200
+      limit_ops: 0
+      reserved_ops: 100
+    - tag: client
+      weight: 700
+      reserved_ops: 1000
+    - tag: background
+      weight: 50
+      limit_ops: 1000
+      reserved_ops: 0
+    - tag: writecache
+      weight: 50
+      limit_ops: 2500
+    - tag: policer
+      weight: 50
+      limit_ops: 2500
+```
+
+| Parameter               | Type     | Default value  | Description                                                                                                     |
+| ----------------------- | -------- | -------------- | --------------------------------------------------------------------------------------------------------------- |
+| `max_read_running_ops`  | `int`    | 0 (no limit)   | The maximum number of runnig read operations.                                                                   |
+| `max_read_waiting_ops`  | `int`    | 0 (no limit)   | The maximum number of waiting read operations.                                                                  |
+| `max_write_running_ops` | `int`    | 0 (no limit)   | The maximum number of running write operations.                                                                 |
+| `max_write_waiting_ops` | `int`    | 0 (no limit)   | The maximum number of running write operations.                                                                 |
+| `read`                  | `[]tag`  | empty          | Array of shard read settings for tags.                                                                          |
+| `write`                 | `[]tag`  | empty          | Array of shard write settings for tags.                                                                         |
+| `tag.tag`               | `string` | empty          | Tag name. Allowed values: `client`, `internal`, `background`, `writecache`, `policer`.                          |
+| `tag.weight`            | `float`  | 0 (no weight)  | Weight for queries with the specified tag. Weights must be specified for all tags or not specified for any one. |
+| `tag.limit_ops`         | `float`  | 0 (no limit)   | Operations per second rate limit for queries with the specified tag.                                            |
+| `tag.reserved_ops`      | `float`  | 0 (no reserve) | Reserved operations per second rate for queries with the specified tag.                                         |
 
 # `node` section
 
@@ -396,18 +454,16 @@ replicator:
   pool_size: 10
 ```
 
-| Parameter     | Type       | Default value                          | Description                                 |
-|---------------|------------|----------------------------------------|---------------------------------------------|
-| `put_timeout` | `duration` | `5s`                                   | Timeout for performing the `PUT` operation. |
-| `pool_size`   | `int`      | Equal to `object.put.remote_pool_size` | Maximum amount of concurrent replications.  |
+| Parameter     | Type       | Default value | Description                                 |
+|---------------|------------|---------------|---------------------------------------------|
+| `put_timeout` | `duration` | `5s`          | Timeout for performing the `PUT` operation. |
+| `pool_size`   | `int`      | `10`          | Maximum amount of concurrent replications.  |
 
 # `object` section
 Contains object-service related parameters.
 
 ```yaml
 object:
-  put:
-    remote_pool_size: 100
   get:
     priority:
       - $attribute:ClusterName
@@ -416,10 +472,29 @@ object:
 | Parameter                   | Type       | Default value | Description                                                                                    |
 |-----------------------------|------------|---------------|------------------------------------------------------------------------------------------------|
 | `delete.tombstone_lifetime` | `int`      | `5`           | Tombstone lifetime for removed objects in epochs.                                              |
-| `put.remote_pool_size`      | `int`      | `10`          | Max pool size for performing remote `PUT` operations. Used by Policer and Replicator services. |
-| `put.local_pool_size`       | `int`      | `10`          | Max pool size for performing local `PUT` operations. Used by Policer and Replicator services.  |
 | `get.priority`              | `[]string` |               | List of metrics of nodes for prioritization. Used for computing response on GET requests.      |
 
+
+# `rpc` section
+Contains limits on the number of active RPC for specified method(s).
+
+```yaml
+rpc:
+  limits:
+    - methods:
+      - /neo.fs.v2.object.ObjectService/PutSingle
+      - /neo.fs.v2.object.ObjectService/Put
+      max_ops: 1000
+    - methods:
+      - /neo.fs.v2.object.ObjectService/Get
+      max_ops: 10000
+```
+
+| Parameter        | Type       | Default value | Description                                                  |
+|------------------|------------|---------------|--------------------------------------------------------------|
+| `limits.max_ops` | `int`      |               | Maximum number of active RPC allowed for the given method(s) |
+| `limits.methods` | `[]string` |               | List of RPC methods sharing the given limit                  |
+
 # `runtime` section
 Contains runtime parameters.
 

go.mod

@@ -4,15 +4,15 @@ go 1.22
 
 require (
 	code.gitea.io/sdk/gitea v0.17.1
-	git.frostfs.info/TrueCloudLab/frostfs-contract v0.21.1-0.20241205083807-762d7f9f9f08
+	git.frostfs.info/TrueCloudLab/frostfs-contract v0.21.1
 	git.frostfs.info/TrueCloudLab/frostfs-crypto v0.6.0
 	git.frostfs.info/TrueCloudLab/frostfs-locode-db v0.4.1-0.20240710074952-65761deb5c0d
 	git.frostfs.info/TrueCloudLab/frostfs-observability v0.0.0-20250212111929-d34e1329c824
-	git.frostfs.info/TrueCloudLab/frostfs-qos v0.0.0-20250128150313-cfbca7fa1dfe
-	git.frostfs.info/TrueCloudLab/frostfs-sdk-go v0.0.0-20250202151421-8389887a3421
+	git.frostfs.info/TrueCloudLab/frostfs-qos v0.0.0-20250310135838-3e7ca9403529
+	git.frostfs.info/TrueCloudLab/frostfs-sdk-go v0.0.0-20250306092416-69b0711d12d9
 	git.frostfs.info/TrueCloudLab/hrw v1.2.1
 	git.frostfs.info/TrueCloudLab/multinet v0.0.0-20241015075604-6cb0d80e0972
-	git.frostfs.info/TrueCloudLab/policy-engine v0.0.0-20240814080254-96225afacb88
+	git.frostfs.info/TrueCloudLab/policy-engine v0.0.0-20240822104152-a3bc3099bd5b
 	git.frostfs.info/TrueCloudLab/tzhash v1.8.0
 	git.frostfs.info/TrueCloudLab/zapjournald v0.0.0-20240124114243-cb2e66427d02
 	github.com/VictoriaMetrics/easyproto v0.1.4

go.sum

@@ -1,25 +1,25 @@
 code.gitea.io/sdk/gitea v0.17.1 h1:3jCPOG2ojbl8AcfaUCRYLT5MUcBMFwS0OSK2mA5Zok8=
 code.gitea.io/sdk/gitea v0.17.1/go.mod h1:aCnBqhHpoEWA180gMbaCtdX9Pl6BWBAuuP2miadoTNM=
-git.frostfs.info/TrueCloudLab/frostfs-contract v0.21.1-0.20241205083807-762d7f9f9f08 h1:tl1TT+zNk1lF/J5EaD3syDrTaYbQwvJKVOVENM4oQ+k=
-git.frostfs.info/TrueCloudLab/frostfs-contract v0.21.1-0.20241205083807-762d7f9f9f08/go.mod h1:5fSm/l5xSjGWqsPUffSdboiGFUHa7y/1S0fvxzQowN8=
+git.frostfs.info/TrueCloudLab/frostfs-contract v0.21.1 h1:k1Qw8dWUQczfo0eVXlhrq9eXEbUMyDLW8jEMzY+gxMc=
+git.frostfs.info/TrueCloudLab/frostfs-contract v0.21.1/go.mod h1:5fSm/l5xSjGWqsPUffSdboiGFUHa7y/1S0fvxzQowN8=
 git.frostfs.info/TrueCloudLab/frostfs-crypto v0.6.0 h1:FxqFDhQYYgpe41qsIHVOcdzSVCB8JNSfPG7Uk4r2oSk=
 git.frostfs.info/TrueCloudLab/frostfs-crypto v0.6.0/go.mod h1:RUIKZATQLJ+TaYQa60X2fTDwfuhMfm8Ar60bQ5fr+vU=
 git.frostfs.info/TrueCloudLab/frostfs-locode-db v0.4.1-0.20240710074952-65761deb5c0d h1:uJ/wvuMdepbkaV8XMS5uN9B0FQWMep0CttSuDZiDhq0=
 git.frostfs.info/TrueCloudLab/frostfs-locode-db v0.4.1-0.20240710074952-65761deb5c0d/go.mod h1:7ZZq8iguY7qFsXajdHGmZd2AW4QbucyrJwhbsRfOfek=
 git.frostfs.info/TrueCloudLab/frostfs-observability v0.0.0-20250212111929-d34e1329c824 h1:Mxw1c/8t96vFIUOffl28lFaHKi413oCBfLMGJmF9cFA=
 git.frostfs.info/TrueCloudLab/frostfs-observability v0.0.0-20250212111929-d34e1329c824/go.mod h1:kbwB4v2o6RyOfCo9kEFeUDZIX3LKhmS0yXPrtvzkQ1g=
-git.frostfs.info/TrueCloudLab/frostfs-qos v0.0.0-20250128150313-cfbca7fa1dfe h1:81gDNdWNLP24oMQukRiCE9R1wGSh0l0dRq3F1W+Oesc=
-git.frostfs.info/TrueCloudLab/frostfs-qos v0.0.0-20250128150313-cfbca7fa1dfe/go.mod h1:PCijYq4oa8vKtIEcUX6jRiszI6XAW+nBwU+T1kB4d1U=
-git.frostfs.info/TrueCloudLab/frostfs-sdk-go v0.0.0-20250202151421-8389887a3421 h1:pP19IawSdsLCKFv7HMNfWAeH6E3uSnntKZkwka+/2+4=
-git.frostfs.info/TrueCloudLab/frostfs-sdk-go v0.0.0-20250202151421-8389887a3421/go.mod h1:aQpPWfG8oyfJ2X+FenPTJpSRWZjwcP5/RAtkW+/VEX8=
+git.frostfs.info/TrueCloudLab/frostfs-qos v0.0.0-20250310135838-3e7ca9403529 h1:CBreXSxGoYJAdZ1QdJPsDs1UCXGF5psinII0lxtohsc=
+git.frostfs.info/TrueCloudLab/frostfs-qos v0.0.0-20250310135838-3e7ca9403529/go.mod h1:PCijYq4oa8vKtIEcUX6jRiszI6XAW+nBwU+T1kB4d1U=
+git.frostfs.info/TrueCloudLab/frostfs-sdk-go v0.0.0-20250306092416-69b0711d12d9 h1:svCl6NDAPZ/KuQPjdVKo74RkCIANesxUPM45zQZDhSw=
+git.frostfs.info/TrueCloudLab/frostfs-sdk-go v0.0.0-20250306092416-69b0711d12d9/go.mod h1:aQpPWfG8oyfJ2X+FenPTJpSRWZjwcP5/RAtkW+/VEX8=
 git.frostfs.info/TrueCloudLab/hrw v1.2.1 h1:ccBRK21rFvY5R1WotI6LNoPlizk7qSvdfD8lNIRudVc=
 git.frostfs.info/TrueCloudLab/hrw v1.2.1/go.mod h1:C1Ygde2n843yTZEQ0FP69jYiuaYV0kriLvP4zm8JuvM=
 git.frostfs.info/TrueCloudLab/multinet v0.0.0-20241015075604-6cb0d80e0972 h1:/960fWeyn2AFHwQUwDsWB3sbP6lTEnFnMzLMM6tx6N8=
 git.frostfs.info/TrueCloudLab/multinet v0.0.0-20241015075604-6cb0d80e0972/go.mod h1:2hM42MBrlhvN6XToaW6OWNk5ZLcu1FhaukGgxtfpDDI=
 git.frostfs.info/TrueCloudLab/neoneo-go v0.106.1-0.20241015133823-8aee80dbdc07 h1:gPaqGsk6gSWQyNVjaStydfUz6Z/loHc9XyvGrJ5qSPY=
 git.frostfs.info/TrueCloudLab/neoneo-go v0.106.1-0.20241015133823-8aee80dbdc07/go.mod h1:bZyJexBlrja4ngxiBgo8by5pVHuAbhg9l09/8yVGDyg=
-git.frostfs.info/TrueCloudLab/policy-engine v0.0.0-20240814080254-96225afacb88 h1:vgbfkcnIexZUm3vREBBSa/Gv1Whjd1SFCUd0A+IaGPQ=
-git.frostfs.info/TrueCloudLab/policy-engine v0.0.0-20240814080254-96225afacb88/go.mod h1:SgioiGhQNWqiV5qpFAXRDJF81SEFRBhtwGEiU0FViyA=
+git.frostfs.info/TrueCloudLab/policy-engine v0.0.0-20240822104152-a3bc3099bd5b h1:M50kdfrf/h8c3cz0bJ2AEUcbXvAlPFVC1Wp1WkfZ/8E=
+git.frostfs.info/TrueCloudLab/policy-engine v0.0.0-20240822104152-a3bc3099bd5b/go.mod h1:GZTk55RI4dKzsK6BCn5h2xxE28UHNfgoq/NJxW/LQ6A=
 git.frostfs.info/TrueCloudLab/rfc6979 v0.4.0 h1:M2KR3iBj7WpY3hP10IevfIB9MURr4O9mwVfJ+SjT3HA=
 git.frostfs.info/TrueCloudLab/rfc6979 v0.4.0/go.mod h1:okpbKfVYf/BpejtfFTfhZqFP+sZ8rsHrP8Rr/jYPNRc=
 git.frostfs.info/TrueCloudLab/tzhash v1.8.0 h1:UFMnUIk0Zh17m8rjGHJMqku2hCgaXDqjqZzS4gsb4UA=

internal/assert/cond.go

@@ -0,0 +1,9 @@
+package assert
+
+import "strings"
+
+func True(cond bool, details ...string) {
+	if !cond {
+		panic(strings.Join(details, " "))
+	}
+}

internal/logs/logs.go

@@ -125,7 +125,6 @@ const (
 	SearchCouldNotWriteObjectIdentifiers                                 = "could not write object identifiers"
 	SearchLocalOperationFailed                                           = "local operation failed"
 	UtilObjectServiceError                                               = "object service error"
-	UtilCouldNotPushTaskToWorkerPool                                     = "could not push task to worker pool"
 	V2CantCheckIfRequestFromInnerRing                                    = "can't check if request from inner ring"
 	V2CantCheckIfRequestFromContainerNode                                = "can't check if request from container node"
 	ClientCouldNotRestoreBlockSubscriptionAfterRPCSwitch                 = "could not restore block subscription after RPC switch"
@@ -253,6 +252,7 @@ const (
 	ShardFailureToMarkLockersAsGarbage                                   = "failure to mark lockers as garbage"
 	ShardFailureToGetExpiredUnlockedObjects                              = "failure to get expired unlocked objects"
 	ShardCouldNotMarkObjectToDeleteInMetabase                            = "could not mark object to delete in metabase"
+	ShardCouldNotFindObject                                              = "could not find object"
 	WritecacheWaitingForChannelsToFlush                                  = "waiting for channels to flush"
 	WritecacheCantRemoveObjectFromWritecache                             = "can't remove object from write-cache"
 	BlobovniczatreeCouldNotGetObjectFromLevel                            = "could not get object from level"
@@ -513,4 +513,6 @@ const (
 	FailedToParseIncomingIOTag                                           = "failed to parse incoming IO tag"
 	NotSupportedIncomingIOTagReplacedWithClient                          = "incoming IO tag is not supported, replaced with `client`"
 	FailedToGetNetmapToAdjustIOTag                                       = "failed to get netmap to adjust IO tag, replaced with `client`"
+	FailedToValidateIncomingIOTag                                        = "failed to validate incoming IO tag, replaced with `client`"
+	WriteCacheFailedToAcquireRPSQuota                                    = "writecache failed to acquire RPS quota to flush object"
 )

internal/metrics/consts.go

@@ -23,6 +23,7 @@ const (
 	policerSubsystem         = "policer"
 	commonCacheSubsystem     = "common_cache"
 	multinetSubsystem        = "multinet"
+	qosSubsystem             = "qos"
 
 	successLabel          = "success"
 	shardIDLabel          = "shard_id"
@@ -43,6 +44,7 @@ const (
 	hitLabel              = "hit"
 	cacheLabel            = "cache"
 	sourceIPLabel         = "source_ip"
+	ioTagLabel            = "io_tag"
 
 	readWriteMode = "READ_WRITE"
 	readOnlyMode  = "READ_ONLY"

internal/metrics/node.go

@@ -26,6 +26,7 @@ type NodeMetrics struct {
 	morphCache    *morphCacheMetrics
 	log           logger.LogMetrics
 	multinet      *multinetMetrics
+	qos           *QoSMetrics
 	// nolint: unused
 	appInfo *ApplicationInfo
 }
@@ -55,6 +56,7 @@ func NewNodeMetrics() *NodeMetrics {
 		log:          logger.NewLogMetrics(namespace),
 		appInfo:      NewApplicationInfo(misc.Version),
 		multinet:     newMultinetMetrics(namespace),
+		qos:          newQoSMetrics(),
 	}
 }
 
@@ -126,3 +128,7 @@ func (m *NodeMetrics) LogMetrics() logger.LogMetrics {
 func (m *NodeMetrics) MultinetMetrics() MultinetMetrics {
 	return m.multinet
 }
+
+func (m *NodeMetrics) QoSMetrics() *QoSMetrics {
+	return m.qos
+}

internal/metrics/object.go

@@ -9,13 +9,14 @@ import (
 )
 
 type ObjectServiceMetrics interface {
-	AddRequestDuration(method string, d time.Duration, success bool)
+	AddRequestDuration(method string, d time.Duration, success bool, ioTag string)
 	AddPayloadSize(method string, size int)
 }
 
 type objectServiceMetrics struct {
-	methodDuration *prometheus.HistogramVec
-	payloadCounter *prometheus.CounterVec
+	methodDuration  *prometheus.HistogramVec
+	payloadCounter  *prometheus.CounterVec
+	ioTagOpsCounter *prometheus.CounterVec
 }
 
 func newObjectServiceMetrics() *objectServiceMetrics {
@@ -32,14 +33,24 @@ func newObjectServiceMetrics() *objectServiceMetrics {
 			Name:      "request_payload_bytes",
 			Help:      "Object Service request payload",
 		}, []string{methodLabel}),
+		ioTagOpsCounter: metrics.NewCounterVec(prometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: objectSubsystem,
+			Name:      "requests_total",
+			Help:      "Count of requests for each IO tag",
+		}, []string{methodLabel, ioTagLabel}),
 	}
 }
 
-func (m *objectServiceMetrics) AddRequestDuration(method string, d time.Duration, success bool) {
+func (m *objectServiceMetrics) AddRequestDuration(method string, d time.Duration, success bool, ioTag string) {
 	m.methodDuration.With(prometheus.Labels{
 		methodLabel:  method,
 		successLabel: strconv.FormatBool(success),
 	}).Observe(d.Seconds())
+	m.ioTagOpsCounter.With(prometheus.Labels{
+		ioTagLabel:  ioTag,
+		methodLabel: method,
+	}).Inc()
 }
 
 func (m *objectServiceMetrics) AddPayloadSize(method string, size int) {

internal/metrics/qos.go

@@ -0,0 +1,52 @@
+package metrics
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-observability/metrics"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type QoSMetrics struct {
+	opsCounter *prometheus.GaugeVec
+}
+
+func newQoSMetrics() *QoSMetrics {
+	return &QoSMetrics{
+		opsCounter: metrics.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: namespace,
+			Subsystem: qosSubsystem,
+			Name:      "operations_total",
+			Help:      "Count of pending, in progree, completed and failed due of resource exhausted error operations for each shard",
+		}, []string{shardIDLabel, operationLabel, ioTagLabel, typeLabel}),
+	}
+}
+
+func (m *QoSMetrics) SetOperationTagCounters(shardID, operation, tag string, pending, inProgress, completed, resourceExhausted uint64) {
+	m.opsCounter.With(prometheus.Labels{
+		shardIDLabel:   shardID,
+		operationLabel: operation,
+		ioTagLabel:     tag,
+		typeLabel:      "pending",
+	}).Set(float64(pending))
+	m.opsCounter.With(prometheus.Labels{
+		shardIDLabel:   shardID,
+		operationLabel: operation,
+		ioTagLabel:     tag,
+		typeLabel:      "in_progress",
+	}).Set(float64(inProgress))
+	m.opsCounter.With(prometheus.Labels{
+		shardIDLabel:   shardID,
+		operationLabel: operation,
+		ioTagLabel:     tag,
+		typeLabel:      "completed",
+	}).Set(float64(completed))
+	m.opsCounter.With(prometheus.Labels{
+		shardIDLabel:   shardID,
+		operationLabel: operation,
+		ioTagLabel:     tag,
+		typeLabel:      "resource_exhausted",
+	}).Set(float64(resourceExhausted))
+}
+
+func (m *QoSMetrics) Close(shardID string) {
+	m.opsCounter.DeletePartialMatch(prometheus.Labels{shardIDLabel: shardID})
+}

internal/metrics/treeservice.go

@@ -12,12 +12,14 @@ type TreeMetricsRegister interface {
 	AddReplicateTaskDuration(time.Duration, bool)
 	AddReplicateWaitDuration(time.Duration, bool)
 	AddSyncDuration(time.Duration, bool)
+	AddOperation(string, string)
 }
 
 type treeServiceMetrics struct {
 	replicateTaskDuration *prometheus.HistogramVec
 	replicateWaitDuration *prometheus.HistogramVec
 	syncOpDuration        *prometheus.HistogramVec
+	ioTagOpsCounter       *prometheus.CounterVec
 }
 
 var _ TreeMetricsRegister = (*treeServiceMetrics)(nil)
@@ -42,6 +44,12 @@ func newTreeServiceMetrics() *treeServiceMetrics {
 			Name:      "sync_duration_seconds",
 			Help:      "Duration of synchronization operations",
 		}, []string{successLabel}),
+		ioTagOpsCounter: metrics.NewCounterVec(prometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: treeServiceSubsystem,
+			Name:      "requests_total",
+			Help:      "Count of requests for each IO tag",
+		}, []string{methodLabel, ioTagLabel}),
 	}
 }
 
@@ -62,3 +70,10 @@ func (m *treeServiceMetrics) AddSyncDuration(d time.Duration, success bool) {
 		successLabel: strconv.FormatBool(success),
 	}).Observe(d.Seconds())
 }
+
+func (m *treeServiceMetrics) AddOperation(op string, ioTag string) {
+	m.ioTagOpsCounter.With(prometheus.Labels{
+		ioTagLabel:  ioTag,
+		methodLabel: op,
+	}).Inc()
+}

internal/qos/grpc.go

@@ -3,7 +3,9 @@ package qos
 import (
 	"context"
 
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/limiting"
 	"git.frostfs.info/TrueCloudLab/frostfs-qos/tagging"
+	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
 	"google.golang.org/grpc"
 )
 
@@ -49,3 +51,36 @@ func NewAdjustOutgoingIOTagStreamClientInterceptor() grpc.StreamClientIntercepto
 		return streamer(ctx, desc, cc, method, opts...)
 	}
 }
+
+func NewMaxActiveRPCLimiterUnaryServerInterceptor(getLimiter func() limiting.Limiter) grpc.UnaryServerInterceptor {
+	return func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp any, err error) {
+		if tag, ok := tagging.IOTagFromContext(ctx); ok && tag == IOTagCritical.String() {
+			return handler(ctx, req)
+		}
+
+		release, ok := getLimiter().Acquire(info.FullMethod)
+		if !ok {
+			return nil, new(apistatus.ResourceExhausted)
+		}
+		defer release()
+
+		return handler(ctx, req)
+	}
+}
+
+//nolint:contextcheck (grpc.ServerStream manages the context itself)
+func NewMaxActiveRPCLimiterStreamServerInterceptor(getLimiter func() limiting.Limiter) grpc.StreamServerInterceptor {
+	return func(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+		if tag, ok := tagging.IOTagFromContext(ss.Context()); ok && tag == IOTagCritical.String() {
+			return handler(srv, ss)
+		}
+
+		release, ok := getLimiter().Acquire(info.FullMethod)
+		if !ok {
+			return new(apistatus.ResourceExhausted)
+		}
+		defer release()
+
+		return handler(srv, ss)
+	}
+}

internal/qos/limiter.go

@@ -0,0 +1,223 @@
+package qos
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/limits"
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/scheduling"
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/tagging"
+	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
+)
+
+const (
+	defaultIdleTimeout time.Duration = 0
+	defaultShare       float64       = 1.0
+	minusOne                         = ^uint64(0)
+
+	defaultMetricsCollectTimeout = 5 * time.Second
+)
+
+type ReleaseFunc scheduling.ReleaseFunc
+
+type Limiter interface {
+	ReadRequest(context.Context) (ReleaseFunc, error)
+	WriteRequest(context.Context) (ReleaseFunc, error)
+	SetParentID(string)
+	SetMetrics(Metrics)
+	Close()
+}
+
+type scheduler interface {
+	RequestArrival(ctx context.Context, tag string) (scheduling.ReleaseFunc, error)
+	Close()
+}
+
+func NewLimiter(c *limits.Config) (Limiter, error) {
+	if err := validateConfig(c); err != nil {
+		return nil, err
+	}
+	readScheduler, err := createScheduler(c.Read())
+	if err != nil {
+		return nil, fmt.Errorf("create read scheduler: %w", err)
+	}
+	writeScheduler, err := createScheduler(c.Write())
+	if err != nil {
+		return nil, fmt.Errorf("create write scheduler: %w", err)
+	}
+	l := &mClockLimiter{
+		readScheduler:  readScheduler,
+		writeScheduler: writeScheduler,
+		closeCh:        make(chan struct{}),
+		wg:             &sync.WaitGroup{},
+		readStats:      createStats(),
+		writeStats:     createStats(),
+	}
+	l.shardID.Store(&shardID{})
+	l.metrics.Store(&metricsHolder{metrics: &noopMetrics{}})
+	l.startMetricsCollect()
+	return l, nil
+}
+
+func createScheduler(config limits.OpConfig) (scheduler, error) {
+	if len(config.Tags) == 0 && config.MaxWaitingOps == limits.NoLimit {
+		return newSemaphoreScheduler(config.MaxRunningOps), nil
+	}
+	return scheduling.NewMClock(
+		uint64(config.MaxRunningOps), uint64(config.MaxWaitingOps),
+		converToSchedulingTags(config.Tags), config.IdleTimeout)
+}
+
+func converToSchedulingTags(limits []limits.IOTagConfig) map[string]scheduling.TagInfo {
+	result := make(map[string]scheduling.TagInfo)
+	for _, tag := range []IOTag{IOTagClient, IOTagBackground, IOTagInternal, IOTagPolicer, IOTagWritecache} {
+		result[tag.String()] = scheduling.TagInfo{
+			Share: defaultShare,
+		}
+	}
+	for _, l := range limits {
+		v := result[l.Tag]
+		if l.Weight != nil && *l.Weight != 0 {
+			v.Share = *l.Weight
+		}
+		if l.LimitOps != nil && *l.LimitOps != 0 {
+			v.LimitIOPS = l.LimitOps
+		}
+		if l.ReservedOps != nil && *l.ReservedOps != 0 {
+			v.ReservedIOPS = l.ReservedOps
+		}
+		result[l.Tag] = v
+	}
+	return result
+}
+
+var (
+	_                   Limiter     = (*noopLimiter)(nil)
+	releaseStub         ReleaseFunc = func() {}
+	noopLimiterInstance             = &noopLimiter{}
+)
+
+func NewNoopLimiter() Limiter {
+	return noopLimiterInstance
+}
+
+type noopLimiter struct{}
+
+func (n *noopLimiter) ReadRequest(context.Context) (ReleaseFunc, error) {
+	return releaseStub, nil
+}
+
+func (n *noopLimiter) WriteRequest(context.Context) (ReleaseFunc, error) {
+	return releaseStub, nil
+}
+
+func (n *noopLimiter) SetParentID(string) {}
+
+func (n *noopLimiter) Close() {}
+
+func (n *noopLimiter) SetMetrics(Metrics) {}
+
+var _ Limiter = (*mClockLimiter)(nil)
+
+type shardID struct {
+	id string
+}
+
+type mClockLimiter struct {
+	readScheduler  scheduler
+	writeScheduler scheduler
+
+	readStats  map[string]*stat
+	writeStats map[string]*stat
+
+	shardID atomic.Pointer[shardID]
+	metrics atomic.Pointer[metricsHolder]
+	closeCh chan struct{}
+	wg      *sync.WaitGroup
+}
+
+func (n *mClockLimiter) ReadRequest(ctx context.Context) (ReleaseFunc, error) {
+	return requestArrival(ctx, n.readScheduler, n.readStats)
+}
+
+func (n *mClockLimiter) WriteRequest(ctx context.Context) (ReleaseFunc, error) {
+	return requestArrival(ctx, n.writeScheduler, n.writeStats)
+}
+
+func requestArrival(ctx context.Context, s scheduler, stats map[string]*stat) (ReleaseFunc, error) {
+	tag, ok := tagging.IOTagFromContext(ctx)
+	if !ok {
+		tag = IOTagClient.String()
+	}
+	stat := getStat(tag, stats)
+	stat.pending.Add(1)
+	if tag == IOTagCritical.String() {
+		stat.inProgress.Add(1)
+		return func() {
+			stat.completed.Add(1)
+		}, nil
+	}
+	rel, err := s.RequestArrival(ctx, tag)
+	stat.inProgress.Add(1)
+	if err != nil {
+		if errors.Is(err, scheduling.ErrMClockSchedulerRequestLimitExceeded) ||
+			errors.Is(err, errSemaphoreLimitExceeded) {
+			stat.resourceExhausted.Add(1)
+			return nil, &apistatus.ResourceExhausted{}
+		}
+		stat.completed.Add(1)
+		return nil, err
+	}
+	return func() {
+		rel()
+		stat.completed.Add(1)
+	}, nil
+}
+
+func (n *mClockLimiter) Close() {
+	n.readScheduler.Close()
+	n.writeScheduler.Close()
+	close(n.closeCh)
+	n.wg.Wait()
+	n.metrics.Load().metrics.Close(n.shardID.Load().id)
+}
+
+func (n *mClockLimiter) SetParentID(parentID string) {
+	n.shardID.Store(&shardID{id: parentID})
+}
+
+func (n *mClockLimiter) SetMetrics(m Metrics) {
+	n.metrics.Store(&metricsHolder{metrics: m})
+}
+
+func (n *mClockLimiter) startMetricsCollect() {
+	n.wg.Add(1)
+	go func() {
+		defer n.wg.Done()
+
+		ticker := time.NewTicker(defaultMetricsCollectTimeout)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-n.closeCh:
+				return
+			case <-ticker.C:
+				shardID := n.shardID.Load().id
+				if shardID == "" {
+					continue
+				}
+				metrics := n.metrics.Load().metrics
+				for tag, s := range n.readStats {
+					metrics.SetOperationTagCounters(shardID, "read", tag, s.pending.Load(), s.inProgress.Load(), s.completed.Load(), s.resourceExhausted.Load())
+				}
+				for tag, s := range n.writeStats {
+					metrics.SetOperationTagCounters(shardID, "write", tag, s.pending.Load(), s.inProgress.Load(), s.completed.Load(), s.resourceExhausted.Load())
+				}
+			}
+		}
+	}()
+}

internal/qos/metrics.go

@@ -0,0 +1,31 @@
+package qos
+
+import "sync/atomic"
+
+type Metrics interface {
+	SetOperationTagCounters(shardID, operation, tag string, pending, inProgress, completed, resourceExhausted uint64)
+	Close(shardID string)
+}
+
+var _ Metrics = (*noopMetrics)(nil)
+
+type noopMetrics struct{}
+
+func (n *noopMetrics) SetOperationTagCounters(string, string, string, uint64, uint64, uint64, uint64) {
+}
+
+func (n *noopMetrics) Close(string) {}
+
+// stat presents limiter statistics cumulative counters.
+//
+// Each operation changes its status as follows: `pending` -> `in_progress` -> `completed` or `resource_exhausted`.
+type stat struct {
+	completed         atomic.Uint64
+	pending           atomic.Uint64
+	resourceExhausted atomic.Uint64
+	inProgress        atomic.Uint64
+}
+
+type metricsHolder struct {
+	metrics Metrics
+}

internal/qos/semaphore.go

@@ -0,0 +1,39 @@
+package qos
+
+import (
+	"context"
+	"errors"
+
+	qosSemaphore "git.frostfs.info/TrueCloudLab/frostfs-qos/limiting/semaphore"
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/scheduling"
+)
+
+var (
+	_                         scheduler = (*semaphore)(nil)
+	errSemaphoreLimitExceeded           = errors.New("semaphore limit exceeded")
+)
+
+type semaphore struct {
+	s *qosSemaphore.Semaphore
+}
+
+func newSemaphoreScheduler(size int64) *semaphore {
+	return &semaphore{
+		s: qosSemaphore.NewSemaphore(size),
+	}
+}
+
+func (s *semaphore) Close() {}
+
+func (s *semaphore) RequestArrival(ctx context.Context, _ string) (scheduling.ReleaseFunc, error) {
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	default:
+	}
+
+	if s.s.Acquire() {
+		return s.s.Release, nil
+	}
+	return nil, errSemaphoreLimitExceeded
+}

internal/qos/stats.go

@@ -0,0 +1,28 @@
+package qos
+
+const unknownStatsTag = "unknown"
+
+var statTags = map[string]struct{}{
+	IOTagClient.String():     {},
+	IOTagBackground.String(): {},
+	IOTagInternal.String():   {},
+	IOTagPolicer.String():    {},
+	IOTagWritecache.String(): {},
+	IOTagCritical.String():   {},
+	unknownStatsTag:          {},
+}
+
+func createStats() map[string]*stat {
+	result := make(map[string]*stat)
+	for tag := range statTags {
+		result[tag] = &stat{}
+	}
+	return result
+}
+
+func getStat(tag string, stats map[string]*stat) *stat {
+	if v, ok := stats[tag]; ok {
+		return v
+	}
+	return stats[unknownStatsTag]
+}

internal/qos/tags.go

@@ -1,6 +1,11 @@
 package qos
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-qos/tagging"
+)
 
 type IOTag string
 
@@ -37,3 +42,11 @@ func FromRawString(s string) (IOTag, error) {
 func (t IOTag) String() string {
 	return string(t)
 }
+
+func IOTagFromContext(ctx context.Context) string {
+	tag, ok := tagging.IOTagFromContext(ctx)
+	if !ok {
+		tag = "undefined"
+	}
+	return tag
+}

internal/qos/validate.go

@@ -0,0 +1,92 @@
+package qos
+
+import (
+	"errors"
+	"fmt"
+	"math"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/limits"
+)
+
+var errWeightsMustBeSpecified = errors.New("invalid weights: weights must be specified for all tags or not specified for any")
+
+type tagConfig struct {
+	Shares, Limit, Reserved *float64
+}
+
+func validateConfig(c *limits.Config) error {
+	if err := validateOpConfig(c.Read()); err != nil {
+		return fmt.Errorf("limits 'read' section validation error: %w", err)
+	}
+	if err := validateOpConfig(c.Write()); err != nil {
+		return fmt.Errorf("limits 'write' section validation error: %w", err)
+	}
+	return nil
+}
+
+func validateOpConfig(c limits.OpConfig) error {
+	if c.MaxRunningOps <= 0 {
+		return fmt.Errorf("invalid 'max_running_ops = %d': must be greater than zero", c.MaxRunningOps)
+	}
+	if c.MaxWaitingOps <= 0 {
+		return fmt.Errorf("invalid 'max_waiting_ops = %d': must be greater than zero", c.MaxWaitingOps)
+	}
+	if c.IdleTimeout <= 0 {
+		return fmt.Errorf("invalid 'idle_timeout = %s': must be greater than zero", c.IdleTimeout.String())
+	}
+	if err := validateTags(c.Tags); err != nil {
+		return fmt.Errorf("'tags' config section validation error: %w", err)
+	}
+	return nil
+}
+
+func validateTags(configTags []limits.IOTagConfig) error {
+	tags := map[IOTag]tagConfig{
+		IOTagClient:     {},
+		IOTagInternal:   {},
+		IOTagBackground: {},
+		IOTagWritecache: {},
+		IOTagPolicer:    {},
+	}
+	for _, t := range configTags {
+		tag, err := FromRawString(t.Tag)
+		if err != nil {
+			return fmt.Errorf("invalid tag %s: %w", t.Tag, err)
+		}
+		if _, ok := tags[tag]; !ok {
+			return fmt.Errorf("tag %s is not configurable", t.Tag)
+		}
+		tags[tag] = tagConfig{
+			Shares:   t.Weight,
+			Limit:    t.LimitOps,
+			Reserved: t.ReservedOps,
+		}
+	}
+	idx := 0
+	var shares float64
+	for t, v := range tags {
+		if idx == 0 {
+			idx++
+			shares = float64Value(v.Shares)
+		} else if (shares != 0 && float64Value(v.Shares) == 0) || (shares == 0 && float64Value(v.Shares) != 0) {
+			return errWeightsMustBeSpecified
+		}
+		if float64Value(v.Shares) < 0 || math.IsNaN(float64Value(v.Shares)) {
+			return fmt.Errorf("invalid weight for tag %s: must be positive value", t.String())
+		}
+		if float64Value(v.Limit) < 0 || math.IsNaN(float64Value(v.Limit)) {
+			return fmt.Errorf("invalid limit_ops for tag %s: must be positive value", t.String())
+		}
+		if float64Value(v.Reserved) < 0 || math.IsNaN(float64Value(v.Reserved)) {
+			return fmt.Errorf("invalid reserved_ops for tag %s: must be positive value", t.String())
+		}
+	}
+	return nil
+}
+
+func float64Value(f *float64) float64 {
+	if f == nil {
+		return 0.0
+	}
+	return *f
+}

pkg/innerring/processors/container/process_container.go

@@ -209,7 +209,7 @@ func checkHomomorphicHashing(ctx context.Context, ns NetworkState, cnr container
 		return fmt.Errorf("could not get setting in contract: %w", err)
 	}
 
-	if cnrSetting := containerSDK.IsHomomorphicHashingDisabled(cnr); netSetting != cnrSetting {
+	if cnrSetting := containerSDK.IsHomomorphicHashingDisabled(cnr); netSetting && !cnrSetting {
 		return fmt.Errorf("network setting: %t, container setting: %t", netSetting, cnrSetting)
 	}
 

pkg/local_object_storage/blobstor/blobovniczatree/rebuild.go

@@ -50,7 +50,7 @@ func (b *Blobovniczas) Rebuild(ctx context.Context, prm common.RebuildPrm) (comm
 	var res common.RebuildRes
 
 	b.log.Debug(ctx, logs.BlobovniczaTreeCompletingPreviousRebuild)
-	completedPreviosMoves, err := b.completeIncompletedMove(ctx, prm.MetaStorage)
+	completedPreviosMoves, err := b.completeIncompletedMove(ctx, prm.MetaStorage, prm.Limiter)
 	res.ObjectsMoved += completedPreviosMoves
 	if err != nil {
 		b.log.Warn(ctx, logs.BlobovniczaTreeCompletedPreviousRebuildFailed, zap.Error(err))
@@ -79,7 +79,7 @@ func (b *Blobovniczas) migrateDBs(ctx context.Context, dbs []string, prm common.
 	var completedDBCount uint32
 	for _, db := range dbs {
 		b.log.Debug(ctx, logs.BlobovniczaTreeRebuildingBlobovnicza, zap.String("path", db))
-		movedObjects, err := b.rebuildDB(ctx, db, prm.MetaStorage, prm.WorkerLimiter)
+		movedObjects, err := b.rebuildDB(ctx, db, prm.MetaStorage, prm.Limiter)
 		res.ObjectsMoved += movedObjects
 		if err != nil {
 			b.log.Warn(ctx, logs.BlobovniczaTreeRebuildingBlobovniczaFailed, zap.String("path", db), zap.Uint64("moved_objects_count", movedObjects), zap.Error(err))
@@ -195,7 +195,7 @@ func (b *Blobovniczas) rebuildBySize(ctx context.Context, path string, targetFil
 	return fp < targetFillPercent || fp > 100+(100-targetFillPercent), nil
 }
 
-func (b *Blobovniczas) rebuildDB(ctx context.Context, path string, meta common.MetaStorage, limiter common.ConcurrentWorkersLimiter) (uint64, error) {
+func (b *Blobovniczas) rebuildDB(ctx context.Context, path string, meta common.MetaStorage, concLimiter common.RebuildLimiter) (uint64, error) {
 	shDB := b.getBlobovnicza(ctx, path)
 	blz, err := shDB.Open(ctx)
 	if err != nil {
@@ -212,7 +212,7 @@ func (b *Blobovniczas) rebuildDB(ctx context.Context, path string, meta common.M
 	if err != nil {
 		return 0, err
 	}
-	migratedObjects, err := b.moveObjects(ctx, blz, shDB.SystemPath(), meta, limiter)
+	migratedObjects, err := b.moveObjects(ctx, blz, shDB.SystemPath(), meta, concLimiter)
 	if err != nil {
 		return migratedObjects, err
 	}
@@ -238,7 +238,7 @@ func (b *Blobovniczas) addRebuildTempFile(ctx context.Context, path string) (fun
 	}, nil
 }
 
-func (b *Blobovniczas) moveObjects(ctx context.Context, blz *blobovnicza.Blobovnicza, blzPath string, meta common.MetaStorage, limiter common.ConcurrentWorkersLimiter) (uint64, error) {
+func (b *Blobovniczas) moveObjects(ctx context.Context, blz *blobovnicza.Blobovnicza, blzPath string, meta common.MetaStorage, limiter common.RebuildLimiter) (uint64, error) {
 	var result atomic.Uint64
 	batch := make(map[oid.Address][]byte)
 
@@ -253,7 +253,12 @@ func (b *Blobovniczas) moveObjects(ctx context.Context, blz *blobovnicza.Blobovn
 	})
 
 	for {
-		_, err := blz.Iterate(ctx, prm)
+		release, err := limiter.ReadRequest(ctx)
+		if err != nil {
+			return result.Load(), err
+		}
+		_, err = blz.Iterate(ctx, prm)
+		release()
 		if err != nil && !errors.Is(err, errBatchFull) {
 			return result.Load(), err
 		}
@@ -265,13 +270,19 @@ func (b *Blobovniczas) moveObjects(ctx context.Context, blz *blobovnicza.Blobovn
 		eg, egCtx := errgroup.WithContext(ctx)
 
 		for addr, data := range batch {
-			if err := limiter.AcquireWorkSlot(egCtx); err != nil {
+			release, err := limiter.AcquireWorkSlot(egCtx)
+			if err != nil {
 				_ = eg.Wait()
 				return result.Load(), err
 			}
 			eg.Go(func() error {
-				defer limiter.ReleaseWorkSlot()
-				err := b.moveObject(egCtx, blz, blzPath, addr, data, meta)
+				defer release()
+				moveRelease, err := limiter.WriteRequest(ctx)
+				if err != nil {
+					return err
+				}
+				err = b.moveObject(egCtx, blz, blzPath, addr, data, meta)
+				moveRelease()
 				if err == nil {
 					result.Add(1)
 				}
@@ -359,7 +370,7 @@ func (b *Blobovniczas) dropDirectoryIfEmpty(path string) error {
 	return b.dropDirectoryIfEmpty(filepath.Dir(path))
 }
 
-func (b *Blobovniczas) completeIncompletedMove(ctx context.Context, metaStore common.MetaStorage) (uint64, error) {
+func (b *Blobovniczas) completeIncompletedMove(ctx context.Context, metaStore common.MetaStorage, rateLimiter common.RateLimiter) (uint64, error) {
 	var count uint64
 	var rebuildTempFilesToRemove []string
 	err := b.iterateIncompletedRebuildDBPaths(ctx, func(s string) (bool, error) {
@@ -372,13 +383,24 @@ func (b *Blobovniczas) completeIncompletedMove(ctx context.Context, metaStore co
 		}
 		defer shDB.Close(ctx)
 
+		release, err := rateLimiter.ReadRequest(ctx)
+		if err != nil {
+			return false, err
+		}
 		incompletedMoves, err := blz.ListMoveInfo(ctx)
+		release()
 		if err != nil {
 			return true, err
 		}
 
 		for _, move := range incompletedMoves {
-			if err := b.performMove(ctx, blz, shDB.SystemPath(), move, metaStore); err != nil {
+			release, err := rateLimiter.WriteRequest(ctx)
+			if err != nil {
+				return false, err
+			}
+			err = b.performMove(ctx, blz, shDB.SystemPath(), move, metaStore)
+			release()
+			if err != nil {
 				return true, err
 			}
 			count++
@@ -388,9 +410,14 @@ func (b *Blobovniczas) completeIncompletedMove(ctx context.Context, metaStore co
 		return false, nil
 	})
 	for _, tmp := range rebuildTempFilesToRemove {
+		release, err := rateLimiter.WriteRequest(ctx)
+		if err != nil {
+			return count, err
+		}
 		if err := os.Remove(filepath.Join(b.rootPath, tmp)); err != nil {
 			b.log.Warn(ctx, logs.BlobovniczatreeFailedToRemoveRebuildTempFile, zap.Error(err))
 		}
+		release()
 	}
 	return count, err
 }

pkg/local_object_storage/blobstor/blobovniczatree/rebuild_failover_test.go

@@ -161,16 +161,18 @@ func testRebuildFailoverValidate(t *testing.T, dir string, obj *objectSDK.Object
 		storageIDs: make(map[oid.Address][]byte),
 		guard:      &sync.Mutex{},
 	}
+	limiter := &rebuildLimiterStub{}
 	rRes, err := b.Rebuild(context.Background(), common.RebuildPrm{
-		MetaStorage:   metaStub,
-		WorkerLimiter: &rebuildLimiterStub{},
-		FillPercent:   1,
+		MetaStorage: metaStub,
+		Limiter:     limiter,
+		FillPercent: 1,
 	})
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), rRes.ObjectsMoved)
 	require.Equal(t, uint64(0), rRes.FilesRemoved)
 
 	require.NoError(t, b.Close(context.Background()))
+	require.NoError(t, limiter.ValidateReleased())
 
 	blz := blobovnicza.New(blobovnicza.WithPath(filepath.Join(dir, "0", "0", "1.db")))
 	require.NoError(t, blz.Open(context.Background()))

pkg/local_object_storage/blobstor/blobovniczatree/rebuild_test.go

@@ -2,7 +2,9 @@ package blobovniczatree
 
 import (
 	"context"
+	"fmt"
 	"sync"
+	"sync/atomic"
 	"testing"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/object"
@@ -76,10 +78,11 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 			storageIDs: storageIDs,
 			guard:      &sync.Mutex{},
 		}
+		limiter := &rebuildLimiterStub{}
 		rRes, err := b.Rebuild(context.Background(), common.RebuildPrm{
-			MetaStorage:   metaStub,
-			WorkerLimiter: &rebuildLimiterStub{},
-			FillPercent:   60,
+			MetaStorage: metaStub,
+			Limiter:     limiter,
+			FillPercent: 60,
 		})
 		require.NoError(t, err)
 		dataMigrated := rRes.ObjectsMoved > 0 || rRes.FilesRemoved > 0 || metaStub.updatedCount > 0
@@ -94,6 +97,7 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 		}
 
 		require.NoError(t, b.Close(context.Background()))
+		require.NoError(t, limiter.ValidateReleased())
 	})
 
 	t.Run("no rebuild single db", func(t *testing.T) {
@@ -128,10 +132,11 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 			storageIDs: storageIDs,
 			guard:      &sync.Mutex{},
 		}
+		limiter := &rebuildLimiterStub{}
 		rRes, err := b.Rebuild(context.Background(), common.RebuildPrm{
-			MetaStorage:   metaStub,
-			WorkerLimiter: &rebuildLimiterStub{},
-			FillPercent:   90, // 64KB / 100KB = 64%
+			MetaStorage: metaStub,
+			Limiter:     limiter,
+			FillPercent: 90, // 64KB / 100KB = 64%
 		})
 		require.NoError(t, err)
 		dataMigrated := rRes.ObjectsMoved > 0 || rRes.FilesRemoved > 0 || metaStub.updatedCount > 0
@@ -146,6 +151,7 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 		}
 
 		require.NoError(t, b.Close(context.Background()))
+		require.NoError(t, limiter.ValidateReleased())
 	})
 
 	t.Run("rebuild by fill percent", func(t *testing.T) {
@@ -193,10 +199,11 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 			storageIDs: storageIDs,
 			guard:      &sync.Mutex{},
 		}
+		limiter := &rebuildLimiterStub{}
 		rRes, err := b.Rebuild(context.Background(), common.RebuildPrm{
-			MetaStorage:   metaStub,
-			WorkerLimiter: &rebuildLimiterStub{},
-			FillPercent:   80,
+			MetaStorage: metaStub,
+			Limiter:     limiter,
+			FillPercent: 80,
 		})
 		require.NoError(t, err)
 		require.Equal(t, uint64(49), rRes.FilesRemoved)
@@ -215,6 +222,7 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 		}
 
 		require.NoError(t, b.Close(context.Background()))
+		require.NoError(t, limiter.ValidateReleased())
 	})
 
 	t.Run("rebuild by overflow", func(t *testing.T) {
@@ -266,10 +274,11 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 		require.NoError(t, b.Open(mode.ComponentReadWrite))
 		require.NoError(t, b.Init())
 
+		limiter := &rebuildLimiterStub{}
 		rRes, err := b.Rebuild(context.Background(), common.RebuildPrm{
-			MetaStorage:   metaStub,
-			WorkerLimiter: &rebuildLimiterStub{},
-			FillPercent:   80,
+			MetaStorage: metaStub,
+			Limiter:     limiter,
+			FillPercent: 80,
 		})
 		require.NoError(t, err)
 		require.Equal(t, uint64(49), rRes.FilesRemoved)
@@ -285,6 +294,7 @@ func TestBlobovniczaTreeFillPercentRebuild(t *testing.T) {
 		}
 
 		require.NoError(t, b.Close(context.Background()))
+		require.NoError(t, limiter.ValidateReleased())
 	})
 }
 
@@ -338,9 +348,10 @@ func TestBlobovniczaTreeRebuildLargeObject(t *testing.T) {
 		storageIDs: storageIDs,
 		guard:      &sync.Mutex{},
 	}
+	limiter := &rebuildLimiterStub{}
 	var rPrm common.RebuildPrm
 	rPrm.MetaStorage = metaStub
-	rPrm.WorkerLimiter = &rebuildLimiterStub{}
+	rPrm.Limiter = limiter
 	rPrm.FillPercent = 1
 	rRes, err := b.Rebuild(context.Background(), rPrm)
 	require.NoError(t, err)
@@ -356,6 +367,7 @@ func TestBlobovniczaTreeRebuildLargeObject(t *testing.T) {
 	}
 
 	require.NoError(t, b.Close(context.Background()))
+	require.NoError(t, limiter.ValidateReleased())
 }
 
 func testBlobovniczaTreeRebuildHelper(t *testing.T, sourceDepth, sourceWidth, targetDepth, targetWidth uint64, shouldMigrate bool) {
@@ -427,9 +439,10 @@ func testBlobovniczaTreeRebuildHelper(t *testing.T, sourceDepth, sourceWidth, ta
 		storageIDs: storageIDs,
 		guard:      &sync.Mutex{},
 	}
+	limiter := &rebuildLimiterStub{}
 	var rPrm common.RebuildPrm
 	rPrm.MetaStorage = metaStub
-	rPrm.WorkerLimiter = &rebuildLimiterStub{}
+	rPrm.Limiter = limiter
 	rPrm.FillPercent = 1
 	rRes, err := b.Rebuild(context.Background(), rPrm)
 	require.NoError(t, err)
@@ -445,6 +458,7 @@ func testBlobovniczaTreeRebuildHelper(t *testing.T, sourceDepth, sourceWidth, ta
 	}
 
 	require.NoError(t, b.Close(context.Background()))
+	require.NoError(t, limiter.ValidateReleased())
 }
 
 type storageIDUpdateStub struct {
@@ -462,7 +476,36 @@ func (s *storageIDUpdateStub) UpdateStorageID(ctx context.Context, addr oid.Addr
 	return nil
 }
 
-type rebuildLimiterStub struct{}
+type rebuildLimiterStub struct {
+	slots         atomic.Int64
+	readRequests  atomic.Int64
+	writeRequests atomic.Int64
+}
 
-func (s *rebuildLimiterStub) AcquireWorkSlot(context.Context) error { return nil }
-func (s *rebuildLimiterStub) ReleaseWorkSlot()                      {}
+func (s *rebuildLimiterStub) AcquireWorkSlot(context.Context) (common.ReleaseFunc, error) {
+	s.slots.Add(1)
+	return func() { s.slots.Add(-1) }, nil
+}
+
+func (s *rebuildLimiterStub) ReadRequest(context.Context) (common.ReleaseFunc, error) {
+	s.readRequests.Add(1)
+	return func() { s.readRequests.Add(-1) }, nil
+}
+
+func (s *rebuildLimiterStub) WriteRequest(context.Context) (common.ReleaseFunc, error) {
+	s.writeRequests.Add(1)
+	return func() { s.writeRequests.Add(-1) }, nil
+}
+
+func (s *rebuildLimiterStub) ValidateReleased() error {
+	if v := s.slots.Load(); v != 0 {
+		return fmt.Errorf("invalid slots value %d", v)
+	}
+	if v := s.readRequests.Load(); v != 0 {
+		return fmt.Errorf("invalid read requests value %d", v)
+	}
+	if v := s.writeRequests.Load(); v != 0 {
+		return fmt.Errorf("invalid write requests value %d", v)
+	}
+	return nil
+}

pkg/local_object_storage/blobstor/common/rebuild.go

@@ -12,16 +12,27 @@ type RebuildRes struct {
 }
 
 type RebuildPrm struct {
-	MetaStorage   MetaStorage
-	WorkerLimiter ConcurrentWorkersLimiter
-	FillPercent   int
+	MetaStorage MetaStorage
+	Limiter     RebuildLimiter
+	FillPercent int
 }
 
 type MetaStorage interface {
 	UpdateStorageID(ctx context.Context, addr oid.Address, storageID []byte) error
 }
 
-type ConcurrentWorkersLimiter interface {
-	AcquireWorkSlot(ctx context.Context) error
-	ReleaseWorkSlot()
+type ReleaseFunc func()
+
+type ConcurrencyLimiter interface {
+	AcquireWorkSlot(ctx context.Context) (ReleaseFunc, error)
+}
+
+type RateLimiter interface {
+	ReadRequest(context.Context) (ReleaseFunc, error)
+	WriteRequest(context.Context) (ReleaseFunc, error)
+}
+
+type RebuildLimiter interface {
+	ConcurrencyLimiter
+	RateLimiter
 }

pkg/local_object_storage/blobstor/internal/blobstortest/iterate.go

@@ -3,6 +3,7 @@ package blobstortest
 import (
 	"context"
 	"errors"
+	"slices"
 	"testing"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/common"
@@ -26,7 +27,7 @@ func TestIterate(t *testing.T, cons Constructor, minSize, maxSize uint64) {
 	_, err := s.Delete(context.Background(), delPrm)
 	require.NoError(t, err)
 
-	objects = append(objects[:delID], objects[delID+1:]...)
+	objects = slices.Delete(objects, delID, delID+1)
 
 	runTestNormalHandler(t, s, objects)
 

pkg/local_object_storage/blobstor/rebuild.go

@@ -13,19 +13,14 @@ type StorageIDUpdate interface {
 	UpdateStorageID(ctx context.Context, addr oid.Address, storageID []byte) error
 }
 
-type ConcurrentWorkersLimiter interface {
-	AcquireWorkSlot(ctx context.Context) error
-	ReleaseWorkSlot()
-}
-
-func (b *BlobStor) Rebuild(ctx context.Context, upd StorageIDUpdate, limiter ConcurrentWorkersLimiter, fillPercent int) error {
+func (b *BlobStor) Rebuild(ctx context.Context, upd StorageIDUpdate, concLimiter common.RebuildLimiter, fillPercent int) error {
 	var summary common.RebuildRes
 	var rErr error
 	for _, storage := range b.storage {
 		res, err := storage.Storage.Rebuild(ctx, common.RebuildPrm{
-			MetaStorage:   upd,
-			WorkerLimiter: limiter,
-			FillPercent:   fillPercent,
+			MetaStorage: upd,
+			Limiter:     concLimiter,
+			FillPercent: fillPercent,
 		})
 		summary.FilesRemoved += res.FilesRemoved
 		summary.ObjectsMoved += res.ObjectsMoved

pkg/local_object_storage/engine/container.go

@@ -74,7 +74,7 @@ func (e *StorageEngine) containerSize(ctx context.Context, prm ContainerSizePrm)
 		var csPrm shard.ContainerSizePrm
 		csPrm.SetContainerID(prm.cnr)
 
-		csRes, err := sh.Shard.ContainerSize(csPrm)
+		csRes, err := sh.Shard.ContainerSize(ctx, csPrm)
 		if err != nil {
 			e.reportShardError(ctx, sh, "can't get container size", err,
 				zap.Stringer("container_id", prm.cnr))

pkg/local_object_storage/engine/control.go

@@ -153,16 +153,10 @@ func (e *StorageEngine) Close(ctx context.Context) error {
 }
 
 // closes all shards. Never returns an error, shard errors are logged.
-func (e *StorageEngine) close(ctx context.Context, releasePools bool) error {
+func (e *StorageEngine) close(ctx context.Context) error {
 	e.mtx.RLock()
 	defer e.mtx.RUnlock()
 
-	if releasePools {
-		for _, p := range e.shardPools {
-			p.Release()
-		}
-	}
-
 	for id, sh := range e.shards {
 		if err := sh.Close(ctx); err != nil {
 			e.log.Debug(ctx, logs.EngineCouldNotCloseShard,
@@ -213,7 +207,7 @@ func (e *StorageEngine) setBlockExecErr(ctx context.Context, err error) error {
 			return e.open(ctx)
 		}
 	} else if prevErr == nil { // ok -> block
-		return e.close(ctx, errors.Is(err, errClosed))
+		return e.close(ctx)
 	}
 
 	// otherwise do nothing

pkg/local_object_storage/engine/control_test.go

@@ -245,7 +245,6 @@ func TestReload(t *testing.T) {
 
 		// no new paths => no new shards
 		require.Equal(t, shardNum, len(e.shards))
-		require.Equal(t, shardNum, len(e.shardPools))
 
 		newMeta := filepath.Join(addPath, fmt.Sprintf("%d.metabase", shardNum))
 
@@ -257,7 +256,6 @@ func TestReload(t *testing.T) {
 		require.NoError(t, e.Reload(context.Background(), rcfg))
 
 		require.Equal(t, shardNum+1, len(e.shards))
-		require.Equal(t, shardNum+1, len(e.shardPools))
 
 		require.NoError(t, e.Close(context.Background()))
 	})
@@ -277,7 +275,6 @@ func TestReload(t *testing.T) {
 
 		// removed one
 		require.Equal(t, shardNum-1, len(e.shards))
-		require.Equal(t, shardNum-1, len(e.shardPools))
 
 		require.NoError(t, e.Close(context.Background()))
 	})
@@ -311,7 +308,6 @@ func engineWithShards(t *testing.T, path string, num int) (*StorageEngine, []str
 	}
 
 	require.Equal(t, num, len(e.shards))
-	require.Equal(t, num, len(e.shardPools))
 
 	return e, currShards
 }

pkg/local_object_storage/engine/engine.go

@@ -12,8 +12,8 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard/mode"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/util/logicerr"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/logger"
+	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
 	"go.uber.org/zap"
 )
@@ -28,8 +28,6 @@ type StorageEngine struct {
 
 	shards map[string]hashedShard
 
-	shardPools map[string]util.WorkerPool
-
 	closeCh   chan struct{}
 	setModeCh chan setModeRequest
 	wg        sync.WaitGroup
@@ -176,7 +174,10 @@ func (e *StorageEngine) reportShardError(
 }
 
 func isLogical(err error) bool {
-	return errors.As(err, &logicerr.Logical{}) || errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)
+	return errors.As(err, &logicerr.Logical{}) ||
+		errors.Is(err, context.Canceled) ||
+		errors.Is(err, context.DeadlineExceeded) ||
+		errors.As(err, new(*apistatus.ResourceExhausted))
 }
 
 // Option represents StorageEngine's constructor option.
@@ -189,8 +190,6 @@ type cfg struct {
 
 	metrics MetricRegister
 
-	shardPoolSize uint32
-
 	lowMem bool
 
 	containerSource atomic.Pointer[containerSource]
@@ -198,9 +197,8 @@ type cfg struct {
 
 func defaultCfg() *cfg {
 	res := &cfg{
-		log:           logger.NewLoggerWrapper(zap.L()),
-		shardPoolSize: 20,
-		metrics:       noopMetrics{},
+		log:     logger.NewLoggerWrapper(zap.L()),
+		metrics: noopMetrics{},
 	}
 	res.containerSource.Store(&containerSource{})
 	return res
@@ -217,7 +215,6 @@ func New(opts ...Option) *StorageEngine {
 	return &StorageEngine{
 		cfg:             c,
 		shards:          make(map[string]hashedShard),
-		shardPools:      make(map[string]util.WorkerPool),
 		closeCh:         make(chan struct{}),
 		setModeCh:       make(chan setModeRequest),
 		evacuateLimiter: &evacuationLimiter{},
@@ -237,13 +234,6 @@ func WithMetrics(v MetricRegister) Option {
 	}
 }
 
-// WithShardPoolSize returns option to specify size of worker pool for each shard.
-func WithShardPoolSize(sz uint32) Option {
-	return func(c *cfg) {
-		c.shardPoolSize = sz
-	}
-}
-
 // WithErrorThreshold returns an option to specify size amount of errors after which
 // shard is moved to read-only mode.
 func WithErrorThreshold(sz uint32) Option {

pkg/local_object_storage/engine/engine_test.go

@@ -3,8 +3,10 @@ package engine
 import (
 	"context"
 	"path/filepath"
+	"sync/atomic"
 	"testing"
 
+	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/qos"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/blobovniczatree"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/fstree"
@@ -55,7 +57,6 @@ func (te *testEngineWrapper) setShardsNumOpts(
 		te.shardIDs[i] = shard.ID()
 	}
 	require.Len(t, te.engine.shards, num)
-	require.Len(t, te.engine.shardPools, num)
 	return te
 }
 
@@ -90,6 +91,7 @@ func testGetDefaultShardOptions(t testing.TB) []shard.Option {
 		),
 		shard.WithPiloramaOptions(pilorama.WithPath(filepath.Join(t.TempDir(), "pilorama"))),
 		shard.WithMetaBaseOptions(testGetDefaultMetabaseOptions(t)...),
+		shard.WithLimiter(&testQoSLimiter{t: t}),
 	}
 }
 
@@ -151,3 +153,30 @@ func newTestStorages(root string, smallSize uint64) ([]blobstor.SubStorage, *tes
 		},
 	}, smallFileStorage, largeFileStorage
 }
+
+var _ qos.Limiter = (*testQoSLimiter)(nil)
+
+type testQoSLimiter struct {
+	t     testing.TB
+	read  atomic.Int64
+	write atomic.Int64
+}
+
+func (t *testQoSLimiter) SetMetrics(qos.Metrics) {}
+
+func (t *testQoSLimiter) Close() {
+	require.Equal(t.t, int64(0), t.read.Load(), "read requests count after limiter close must be 0")
+	require.Equal(t.t, int64(0), t.write.Load(), "write requests count after limiter close must be 0")
+}
+
+func (t *testQoSLimiter) ReadRequest(context.Context) (qos.ReleaseFunc, error) {
+	t.read.Add(1)
+	return func() { t.read.Add(-1) }, nil
+}
+
+func (t *testQoSLimiter) WriteRequest(context.Context) (qos.ReleaseFunc, error) {
+	t.write.Add(1)
+	return func() { t.write.Add(-1) }, nil
+}
+
+func (t *testQoSLimiter) SetParentID(string) {}

pkg/local_object_storage/engine/error_test.go

@@ -46,7 +46,6 @@ func newEngineWithErrorThreshold(t testing.TB, dir string, errThreshold uint32)
 	var testShards [2]*testShard
 
 	te := testNewEngine(t,
-		WithShardPoolSize(1),
 		WithErrorThreshold(errThreshold),
 	).
 		setShardsNumOpts(t, 2, func(id int) []shard.Option {

pkg/local_object_storage/engine/evacuate.go

@@ -15,7 +15,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/pilorama"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/util/logicerr"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util"
 	"git.frostfs.info/TrueCloudLab/frostfs-observability/tracing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client"
 	containerSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container"
@@ -201,11 +200,6 @@ func (p *EvacuateShardRes) DeepCopy() *EvacuateShardRes {
 	return res
 }
 
-type pooledShard struct {
-	hashedShard
-	pool util.WorkerPool
-}
-
 var errMustHaveTwoShards = errors.New("must have at least 1 spare shard")
 
 // Evacuate moves data from one shard to the others.
@@ -252,7 +246,7 @@ func (e *StorageEngine) Evacuate(ctx context.Context, prm EvacuateShardPrm) erro
 	}
 
 	var mtx sync.RWMutex
-	copyShards := func() []pooledShard {
+	copyShards := func() []hashedShard {
 		mtx.RLock()
 		defer mtx.RUnlock()
 		t := slices.Clone(shards)
@@ -266,7 +260,7 @@ func (e *StorageEngine) Evacuate(ctx context.Context, prm EvacuateShardPrm) erro
 }
 
 func (e *StorageEngine) evacuateShards(ctx context.Context, shardIDs []string, prm EvacuateShardPrm, res *EvacuateShardRes,
-	shards func() []pooledShard, shardsToEvacuate map[string]*shard.Shard,
+	shards func() []hashedShard, shardsToEvacuate map[string]*shard.Shard,
 ) error {
 	var err error
 	ctx, span := tracing.StartSpanFromContext(ctx, "StorageEngine.evacuateShards",
@@ -388,7 +382,7 @@ func (e *StorageEngine) getTotals(ctx context.Context, prm EvacuateShardPrm, sha
 }
 
 func (e *StorageEngine) evacuateShard(ctx context.Context, cancel context.CancelCauseFunc, shardID string, prm EvacuateShardPrm, res *EvacuateShardRes,
-	shards func() []pooledShard, shardsToEvacuate map[string]*shard.Shard,
+	shards func() []hashedShard, shardsToEvacuate map[string]*shard.Shard,
 	egContainer *errgroup.Group, egObject *errgroup.Group,
 ) error {
 	ctx, span := tracing.StartSpanFromContext(ctx, "StorageEngine.evacuateShard",
@@ -412,7 +406,7 @@ func (e *StorageEngine) evacuateShard(ctx context.Context, cancel context.Cancel
 }
 
 func (e *StorageEngine) evacuateShardObjects(ctx context.Context, cancel context.CancelCauseFunc, shardID string, prm EvacuateShardPrm, res *EvacuateShardRes,
-	shards func() []pooledShard, shardsToEvacuate map[string]*shard.Shard,
+	shards func() []hashedShard, shardsToEvacuate map[string]*shard.Shard,
 	egContainer *errgroup.Group, egObject *errgroup.Group,
 ) error {
 	sh := shardsToEvacuate[shardID]
@@ -485,7 +479,7 @@ func (e *StorageEngine) evacuateShardObjects(ctx context.Context, cancel context
 }
 
 func (e *StorageEngine) evacuateShardTrees(ctx context.Context, shardID string, prm EvacuateShardPrm, res *EvacuateShardRes,
-	getShards func() []pooledShard, shardsToEvacuate map[string]*shard.Shard,
+	getShards func() []hashedShard, shardsToEvacuate map[string]*shard.Shard,
 ) error {
 	sh := shardsToEvacuate[shardID]
 	shards := getShards()
@@ -515,7 +509,7 @@ func (e *StorageEngine) evacuateShardTrees(ctx context.Context, shardID string,
 }
 
 func (e *StorageEngine) evacuateTrees(ctx context.Context, sh *shard.Shard, trees []pilorama.ContainerIDTreeID,
-	prm EvacuateShardPrm, res *EvacuateShardRes, shards []pooledShard, shardsToEvacuate map[string]*shard.Shard,
+	prm EvacuateShardPrm, res *EvacuateShardRes, shards []hashedShard, shardsToEvacuate map[string]*shard.Shard,
 ) error {
 	ctx, span := tracing.StartSpanFromContext(ctx, "StorageEngine.evacuateTrees",
 		trace.WithAttributes(
@@ -583,7 +577,7 @@ func (e *StorageEngine) evacuateTreeToOtherNode(ctx context.Context, sh *shard.S
 }
 
 func (e *StorageEngine) tryEvacuateTreeLocal(ctx context.Context, sh *shard.Shard, tree pilorama.ContainerIDTreeID,
-	prm EvacuateShardPrm, shards []pooledShard, shardsToEvacuate map[string]*shard.Shard,
+	prm EvacuateShardPrm, shards []hashedShard, shardsToEvacuate map[string]*shard.Shard,
 ) (bool, string, error) {
 	target, found, err := e.findShardToEvacuateTree(ctx, tree, shards, shardsToEvacuate)
 	if err != nil {
@@ -653,15 +647,15 @@ func (e *StorageEngine) tryEvacuateTreeLocal(ctx context.Context, sh *shard.Shar
 
 // findShardToEvacuateTree returns first shard according HRW or first shard with tree exists.
 func (e *StorageEngine) findShardToEvacuateTree(ctx context.Context, tree pilorama.ContainerIDTreeID,
-	shards []pooledShard, shardsToEvacuate map[string]*shard.Shard,
-) (pooledShard, bool, error) {
+	shards []hashedShard, shardsToEvacuate map[string]*shard.Shard,
+) (hashedShard, bool, error) {
 	hrw.SortHasherSliceByValue(shards, hrw.StringHash(tree.CID.EncodeToString()))
-	var result pooledShard
+	var result hashedShard
 	var found bool
 	for _, target := range shards {
 		select {
 		case <-ctx.Done():
-			return pooledShard{}, false, ctx.Err()
+			return hashedShard{}, false, ctx.Err()
 		default:
 		}
 
@@ -689,7 +683,7 @@ func (e *StorageEngine) findShardToEvacuateTree(ctx context.Context, tree pilora
 	return result, found, nil
 }
 
-func (e *StorageEngine) getActualShards(shardIDs []string, prm EvacuateShardPrm) ([]pooledShard, error) {
+func (e *StorageEngine) getActualShards(shardIDs []string, prm EvacuateShardPrm) ([]hashedShard, error) {
 	e.mtx.RLock()
 	defer e.mtx.RUnlock()
 
@@ -719,18 +713,15 @@ func (e *StorageEngine) getActualShards(shardIDs []string, prm EvacuateShardPrm)
 	// We must have all shards, to have correct information about their
 	// indexes in a sorted slice and set appropriate marks in the metabase.
 	// Evacuated shard is skipped during put.
-	shards := make([]pooledShard, 0, len(e.shards))
+	shards := make([]hashedShard, 0, len(e.shards))
 	for id := range e.shards {
-		shards = append(shards, pooledShard{
-			hashedShard: e.shards[id],
-			pool:        e.shardPools[id],
-		})
+		shards = append(shards, e.shards[id])
 	}
 	return shards, nil
 }
 
 func (e *StorageEngine) evacuateObject(ctx context.Context, shardID string, objInfo *object.Info, prm EvacuateShardPrm, res *EvacuateShardRes,
-	getShards func() []pooledShard, shardsToEvacuate map[string]*shard.Shard, cnr containerSDK.Container,
+	getShards func() []hashedShard, shardsToEvacuate map[string]*shard.Shard, cnr containerSDK.Container,
 ) error {
 	ctx, span := tracing.StartSpanFromContext(ctx, "StorageEngine.evacuateObjects")
 	defer span.End()
@@ -800,7 +791,7 @@ func (e *StorageEngine) isNotRepOne(c *container.Container) bool {
 }
 
 func (e *StorageEngine) tryEvacuateObjectLocal(ctx context.Context, addr oid.Address, object *objectSDK.Object, sh *shard.Shard,
-	shards []pooledShard, shardsToEvacuate map[string]*shard.Shard, res *EvacuateShardRes, cnr containerSDK.Container,
+	shards []hashedShard, shardsToEvacuate map[string]*shard.Shard, res *EvacuateShardRes, cnr containerSDK.Container,
 ) (bool, error) {
 	hrw.SortHasherSliceByValue(shards, hrw.StringHash(addr.EncodeToString()))
 	for j := range shards {
@@ -813,7 +804,7 @@ func (e *StorageEngine) tryEvacuateObjectLocal(ctx context.Context, addr oid.Add
 		if _, ok := shardsToEvacuate[shards[j].ID().String()]; ok {
 			continue
 		}
-		switch e.putToShard(ctx, shards[j].hashedShard, shards[j].pool, addr, object, container.IsIndexedContainer(cnr)).status {
+		switch e.putToShard(ctx, shards[j], addr, object, container.IsIndexedContainer(cnr)).status {
 		case putToShardSuccess:
 			res.objEvacuated.Add(1)
 			e.log.Debug(ctx, logs.EngineObjectIsMovedToAnotherShard,

pkg/local_object_storage/engine/evacuate_test.go

@@ -196,7 +196,6 @@ func TestEvacuateShardObjects(t *testing.T) {
 
 	e.mtx.Lock()
 	delete(e.shards, evacuateShardID)
-	delete(e.shardPools, evacuateShardID)
 	e.mtx.Unlock()
 
 	checkHasObjects(t)
@@ -405,8 +404,8 @@ func TestEvacuateSingleProcess(t *testing.T) {
 	require.NoError(t, e.shards[ids[0].String()].SetMode(context.Background(), mode.ReadOnly))
 	require.NoError(t, e.shards[ids[1].String()].SetMode(context.Background(), mode.ReadOnly))
 
-	blocker := make(chan interface{})
-	running := make(chan interface{})
+	blocker := make(chan any)
+	running := make(chan any)
 
 	var prm EvacuateShardPrm
 	prm.ShardID = ids[1:2]
@@ -447,8 +446,8 @@ func TestEvacuateObjectsAsync(t *testing.T) {
 	require.NoError(t, e.shards[ids[0].String()].SetMode(context.Background(), mode.ReadOnly))
 	require.NoError(t, e.shards[ids[1].String()].SetMode(context.Background(), mode.ReadOnly))
 
-	blocker := make(chan interface{})
-	running := make(chan interface{})
+	blocker := make(chan any)
+	running := make(chan any)
 
 	var prm EvacuateShardPrm
 	prm.ShardID = ids[1:2]
@@ -475,7 +474,7 @@ func TestEvacuateObjectsAsync(t *testing.T) {
 	eg, egCtx := errgroup.WithContext(context.Background())
 	eg.Go(func() error {
 		require.NoError(t, e.Evacuate(egCtx, prm), "first evacuation failed")
-		st = testWaitForEvacuationCompleted(t, e)
+		st := testWaitForEvacuationCompleted(t, e)
 		require.Equal(t, uint64(3), st.ObjectsEvacuated(), "invalid final count")
 		return nil
 	})

pkg/local_object_storage/engine/inhume.go

@@ -339,7 +339,7 @@ func (e *StorageEngine) processZeroSizeContainers(ctx context.Context, ids []cid
 		var drop []cid.ID
 		for id := range idMap {
 			prm.SetContainerID(id)
-			s, err := sh.ContainerSize(prm)
+			s, err := sh.ContainerSize(ctx, prm)
 			if err != nil {
 				e.log.Warn(ctx, logs.EngineFailedToGetContainerSize, zap.Stringer("container_id", id), zap.Error(err))
 				failed = true

pkg/local_object_storage/engine/inhume_test.go

@@ -205,7 +205,7 @@ func BenchmarkInhumeMultipart(b *testing.B) {
 func benchmarkInhumeMultipart(b *testing.B, numShards, numObjects int) {
 	b.StopTimer()
 
-	engine := testNewEngine(b, WithShardPoolSize(uint32(numObjects))).
+	engine := testNewEngine(b).
 		setShardsNum(b, numShards).prepare(b).engine
 	defer func() { require.NoError(b, engine.Close(context.Background())) }()
 

pkg/local_object_storage/engine/put.go

@@ -9,7 +9,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/common"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util"
 	"git.frostfs.info/TrueCloudLab/frostfs-observability/tracing"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client"
 	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
@@ -99,13 +98,13 @@ func (e *StorageEngine) put(ctx context.Context, prm PutPrm) error {
 	var shRes putToShardRes
 	e.iterateOverSortedShards(addr, func(_ int, sh hashedShard) (stop bool) {
 		e.mtx.RLock()
-		pool, ok := e.shardPools[sh.ID().String()]
+		_, ok := e.shards[sh.ID().String()]
 		e.mtx.RUnlock()
 		if !ok {
 			// Shard was concurrently removed, skip.
 			return false
 		}
-		shRes = e.putToShard(ctx, sh, pool, addr, prm.Object, prm.IsIndexedContainer)
+		shRes = e.putToShard(ctx, sh, addr, prm.Object, prm.IsIndexedContainer)
 		return shRes.status != putToShardUnknown
 	})
 	switch shRes.status {
@@ -122,70 +121,59 @@ func (e *StorageEngine) put(ctx context.Context, prm PutPrm) error {
 
 // putToShard puts object to sh.
 // Return putToShardStatus and error if it is necessary to propagate an error upper.
-func (e *StorageEngine) putToShard(ctx context.Context, sh hashedShard, pool util.WorkerPool,
+func (e *StorageEngine) putToShard(ctx context.Context, sh hashedShard,
 	addr oid.Address, obj *objectSDK.Object, isIndexedContainer bool,
 ) (res putToShardRes) {
-	exitCh := make(chan struct{})
+	var existPrm shard.ExistsPrm
+	existPrm.Address = addr
 
-	if err := pool.Submit(func() {
-		defer close(exitCh)
-
-		var existPrm shard.ExistsPrm
-		existPrm.Address = addr
-
-		exists, err := sh.Exists(ctx, existPrm)
-		if err != nil {
-			if shard.IsErrObjectExpired(err) {
-				// object is already found but
-				// expired => do nothing with it
-				res.status = putToShardExists
-			} else {
-				e.log.Warn(ctx, logs.EngineCouldNotCheckObjectExistence,
-					zap.Stringer("shard_id", sh.ID()),
-					zap.Error(err))
-			}
-
-			return // this is not ErrAlreadyRemoved error so we can go to the next shard
-		}
-
-		if exists.Exists() {
+	exists, err := sh.Exists(ctx, existPrm)
+	if err != nil {
+		if shard.IsErrObjectExpired(err) {
+			// object is already found but
+			// expired => do nothing with it
 			res.status = putToShardExists
-			return
+		} else {
+			e.log.Warn(ctx, logs.EngineCouldNotCheckObjectExistence,
+				zap.Stringer("shard_id", sh.ID()),
+				zap.Error(err))
 		}
 
-		var putPrm shard.PutPrm
-		putPrm.SetObject(obj)
-		putPrm.SetIndexAttributes(isIndexedContainer)
-
-		_, err = sh.Put(ctx, putPrm)
-		if err != nil {
-			if errors.Is(err, shard.ErrReadOnlyMode) || errors.Is(err, blobstor.ErrNoPlaceFound) ||
-				errors.Is(err, common.ErrReadOnly) || errors.Is(err, common.ErrNoSpace) {
-				e.log.Warn(ctx, logs.EngineCouldNotPutObjectToShard,
-					zap.Stringer("shard_id", sh.ID()),
-					zap.Error(err))
-				return
-			}
-			if client.IsErrObjectAlreadyRemoved(err) {
-				e.log.Warn(ctx, logs.EngineCouldNotPutObjectToShard,
-					zap.Stringer("shard_id", sh.ID()),
-					zap.Error(err))
-				res.status = putToShardRemoved
-				res.err = err
-				return
-			}
-
-			e.reportShardError(ctx, sh, "could not put object to shard", err, zap.Stringer("address", addr))
-			return
-		}
-
-		res.status = putToShardSuccess
-	}); err != nil {
-		e.log.Warn(ctx, logs.EngineCouldNotPutObjectToShard, zap.Error(err))
-		close(exitCh)
+		return // this is not ErrAlreadyRemoved error so we can go to the next shard
 	}
 
-	<-exitCh
+	if exists.Exists() {
+		res.status = putToShardExists
+		return
+	}
+
+	var putPrm shard.PutPrm
+	putPrm.SetObject(obj)
+	putPrm.SetIndexAttributes(isIndexedContainer)
+
+	_, err = sh.Put(ctx, putPrm)
+	if err != nil {
+		if errors.Is(err, shard.ErrReadOnlyMode) || errors.Is(err, blobstor.ErrNoPlaceFound) ||
+			errors.Is(err, common.ErrReadOnly) || errors.Is(err, common.ErrNoSpace) {
+			e.log.Warn(ctx, logs.EngineCouldNotPutObjectToShard,
+				zap.Stringer("shard_id", sh.ID()),
+				zap.Error(err))
+			return
+		}
+		if client.IsErrObjectAlreadyRemoved(err) {
+			e.log.Warn(ctx, logs.EngineCouldNotPutObjectToShard,
+				zap.Stringer("shard_id", sh.ID()),
+				zap.Error(err))
+			res.status = putToShardRemoved
+			res.err = err
+			return
+		}
+
+		e.reportShardError(ctx, sh, "could not put object to shard", err, zap.Stringer("address", addr))
+		return
+	}
+
+	res.status = putToShardSuccess
 
 	return
 }

pkg/local_object_storage/engine/rebuild.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"sync"
 
+	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/common"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard"
 	"git.frostfs.info/TrueCloudLab/frostfs-observability/tracing"
 	"go.opentelemetry.io/otel/attribute"
@@ -41,7 +42,7 @@ func (e *StorageEngine) Rebuild(ctx context.Context, prm RebuildPrm) (RebuildRes
 	}
 	resGuard := &sync.Mutex{}
 
-	limiter := shard.NewRebuildLimiter(prm.ConcurrencyLimit)
+	concLimiter := &concurrencyLimiter{semaphore: make(chan struct{}, prm.ConcurrencyLimit)}
 
 	eg, egCtx := errgroup.WithContext(ctx)
 	for _, shardID := range prm.ShardIDs {
@@ -61,7 +62,7 @@ func (e *StorageEngine) Rebuild(ctx context.Context, prm RebuildPrm) (RebuildRes
 			}
 
 			err := sh.ScheduleRebuild(egCtx, shard.RebuildPrm{
-				ConcurrencyLimiter: limiter,
+				ConcurrencyLimiter: concLimiter,
 				TargetFillPercent:  prm.TargetFillPercent,
 			})
 
@@ -88,3 +89,20 @@ func (e *StorageEngine) Rebuild(ctx context.Context, prm RebuildPrm) (RebuildRes
 	}
 	return res, nil
 }
+
+type concurrencyLimiter struct {
+	semaphore chan struct{}
+}
+
+func (l *concurrencyLimiter) AcquireWorkSlot(ctx context.Context) (common.ReleaseFunc, error) {
+	select {
+	case l.semaphore <- struct{}{}:
+		return l.releaseWorkSlot, nil
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+func (l *concurrencyLimiter) releaseWorkSlot() {
+	<-l.semaphore
+}

pkg/local_object_storage/engine/shards.go

@@ -11,10 +11,12 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard/mode"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/util/logicerr"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client"
+	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
+	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
 	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
 	"git.frostfs.info/TrueCloudLab/hrw"
 	"github.com/google/uuid"
-	"github.com/panjf2000/ants/v2"
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
 )
@@ -178,11 +180,6 @@ func (e *StorageEngine) addShard(sh *shard.Shard) error {
 	e.mtx.Lock()
 	defer e.mtx.Unlock()
 
-	pool, err := ants.NewPool(int(e.shardPoolSize), ants.WithNonblocking(true))
-	if err != nil {
-		return fmt.Errorf("create pool: %w", err)
-	}
-
 	strID := sh.ID().String()
 	if _, ok := e.shards[strID]; ok {
 		return fmt.Errorf("shard with id %s was already added", strID)
@@ -196,8 +193,6 @@ func (e *StorageEngine) addShard(sh *shard.Shard) error {
 		hash: hrw.StringHash(strID),
 	}
 
-	e.shardPools[strID] = pool
-
 	return nil
 }
 
@@ -222,12 +217,6 @@ func (e *StorageEngine) removeShards(ctx context.Context, ids ...string) {
 		ss = append(ss, sh)
 		delete(e.shards, id)
 
-		pool, ok := e.shardPools[id]
-		if ok {
-			pool.Release()
-			delete(e.shardPools, id)
-		}
-
 		e.log.Info(ctx, logs.EngineShardHasBeenRemoved,
 			zap.String("id", id))
 	}
@@ -426,12 +415,6 @@ func (e *StorageEngine) deleteShards(ctx context.Context, ids []*shard.ID) ([]ha
 
 		delete(e.shards, idStr)
 
-		pool, ok := e.shardPools[idStr]
-		if ok {
-			pool.Release()
-			delete(e.shardPools, idStr)
-		}
-
 		e.log.Info(ctx, logs.EngineShardHasBeenRemoved,
 			zap.String("id", idStr))
 	}
@@ -442,3 +425,46 @@ func (e *StorageEngine) deleteShards(ctx context.Context, ids []*shard.ID) ([]ha
 func (s hashedShard) Hash() uint64 {
 	return s.hash
 }
+
+func (e *StorageEngine) ListShardsForObject(ctx context.Context, obj oid.Address) ([]shard.Info, error) {
+	var err error
+	var info []shard.Info
+	prm := shard.ExistsPrm{
+		Address: obj,
+	}
+	var siErr *objectSDK.SplitInfoError
+	var ecErr *objectSDK.ECInfoError
+
+	e.iterateOverUnsortedShards(func(hs hashedShard) (stop bool) {
+		res, exErr := hs.Exists(ctx, prm)
+		if exErr != nil {
+			if client.IsErrObjectAlreadyRemoved(exErr) {
+				err = new(apistatus.ObjectAlreadyRemoved)
+				return true
+			}
+
+			// Check if error is either SplitInfoError or ECInfoError.
+			// True means the object is virtual.
+			if errors.As(exErr, &siErr) || errors.As(exErr, &ecErr) {
+				info = append(info, hs.DumpInfo())
+				return false
+			}
+
+			if shard.IsErrObjectExpired(exErr) {
+				err = exErr
+				return true
+			}
+
+			if !client.IsErrObjectNotFound(exErr) {
+				e.reportShardError(ctx, hs, "could not check existence of object in shard", exErr, zap.Stringer("address", prm.Address))
+			}
+
+			return false
+		}
+		if res.Exists() {
+			info = append(info, hs.DumpInfo())
+		}
+		return false
+	})
+	return info, err
+}

pkg/local_object_storage/engine/shards_test.go

@@ -17,7 +17,6 @@ func TestRemoveShard(t *testing.T) {
 	e, ids := te.engine, te.shardIDs
 	defer func() { require.NoError(t, e.Close(context.Background())) }()
 
-	require.Equal(t, numOfShards, len(e.shardPools))
 	require.Equal(t, numOfShards, len(e.shards))
 
 	removedNum := numOfShards / 2
@@ -37,7 +36,6 @@ func TestRemoveShard(t *testing.T) {
 		}
 	}
 
-	require.Equal(t, numOfShards-removedNum, len(e.shardPools))
 	require.Equal(t, numOfShards-removedNum, len(e.shards))
 
 	for id, removed := range mSh {

pkg/local_object_storage/metabase/lock.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"slices"
 	"time"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/internal/metaerr"
@@ -250,7 +251,7 @@ func freePotentialLocks(tx *bbolt.Tx, idCnr cid.ID, locker oid.ID) ([]oid.Addres
 					unlockedObjects = append(unlockedObjects, addr)
 				} else {
 					// exclude locker
-					keyLockers = append(keyLockers[:i], keyLockers[i+1:]...)
+					keyLockers = slices.Delete(keyLockers, i, i+1)
 
 					v, err = encodeList(keyLockers)
 					if err != nil {

pkg/local_object_storage/metabase/reset_test.go

@@ -37,7 +37,7 @@ func TestResetDropsContainerBuckets(t *testing.T) {
 	for idx := range 100 {
 		var putPrm PutPrm
 		putPrm.SetObject(testutil.GenerateObject())
-		putPrm.SetStorageID([]byte(fmt.Sprintf("0/%d", idx)))
+		putPrm.SetStorageID(fmt.Appendf(nil, "0/%d", idx))
 		_, err := db.Put(context.Background(), putPrm)
 		require.NoError(t, err)
 	}

pkg/local_object_storage/pilorama/forest.go

@@ -205,10 +205,7 @@ func (f *memoryForest) TreeSortedByFilename(_ context.Context, cid cid.ID, treeI
 	r := mergeNodeInfos(res)
 	for i := range r {
 		if start == nil || string(findAttr(r[i].Meta, AttributeFilename)) > *start {
-			finish := i + count
-			if len(res) < finish {
-				finish = len(res)
-			}
+			finish := min(len(res), i+count)
 			last := string(findAttr(r[finish-1].Meta, AttributeFilename))
 			return r[i:finish], &last, nil
 		}