WIP Auto-tune recovery speed

Hotfix to 1.3.0 - new "journal space reservation" had a bug which
caused OSDs to crash with EC and without immediate_commit.

CMakeLists.txt

@@ -2,6 +2,6 @@ cmake_minimum_required(VERSION 2.8.12)
 
 project(vitastor)
 
-set(VERSION "1.2.0")
+set(VERSION "1.3.1")
 
 add_subdirectory(src)

csi/Dockerfile

@@ -1,14 +1,15 @@
 # Compile stage
-FROM golang:buster AS build
+FROM golang:bookworm AS build
 
 ADD go.sum go.mod /app/
 RUN cd /app; CGO_ENABLED=1 GOOS=linux GOARCH=amd64 go mod download -x
 ADD . /app
-RUN perl -i -e '$/ = undef; while(<>) { s/\n\s*(\{\s*\n)/$1\n/g; s/\}(\s*\n\s*)else\b/$1} else/g; print; }' `find /app -name '*.go'`
-RUN cd /app; CGO_ENABLED=1 GOOS=linux GOARCH=amd64 go build -o vitastor-csi
+RUN perl -i -e '$/ = undef; while(<>) { s/\n\s*(\{\s*\n)/$1\n/g; s/\}(\s*\n\s*)else\b/$1} else/g; print; }' `find /app -name '*.go'` && \
+    cd /app && \
+    CGO_ENABLED=1 GOOS=linux GOARCH=amd64 go build -o vitastor-csi
 
 # Final stage
-FROM debian:buster
+FROM debian:bookworm
 
 LABEL maintainers="Vitaliy Filippov <vitalif@yourcmc.ru>"
 LABEL description="Vitastor CSI Driver"
@@ -18,19 +19,30 @@ ENV CSI_ENDPOINT=""
 
 RUN apt-get update && \
     apt-get install -y wget && \
-    (echo deb http://deb.debian.org/debian buster-backports main > /etc/apt/sources.list.d/backports.list) && \
     (echo "APT::Install-Recommends false;" > /etc/apt/apt.conf) && \
     apt-get update && \
-    apt-get install -y e2fsprogs xfsprogs kmod && \
+    apt-get install -y e2fsprogs xfsprogs kmod iproute2 \
+        # dependencies of qemu-storage-daemon
+        libnuma1 liburing2 libglib2.0-0 libfuse3-3 libaio1 libzstd1 libnettle8 \
+        libgmp10 libhogweed6 libp11-kit0 libidn2-0 libunistring2 libtasn1-6 libpcre2-8-0 libffi8 && \
     apt-get clean && \
     (echo options nbd nbds_max=128 > /etc/modprobe.d/nbd.conf)
 
 COPY --from=build /app/vitastor-csi /bin/
 
-RUN (echo deb http://vitastor.io/debian buster main > /etc/apt/sources.list.d/vitastor.list) && \
+RUN (echo deb http://vitastor.io/debian bookworm main > /etc/apt/sources.list.d/vitastor.list) && \
+    ((echo 'Package: *'; echo 'Pin: origin "vitastor.io"'; echo 'Pin-Priority: 1000') > /etc/apt/preferences.d/vitastor.pref) && \
     wget -q -O /etc/apt/trusted.gpg.d/vitastor.gpg https://vitastor.io/debian/pubkey.gpg && \
     apt-get update && \
     apt-get install -y vitastor-client && \
+    wget https://vitastor.io/archive/qemu/qemu-bookworm-8.1.2%2Bds-1%2Bvitastor1/qemu-utils_8.1.2%2Bds-1%2Bvitastor1_amd64.deb && \
+    wget https://vitastor.io/archive/qemu/qemu-bookworm-8.1.2%2Bds-1%2Bvitastor1/qemu-block-extra_8.1.2%2Bds-1%2Bvitastor1_amd64.deb && \
+    dpkg -x qemu-utils*.deb tmp1 && \
+    dpkg -x qemu-block-extra*.deb tmp1 && \
+    cp -a tmp1/usr/bin/qemu-storage-daemon /usr/bin/ && \
+    mkdir -p /usr/lib/x86_64-linux-gnu/qemu && \
+    cp -a tmp1/usr/lib/x86_64-linux-gnu/qemu/block-vitastor.so /usr/lib/x86_64-linux-gnu/qemu/ && \
+    rm -rf tmp1 *.deb && \
     apt-get clean
 
 ENTRYPOINT ["/bin/vitastor-csi"]

csi/Makefile

@@ -1,4 +1,4 @@
-VERSION ?= v1.2.0
+VERSION ?= v1.3.1
 
 all: build push
 

csi/deploy/001-csi-config-map.yaml

@@ -2,6 +2,7 @@
 apiVersion: v1
 kind: ConfigMap
 data:
+  # You can add multiple configuration files here to use a multi-cluster setup
   vitastor.conf: |-
     {"etcd_address":"http://192.168.7.2:2379","etcd_prefix":"/vitastor"}
 metadata:

csi/deploy/004-csi-nodeplugin.yaml

@@ -49,7 +49,7 @@ spec:
             capabilities:
               add: ["SYS_ADMIN"]
             allowPrivilegeEscalation: true
-          image: vitalif/vitastor-csi:v1.2.0
+          image: vitalif/vitastor-csi:v1.3.1
           args:
             - "--node=$(NODE_ID)"
             - "--endpoint=$(CSI_ENDPOINT)"
@@ -82,6 +82,8 @@ spec:
               name: host-sys
             - mountPath: /run/mount
               name: host-mount
+            - mountPath: /run/vitastor-csi
+              name: run-vitastor-csi
             - mountPath: /lib/modules
               name: lib-modules
               readOnly: true
@@ -132,6 +134,9 @@ spec:
         - name: host-mount
           hostPath:
             path: /run/mount
+        - name: run-vitastor-csi
+          hostPath:
+            path: /run/vitastor-csi
         - name: lib-modules
           hostPath:
             path: /lib/modules

csi/deploy/007-csi-provisioner.yaml

@@ -121,7 +121,7 @@ spec:
             privileged: true
             capabilities:
               add: ["SYS_ADMIN"]
-          image: vitalif/vitastor-csi:v1.2.0
+          image: vitalif/vitastor-csi:v1.3.1
           args:
             - "--node=$(NODE_ID)"
             - "--endpoint=$(CSI_ENDPOINT)"

csi/deploy/009-storage-class.yaml

@@ -12,9 +12,6 @@ parameters:
   etcdVolumePrefix: ""
   poolId: "1"
   # you can choose other configuration file if you have it in the config map
+  # different etcd URLs and prefixes should also be put in the config
   #configPath: "/etc/vitastor/vitastor.conf"
-  # you can also specify etcdUrl here, maybe to connect to another Vitastor cluster
-  # multiple etcdUrls may be specified, delimited by comma
-  #etcdUrl: "http://192.168.7.2:2379"
-  #etcdPrefix: "/vitastor"
 allowVolumeExpansion: true

csi/src/config.go

@@ -5,7 +5,7 @@ package vitastor
 
 const (
     vitastorCSIDriverName    = "csi.vitastor.io"
-    vitastorCSIDriverVersion = "1.2.0"
+    vitastorCSIDriverVersion = "1.3.1"
 )
 
 // Config struct fills the parameters of request or user input

csi/src/controllerserver.go

@@ -62,7 +62,7 @@ func NewControllerServer(driver *Driver) *ControllerServer
     }
 }
 
-func GetConnectionParams(params map[string]string) (map[string]string, []string, string)
+func GetConnectionParams(params map[string]string) (map[string]string, error)
 {
     ctxVars := make(map[string]string)
     configPath := params["configPath"]
@@ -75,71 +75,69 @@ func GetConnectionParams(params map[string]string) (map[string]string, []string,
         ctxVars["configPath"] = configPath
     }
     config := make(map[string]interface{})
-    if configFD, err := os.Open(configPath); err == nil
+    configFD, err := os.Open(configPath)
+    if (err != nil)
     {
-        defer configFD.Close()
-        data, _ := ioutil.ReadAll(configFD)
-        json.Unmarshal(data, &config)
+        return nil, err
     }
-    // Try to load prefix & etcd URL from the config
+    defer configFD.Close()
+    data, _ := ioutil.ReadAll(configFD)
+    json.Unmarshal(data, &config)
+    // Check etcd URL in the config, but do not use the explicit etcdUrl
+    // parameter for CLI calls, otherwise users won't be able to later
+    // change them - storage class parameters are saved in volume IDs
     var etcdUrl []string
-    if (params["etcdUrl"] != "")
+    switch config["etcd_address"].(type)
     {
-        ctxVars["etcdUrl"] = params["etcdUrl"]
-        etcdUrl = strings.Split(params["etcdUrl"], ",")
+    case string:
+        url := strings.TrimSpace(config["etcd_address"].(string))
+        if (url != "")
+        {
+            etcdUrl = strings.Split(url, ",")
+        }
+    case []string:
+        etcdUrl = config["etcd_address"].([]string)
+    case []interface{}:
+        for _, url := range config["etcd_address"].([]interface{})
+        {
+            s, ok := url.(string)
+            if (ok)
+            {
+                etcdUrl = append(etcdUrl, s)
+            }
+        }
     }
     if (len(etcdUrl) == 0)
     {
-        switch config["etcd_address"].(type)
-        {
-        case string:
-            etcdUrl = strings.Split(config["etcd_address"].(string), ",")
-        case []string:
-            etcdUrl = config["etcd_address"].([]string)
-        }
+        return nil, status.Error(codes.InvalidArgument, "etcd_address is missing in "+configPath)
     }
-    etcdPrefix := params["etcdPrefix"]
-    if (etcdPrefix == "")
+    return ctxVars, nil
+}
+
+func system(program string, args ...string) ([]byte, []byte, error)
+{
+    klog.Infof("Running "+program+" "+strings.Join(args, " "))
+    c := exec.Command(program, args...)
+    var stdout, stderr bytes.Buffer
+    c.Stdout, c.Stderr = &stdout, &stderr
+    err := c.Run()
+    if (err != nil)
     {
-        etcdPrefix, _ = config["etcd_prefix"].(string)
-        if (etcdPrefix == "")
-        {
-            etcdPrefix = "/vitastor"
-        }
+        stdoutStr, stderrStr := string(stdout.Bytes()), string(stderr.Bytes())
+        klog.Errorf(program+" "+strings.Join(args, " ")+" failed: %s, status %s\n", stdoutStr+stderrStr, err)
+        return nil, nil, status.Error(codes.Internal, stdoutStr+stderrStr+" (status "+err.Error()+")")
     }
-    else
-    {
-        ctxVars["etcdPrefix"] = etcdPrefix
-    }
-    return ctxVars, etcdUrl, etcdPrefix
+    return stdout.Bytes(), stderr.Bytes(), nil
 }
 
 func invokeCLI(ctxVars map[string]string, args []string) ([]byte, error)
 {
-    if (ctxVars["etcdUrl"] != "")
-    {
-        args = append(args, "--etcd_address", ctxVars["etcdUrl"])
-    }
-    if (ctxVars["etcdPrefix"] != "")
-    {
-        args = append(args, "--etcd_prefix", ctxVars["etcdPrefix"])
-    }
     if (ctxVars["configPath"] != "")
     {
         args = append(args, "--config_path", ctxVars["configPath"])
     }
-    c := exec.Command("/usr/bin/vitastor-cli", args...)
-    var stdout, stderr bytes.Buffer
-    c.Stdout = &stdout
-    c.Stderr = &stderr
-    err := c.Run()
-    stderrStr := string(stderr.Bytes())
-    if (err != nil)
-    {
-        klog.Errorf("vitastor-cli %s failed: %s, status %s\n", strings.Join(args, " "), stderrStr, err)
-        return nil, status.Error(codes.Internal, stderrStr+" (status "+err.Error()+")")
-    }
-    return stdout.Bytes(), nil
+    stdout, _, err := system("/usr/bin/vitastor-cli", args...)
+    return stdout, err
 }
 
 // Create the volume
@@ -174,10 +172,10 @@ func (cs *ControllerServer) CreateVolume(ctx context.Context, req *csi.CreateVol
         volSize = ((capRange.GetRequiredBytes() + MB - 1) / MB) * MB
     }
 
-    ctxVars, etcdUrl, _ := GetConnectionParams(req.Parameters)
-    if (len(etcdUrl) == 0)
+    ctxVars, err := GetConnectionParams(req.Parameters)
+    if (err != nil)
     {
-        return nil, status.Error(codes.InvalidArgument, "no etcdUrl in storage class configuration and no etcd_address in vitastor.conf")
+        return nil, err
     }
 
     args := []string{ "create", volName, "-s", fmt.Sprintf("%v", volSize), "--pool", fmt.Sprintf("%v", poolId) }
@@ -207,7 +205,7 @@ func (cs *ControllerServer) CreateVolume(ctx context.Context, req *csi.CreateVol
     }
 
     // Create image using vitastor-cli
-    _, err := invokeCLI(ctxVars, args)
+    _, err = invokeCLI(ctxVars, args)
     if (err != nil)
     {
         if (strings.Index(err.Error(), "already exists") > 0)
@@ -257,7 +255,11 @@ func (cs *ControllerServer) DeleteVolume(ctx context.Context, req *csi.DeleteVol
     }
     volName := volVars["name"]
 
-    ctxVars, _, _ := GetConnectionParams(volVars)
+    ctxVars, err := GetConnectionParams(volVars)
+    if (err != nil)
+    {
+        return nil, err
+    }
 
     _, err = invokeCLI(ctxVars, []string{ "rm", volName })
     if (err != nil)
@@ -469,7 +471,11 @@ func (cs *ControllerServer) DeleteSnapshot(ctx context.Context, req *csi.DeleteS
     volName := volVars["name"]
     snapName := volVars["snapshot"]
 
-    ctxVars, _, _ := GetConnectionParams(volVars)
+    ctxVars, err := GetConnectionParams(volVars)
+    if (err != nil)
+    {
+        return nil, err
+    }
 
     _, err = invokeCLI(ctxVars, []string{ "rm", volName+"@"+snapName })
     if (err != nil)
@@ -496,7 +502,11 @@ func (cs *ControllerServer) ListSnapshots(ctx context.Context, req *csi.ListSnap
         return nil, status.Error(codes.Internal, "volume ID not in JSON format")
     }
     volName := volVars["name"]
-    ctxVars, _, _ := GetConnectionParams(volVars)
+    ctxVars, err := GetConnectionParams(volVars)
+    if (err != nil)
+    {
+        return nil, err
+    }
 
     inodeCfg, err := invokeList(ctxVars, volName+"@*", false)
     if (err != nil)
@@ -555,7 +565,11 @@ func (cs *ControllerServer) ControllerExpandVolume(ctx context.Context, req *csi
         return nil, status.Error(codes.Internal, "volume ID not in JSON format")
     }
     volName := volVars["name"]
-    ctxVars, _, _ := GetConnectionParams(volVars)
+    ctxVars, err := GetConnectionParams(volVars)
+    if (err != nil)
+    {
+        return nil, err
+    }
 
     inodeCfg, err := invokeList(ctxVars, volName, true)
     if (err != nil)

csi/src/nodeserver.go

@@ -5,11 +5,15 @@ package vitastor
 
 import (
     "context"
+    "errors"
+    "encoding/json"
+    "fmt"
     "os"
     "os/exec"
-    "encoding/json"
+    "path/filepath"
+    "strconv"
     "strings"
-    "bytes"
+    "syscall"
 
     "google.golang.org/grpc/codes"
     "google.golang.org/grpc/status"
@@ -25,16 +29,91 @@ import (
 type NodeServer struct
 {
     *Driver
+    useVduse bool
+    stateDir string
     mounter mount.Interface
 }
 
+type DeviceState struct
+{
+    ConfigPath string `json:"configPath"`
+    VdpaId     string `json:"vdpaId"`
+    Image      string `json:"image"`
+    Blockdev   string `json:"blockdev"`
+    Readonly   bool   `json:"readonly"`
+    PidFile    string `json:"pidFile"`
+}
+
 // NewNodeServer create new instance node
 func NewNodeServer(driver *Driver) *NodeServer
 {
-    return &NodeServer{
+    stateDir := os.Getenv("STATE_DIR")
+    if (stateDir == "")
+    {
+        stateDir = "/run/vitastor-csi"
+    }
+    if (stateDir[len(stateDir)-1] != '/')
+    {
+        stateDir += "/"
+    }
+    ns := &NodeServer{
         Driver: driver,
+        useVduse: checkVduseSupport(),
+        stateDir: stateDir,
         mounter: mount.New(""),
     }
+    if (ns.useVduse)
+    {
+        ns.restoreVduseDaemons()
+    }
+    return ns
+}
+
+func checkVduseSupport() bool
+{
+    // Check VDUSE support (vdpa, vduse, virtio-vdpa kernel modules)
+    vduse := true
+    for _, mod := range []string{"vdpa", "vduse", "virtio-vdpa"}
+    {
+        _, err := os.Stat("/sys/module/"+mod)
+        if (err != nil)
+        {
+            if (!errors.Is(err, os.ErrNotExist))
+            {
+                klog.Errorf("failed to check /sys/module/%s: %v", mod, err)
+            }
+            c := exec.Command("/sbin/modprobe", mod)
+            c.Stdout = os.Stderr
+            c.Stderr = os.Stderr
+            err := c.Run()
+            if (err != nil)
+            {
+                klog.Errorf("/sbin/modprobe %s failed: %v", mod, err)
+                vduse = false
+                break
+            }
+        }
+    }
+    // Check that vdpa tool functions
+    if (vduse)
+    {
+        c := exec.Command("/sbin/vdpa", "-j", "dev")
+        c.Stderr = os.Stderr
+        err := c.Run()
+        if (err != nil)
+        {
+            klog.Errorf("/sbin/vdpa -j dev failed: %v", err)
+            vduse = false
+        }
+    }
+    if (!vduse)
+    {
+        klog.Errorf(
+            "Your host apparently has no VDUSE support. VDUSE support disabled, NBD will be used to map devices."+
+            " For VDUSE you need at least Linux 5.15 and the following kernel modules: vdpa, virtio-vdpa, vduse.",
+        )
+    }
+    return vduse
 }
 
 // NodeStageVolume mounts the volume to a staging path on the node.
@@ -61,6 +140,303 @@ func Contains(list []string, s string) bool
     return false
 }
 
+func (ns *NodeServer) mapNbd(volName string, ctxVars map[string]string, readonly bool) (string, error)
+{
+    // Map NBD device
+    // FIXME: Check if already mapped
+    args := []string{
+        "map", "--image", volName,
+    }
+    if (ctxVars["configPath"] != "")
+    {
+        args = append(args, "--config_path", ctxVars["configPath"])
+    }
+    if (readonly)
+    {
+        args = append(args, "--readonly", "1")
+    }
+    stdout, stderr, err := system("/usr/bin/vitastor-nbd", args...)
+    dev := strings.TrimSpace(string(stdout))
+    if (dev == "")
+    {
+        return "", fmt.Errorf("vitastor-nbd did not return the name of NBD device. output: %s", stderr)
+    }
+    return dev, err
+}
+
+func (ns *NodeServer) unmapNbd(devicePath string)
+{
+    // unmap NBD device
+    unmapOut, unmapErr := exec.Command("/usr/bin/vitastor-nbd", "unmap", devicePath).CombinedOutput()
+    if (unmapErr != nil)
+    {
+        klog.Errorf("failed to unmap NBD device %s: %s, error: %v", devicePath, unmapOut, unmapErr)
+    }
+}
+
+func findByPidFile(pidFile string) (*os.Process, error)
+{
+    klog.Infof("killing process with PID from file %s", pidFile)
+    pidBuf, err := os.ReadFile(pidFile)
+    if (err != nil)
+    {
+        return nil, err
+    }
+    pid, err := strconv.ParseInt(strings.TrimSpace(string(pidBuf)), 0, 64)
+    if (err != nil)
+    {
+        return nil, err
+    }
+    proc, err := os.FindProcess(int(pid))
+    if (err != nil)
+    {
+        return nil, err
+    }
+    return proc, nil
+}
+
+func killByPidFile(pidFile string) error
+{
+    proc, err := findByPidFile(pidFile)
+    if (err != nil)
+    {
+        return err
+    }
+    return proc.Signal(syscall.SIGTERM)
+}
+
+func startStorageDaemon(vdpaId, volName, pidFile, configPath string, readonly bool) error
+{
+    // Start qemu-storage-daemon
+    blockSpec := map[string]interface{}{
+        "node-name": "disk1",
+        "driver": "vitastor",
+        "image": volName,
+        "cache": map[string]bool{
+            "direct": true,
+            "no-flush": false,
+        },
+        "discard": "unmap",
+    }
+    if (configPath != "")
+    {
+        blockSpec["config-path"] = configPath
+    }
+    blockSpecJson, _ := json.Marshal(blockSpec)
+    writable := "true"
+    if (readonly)
+    {
+        writable = "false"
+    }
+    _, _, err := system(
+        "/usr/bin/qemu-storage-daemon", "--daemonize", "--pidfile", pidFile, "--blockdev", string(blockSpecJson),
+        "--export", "vduse-blk,id="+vdpaId+",node-name=disk1,name="+vdpaId+",num-queues=16,queue-size=128,writable="+writable,
+    )
+    return err
+}
+
+func (ns *NodeServer) mapVduse(volName string, ctxVars map[string]string, readonly bool) (string, string, error)
+{
+    // Generate state file
+    stateFd, err := os.CreateTemp(ns.stateDir, "vitastor-vduse-*.json")
+    if (err != nil)
+    {
+        return "", "", err
+    }
+    stateFile := stateFd.Name()
+    stateFd.Close()
+    vdpaId := filepath.Base(stateFile)
+    vdpaId = vdpaId[0:len(vdpaId)-5] // remove ".json"
+    pidFile := ns.stateDir + vdpaId + ".pid"
+    // Map VDUSE device via qemu-storage-daemon
+    err = startStorageDaemon(vdpaId, volName, pidFile, ctxVars["configPath"], readonly)
+    if (err == nil)
+    {
+        // Add device to VDPA bus
+        _, _, err = system("/sbin/vdpa", "-j", "dev", "add", "name", vdpaId, "mgmtdev", "vduse")
+        if (err == nil)
+        {
+            // Find block device name
+            var matches []string
+            matches, err = filepath.Glob("/sys/bus/vdpa/devices/"+vdpaId+"/virtio*/block/*")
+            if (err == nil && len(matches) == 0)
+            {
+                err = errors.New("/sys/bus/vdpa/devices/"+vdpaId+"/virtio*/block/* is not found")
+            }
+            if (err == nil)
+            {
+                blockdev := "/dev/"+filepath.Base(matches[0])
+                _, err = os.Stat(blockdev)
+                if (err == nil)
+                {
+                    // Generate state file
+                    stateJSON, _ := json.Marshal(&DeviceState{
+                        ConfigPath: ctxVars["configPath"],
+                        VdpaId:     vdpaId,
+                        Image:      volName,
+                        Blockdev:   blockdev,
+                        Readonly:   readonly,
+                        PidFile:    pidFile,
+                    })
+                    err = os.WriteFile(stateFile, stateJSON, 0600)
+                    if (err == nil)
+                    {
+                        return blockdev, vdpaId, nil
+                    }
+                }
+            }
+        }
+        killErr := killByPidFile(pidFile)
+        if (killErr != nil)
+        {
+            klog.Errorf("Failed to kill started qemu-storage-daemon: %v", killErr)
+        }
+        os.Remove(stateFile)
+        os.Remove(pidFile)
+    }
+    return "", "", err
+}
+
+func (ns *NodeServer) unmapVduse(devicePath string)
+{
+    if (len(devicePath) < 6 || devicePath[0:6] != "/dev/v")
+    {
+        klog.Errorf("%s does not start with /dev/v", devicePath)
+        return
+    }
+    vduseDev, err := os.Readlink("/sys/block/"+devicePath[5:])
+    if (err != nil)
+    {
+        klog.Errorf("%s is not a symbolic link to VDUSE device (../devices/virtual/vduse/xxx): %v", devicePath, err)
+        return
+    }
+    vdpaId := ""
+    p := strings.Index(vduseDev, "/vduse/")
+    if (p >= 0)
+    {
+        vduseDev = vduseDev[p+7:]
+        p = strings.Index(vduseDev, "/")
+        if (p >= 0)
+        {
+            vdpaId = vduseDev[0:p]
+        }
+    }
+    if (vdpaId == "")
+    {
+        klog.Errorf("%s is not a symbolic link to VDUSE device (../devices/virtual/vduse/xxx), but is %v", devicePath, vduseDev)
+        return
+    }
+    ns.unmapVduseById(vdpaId)
+}
+
+func (ns *NodeServer) unmapVduseById(vdpaId string)
+{
+    _, err := os.Stat("/sys/bus/vdpa/devices/"+vdpaId)
+    if (err != nil)
+    {
+        klog.Errorf("failed to stat /sys/bus/vdpa/devices/"+vdpaId+": %v", err)
+    }
+    else
+    {
+        _, _, _ = system("/sbin/vdpa", "-j", "dev", "del", vdpaId)
+    }
+    stateFile := ns.stateDir + vdpaId + ".json"
+    os.Remove(stateFile)
+    pidFile := ns.stateDir + vdpaId + ".pid"
+    _, err = os.Stat(pidFile)
+    if (os.IsNotExist(err))
+    {
+        // ok, already killed
+    }
+    else if (err != nil)
+    {
+        klog.Errorf("Failed to stat %v: %v", pidFile, err)
+        return
+    }
+    else
+    {
+        err = killByPidFile(pidFile)
+        if (err != nil)
+        {
+            klog.Errorf("Failed to kill started qemu-storage-daemon: %v", err)
+        }
+        os.Remove(pidFile)
+    }
+}
+
+func (ns *NodeServer) restoreVduseDaemons()
+{
+    pattern := ns.stateDir+"vitastor-vduse-*.json"
+    matches, err := filepath.Glob(pattern)
+    if (err != nil)
+    {
+        klog.Errorf("failed to list %s: %v", pattern, err)
+    }
+    if (len(matches) == 0)
+    {
+        return
+    }
+    devList := make(map[string]interface{})
+    // example output: {"dev":{"test1":{"type":"block","mgmtdev":"vduse","vendor_id":0,"max_vqs":16,"max_vq_size":128}}}
+    devListJSON, _, err := system("/sbin/vdpa", "-j", "dev", "list")
+    if (err != nil)
+    {
+        return
+    }
+    err = json.Unmarshal(devListJSON, &devList)
+    devs, ok := devList["dev"].(map[string]interface{})
+    if (err != nil || !ok)
+    {
+        klog.Errorf("/sbin/vdpa -j dev list returned bad JSON (error %v): %v", err, string(devListJSON))
+        return
+    }
+    for _, stateFile := range matches
+    {
+        vdpaId := filepath.Base(stateFile)
+        vdpaId = vdpaId[0:len(vdpaId)-5]
+        // Check if VDPA device is still added to the bus
+        if (devs[vdpaId] != nil)
+        {
+            // Check if the storage daemon is still active
+            pidFile := ns.stateDir + vdpaId + ".pid"
+            exists := false
+            proc, err := findByPidFile(pidFile)
+            if (err == nil)
+            {
+                exists = proc.Signal(syscall.Signal(0)) == nil
+            }
+            if (!exists)
+            {
+                // Restart daemon
+                stateJSON, err := os.ReadFile(stateFile)
+                if (err != nil)
+                {
+                    klog.Warningf("error reading state file %v: %v", stateFile, err)
+                }
+                else
+                {
+                    var state DeviceState
+                    err := json.Unmarshal(stateJSON, &state)
+                    if (err != nil)
+                    {
+                        klog.Warningf("state file %v contains invalid JSON (error %v): %v", stateFile, err, string(stateJSON))
+                    }
+                    else
+                    {
+                        klog.Warningf("restarting storage daemon for volume %v (VDPA ID %v)", state.Image, vdpaId)
+                        _ = startStorageDaemon(vdpaId, state.Image, pidFile, state.ConfigPath, state.Readonly)
+                    }
+                }
+            }
+        }
+        else
+        {
+            // Unused, clean it up
+            ns.unmapVduseById(vdpaId)
+        }
+    }
+}
+
 // NodePublishVolume mounts the volume mounted to the staging path to the target path
 func (ns *NodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublishVolumeRequest) (*csi.NodePublishVolumeResponse, error)
 {
@@ -81,13 +457,13 @@ func (ns *NodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublis
                 if (err != nil)
                 {
                     klog.Errorf("failed to create block device mount target %s with error: %v", targetPath, err)
-                    return nil, status.Error(codes.Internal, err.Error())
+                    return nil, err
                 }
                 err = pathFile.Close()
                 if (err != nil)
                 {
                     klog.Errorf("failed to close %s with error: %v", targetPath, err)
-                    return nil, status.Error(codes.Internal, err.Error())
+                    return nil, err
                 }
             }
             else
@@ -96,13 +472,13 @@ func (ns *NodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublis
                 if (err != nil)
                 {
                     klog.Errorf("failed to create fs mount target %s with error: %v", targetPath, err)
-                    return nil, status.Error(codes.Internal, err.Error())
+                    return nil, err
                 }
             }
         }
         else
         {
-            return nil, status.Error(codes.Internal, err.Error())
+            return nil, err
         }
     }
 
@@ -114,38 +490,25 @@ func (ns *NodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublis
     }
     volName := ctxVars["name"]
 
-    _, etcdUrl, etcdPrefix := GetConnectionParams(ctxVars)
-    if (len(etcdUrl) == 0)
-    {
-        return nil, status.Error(codes.InvalidArgument, "no etcdUrl in storage class configuration and no etcd_address in vitastor.conf")
-    }
-
-    // Map NBD device
-    // FIXME: Check if already mapped
-    args := []string{
-        "map", "--etcd_address", strings.Join(etcdUrl, ","),
-        "--etcd_prefix", etcdPrefix,
-        "--image", volName,
-    };
-    if (ctxVars["configPath"] != "")
-    {
-        args = append(args, "--config_path", ctxVars["configPath"])
-    }
-    if (req.GetReadonly())
-    {
-        args = append(args, "--readonly", "1")
-    }
-    c := exec.Command("/usr/bin/vitastor-nbd", args...)
-    var stdout, stderr bytes.Buffer
-    c.Stdout, c.Stderr = &stdout, &stderr
-    err = c.Run()
-    stdoutStr, stderrStr := string(stdout.Bytes()), string(stderr.Bytes())
+    _, err = GetConnectionParams(ctxVars)
     if (err != nil)
     {
-        klog.Errorf("vitastor-nbd map failed: %s, status %s\n", stdoutStr+stderrStr, err)
-        return nil, status.Error(codes.Internal, stdoutStr+stderrStr+" (status "+err.Error()+")")
+        return nil, err
+    }
+
+    var devicePath, vdpaId string
+    if (!ns.useVduse)
+    {
+        devicePath, err = ns.mapNbd(volName, ctxVars, req.GetReadonly())
+    }
+    else
+    {
+        devicePath, vdpaId, err = ns.mapVduse(volName, ctxVars, req.GetReadonly())
+    }
+    if (err != nil)
+    {
+        return nil, err
     }
-    devicePath := strings.TrimSpace(stdoutStr)
 
     diskMounter := &mount.SafeFormatAndMount{Interface: ns.mounter, Exec: utilexec.New()}
     if (isBlock)
@@ -227,13 +590,15 @@ func (ns *NodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublis
     return &csi.NodePublishVolumeResponse{}, nil
 
 unmap:
-    // unmap NBD device
-    unmapOut, unmapErr := exec.Command("/usr/bin/vitastor-nbd", "unmap", devicePath).CombinedOutput()
-    if (unmapErr != nil)
+    if (!ns.useVduse || len(devicePath) >= 8 && devicePath[0:8] == "/dev/nbd")
     {
-        klog.Errorf("failed to unmap NBD device %s: %s, error: %v", devicePath, unmapOut, unmapErr)
+        ns.unmapNbd(devicePath)
     }
-    return nil, status.Error(codes.Internal, err.Error())
+    else
+    {
+        ns.unmapVduseById(vdpaId)
+    }
+    return nil, err
 }
 
 // NodeUnpublishVolume unmounts the volume from the target path
@@ -248,25 +613,31 @@ func (ns *NodeServer) NodeUnpublishVolume(ctx context.Context, req *csi.NodeUnpu
         {
             return nil, status.Error(codes.NotFound, "Target path not found")
         }
-        return nil, status.Error(codes.Internal, err.Error())
+        return nil, err
     }
     if (devicePath == "")
     {
-        return nil, status.Error(codes.NotFound, "Volume not mounted")
+        // volume not mounted
+        klog.Warningf("%s is not a mountpoint, deleting", targetPath)
+        os.Remove(targetPath)
+        return &csi.NodeUnpublishVolumeResponse{}, nil
     }
     // unmount
     err = mount.CleanupMountPoint(targetPath, ns.mounter, false)
     if (err != nil)
     {
-        return nil, status.Error(codes.Internal, err.Error())
+        return nil, err
     }
     // unmap NBD device
     if (refCount == 1)
     {
-        unmapOut, unmapErr := exec.Command("/usr/bin/vitastor-nbd", "unmap", devicePath).CombinedOutput()
-        if (unmapErr != nil)
+        if (!ns.useVduse)
         {
-            klog.Errorf("failed to unmap NBD device %s: %s, error: %v", devicePath, unmapOut, unmapErr)
+            ns.unmapNbd(devicePath)
+        }
+        else
+        {
+            ns.unmapVduse(devicePath)
         }
     }
     return &csi.NodeUnpublishVolumeResponse{}, nil

debian/changelog

@@ -1,10 +1,10 @@
-vitastor (1.2.0-1) unstable; urgency=medium
+vitastor (1.3.1-1) unstable; urgency=medium
 
   * Bugfixes
 
  -- Vitaliy Filippov <vitalif@yourcmc.ru>  Fri, 03 Jun 2022 02:09:44 +0300
 
-vitastor (1.2.0-1) unstable; urgency=medium
+vitastor (0.7.0-1) unstable; urgency=medium
 
   * Implement NFS proxy
   * Add documentation

debian/patched-qemu.Dockerfile

@@ -7,7 +7,7 @@ ARG REL=
 
 WORKDIR /root
 
-RUN if [ "$REL" = "buster" -o "$REL" = "bullseye" ]; then \
+RUN if [ "$REL" = "buster" -o "$REL" = "bullseye" -o "$REL" = "bookworm" ]; then \
         echo "deb http://deb.debian.org/debian $REL-backports main" >> /etc/apt/sources.list; \
         echo >> /etc/apt/preferences; \
         echo 'Package: *' >> /etc/apt/preferences; \
@@ -45,7 +45,7 @@ RUN set -e; \
     rm -rf /root/packages/qemu-$REL/*; \
     cd /root/packages/qemu-$REL; \
     dpkg-source -x /root/qemu*.dsc; \
-    QEMU_VER=$(ls -d qemu*/ | perl -pe 's!^.*(\d+\.\d+).*!$1!'); \
+    QEMU_VER=$(ls -d qemu*/ | perl -pe 's!^.*?(\d+\.\d+).*!$1!'); \
     D=$(ls -d qemu*/); \
     cp /root/vitastor/patches/qemu-$QEMU_VER-vitastor.patch ./qemu-*/debian/patches; \
     echo qemu-$QEMU_VER-vitastor.patch >> $D/debian/patches/series; \

debian/vitastor.Dockerfile

@@ -35,8 +35,8 @@ RUN set -e -x; \
     mkdir -p /root/packages/vitastor-$REL; \
     rm -rf /root/packages/vitastor-$REL/*; \
     cd /root/packages/vitastor-$REL; \
-    cp -r /root/vitastor vitastor-1.2.0; \
-    cd vitastor-1.2.0; \
+    cp -r /root/vitastor vitastor-1.3.1; \
+    cd vitastor-1.3.1; \
     ln -s /root/fio-build/fio-*/ ./fio; \
     FIO=$(head -n1 fio/debian/changelog | perl -pe 's/^.*\((.*?)\).*$/$1/'); \
     ls /usr/include/linux/raw.h || cp ./debian/raw.h /usr/include/linux/raw.h; \
@@ -49,8 +49,8 @@ RUN set -e -x; \
     rm -rf a b; \
     echo "dep:fio=$FIO" > debian/fio_version; \
     cd /root/packages/vitastor-$REL; \
-    tar --sort=name --mtime='2020-01-01' --owner=0 --group=0 --exclude=debian -cJf vitastor_1.2.0.orig.tar.xz vitastor-1.2.0; \
-    cd vitastor-1.2.0; \
+    tar --sort=name --mtime='2020-01-01' --owner=0 --group=0 --exclude=debian -cJf vitastor_1.3.1.orig.tar.xz vitastor-1.3.1; \
+    cd vitastor-1.3.1; \
     V=$(head -n1 debian/changelog | perl -pe 's/^.*\((.*?)\).*$/$1/'); \
     DEBFULLNAME="Vitaliy Filippov <vitalif@yourcmc.ru>" dch -D $REL -v "$V""$REL" "Rebuild for $REL"; \
     DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage --jobs=auto -sa; \

docs/config/client.en.md

@@ -15,6 +15,9 @@ the cluster.
 - [client_max_buffered_bytes](#client_max_buffered_bytes)
 - [client_max_buffered_ops](#client_max_buffered_ops)
 - [client_max_writeback_iodepth](#client_max_writeback_iodepth)
+- [nbd_timeout](#nbd_timeout)
+- [nbd_max_devices](#nbd_max_devices)
+- [nbd_max_part](#nbd_max_part)
 
 ## client_max_dirty_bytes
 
@@ -101,3 +104,34 @@ Multiple consecutive modified data regions are counted as 1 write here.
 - Can be changed online: yes
 
 Maximum number of parallel writes when flushing buffered data to the server.
+
+## nbd_timeout
+
+- Type: seconds
+- Default: 300
+
+Timeout for I/O operations for [NBD](../usage/nbd.en.md). If an operation
+executes for longer than this timeout, including when your cluster is just
+temporarily down for more than timeout, the NBD device will detach by itself
+(and possibly break the mounted file system).
+
+You can set timeout to 0 to never detach, but in that case you won't be
+able to remove the kernel device at all if the NBD process dies - you'll have
+to reboot the host.
+
+## nbd_max_devices
+
+- Type: integer
+- Default: 64
+
+Maximum number of NBD devices in the system. This value is passed as
+`nbds_max` parameter for the nbd kernel module when vitastor-nbd autoloads it.
+
+## nbd_max_part
+
+- Type: integer
+- Default: 3
+
+Maximum number of partitions per NBD device. This value is passed as
+`max_part` parameter for the nbd kernel module when vitastor-nbd autoloads it.
+Note that (nbds_max)*(1+max_part) usually can't exceed 256.

docs/config/client.ru.md

@@ -15,6 +15,9 @@
 - [client_max_buffered_bytes](#client_max_buffered_bytes)
 - [client_max_buffered_ops](#client_max_buffered_ops)
 - [client_max_writeback_iodepth](#client_max_writeback_iodepth)
+- [nbd_timeout](#nbd_timeout)
+- [nbd_max_devices](#nbd_max_devices)
+- [nbd_max_part](#nbd_max_part)
 
 ## client_max_dirty_bytes
 
@@ -101,3 +104,34 @@
 - Можно менять на лету: да
 
 Максимальное число параллельных операций записи при сбросе буферов на сервер.
+
+## nbd_timeout
+
+- Тип: секунды
+- Значение по умолчанию: 300
+
+Таймаут для операций чтения/записи через [NBD](../usage/nbd.ru.md). Если
+операция выполняется дольше таймаута, включая временную недоступность
+кластера на время, большее таймаута, NBD-устройство отключится само собой
+(и, возможно, сломает примонтированную ФС).
+
+Вы можете установить таймаут в 0, чтобы никогда не отключать устройство по
+таймауту, но в этом случае вы вообще не сможете удалить устройство, если
+процесс NBD умрёт - вам придётся перезагружать сервер.
+
+## nbd_max_devices
+
+- Тип: целое число
+- Значение по умолчанию: 64
+
+Максимальное число NBD-устройств в системе. Данное значение передаётся
+модулю ядра nbd как параметр `nbds_max`, когда его загружает vitastor-nbd.
+
+## nbd_max_part
+
+- Тип: целое число
+- Значение по умолчанию: 3
+
+Максимальное число разделов на одном NBD-устройстве. Данное значение передаётся
+модулю ядра nbd как параметр `max_part`, когда его загружает vitastor-nbd.
+Имейте в виду, что (nbds_max)*(1+max_part) обычно не может превышать 256.

docs/config/src/client.en.md

@@ -1,4 +1,4 @@
 # Client Parameters
 
-These parameters apply only to clients and affect their interaction with
-the cluster.
+These parameters apply only to Vitastor clients (QEMU, fio, NBD and so on) and
+affect their interaction with the cluster.

docs/config/src/client.ru.md

@@ -1,4 +1,4 @@
 # Параметры клиентского кода
 
-Данные параметры применяются только к клиентам Vitastor (QEMU, fio, NBD) и
+Данные параметры применяются только к клиентам Vitastor (QEMU, fio, NBD и т.п.) и
 затрагивают логику их работы с кластером.

docs/config/src/client.yml

@@ -122,3 +122,47 @@
     Maximum number of parallel writes when flushing buffered data to the server.
   info_ru: |
     Максимальное число параллельных операций записи при сбросе буферов на сервер.
+- name: nbd_timeout
+  type: sec
+  default: 300
+  online: false
+  info: |
+    Timeout for I/O operations for [NBD](../usage/nbd.en.md). If an operation
+    executes for longer than this timeout, including when your cluster is just
+    temporarily down for more than timeout, the NBD device will detach by itself
+    (and possibly break the mounted file system).
+
+    You can set timeout to 0 to never detach, but in that case you won't be
+    able to remove the kernel device at all if the NBD process dies - you'll have
+    to reboot the host.
+  info_ru: |
+    Таймаут для операций чтения/записи через [NBD](../usage/nbd.ru.md). Если
+    операция выполняется дольше таймаута, включая временную недоступность
+    кластера на время, большее таймаута, NBD-устройство отключится само собой
+    (и, возможно, сломает примонтированную ФС).
+
+    Вы можете установить таймаут в 0, чтобы никогда не отключать устройство по
+    таймауту, но в этом случае вы вообще не сможете удалить устройство, если
+    процесс NBD умрёт - вам придётся перезагружать сервер.
+- name: nbd_max_devices
+  type: int
+  default: 64
+  online: false
+  info: |
+    Maximum number of NBD devices in the system. This value is passed as
+    `nbds_max` parameter for the nbd kernel module when vitastor-nbd autoloads it.
+  info_ru: |
+    Максимальное число NBD-устройств в системе. Данное значение передаётся
+    модулю ядра nbd как параметр `nbds_max`, когда его загружает vitastor-nbd.
+- name: nbd_max_part
+  type: int
+  default: 3
+  online: false
+  info: |
+    Maximum number of partitions per NBD device. This value is passed as
+    `max_part` parameter for the nbd kernel module when vitastor-nbd autoloads it.
+    Note that (nbds_max)*(1+max_part) usually can't exceed 256.
+  info_ru: |
+    Максимальное число разделов на одном NBD-устройстве. Данное значение передаётся
+    модулю ядра nbd как параметр `max_part`, когда его загружает vitastor-nbd.
+    Имейте в виду, что (nbds_max)*(1+max_part) обычно не может превышать 256.

docs/installation/kubernetes.en.md

@@ -19,6 +19,14 @@ for i in ./???-*.yaml; do kubectl apply -f $i; done
 
 After that you'll be able to create PersistentVolumes.
 
+**Important:** For best experience, use Linux kernel at least 5.15 with [VDUSE](../usage/qemu.en.md#vduse)
+kernel modules enabled (vdpa, vduse, virtio-vdpa). If your distribution doesn't
+have them pre-built - build them yourself ([instructions](../usage/qemu.en.md#vduse)),
+I promise it's worth it :-). When VDUSE is unavailable, CSI driver uses [NBD](../usage/nbd.en.md)
+to map Vitastor devices. NBD is slower and prone to timeout issues: if Vitastor
+cluster becomes unresponsible for more than [nbd_timeout](../config/client.en.md#nbd_timeout),
+the NBD device detaches and breaks pods using it.
+
 ## Features
 
 Vitastor CSI supports:
@@ -27,5 +35,8 @@ Vitastor CSI supports:
 - Raw block RWX (ReadWriteMany) volumes. Example: [PVC](../../csi/deploy/example-pvc-block.yaml), [pod](../../csi/deploy/example-test-pod-block.yaml)
 - Volume expansion
 - Volume snapshots. Example: [snapshot class](../../csi/deploy/example-snapshot-class.yaml), [snapshot](../../csi/deploy/example-snapshot.yaml), [clone](../../csi/deploy/example-snapshot-clone.yaml)
+- [VDUSE](../usage/qemu.en.md#vduse) (preferred) and [NBD](../usage/nbd.en.md) device mapping methods
+- Upgrades with VDUSE - new handler processes are restarted when CSI pods are restarted themselves
+- Multiple clusters by using multiple configuration files in ConfigMap.
 
 Remember that to use snapshots with CSI you also have to install [Snapshot Controller and CRDs](https://kubernetes-csi.github.io/docs/snapshot-controller.html#deployment).

docs/installation/kubernetes.ru.md

@@ -19,6 +19,14 @@ for i in ./???-*.yaml; do kubectl apply -f $i; done
 
 После этого вы сможете создавать PersistentVolume.
 
+**Важно:** Лучше всего использовать ядро Linux версии не менее 5.15 с включёнными модулями
+[VDUSE](../usage/qemu.ru.md#vduse) (vdpa, vduse, virtio-vdpa). Если в вашем дистрибутиве
+они не собраны из коробки - соберите их сами, обещаю, что это стоит того ([инструкция](../usage/qemu.ru.md#vduse)) :-).
+Когда VDUSE недоступно, CSI-плагин использует [NBD](../usage/nbd.ru.md) для подключения
+дисков, а NBD медленнее и имеет проблему таймаута - если кластер остаётся недоступным
+дольше, чем [nbd_timeout](../config/client.ru.md#nbd_timeout), NBD-устройство отключается
+и ломает поды, использующие его.
+
 ## Возможности
 
 CSI-плагин Vitastor поддерживает:
@@ -27,5 +35,8 @@ CSI-плагин Vitastor поддерживает:
 - Сырые блочные RWX (ReadWriteMany) тома. Пример: [PVC](../../csi/deploy/example-pvc-block.yaml), [под](../../csi/deploy/example-test-pod-block.yaml)
 - Расширение размера томов
 - Снимки томов. Пример: [класс снимков](../../csi/deploy/example-snapshot-class.yaml), [снимок](../../csi/deploy/example-snapshot.yaml), [клон снимка](../../csi/deploy/example-snapshot-clone.yaml)
+- Способы подключения устройств [VDUSE](../usage/qemu.ru.md#vduse) (предпочитаемый) и [NBD](../usage/nbd.ru.md)
+- Обновление при использовании VDUSE - новые процессы-обработчики устройств успешно перезапускаются вместе с самими подами CSI
+- Несколько кластеров через задание нескольких файлов конфигурации в ConfigMap.
 
 Не забывайте, что для использования снимков нужно сначала установить [контроллер снимков и CRD](https://kubernetes-csi.github.io/docs/snapshot-controller.html#deployment).

docs/installation/packages.en.md

@@ -18,7 +18,7 @@
     stable version from 0.9.x branch instead of 1.x
 - For Debian 10 (Buster) also enable backports repository:
   `deb http://deb.debian.org/debian buster-backports main`
-- Install packages: `apt update; apt install vitastor lp-solve etcd linux-image-amd64 qemu`
+- Install packages: `apt update; apt install vitastor lp-solve etcd linux-image-amd64 qemu-system-x86`
 
 ## CentOS
 

docs/installation/packages.ru.md

@@ -18,7 +18,7 @@
     установить последнюю стабильную версию из ветки 0.9.x вместо 1.x
 - Для Debian 10 (Buster) также включите репозиторий backports:
   `deb http://deb.debian.org/debian buster-backports main`
-- Установите пакеты: `apt update; apt install vitastor lp-solve etcd linux-image-amd64 qemu`
+- Установите пакеты: `apt update; apt install vitastor lp-solve etcd linux-image-amd64 qemu-system-x86`
 
 ## CentOS
 

docs/installation/proxmox.en.md

@@ -6,10 +6,10 @@
 
 # Proxmox VE
 
-To enable Vitastor support in Proxmox Virtual Environment (6.4-8.0 are supported):
+To enable Vitastor support in Proxmox Virtual Environment (6.4-8.1 are supported):
 
 - Add the corresponding Vitastor Debian repository into sources.list on Proxmox hosts:
-  bookworm for 8.0, bullseye for 7.4, pve7.3 for 7.3, pve7.2 for 7.2, pve7.1 for 7.1, buster for 6.4
+  bookworm for 8.1, pve8.0 for 8.0, bullseye for 7.4, pve7.3 for 7.3, pve7.2 for 7.2, pve7.1 for 7.1, buster for 6.4
 - Install vitastor-client, pve-qemu-kvm, pve-storage-vitastor (* or see note) packages from Vitastor repository
 - Define storage in `/etc/pve/storage.cfg` (see below)
 - Block network access from VMs to Vitastor network (to OSDs and etcd),

docs/installation/proxmox.ru.md

@@ -6,10 +6,10 @@
 
 # Proxmox VE
 
-Чтобы подключить Vitastor к Proxmox Virtual Environment (поддерживаются версии 6.4-8.0):
+Чтобы подключить Vitastor к Proxmox Virtual Environment (поддерживаются версии 6.4-8.1):
 
 - Добавьте соответствующий Debian-репозиторий Vitastor в sources.list на хостах Proxmox:
-  bookworm для 8.0, bullseye для 7.4, pve7.3 для 7.3, pve7.2 для 7.2, pve7.1 для 7.1, buster для 6.4
+  bookworm для 8.1, pve8.0 для 8.0, bullseye для 7.4, pve7.3 для 7.3, pve7.2 для 7.2, pve7.1 для 7.1, buster для 6.4
 - Установите пакеты vitastor-client, pve-qemu-kvm, pve-storage-vitastor (* или см. сноску) из репозитория Vitastor
 - Определите тип хранилища в `/etc/pve/storage.cfg` (см. ниже)
 - Обязательно заблокируйте доступ от виртуальных машин к сети Vitastor (OSD и etcd), т.к. Vitastor (пока) не поддерживает аутентификацию

docs/intro/architecture.ru.md

@@ -54,7 +54,8 @@
   виртуальные диски, их снимки и клоны.
 - **Драйвер QEMU** — подключаемый модуль QEMU, позволяющий QEMU/KVM виртуальным машинам работать
   с виртуальными дисками Vitastor напрямую из пространства пользователя с помощью клиентской
-  библиотеки, без необходимости отображения дисков в виде блочных устройств.
+  библиотеки, без необходимости отображения дисков в виде блочных устройств. Тот же драйвер
+  позволяет подключать диски в систему через [VDUSE](../usage/qemu.ru.md#vduse).
 - **vitastor-nbd** — утилита, позволяющая монтировать образы Vitastor в виде блочных устройств
   с помощью NBD (Network Block Device), на самом деле скорее работающего как "BUSE"
   (Block Device In Userspace). Модуля ядра Linux для выполнения той же задачи в Vitastor нет

docs/usage/cli.en.md

@@ -28,7 +28,8 @@ It supports the following commands:
 Global options:
 
 ```
---etcd_address ADDR  Etcd connection address
+--config_file FILE   Path to Vitastor configuration file
+--etcd_address URL   Etcd connection address
 --iodepth N          Send N operations in parallel to each OSD when possible (default 32)
 --parallel_osds M    Work with M osds in parallel when possible (default 4)
 --progress 1|0       Report progress (default 1)

docs/usage/cli.ru.md

@@ -27,7 +27,8 @@ vitastor-cli - интерфейс командной строки для адм
 Глобальные опции:
 
 ```
---etcd_address ADDR  Адрес соединения с etcd
+--config_file FILE   Путь к файлу конфигурации Vitastor
+--etcd_address URL   Адрес соединения с etcd
 --iodepth N          Отправлять параллельно N операций на каждый OSD (по умолчанию 32)
 --parallel_osds M    Работать параллельно с M OSD (по умолчанию 4)
 --progress 1|0       Печатать прогресс выполнения (по умолчанию 1)

docs/usage/disk.en.md

@@ -17,6 +17,7 @@ It supports the following commands:
 - [purge](#purge)
 - [read-sb](#read-sb)
 - [write-sb](#write-sb)
+- [update-sb](#update-sb)
 - [udev](#udev)
 - [exec-osd](#exec-osd)
 - [pre-exec](#pre-exec)
@@ -182,6 +183,14 @@ Try to read Vitastor OSD superblock from `<device>` and print it in JSON format.
 
 Read JSON from STDIN and write it into Vitastor OSD superblock on `<device>`.
 
+## update-sb
+
+`vitastor-disk update-sb <device> [--force] [--<parameter> <value>] [...]`
+
+Read Vitastor OSD superblock from <device>, update parameters in it and write it back.
+
+`--force` allows to ignore validation errors.
+
 ## udev
 
 `vitastor-disk udev <device>`

docs/usage/disk.ru.md

@@ -17,6 +17,7 @@ vitastor-disk - инструмент командной строки для уп
 - [purge](#purge)
 - [read-sb](#read-sb)
 - [write-sb](#write-sb)
+- [update-sb](#update-sb)
 - [udev](#udev)
 - [exec-osd](#exec-osd)
 - [pre-exec](#pre-exec)
@@ -187,6 +188,15 @@ throttle_target_mbs, throttle_target_parallelism, throttle_threshold_us.
 
 Прочитать JSON со стандартного ввода и записать его в суперблок OSD на диск `<device>`.
 
+## update-sb
+
+`vitastor-disk update-sb <device> [--force] [--<параметр> <значение>] [...]`
+
+Прочитать суперблок OSD с диска `<device>`, изменить в нём заданные параметры и записать обратно.
+
+Опция `--force` позволяет читать суперблок, даже если он считается некорректным
+из-за ошибок валидации.
+
 ## udev
 
 `vitastor-disk udev <device>`

docs/usage/nbd.en.md

@@ -11,25 +11,25 @@ NBD stands for "Network Block Device", but in fact it also functions as "BUSE"
 NBD slighly lowers the performance due to additional overhead, but performance still
 remains decent (see an example [here](../performance/comparison1.en.md#vitastor-0-4-0-nbd)).
 
-Vitastor Kubernetes CSI driver is based on NBD.
+See also [VDUSE](qemu.en.md#vduse) as a better alternative to NBD.
 
-See also [VDUSE](qemu.en.md#vduse).
+Vitastor Kubernetes CSI driver uses NBD when VDUSE is unavailable.
 
 ## Map image
 
 To create a local block device for a Vitastor image run:
 
 ```
-vitastor-nbd map --etcd_address 10.115.0.10:2379/v3 --image testimg
+vitastor-nbd map --image testimg
 ```
 
 It will output a block device name like /dev/nbd0 which you can then use as a normal disk.
 
 You can also use `--pool <POOL> --inode <INODE> --size <SIZE>` instead of `--image <IMAGE>` if you want.
 
-Additional options for map command:
+vitastor-nbd supports all usual Vitastor configuration options like `--config_file <path_to_config>` plus NBD-specific:
 
-* `--nbd_timeout 30` \
+* `--nbd_timeout 300` \
   Timeout for I/O operations in seconds after exceeding which the kernel stops
   the device. You can set it to 0 to disable the timeout, but beware that you
   won't be able to stop the device at all if vitastor-nbd process dies.
@@ -44,6 +44,9 @@ Additional options for map command:
 * `--foreground 1` \
   Stay in foreground, do not daemonize.
 
+Note that `nbd_timeout`, `nbd_max_devices` and `nbd_max_part` options may also be specified
+in `/etc/vitastor/vitastor.conf` or in other configuration file specified with `--config_file`.
+
 ## Unmap image
 
 To unmap the device run:

docs/usage/nbd.ru.md

@@ -14,16 +14,16 @@ NBD на данный момент необходимо, чтобы монтир
 NBD немного снижает производительность из-за дополнительных копирований памяти,
 но она всё равно остаётся на неплохом уровне (см. для примера [тест](../performance/comparison1.ru.md#vitastor-0-4-0-nbd)).
 
-CSI-драйвер Kubernetes Vitastor основан на NBD.
+Смотрите также [VDUSE](qemu.ru.md#vduse), как лучшую альтернативу NBD.
 
-Смотрите также [VDUSE](qemu.ru.md#vduse).
+CSI-драйвер Kubernetes Vitastor использует NBD, когда VDUSE недоступен.
 
 ## Подключить устройство
 
 Чтобы создать локальное блочное устройство для образа, выполните команду:
 
 ```
-vitastor-nbd map --etcd_address 10.115.0.10:2379/v3 --image testimg
+vitastor-nbd map --image testimg
 ```
 
 Команда напечатает название блочного устройства вида /dev/nbd0, которое потом можно
@@ -32,7 +32,8 @@ vitastor-nbd map --etcd_address 10.115.0.10:2379/v3 --image testimg
 Для обращения по номеру инода, аналогично другим командам, можно использовать опции
 `--pool <POOL> --inode <INODE> --size <SIZE>` вместо `--image testimg`.
 
-Дополнительные опции для команды подключения NBD-устройства:
+vitastor-nbd поддерживает все обычные опции Vitastor, например, `--config_file <path_to_config>`,
+плюс специфичные для NBD:
 
 * `--nbd_timeout 30` \
   Максимальное время выполнения любой операции чтения/записи в секундах, при
@@ -53,6 +54,10 @@ vitastor-nbd map --etcd_address 10.115.0.10:2379/v3 --image testimg
 * `--foreground 1` \
   Не уводить процесс в фоновый режим.
 
+Обратите внимание, что опции `nbd_timeout`, `nbd_max_devices` и `nbd_max_part` можно
+также задавать в `/etc/vitastor/vitastor.conf` или в другом файле конфигурации,
+заданном опцией `--config_file`.
+
 ## Отключить устройство
 
 Для отключения устройства выполните:

docs/usage/nfs.en.md

@@ -23,7 +23,7 @@ balancer or any failover method you want to in that case.
 vitastor-nfs usage:
 
 ```
-vitastor-nfs [--etcd_address ADDR] [OTHER OPTIONS]
+vitastor-nfs [STANDARD OPTIONS] [OTHER OPTIONS]
 
 --subdir <DIR>    export images prefixed <DIR>/ (default empty - export all images)
 --portmap 0       do not listen on port 111 (portmap/rpcbind, requires root)

docs/usage/nfs.ru.md

@@ -22,7 +22,7 @@
 Использование vitastor-nfs:
 
 ```
-vitastor-nfs [--etcd_address ADDR] [ДРУГИЕ ОПЦИИ]
+vitastor-nfs [СТАНДАРТНЫЕ ОПЦИИ] [ДРУГИЕ ОПЦИИ]
 
 --subdir <DIR>    экспортировать "поддиректорию" - образы с префиксом имени <DIR>/ (по умолчанию пусто - экспортировать все образы)
 --portmap 0       отключить сервис portmap/rpcbind на порту 111 (по умолчанию включён и требует root привилегий)

docs/usage/qemu.en.md

@@ -146,7 +146,7 @@ Example performance comparison:
 | 4k random read Q1    | 9600 iops   | 7640 iops   | 7780 iops   |
 
 To try VDUSE you need at least Linux 5.15, built with VDUSE support
-(CONFIG_VIRTIO_VDPA=m, CONFIG_VDPA_USER=m, CONFIG_VIRTIO_VDPA=m).
+(CONFIG_VDPA=m, CONFIG_VDPA_USER=m, CONFIG_VIRTIO_VDPA=m).
 
 Debian Linux kernels have these options disabled by now, so if you want to try it on Debian,
 use a kernel from Ubuntu [kernel-ppa/mainline](https://kernel.ubuntu.com/~kernel-ppa/mainline/), Proxmox,

docs/usage/qemu.ru.md

@@ -149,7 +149,7 @@ VDUSE - на данный момент лучший интерфейс для п
 | 4k случайное чтение Q1   | 9600 iops   | 7640 iops   | 7780 iops   |
 
 Чтобы попробовать VDUSE, вам нужно ядро Linux как минимум версии 5.15, собранное с поддержкой
-VDUSE (CONFIG_VIRTIO_VDPA=m, CONFIG_VDPA_USER=m, CONFIG_VIRTIO_VDPA=m).
+VDUSE (CONFIG_VDPA=m, CONFIG_VDPA_USER=m, CONFIG_VIRTIO_VDPA=m).
 
 В ядрах в Debian Linux поддержка пока отключена по умолчанию, так что чтобы попробовать VDUSE
 на Debian, поставьте ядро из Ubuntu [kernel-ppa/mainline](https://kernel.ubuntu.com/~kernel-ppa/mainline/),

mon/mon.js

@@ -110,7 +110,15 @@ const etcd_tree = {
             autosync_interval: 5,
             autosync_writes: 128,
             client_queue_depth: 128, // unused
-            recovery_queue_depth: 4,
+            recovery_queue_depth: 1,
+            recovery_sleep_us: 0,
+            recovery_tune_min_util: 0.1,
+            recovery_tune_min_client_util: 0,
+            recovery_tune_max_util: 1.0,
+            recovery_tune_max_client_util: 0.5,
+            recovery_tune_interval: 1,
+            recovery_tune_ewma_rate: 0.5,
+            recovery_tune_sleep_min_us: 10, // 10 microseconds
             recovery_pg_switch: 128,
             recovery_sync_batch: 16,
             no_recovery: false,

mon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitastor-mon",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Vitastor SDS monitor service",
   "main": "mon-main.js",
   "scripts": {

patches/cinder-vitastor.py

@@ -50,7 +50,7 @@ from cinder.volume import configuration
 from cinder.volume import driver
 from cinder.volume import volume_utils
 
-VERSION = '1.2.0'
+VERSION = '1.3.1'
 
 LOG = logging.getLogger(__name__)
 

patches/pve-qemu-8.1-vitastor.patch

@@ -0,0 +1,190 @@
+Index: pve-qemu-kvm-8.1.2/block/meson.build
+===================================================================
+--- pve-qemu-kvm-8.1.2.orig/block/meson.build
++++ pve-qemu-kvm-8.1.2/block/meson.build
+@@ -123,6 +123,7 @@ foreach m : [
+   [libnfs, 'nfs', files('nfs.c')],
+   [libssh, 'ssh', files('ssh.c')],
+   [rbd, 'rbd', files('rbd.c')],
++  [vitastor, 'vitastor', files('vitastor.c')],
+ ]
+   if m[0].found()
+     module_ss = ss.source_set()
+Index: pve-qemu-kvm-8.1.2/meson.build
+===================================================================
+--- pve-qemu-kvm-8.1.2.orig/meson.build
++++ pve-qemu-kvm-8.1.2/meson.build
+@@ -1303,6 +1303,26 @@ if not get_option('rbd').auto() or have_
+   endif
+ endif
+ 
++vitastor = not_found
++if not get_option('vitastor').auto() or have_block
++  libvitastor_client = cc.find_library('vitastor_client', has_headers: ['vitastor_c.h'],
++    required: get_option('vitastor'))
++  if libvitastor_client.found()
++    if cc.links('''
++      #include <vitastor_c.h>
++      int main(void) {
++        vitastor_c_create_qemu(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
++        return 0;
++      }''', dependencies: libvitastor_client)
++      vitastor = declare_dependency(dependencies: libvitastor_client)
++    elif get_option('vitastor').enabled()
++      error('could not link libvitastor_client')
++    else
++      warning('could not link libvitastor_client, disabling')
++    endif
++  endif
++endif
++
+ glusterfs = not_found
+ glusterfs_ftruncate_has_stat = false
+ glusterfs_iocb_has_stat = false
+@@ -2123,6 +2143,7 @@ if numa.found()
+ endif
+ config_host_data.set('CONFIG_OPENGL', opengl.found())
+ config_host_data.set('CONFIG_RBD', rbd.found())
++config_host_data.set('CONFIG_VITASTOR', vitastor.found())
+ config_host_data.set('CONFIG_RDMA', rdma.found())
+ config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack'))
+ config_host_data.set('CONFIG_SDL', sdl.found())
+@@ -4298,6 +4319,7 @@ summary_info += {'fdt support':       fd
+ summary_info += {'libcap-ng support': libcap_ng}
+ summary_info += {'bpf support':       libbpf}
+ summary_info += {'rbd support':       rbd}
++summary_info += {'vitastor support':  vitastor}
+ summary_info += {'smartcard support': cacard}
+ summary_info += {'U2F support':       u2f}
+ summary_info += {'libusb':            libusb}
+Index: pve-qemu-kvm-8.1.2/meson_options.txt
+===================================================================
+--- pve-qemu-kvm-8.1.2.orig/meson_options.txt
++++ pve-qemu-kvm-8.1.2/meson_options.txt
+@@ -186,6 +186,8 @@ option('lzo', type : 'feature', value :
+        description: 'lzo compression support')
+ option('rbd', type : 'feature', value : 'auto',
+        description: 'Ceph block device driver')
++option('vitastor', type : 'feature', value : 'auto',
++       description: 'Vitastor block device driver')
+ option('opengl', type : 'feature', value : 'auto',
+        description: 'OpenGL support')
+ option('rdma', type : 'feature', value : 'auto',
+Index: pve-qemu-kvm-8.1.2/qapi/block-core.json
+===================================================================
+--- pve-qemu-kvm-8.1.2.orig/qapi/block-core.json
++++ pve-qemu-kvm-8.1.2/qapi/block-core.json
+@@ -3403,7 +3403,7 @@
+             'raw', 'rbd',
+             { 'name': 'replication', 'if': 'CONFIG_REPLICATION' },
+             'pbs',
+-            'ssh', 'throttle', 'vdi', 'vhdx',
++            'ssh', 'throttle', 'vdi', 'vhdx', 'vitastor',
+             { 'name': 'virtio-blk-vfio-pci', 'if': 'CONFIG_BLKIO' },
+             { 'name': 'virtio-blk-vhost-user', 'if': 'CONFIG_BLKIO' },
+             { 'name': 'virtio-blk-vhost-vdpa', 'if': 'CONFIG_BLKIO' },
+@@ -4465,6 +4465,28 @@
+             '*server': ['InetSocketAddressBase'] } }
+ 
+ ##
++# @BlockdevOptionsVitastor:
++#
++# Driver specific block device options for vitastor
++#
++# @image:       Image name
++# @inode:       Inode number
++# @pool:        Pool ID
++# @size:        Desired image size in bytes
++# @config-path: Path to Vitastor configuration
++# @etcd-host:   etcd connection address(es)
++# @etcd-prefix: etcd key/value prefix
++##
++{ 'struct': 'BlockdevOptionsVitastor',
++  'data': { '*inode': 'uint64',
++            '*pool': 'uint64',
++            '*size': 'uint64',
++            '*image': 'str',
++            '*config-path': 'str',
++            '*etcd-host': 'str',
++            '*etcd-prefix': 'str' } }
++
++##
+ # @ReplicationMode:
+ #
+ # An enumeration of replication modes.
+@@ -4923,6 +4945,7 @@
+       'throttle':   'BlockdevOptionsThrottle',
+       'vdi':        'BlockdevOptionsGenericFormat',
+       'vhdx':       'BlockdevOptionsGenericFormat',
++      'vitastor':   'BlockdevOptionsVitastor',
+       'virtio-blk-vfio-pci':
+                     { 'type': 'BlockdevOptionsVirtioBlkVfioPci',
+                       'if': 'CONFIG_BLKIO' },
+@@ -5360,6 +5383,17 @@
+             '*encrypt' :        'RbdEncryptionCreateOptions' } }
+ 
+ ##
++# @BlockdevCreateOptionsVitastor:
++#
++# Driver specific image creation options for Vitastor.
++#
++# @size: Size of the virtual disk in bytes
++##
++{ 'struct': 'BlockdevCreateOptionsVitastor',
++  'data': { 'location':         'BlockdevOptionsVitastor',
++            'size':             'size' } }
++
++##
+ # @BlockdevVmdkSubformat:
+ #
+ # Subformat options for VMDK images
+@@ -5581,6 +5615,7 @@
+       'ssh':            'BlockdevCreateOptionsSsh',
+       'vdi':            'BlockdevCreateOptionsVdi',
+       'vhdx':           'BlockdevCreateOptionsVhdx',
++      'vitastor':       'BlockdevCreateOptionsVitastor',
+       'vmdk':           'BlockdevCreateOptionsVmdk',
+       'vpc':            'BlockdevCreateOptionsVpc'
+   } }
+Index: pve-qemu-kvm-8.1.2/scripts/ci/org.centos/stream/8/x86_64/configure
+===================================================================
+--- pve-qemu-kvm-8.1.2.orig/scripts/ci/org.centos/stream/8/x86_64/configure
++++ pve-qemu-kvm-8.1.2/scripts/ci/org.centos/stream/8/x86_64/configure
+@@ -30,7 +30,7 @@
+ --with-suffix="qemu-kvm" \
+ --firmwarepath=/usr/share/qemu-firmware \
+ --target-list="x86_64-softmmu" \
+---block-drv-rw-whitelist="qcow2,raw,file,host_device,nbd,iscsi,rbd,blkdebug,luks,null-co,nvme,copy-on-read,throttle,gluster" \
++--block-drv-rw-whitelist="qcow2,raw,file,host_device,nbd,iscsi,rbd,vitastor,blkdebug,luks,null-co,nvme,copy-on-read,throttle,gluster" \
+ --audio-drv-list="" \
+ --block-drv-ro-whitelist="vmdk,vhdx,vpc,https,ssh" \
+ --with-coroutine=ucontext \
+@@ -176,6 +176,7 @@
+ --enable-opengl \
+ --enable-pie \
+ --enable-rbd \
++--enable-vitastor \
+ --enable-rdma \
+ --enable-seccomp \
+ --enable-snappy \
+Index: pve-qemu-kvm-8.1.2/scripts/meson-buildoptions.sh
+===================================================================
+--- pve-qemu-kvm-8.1.2.orig/scripts/meson-buildoptions.sh
++++ pve-qemu-kvm-8.1.2/scripts/meson-buildoptions.sh
+@@ -153,6 +153,7 @@ meson_options_help() {
+   printf "%s\n" '  qed             qed image format support'
+   printf "%s\n" '  qga-vss         build QGA VSS support (broken with MinGW)'
+   printf "%s\n" '  rbd             Ceph block device driver'
++  printf "%s\n" '  vitastor        Vitastor block device driver'
+   printf "%s\n" '  rdma            Enable RDMA-based migration'
+   printf "%s\n" '  replication     replication support'
+   printf "%s\n" '  sdl             SDL user interface'
+@@ -416,6 +417,8 @@ _meson_option_parse() {
+     --disable-qom-cast-debug) printf "%s" -Dqom_cast_debug=false ;;
+     --enable-rbd) printf "%s" -Drbd=enabled ;;
+     --disable-rbd) printf "%s" -Drbd=disabled ;;
++    --enable-vitastor) printf "%s" -Dvitastor=enabled ;;
++    --disable-vitastor) printf "%s" -Dvitastor=disabled ;;
+     --enable-rdma) printf "%s" -Drdma=enabled ;;
+     --disable-rdma) printf "%s" -Drdma=disabled ;;
+     --enable-replication) printf "%s" -Dreplication=enabled ;;

patches/qemu-8.1-vitastor.patch

@@ -0,0 +1,190 @@
+diff --git a/block/meson.build b/block/meson.build
+index 529fc172c6..d542dc0609 100644
+--- a/block/meson.build
++++ b/block/meson.build
+@@ -110,6 +110,7 @@ foreach m : [
+   [libnfs, 'nfs', files('nfs.c')],
+   [libssh, 'ssh', files('ssh.c')],
+   [rbd, 'rbd', files('rbd.c')],
++  [vitastor, 'vitastor', files('vitastor.c')],
+ ]
+   if m[0].found()
+     module_ss = ss.source_set()
+diff --git a/meson.build b/meson.build
+index a9c4f28247..8496cf13f1 100644
+--- a/meson.build
++++ b/meson.build
+@@ -1303,6 +1303,26 @@ if not get_option('rbd').auto() or have_block
+   endif
+ endif
+ 
++vitastor = not_found
++if not get_option('vitastor').auto() or have_block
++  libvitastor_client = cc.find_library('vitastor_client', has_headers: ['vitastor_c.h'],
++    required: get_option('vitastor'))
++  if libvitastor_client.found()
++    if cc.links('''
++      #include <vitastor_c.h>
++      int main(void) {
++        vitastor_c_create_qemu(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
++        return 0;
++      }''', dependencies: libvitastor_client)
++      vitastor = declare_dependency(dependencies: libvitastor_client)
++    elif get_option('vitastor').enabled()
++      error('could not link libvitastor_client')
++    else
++      warning('could not link libvitastor_client, disabling')
++    endif
++  endif
++endif
++
+ glusterfs = not_found
+ glusterfs_ftruncate_has_stat = false
+ glusterfs_iocb_has_stat = false
+@@ -2119,6 +2139,7 @@ if numa.found()
+ endif
+ config_host_data.set('CONFIG_OPENGL', opengl.found())
+ config_host_data.set('CONFIG_RBD', rbd.found())
++config_host_data.set('CONFIG_VITASTOR', vitastor.found())
+ config_host_data.set('CONFIG_RDMA', rdma.found())
+ config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack'))
+ config_host_data.set('CONFIG_SDL', sdl.found())
+@@ -4286,6 +4307,7 @@ summary_info += {'fdt support':       fdt_opt == 'disabled' ? false : fdt_opt}
+ summary_info += {'libcap-ng support': libcap_ng}
+ summary_info += {'bpf support':       libbpf}
+ summary_info += {'rbd support':       rbd}
++summary_info += {'vitastor support':  vitastor}
+ summary_info += {'smartcard support': cacard}
+ summary_info += {'U2F support':       u2f}
+ summary_info += {'libusb':            libusb}
+diff --git a/meson_options.txt b/meson_options.txt
+index ae6d8f469d..e3d9f8404d 100644
+--- a/meson_options.txt
++++ b/meson_options.txt
+@@ -186,6 +186,8 @@ option('lzo', type : 'feature', value : 'auto',
+        description: 'lzo compression support')
+ option('rbd', type : 'feature', value : 'auto',
+        description: 'Ceph block device driver')
++option('vitastor', type : 'feature', value : 'auto',
++       description: 'Vitastor block device driver')
+ option('opengl', type : 'feature', value : 'auto',
+        description: 'OpenGL support')
+ option('rdma', type : 'feature', value : 'auto',
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index 2b1d493d6e..90673fdbdc 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -3146,7 +3146,7 @@
+             'parallels', 'preallocate', 'qcow', 'qcow2', 'qed', 'quorum',
+             'raw', 'rbd',
+             { 'name': 'replication', 'if': 'CONFIG_REPLICATION' },
+-            'ssh', 'throttle', 'vdi', 'vhdx',
++            'ssh', 'throttle', 'vdi', 'vhdx', 'vitastor',
+             { 'name': 'virtio-blk-vfio-pci', 'if': 'CONFIG_BLKIO' },
+             { 'name': 'virtio-blk-vhost-user', 'if': 'CONFIG_BLKIO' },
+             { 'name': 'virtio-blk-vhost-vdpa', 'if': 'CONFIG_BLKIO' },
+@@ -4196,6 +4196,28 @@
+             '*key-secret': 'str',
+             '*server': ['InetSocketAddressBase'] } }
+ 
++##
++# @BlockdevOptionsVitastor:
++#
++# Driver specific block device options for vitastor
++#
++# @image:       Image name
++# @inode:       Inode number
++# @pool:        Pool ID
++# @size:        Desired image size in bytes
++# @config-path: Path to Vitastor configuration
++# @etcd-host:   etcd connection address(es)
++# @etcd-prefix: etcd key/value prefix
++##
++{ 'struct': 'BlockdevOptionsVitastor',
++  'data': { '*inode': 'uint64',
++            '*pool': 'uint64',
++            '*size': 'uint64',
++            '*image': 'str',
++            '*config-path': 'str',
++            '*etcd-host': 'str',
++            '*etcd-prefix': 'str' } }
++
+ ##
+ # @ReplicationMode:
+ #
+@@ -4654,6 +4676,7 @@
+       'throttle':   'BlockdevOptionsThrottle',
+       'vdi':        'BlockdevOptionsGenericFormat',
+       'vhdx':       'BlockdevOptionsGenericFormat',
++      'vitastor':   'BlockdevOptionsVitastor',
+       'virtio-blk-vfio-pci':
+                     { 'type': 'BlockdevOptionsVirtioBlkVfioPci',
+                       'if': 'CONFIG_BLKIO' },
+@@ -5089,6 +5112,17 @@
+             '*cluster-size' :   'size',
+             '*encrypt' :        'RbdEncryptionCreateOptions' } }
+ 
++##
++# @BlockdevCreateOptionsVitastor:
++#
++# Driver specific image creation options for Vitastor.
++#
++# @size: Size of the virtual disk in bytes
++##
++{ 'struct': 'BlockdevCreateOptionsVitastor',
++  'data': { 'location':         'BlockdevOptionsVitastor',
++            'size':             'size' } }
++
+ ##
+ # @BlockdevVmdkSubformat:
+ #
+@@ -5311,6 +5345,7 @@
+       'ssh':            'BlockdevCreateOptionsSsh',
+       'vdi':            'BlockdevCreateOptionsVdi',
+       'vhdx':           'BlockdevCreateOptionsVhdx',
++      'vitastor':       'BlockdevCreateOptionsVitastor',
+       'vmdk':           'BlockdevCreateOptionsVmdk',
+       'vpc':            'BlockdevCreateOptionsVpc'
+   } }
+diff --git a/scripts/ci/org.centos/stream/8/x86_64/configure b/scripts/ci/org.centos/stream/8/x86_64/configure
+index d02b09a4b9..f0b5fbfef3 100755
+--- a/scripts/ci/org.centos/stream/8/x86_64/configure
++++ b/scripts/ci/org.centos/stream/8/x86_64/configure
+@@ -30,7 +30,7 @@
+ --with-suffix="qemu-kvm" \
+ --firmwarepath=/usr/share/qemu-firmware \
+ --target-list="x86_64-softmmu" \
+---block-drv-rw-whitelist="qcow2,raw,file,host_device,nbd,iscsi,rbd,blkdebug,luks,null-co,nvme,copy-on-read,throttle,gluster" \
++--block-drv-rw-whitelist="qcow2,raw,file,host_device,nbd,iscsi,rbd,vitastor,blkdebug,luks,null-co,nvme,copy-on-read,throttle,gluster" \
+ --audio-drv-list="" \
+ --block-drv-ro-whitelist="vmdk,vhdx,vpc,https,ssh" \
+ --with-coroutine=ucontext \
+@@ -176,6 +176,7 @@
+ --enable-opengl \
+ --enable-pie \
+ --enable-rbd \
++--enable-vitastor \
+ --enable-rdma \
+ --enable-seccomp \
+ --enable-snappy \
+diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
+index d7020af175..94958eb6fa 100644
+--- a/scripts/meson-buildoptions.sh
++++ b/scripts/meson-buildoptions.sh
+@@ -153,6 +153,7 @@ meson_options_help() {
+   printf "%s\n" '  qed             qed image format support'
+   printf "%s\n" '  qga-vss         build QGA VSS support (broken with MinGW)'
+   printf "%s\n" '  rbd             Ceph block device driver'
++  printf "%s\n" '  vitastor        Vitastor block device driver'
+   printf "%s\n" '  rdma            Enable RDMA-based migration'
+   printf "%s\n" '  replication     replication support'
+   printf "%s\n" '  sdl             SDL user interface'
+@@ -416,6 +417,8 @@ _meson_option_parse() {
+     --disable-qom-cast-debug) printf "%s" -Dqom_cast_debug=false ;;
+     --enable-rbd) printf "%s" -Drbd=enabled ;;
+     --disable-rbd) printf "%s" -Drbd=disabled ;;
++    --enable-vitastor) printf "%s" -Dvitastor=enabled ;;
++    --disable-vitastor) printf "%s" -Dvitastor=disabled ;;
+     --enable-rdma) printf "%s" -Drdma=enabled ;;
+     --disable-rdma) printf "%s" -Drdma=disabled ;;
+     --enable-replication) printf "%s" -Dreplication=enabled ;;

rpm/build-tarball.sh

@@ -24,4 +24,4 @@ rm fio
 mv fio-copy fio
 FIO=`rpm -qi fio | perl -e 'while(<>) { /^Epoch[\s:]+(\S+)/ && print "$1:"; /^Version[\s:]+(\S+)/ && print $1; /^Release[\s:]+(\S+)/ && print "-$1"; }'`
 perl -i -pe 's/(Requires:\s*fio)([^\n]+)?/$1 = '$FIO'/' $VITASTOR/rpm/vitastor-el$EL.spec
-tar --transform 's#^#vitastor-1.2.0/#' --exclude 'rpm/*.rpm' -czf $VITASTOR/../vitastor-1.2.0$(rpm --eval '%dist').tar.gz *
+tar --transform 's#^#vitastor-1.3.1/#' --exclude 'rpm/*.rpm' -czf $VITASTOR/../vitastor-1.3.1$(rpm --eval '%dist').tar.gz *

rpm/vitastor-el7.Dockerfile

@@ -15,6 +15,7 @@ RUN yumdownloader --disablerepo=centos-sclo-rh --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN rm -f /etc/yum.repos.d/CentOS-Media.repo
 RUN cd ~/rpmbuild/SPECS && yum-builddep -y fio.spec
+RUN yum -y install cmake3
 
 ADD https://vitastor.io/rpms/liburing-el7/liburing-0.7-2.el7.src.rpm /root
 
@@ -35,7 +36,7 @@ ADD . /root/vitastor
 RUN set -e; \
     cd /root/vitastor/rpm; \
     sh build-tarball.sh; \
-    cp /root/vitastor-1.2.0.el7.tar.gz ~/rpmbuild/SOURCES; \
+    cp /root/vitastor-1.3.1.el7.tar.gz ~/rpmbuild/SOURCES; \
     cp vitastor-el7.spec ~/rpmbuild/SPECS/vitastor.spec; \
     cd ~/rpmbuild/SPECS/; \
     rpmbuild -ba vitastor.spec; \

rpm/vitastor-el7.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        1.2.0
+Version:        1.3.1
 Release:        1%{?dist}
 Summary:        Vitastor, a fast software-defined clustered block storage
 
 License:        Vitastor Network Public License 1.1
 URL:            https://vitastor.io/
-Source0:        vitastor-1.2.0.el7.tar.gz
+Source0:        vitastor-1.3.1.el7.tar.gz
 
 BuildRequires:  liburing-devel >= 0.6
 BuildRequires:  gperftools-devel
@@ -16,7 +16,7 @@ BuildRequires:  jerasure-devel
 BuildRequires:  libisa-l-devel
 BuildRequires:  gf-complete-devel
 BuildRequires:  libibverbs-devel
-BuildRequires:  cmake
+BuildRequires:  cmake3
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -94,7 +94,7 @@ Vitastor fio drivers for benchmarking.
 
 %build
 . /opt/rh/devtoolset-9/enable
-%cmake .
+%cmake3 .
 %make_build
 
 

rpm/vitastor-el8.Dockerfile

@@ -35,7 +35,7 @@ ADD . /root/vitastor
 RUN set -e; \
     cd /root/vitastor/rpm; \
     sh build-tarball.sh; \
-    cp /root/vitastor-1.2.0.el8.tar.gz ~/rpmbuild/SOURCES; \
+    cp /root/vitastor-1.3.1.el8.tar.gz ~/rpmbuild/SOURCES; \
     cp vitastor-el8.spec ~/rpmbuild/SPECS/vitastor.spec; \
     cd ~/rpmbuild/SPECS/; \
     rpmbuild -ba vitastor.spec; \

rpm/vitastor-el8.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        1.2.0
+Version:        1.3.1
 Release:        1%{?dist}
 Summary:        Vitastor, a fast software-defined clustered block storage
 
 License:        Vitastor Network Public License 1.1
 URL:            https://vitastor.io/
-Source0:        vitastor-1.2.0.el8.tar.gz
+Source0:        vitastor-1.3.1.el8.tar.gz
 
 BuildRequires:  liburing-devel >= 0.6
 BuildRequires:  gperftools-devel

rpm/vitastor-el9.Dockerfile

@@ -18,7 +18,7 @@ ADD . /root/vitastor
 RUN set -e; \
     cd /root/vitastor/rpm; \
     sh build-tarball.sh; \
-    cp /root/vitastor-1.2.0.el9.tar.gz ~/rpmbuild/SOURCES; \
+    cp /root/vitastor-1.3.1.el9.tar.gz ~/rpmbuild/SOURCES; \
     cp vitastor-el9.spec ~/rpmbuild/SPECS/vitastor.spec; \
     cd ~/rpmbuild/SPECS/; \
     rpmbuild -ba vitastor.spec; \

rpm/vitastor-el9.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        1.2.0
+Version:        1.3.1
 Release:        1%{?dist}
 Summary:        Vitastor, a fast software-defined clustered block storage
 
 License:        Vitastor Network Public License 1.1
 URL:            https://vitastor.io/
-Source0:        vitastor-1.2.0.el9.tar.gz
+Source0:        vitastor-1.3.1.el9.tar.gz
 
 BuildRequires:  liburing-devel >= 0.6
 BuildRequires:  gperftools-devel

src/CMakeLists.txt

@@ -16,7 +16,7 @@ if("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/local/?$")
 	set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
 endif()
 
-add_definitions(-DVERSION="1.2.0")
+add_definitions(-DVERSION="1.3.1")
 add_definitions(-Wall -Wno-sign-compare -Wno-comment -Wno-parentheses -Wno-pointer-arith -fdiagnostics-color=always -fno-omit-frame-pointer -I ${CMAKE_SOURCE_DIR}/src)
 add_link_options(-fno-omit-frame-pointer)
 if (${WITH_ASAN})
@@ -181,25 +181,6 @@ target_link_libraries(vitastor-nbd
 	vitastor_client
 )
 
-# vitastor-kv
-add_executable(vitastor-kv
-	kv_cli.cpp
-	kv_db.cpp
-	kv_db.h
-)
-target_link_libraries(vitastor-kv
-	vitastor_client
-)
-
-add_executable(vitastor-kv-stress
-	kv_stress.cpp
-	kv_db.cpp
-	kv_db.h
-)
-target_link_libraries(vitastor-kv-stress
-	vitastor_client
-)
-
 # vitastor-nfs
 add_executable(vitastor-nfs
 	nfs_proxy.cpp

src/blockstore_init.cpp

@@ -732,8 +732,9 @@ int blockstore_init_journal::handle_journal_part(void *buf, uint64_t done_pos, u
     resume:
         while (pos < bs->journal.block_size)
         {
-            journal_entry *je = (journal_entry*)((uint8_t*)buf + proc_pos - done_pos + pos);
-            if (je->magic != JOURNAL_MAGIC || je_crc32(je) != je->crc32 ||
+            auto buf_pos = proc_pos - done_pos + pos;
+            journal_entry *je = (journal_entry*)((uint8_t*)buf + buf_pos);
+            if (je->magic != JOURNAL_MAGIC || buf_pos+je->size > len || je_crc32(je) != je->crc32 ||
                 je->type < JE_MIN || je->type > JE_MAX || started && je->crc32_prev != crc32_last)
             {
                 if (pos == 0)

src/blockstore_journal.cpp

@@ -144,8 +144,10 @@ journal_entry* prefill_single_journal_entry(journal_t & journal, uint16_t type,
         journal.sector_info[journal.cur_sector].written = false;
         journal.sector_info[journal.cur_sector].offset = journal.next_free;
         journal.in_sector_pos = 0;
-        journal.next_free = (journal.next_free+journal.block_size) < journal.len ? journal.next_free + journal.block_size : journal.block_size;
-        assert(journal.next_free != journal.used_start);
+        auto next_next_free = (journal.next_free+journal.block_size) < journal.len ? journal.next_free + journal.block_size : journal.block_size;
+        // double check that next_free doesn't cross used_start from the left
+        assert(journal.next_free >= journal.used_start || next_next_free < journal.used_start);
+        journal.next_free = next_next_free;
         memset(journal.inmemory
             ? (uint8_t*)journal.buffer + journal.sector_info[journal.cur_sector].offset
             : (uint8_t*)journal.sector_buf + journal.block_size*journal.cur_sector, 0, journal.block_size);

src/blockstore_write.cpp

@@ -386,7 +386,7 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op)
             sqe, dsk.data_fd, PRIV(op)->iov_zerofill, vcnt, dsk.data_offset + (loc << dsk.block_order) + op->offset - stripe_offset
         );
         PRIV(op)->pending_ops = 1;
-        if (immediate_commit != IMMEDIATE_ALL && !(dirty_it->second.state & BS_ST_INSTANT))
+        if (!(dirty_it->second.state & BS_ST_INSTANT))
         {
             unstable_unsynced++;
         }
@@ -412,7 +412,7 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op)
                 sizeof(journal_entry_big_write) + dsk.clean_dyn_size, 0)
             || !space_check.check_available(op, 1,
                 sizeof(journal_entry_small_write) + dyn_size,
-                (unstable_writes.size()+unstable_unsynced)*journal.block_size))
+                op->len + (unstable_writes.size()+unstable_unsynced)*journal.block_size))
         {
             return 0;
         }
@@ -462,6 +462,8 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op)
                 exit(1);
             }
         }
+        // double check that next_free doesn't cross used_start from the left
+        assert(journal.next_free >= journal.used_start || next_next_free < journal.used_start);
         journal.next_free = next_next_free;
         je->oid = op->oid;
         je->version = op->version;
@@ -499,13 +501,13 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op)
         }
         dirty_it->second.location = journal.next_free;
         dirty_it->second.state = (dirty_it->second.state & ~BS_ST_WORKFLOW_MASK) | BS_ST_SUBMITTED;
-        journal.next_free += op->len;
-        if (journal.next_free >= journal.len)
-        {
-            journal.next_free = dsk.journal_block_size;
-            assert(journal.next_free != journal.used_start);
-        }
-        if (immediate_commit == IMMEDIATE_NONE && !(dirty_it->second.state & BS_ST_INSTANT))
+        next_next_free = journal.next_free + op->len;
+        if (next_next_free >= journal.len)
+            next_next_free = dsk.journal_block_size;
+        // double check that next_free doesn't cross used_start from the left
+        assert(journal.next_free >= journal.used_start || next_next_free < journal.used_start);
+        journal.next_free = next_next_free;
+        if (!(dirty_it->second.state & BS_ST_INSTANT))
         {
             unstable_unsynced++;
         }
@@ -596,11 +598,11 @@ resume_4:
         {
             auto & unstab = unstable_writes[op->oid];
             unstab = unstab < op->version ? op->version : unstab;
-        }
-        else if (!is_instant)
-        {
-            unstable_unsynced--;
-            assert(unstable_unsynced >= 0);
+            if (!is_instant)
+            {
+                unstable_unsynced--;
+                assert(unstable_unsynced >= 0);
+            }
         }
         dirty_it->second.state = (dirty_it->second.state & ~BS_ST_WORKFLOW_MASK)
             | (imm ? BS_ST_SYNCED : BS_ST_WRITTEN);

src/cli.cpp

@@ -116,7 +116,8 @@ static const char* help_text =
     "Use vitastor-cli --help <command> for command details or vitastor-cli --help --all for all details.\n"
     "\n"
     "GLOBAL OPTIONS:\n"
-    "  --etcd_address <etcd_address>\n"
+    "  --config_file FILE  Path to Vitastor configuration file\n"
+    "  --etcd_address URL  Etcd connection address\n"
     "  --iodepth N         Send N operations in parallel to each OSD when possible (default 32)\n"
     "  --parallel_osds M   Work with M osds in parallel when possible (default 4)\n"
     "  --progress 1|0      Report progress (default 1)\n"

src/cluster_client.cpp

@@ -6,7 +6,7 @@
 #include "cluster_client_impl.h"
 #include "http_client.h" // json_is_true
 
-cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config)
+cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json & config)
 {
     wb = new writeback_cache_t();
 
@@ -532,7 +532,7 @@ void cluster_client_t::execute_internal(cluster_op_t *op)
         return;
     }
     if (op->opcode == OSD_OP_WRITE && enable_writeback && !(op->flags & OP_FLUSH_BUFFER) &&
-        !op->version /* no CAS writeback */)
+        !op->version /* FIXME no CAS writeback */)
     {
         if (wb->writebacks_active >= client_max_writeback_iodepth)
         {
@@ -553,7 +553,7 @@ void cluster_client_t::execute_internal(cluster_op_t *op)
     }
     if (op->opcode == OSD_OP_WRITE && !(op->flags & OP_IMMEDIATE_COMMIT))
     {
-        if (!(op->flags & OP_FLUSH_BUFFER) && !op->version /* no CAS write-repeat */)
+        if (!(op->flags & OP_FLUSH_BUFFER))
         {
             wb->copy_write(op, CACHE_WRITTEN);
         }
@@ -1152,7 +1152,7 @@ void cluster_client_t::handle_op_part(cluster_op_part_t *part)
                 osd_op_names[part->op.req.hdr.opcode], part->osd_num, part->op.reply.hdr.retval, expected
             );
         }
-        else if (log_level > 0)
+        else
         {
             fprintf(
                 stderr, "%s operation failed on OSD %lu: retval=%ld (expected %d)\n",

src/cluster_client.h

@@ -121,7 +121,7 @@ public:
     json11::Json::object cli_config, file_config, etcd_global_config;
     json11::Json::object config;
 
-    cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config);
+    cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json & config);
     ~cluster_client_t();
     void execute(cluster_op_t *op);
     void execute_raw(osd_num_t osd_num, osd_op_t *op);

src/disk_tool.cpp

@@ -127,6 +127,10 @@ static const char *help_text =
     "vitastor-disk write-sb <device>\n"
     "  Read JSON from STDIN and write it into Vitastor OSD superblock on <device>.\n"
     "\n"
+    "vitastor-disk update-sb <device> [--force] [--<parameter> <value>] [...]\n"
+    "  Read Vitastor OSD superblock from <device>, update parameters in it and write it back.\n"
+    "  --force allows to ignore validation errors.\n"
+    "\n"
     "vitastor-disk udev <device>\n"
     "  Try to read Vitastor OSD superblock from <device> and print variables for udev.\n"
     "\n"
@@ -363,6 +367,15 @@ int main(int argc, char *argv[])
         }
         return self.write_sb(cmd[1]);
     }
+    else if (!strcmp(cmd[0], "update-sb"))
+    {
+        if (cmd.size() != 2)
+        {
+            fprintf(stderr, "Exactly 1 device path argument is required\n");
+            return 1;
+        }
+        return self.update_sb(cmd[1]);
+    }
     else if (!strcmp(cmd[0], "start") || !strcmp(cmd[0], "stop") ||
         !strcmp(cmd[0], "restart") || !strcmp(cmd[0], "enable") || !strcmp(cmd[0], "disable"))
     {

src/disk_tool.h

@@ -109,6 +109,7 @@ struct disk_tool_t
     int udev_import(std::string device);
     int read_sb(std::string device);
     int write_sb(std::string device);
+    int update_sb(std::string device);
     int exec_osd(std::string device);
     int systemd_start_stop_osds(const std::vector<std::string> & cmd, const std::vector<std::string> & devices);
     int pre_exec_osd(std::string device);

src/disk_tool_udev.cpp

@@ -86,6 +86,24 @@ int disk_tool_t::write_sb(std::string device)
     return !write_osd_superblock(device, params);
 }
 
+int disk_tool_t::update_sb(std::string device)
+{
+    json11::Json sb = read_osd_superblock(device, true, options.find("force") != options.end());
+    if (sb.is_null())
+    {
+        return 1;
+    }
+    auto sb_obj = sb["params"].object_items();
+    for (auto & kv: options)
+    {
+        if (kv.first != "force")
+        {
+            sb_obj[kv.first] = kv.second;
+        }
+    }
+    return !write_osd_superblock(device, sb_obj);
+}
+
 uint32_t disk_tool_t::write_osd_superblock(std::string device, json11::Json params)
 {
     std::string json_data = params.dump();

src/etcd_state_client.cpp

@@ -135,8 +135,8 @@ void etcd_state_client_t::etcd_call(std::string api, json11::Json payload, int t
             {
                 if (this->log_level > 0)
                 {
-                    printf(
-                        "Warning: etcd request failed: %s, retrying %d more times\n",
+                    fprintf(
+                        stderr, "Warning: etcd request failed: %s, retrying %d more times\n",
                         err.c_str(), retries
                     );
                 }
@@ -333,7 +333,7 @@ void etcd_state_client_t::start_etcd_watcher()
         etcd_watch_ws = NULL;
     }
     if (this->log_level > 1)
-        printf("Trying to connect to etcd websocket at %s\n", etcd_address.c_str());
+        fprintf(stderr, "Trying to connect to etcd websocket at %s\n", etcd_address.c_str());
     etcd_watch_ws = open_websocket(tfd, etcd_address, etcd_api_path+"/watch", etcd_slow_timeout,
         [this, cur_addr = selected_etcd_address](const http_response_t *msg)
     {

src/kv_cli.cpp

@@ -1,401 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 (see README.md for details)
-//
-// Vitastor shared key/value database test CLI
-
-#define _XOPEN_SOURCE
-#include <limits.h>
-
-#include <netinet/tcp.h>
-#include <sys/epoll.h>
-#include <unistd.h>
-#include <fcntl.h>
-//#include <signal.h>
-
-#include "epoll_manager.h"
-#include "str_util.h"
-#include "kv_db.h"
-
-const char *exe_name = NULL;
-
-class kv_cli_t
-{
-public:
-    kv_dbw_t *db = NULL;
-    ring_loop_t *ringloop = NULL;
-    epoll_manager_t *epmgr = NULL;
-    cluster_client_t *cli = NULL;
-    bool interactive = false;
-    int in_progress = 0;
-    char *cur_cmd = NULL;
-    int cur_cmd_size = 0, cur_cmd_alloc = 0;
-    bool finished = false, eof = false;
-    json11::Json::object cfg;
-
-    ~kv_cli_t();
-
-    static json11::Json::object parse_args(int narg, const char *args[]);
-    void run(const json11::Json::object & cfg);
-    void read_cmd();
-    void next_cmd();
-    void handle_cmd(const std::string & cmd, std::function<void()> cb);
-};
-
-kv_cli_t::~kv_cli_t()
-{
-    if (cur_cmd)
-    {
-        free(cur_cmd);
-        cur_cmd = NULL;
-    }
-    cur_cmd_alloc = 0;
-    if (db)
-        delete db;
-    if (cli)
-    {
-        cli->flush();
-        delete cli;
-    }
-    if (epmgr)
-        delete epmgr;
-    if (ringloop)
-        delete ringloop;
-}
-
-json11::Json::object kv_cli_t::parse_args(int narg, const char *args[])
-{
-    json11::Json::object cfg;
-    for (int i = 1; i < narg; i++)
-    {
-        if (!strcmp(args[i], "-h") || !strcmp(args[i], "--help"))
-        {
-            printf(
-                "Vitastor Key/Value CLI\n"
-                "(c) Vitaliy Filippov, 2023+ (VNPL-1.1)\n"
-                "\n"
-                "USAGE: %s [--etcd_address ADDR] [OTHER OPTIONS]\n",
-                exe_name
-            );
-            exit(0);
-        }
-        else if (args[i][0] == '-' && args[i][1] == '-')
-        {
-            const char *opt = args[i]+2;
-            cfg[opt] = !strcmp(opt, "json") || i == narg-1 ? "1" : args[++i];
-        }
-    }
-    return cfg;
-}
-
-void kv_cli_t::run(const json11::Json::object & cfg)
-{
-    // Create client
-    ringloop = new ring_loop_t(512);
-    epmgr = new epoll_manager_t(ringloop);
-    cli = new cluster_client_t(ringloop, epmgr->tfd, cfg);
-    db = new kv_dbw_t(cli);
-    // Load image metadata
-    while (!cli->is_ready())
-    {
-        ringloop->loop();
-        if (cli->is_ready())
-            break;
-        ringloop->wait();
-    }
-    // Run
-    fcntl(0, F_SETFL, fcntl(0, F_GETFL, 0) | O_NONBLOCK);
-    try
-    {
-        epmgr->tfd->set_fd_handler(0, false, [this](int fd, int events)
-        {
-            if (events & EPOLLIN)
-            {
-                read_cmd();
-            }
-            if (events & EPOLLRDHUP)
-            {
-                epmgr->tfd->set_fd_handler(0, false, NULL);
-                finished = true;
-            }
-        });
-        interactive = true;
-        printf("> ");
-    }
-    catch (std::exception & e)
-    {
-        // Can't add to epoll, STDIN is probably a file
-        read_cmd();
-    }
-    while (!finished)
-    {
-        ringloop->loop();
-        if (!finished)
-            ringloop->wait();
-    }
-    // Destroy the client
-    delete db;
-    db = NULL;
-    cli->flush();
-    delete cli;
-    delete epmgr;
-    delete ringloop;
-    cli = NULL;
-    epmgr = NULL;
-    ringloop = NULL;
-}
-
-void kv_cli_t::read_cmd()
-{
-    if (!cur_cmd_alloc)
-    {
-        cur_cmd_alloc = 65536;
-        cur_cmd = (char*)malloc_or_die(cur_cmd_alloc);
-    }
-    while (cur_cmd_size < cur_cmd_alloc)
-    {
-        int r = read(0, cur_cmd+cur_cmd_size, cur_cmd_alloc-cur_cmd_size);
-        if (r < 0 && errno != EAGAIN)
-            fprintf(stderr, "Error reading from stdin: %s\n", strerror(errno));
-        if (r > 0)
-            cur_cmd_size += r;
-        if (r == 0)
-            eof = true;
-        if (r <= 0)
-            break;
-    }
-    next_cmd();
-}
-
-void kv_cli_t::next_cmd()
-{
-    if (in_progress > 0)
-    {
-        return;
-    }
-    int pos = 0;
-    for (; pos < cur_cmd_size; pos++)
-    {
-        if (cur_cmd[pos] == '\n' || cur_cmd[pos] == '\r')
-        {
-            auto cmd = trim(std::string(cur_cmd, pos));
-            pos++;
-            memmove(cur_cmd, cur_cmd+pos, cur_cmd_size-pos);
-            cur_cmd_size -= pos;
-            in_progress++;
-            handle_cmd(cmd, [this]()
-            {
-                in_progress--;
-                if (interactive)
-                    printf("> ");
-                next_cmd();
-                if (!in_progress)
-                    read_cmd();
-            });
-            break;
-        }
-    }
-    if (eof && !in_progress)
-    {
-        finished = true;
-    }
-}
-
-void kv_cli_t::handle_cmd(const std::string & cmd, std::function<void()> cb)
-{
-    if (cmd == "")
-    {
-        cb();
-        return;
-    }
-    auto pos = cmd.find_first_of(" \t");
-    if (pos != std::string::npos)
-    {
-        while (pos < cmd.size()-1 && (cmd[pos+1] == ' ' || cmd[pos+1] == '\t'))
-            pos++;
-    }
-    auto opname = strtolower(pos == std::string::npos ? cmd : cmd.substr(0, pos));
-    if (opname == "open")
-    {
-        uint64_t pool_id = 0;
-        inode_t inode_id = 0;
-        uint32_t kv_block_size = 0;
-        int scanned = sscanf(cmd.c_str() + pos+1, "%lu %lu %u", &pool_id, &inode_id, &kv_block_size);
-        if (scanned == 2)
-        {
-            kv_block_size = 4096;
-        }
-        if (scanned < 2 || !pool_id || !inode_id || !kv_block_size || (kv_block_size & (kv_block_size-1)) != 0)
-        {
-            fprintf(stderr, "Usage: open <pool_id> <inode_id> [block_size]. Block size must be a power of 2. Default is 4096.\n");
-            cb();
-            return;
-        }
-        cfg["kv_block_size"] = (uint64_t)kv_block_size;
-        db->open(INODE_WITH_POOL(pool_id, inode_id), cfg, [=](int res)
-        {
-            if (res < 0)
-                fprintf(stderr, "Error opening index: %s (code %d)\n", strerror(-res), res);
-            else
-                printf("Index opened. Current size: %lu bytes\n", db->get_size());
-            cb();
-        });
-    }
-    else if (opname == "config")
-    {
-        auto pos2 = cmd.find_first_of(" \t", pos+1);
-        if (pos2 == std::string::npos)
-        {
-            fprintf(stderr, "Usage: config <property> <value>\n");
-            cb();
-            return;
-        }
-        auto key = trim(cmd.substr(pos+1, pos2-pos-1));
-        auto value = parse_size(trim(cmd.substr(pos2+1)));
-        if (key != "kv_memory_limit" &&
-            key != "kv_allocate_blocks" &&
-            key != "kv_evict_max_misses" &&
-            key != "kv_evict_attempts_per_level" &&
-            key != "kv_evict_unused_age" &&
-            key != "kv_log_level")
-        {
-            fprintf(
-                stderr, "Allowed properties: kv_memory_limit, kv_allocate_blocks,"
-                " kv_evict_max_misses, kv_evict_attempts_per_level, kv_evict_unused_age, kv_log_level\n"
-            );
-        }
-        else
-        {
-            cfg[key] = value;
-            db->set_config(cfg);
-        }
-        cb();
-    }
-    else if (opname == "get" || opname == "set" || opname == "del")
-    {
-        if (opname == "get" || opname == "del")
-        {
-            if (pos == std::string::npos)
-            {
-                fprintf(stderr, "Usage: %s <key>\n", opname.c_str());
-                cb();
-                return;
-            }
-            auto key = trim(cmd.substr(pos+1));
-            if (opname == "get")
-            {
-                db->get(key, [this, cb](int res, const std::string & value)
-                {
-                    if (res < 0)
-                        fprintf(stderr, "Error: %s (code %d)\n", strerror(-res), res);
-                    else
-                    {
-                        write(1, value.c_str(), value.size());
-                        write(1, "\n", 1);
-                    }
-                    cb();
-                });
-            }
-            else
-            {
-                db->del(key, [this, cb](int res)
-                {
-                    if (res < 0)
-                        fprintf(stderr, "Error: %s (code %d)\n", strerror(-res), res);
-                    else
-                        printf("OK\n");
-                    cb();
-                });
-            }
-        }
-        else
-        {
-            auto pos2 = cmd.find_first_of(" \t", pos+1);
-            if (pos2 == std::string::npos)
-            {
-                fprintf(stderr, "Usage: set <key> <value>\n");
-                cb();
-                return;
-            }
-            auto key = trim(cmd.substr(pos+1, pos2-pos-1));
-            auto value = trim(cmd.substr(pos2+1));
-            db->set(key, value, [this, cb](int res)
-            {
-                if (res < 0)
-                    fprintf(stderr, "Error: %s (code %d)\n", strerror(-res), res);
-                else
-                    printf("OK\n");
-                cb();
-            });
-        }
-    }
-    else if (opname == "list")
-    {
-        std::string start, end;
-        if (pos != std::string::npos)
-        {
-            auto pos2 = cmd.find_first_of(" \t", pos+1);
-            if (pos2 != std::string::npos)
-            {
-                start = trim(cmd.substr(pos+1, pos2-pos-1));
-                end = trim(cmd.substr(pos2+1));
-            }
-            else
-            {
-                start = trim(cmd.substr(pos+1));
-            }
-        }
-        void *handle = db->list_start(start);
-        db->list_next(handle, [=](int res, const std::string & key, const std::string & value)
-        {
-            if (res < 0)
-            {
-                if (res != -ENOENT)
-                {
-                    fprintf(stderr, "Error: %s (code %d)\n", strerror(-res), res);
-                }
-                db->list_close(handle);
-                cb();
-            }
-            else
-            {
-                printf("%s = %s\n", key.c_str(), value.c_str());
-                db->list_next(handle, NULL);
-            }
-        });
-    }
-    else if (opname == "close")
-    {
-        db->close([=]()
-        {
-            printf("Index closed\n");
-            cb();
-        });
-    }
-    else if (opname == "quit" || opname == "q")
-    {
-        ::close(0);
-        finished = true;
-    }
-    else
-    {
-        fprintf(
-            stderr, "Unknown operation: %s. Supported operations:\n"
-            "open <pool_id> <inode_id> [block_size]\n"
-            "config <property> <value>\n"
-            "get <key>\nset <key> <value>\ndel <key>\nlist [<start> [end]]\n"
-            "close\nquit\n", opname.c_str()
-        );
-        cb();
-    }
-}
-
-int main(int narg, const char *args[])
-{
-    setvbuf(stdout, NULL, _IONBF, 0);
-    setvbuf(stderr, NULL, _IONBF, 0);
-    exe_name = args[0];
-    kv_cli_t *p = new kv_cli_t();
-    p->run(kv_cli_t::parse_args(narg, args));
-    delete p;
-    return 0;
-}

src/kv_db.h

@@ -1,36 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 (see README.md for details)
-//
-// Vitastor shared key/value database
-// Parallel optimistic B-Tree O:-)
-
-#pragma once
-
-#include "cluster_client.h"
-
-struct kv_db_t;
-
-struct kv_dbw_t
-{
-    kv_dbw_t(cluster_client_t *cli);
-    ~kv_dbw_t();
-
-    void open(inode_t inode_id, json11::Json cfg, std::function<void(int)> cb);
-    void set_config(json11::Json cfg);
-    void close(std::function<void()> cb);
-
-    uint64_t get_size();
-
-    void get(const std::string & key, std::function<void(int res, const std::string & value)> cb,
-        bool allow_old_cached = false);
-    void set(const std::string & key, const std::string & value, std::function<void(int res)> cb,
-        std::function<bool(int res, const std::string & value)> cas_compare = NULL);
-    void del(const std::string & key, std::function<void(int res)> cb,
-        std::function<bool(int res, const std::string & value)> cas_compare = NULL);
-
-    void* list_start(const std::string & start);
-    void list_next(void *handle, std::function<void(int res, const std::string & key, const std::string & value)> cb);
-    void list_close(void *handle);
-
-    kv_db_t *db;
-};

src/kv_stress.cpp

@@ -1,697 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 (see README.md for details)
-//
-// Vitastor shared key/value database stress tester / benchmark
-
-#define _XOPEN_SOURCE
-#include <limits.h>
-
-#include <netinet/tcp.h>
-#include <sys/epoll.h>
-#include <unistd.h>
-#include <fcntl.h>
-//#include <signal.h>
-
-#include "epoll_manager.h"
-#include "str_util.h"
-#include "kv_db.h"
-
-const char *exe_name = NULL;
-
-struct kv_test_listing_t
-{
-    uint64_t count = 0, done = 0;
-    void *handle = NULL;
-    std::string next_after;
-    std::set<std::string> inflights;
-    timespec tv_begin;
-    bool error = false;
-};
-
-struct kv_test_lat_t
-{
-    const char *name = NULL;
-    uint64_t usec = 0, count = 0;
-};
-
-struct kv_test_stat_t
-{
-    kv_test_lat_t get, add, update, del, list;
-    uint64_t list_keys = 0;
-};
-
-class kv_test_t
-{
-public:
-    // Config
-    json11::Json::object kv_cfg;
-    std::string key_prefix, key_suffix;
-    uint64_t inode_id = 0;
-    uint64_t op_count = 1000000;
-    uint64_t runtime_sec = 0;
-    uint64_t parallelism = 4;
-    uint64_t reopen_prob = 1;
-    uint64_t get_prob = 30000;
-    uint64_t add_prob = 20000;
-    uint64_t update_prob = 20000;
-    uint64_t del_prob = 5000;
-    uint64_t list_prob = 300;
-    uint64_t min_key_len = 10;
-    uint64_t max_key_len = 70;
-    uint64_t min_value_len = 50;
-    uint64_t max_value_len = 300;
-    uint64_t min_list_count = 10;
-    uint64_t max_list_count = 1000;
-    uint64_t print_stats_interval = 1;
-    bool json_output = false;
-    uint64_t log_level = 1;
-    bool trace = false;
-    bool stop_on_error = false;
-    // FIXME: Multiple clients
-    kv_test_stat_t stat, prev_stat;
-    timespec prev_stat_time, start_stat_time;
-
-    // State
-    kv_dbw_t *db = NULL;
-    ring_loop_t *ringloop = NULL;
-    epoll_manager_t *epmgr = NULL;
-    cluster_client_t *cli = NULL;
-    ring_consumer_t consumer;
-    bool finished = false;
-    uint64_t total_prob = 0;
-    uint64_t ops_sent = 0, ops_done = 0;
-    int stat_timer_id = -1;
-    int in_progress = 0;
-    bool reopening = false;
-    std::set<kv_test_listing_t*> listings;
-    std::set<std::string> changing_keys;
-    std::map<std::string, std::string> values;
-
-    ~kv_test_t();
-
-    static json11::Json::object parse_args(int narg, const char *args[]);
-    void parse_config(json11::Json cfg);
-    void run(json11::Json cfg);
-    void loop();
-    void print_stats(kv_test_stat_t & prev_stat, timespec & prev_stat_time);
-    void print_total_stats();
-    void start_change(const std::string & key);
-    void stop_change(const std::string & key);
-    void add_stat(kv_test_lat_t & stat, timespec tv_begin);
-};
-
-kv_test_t::~kv_test_t()
-{
-    if (db)
-        delete db;
-    if (cli)
-    {
-        cli->flush();
-        delete cli;
-    }
-    if (epmgr)
-        delete epmgr;
-    if (ringloop)
-        delete ringloop;
-}
-
-json11::Json::object kv_test_t::parse_args(int narg, const char *args[])
-{
-    json11::Json::object cfg;
-    for (int i = 1; i < narg; i++)
-    {
-        if (!strcmp(args[i], "-h") || !strcmp(args[i], "--help"))
-        {
-            printf(
-                "Vitastor Key/Value DB stress tester / benchmark\n"
-                "(c) Vitaliy Filippov, 2023+ (VNPL-1.1)\n"
-                "\n"
-                "USAGE: %s --pool_id POOL_ID --inode_id INODE_ID [OPTIONS]\n"
-                "  --op_count 1000000\n"
-                "    Total operations to run during test. 0 means unlimited\n"
-                "  --key_prefix \"\"\n"
-                "    Prefix for all keys read or written (to avoid collisions)\n"
-                "  --key_suffix \"\"\n"
-                "    Suffix for all keys read or written (to avoid collisions, but scan all DB)\n"
-                "  --runtime 0\n"
-                "    Run for this number of seconds. 0 means unlimited\n"
-                "  --parallelism 4\n"
-                "    Run this number of operations in parallel\n"
-                "  --get_prob 30000\n"
-                "    Fraction of key retrieve operations\n"
-                "  --add_prob 20000\n"
-                "    Fraction of key addition operations\n"
-                "  --update_prob 20000\n"
-                "    Fraction of key update operations\n"
-                "  --del_prob 30000\n"
-                "    Fraction of key delete operations\n"
-                "  --list_prob 300\n"
-                "    Fraction of listing operations\n"
-                "  --min_key_len 10\n"
-                "    Minimum key size in bytes\n"
-                "  --max_key_len 70\n"
-                "    Maximum key size in bytes\n"
-                "  --min_value_len 50\n"
-                "    Minimum value size in bytes\n"
-                "  --max_value_len 300\n"
-                "    Maximum value size in bytes\n"
-                "  --min_list_count 10\n"
-                "    Minimum number of keys read in listing (0 = all keys)\n"
-                "  --max_list_count 1000\n"
-                "    Maximum number of keys read in listing\n"
-                "  --print_stats 1\n"
-                "    Print operation statistics every this number of seconds\n"
-                "  --json\n"
-                "    JSON output\n"
-                "  --stop_on_error 0\n"
-                "    Stop on first execution error, mismatch, lost key or extra key during listing\n"
-                "  --kv_memory_limit 128M\n"
-                "    Maximum memory to use for vitastor-kv index cache\n"
-                "  --kv_allocate_blocks 4\n"
-                "    Number of PG blocks used for new tree block allocation in parallel\n"
-                "  --kv_evict_max_misses 10\n"
-                "    Eviction algorithm parameter: retry eviction from another random spot\n"
-                "    if this number of keys is used currently or was used recently\n"
-                "  --kv_evict_attempts_per_level 3\n"
-                "    Retry eviction at most this number of times per tree level, starting\n"
-                "    with bottom-most levels\n"
-                "  --kv_evict_unused_age 1000\n"
-                "    Evict only keys unused during this number of last operations\n"
-                "  --kv_log_level 1\n"
-                "    Log level. 0 = errors, 1 = warnings, 10 = trace operations\n",
-                exe_name
-            );
-            exit(0);
-        }
-        else if (args[i][0] == '-' && args[i][1] == '-')
-        {
-            const char *opt = args[i]+2;
-            cfg[opt] = !strcmp(opt, "json") || i == narg-1 ? "1" : args[++i];
-        }
-    }
-    return cfg;
-}
-
-void kv_test_t::parse_config(json11::Json cfg)
-{
-    inode_id = INODE_WITH_POOL(cfg["pool_id"].uint64_value(), cfg["inode_id"].uint64_value());
-    if (cfg["op_count"].uint64_value() > 0)
-        op_count = cfg["op_count"].uint64_value();
-    key_prefix = cfg["key_prefix"].string_value();
-    key_suffix = cfg["key_suffix"].string_value();
-    if (cfg["runtime"].uint64_value() > 0)
-        runtime_sec = cfg["runtime"].uint64_value();
-    if (cfg["parallelism"].uint64_value() > 0)
-        parallelism = cfg["parallelism"].uint64_value();
-    if (!cfg["reopen_prob"].is_null())
-        reopen_prob = cfg["reopen_prob"].uint64_value();
-    if (!cfg["get_prob"].is_null())
-        get_prob = cfg["get_prob"].uint64_value();
-    if (!cfg["add_prob"].is_null())
-        add_prob = cfg["add_prob"].uint64_value();
-    if (!cfg["update_prob"].is_null())
-        update_prob = cfg["update_prob"].uint64_value();
-    if (!cfg["del_prob"].is_null())
-        del_prob = cfg["del_prob"].uint64_value();
-    if (!cfg["list_prob"].is_null())
-        list_prob = cfg["list_prob"].uint64_value();
-    if (!cfg["min_key_len"].is_null())
-        min_key_len = cfg["min_key_len"].uint64_value();
-    if (cfg["max_key_len"].uint64_value() > 0)
-        max_key_len = cfg["max_key_len"].uint64_value();
-    if (!cfg["min_value_len"].is_null())
-        min_value_len = cfg["min_value_len"].uint64_value();
-    if (cfg["max_value_len"].uint64_value() > 0)
-        max_value_len = cfg["max_value_len"].uint64_value();
-    if (!cfg["min_list_count"].is_null())
-        min_list_count = cfg["min_list_count"].uint64_value();
-    if (!cfg["max_list_count"].is_null())
-        max_list_count = cfg["max_list_count"].uint64_value();
-    if (!cfg["print_stats"].is_null())
-        print_stats_interval = cfg["print_stats"].uint64_value();
-    if (!cfg["json"].is_null())
-        json_output = true;
-    if (!cfg["stop_on_error"].is_null())
-        stop_on_error = cfg["stop_on_error"].bool_value();
-    if (!cfg["kv_memory_limit"].is_null())
-        kv_cfg["kv_memory_limit"] = cfg["kv_memory_limit"];
-    if (!cfg["kv_allocate_blocks"].is_null())
-        kv_cfg["kv_allocate_blocks"] = cfg["kv_allocate_blocks"];
-    if (!cfg["kv_evict_max_misses"].is_null())
-        kv_cfg["kv_evict_max_misses"] = cfg["kv_evict_max_misses"];
-    if (!cfg["kv_evict_attempts_per_level"].is_null())
-        kv_cfg["kv_evict_attempts_per_level"] = cfg["kv_evict_attempts_per_level"];
-    if (!cfg["kv_evict_unused_age"].is_null())
-        kv_cfg["kv_evict_unused_age"] = cfg["kv_evict_unused_age"];
-    if (!cfg["kv_log_level"].is_null())
-    {
-        log_level = cfg["kv_log_level"].uint64_value();
-        trace = log_level >= 10;
-        kv_cfg["kv_log_level"] = cfg["kv_log_level"];
-    }
-    total_prob = reopen_prob+get_prob+add_prob+update_prob+del_prob+list_prob;
-    stat.get.name = "get";
-    stat.add.name = "add";
-    stat.update.name = "update";
-    stat.del.name = "del";
-    stat.list.name = "list";
-}
-
-void kv_test_t::run(json11::Json cfg)
-{
-    srand48(time(NULL));
-    parse_config(cfg);
-    // Create client
-    ringloop = new ring_loop_t(512);
-    epmgr = new epoll_manager_t(ringloop);
-    cli = new cluster_client_t(ringloop, epmgr->tfd, cfg);
-    db = new kv_dbw_t(cli);
-    // Load image metadata
-    while (!cli->is_ready())
-    {
-        ringloop->loop();
-        if (cli->is_ready())
-            break;
-        ringloop->wait();
-    }
-    // Run
-    reopening = true;
-    db->open(inode_id, kv_cfg, [this](int res)
-    {
-        reopening = false;
-        if (res < 0)
-        {
-            fprintf(stderr, "ERROR: Open index: %d (%s)\n", res, strerror(-res));
-            exit(1);
-        }
-        if (trace)
-            printf("Index opened\n");
-        ringloop->wakeup();
-    });
-    consumer.loop = [this]() { loop(); };
-    ringloop->register_consumer(&consumer);
-    if (print_stats_interval)
-        stat_timer_id = epmgr->tfd->set_timer(print_stats_interval*1000, true, [this](int) { print_stats(prev_stat, prev_stat_time); });
-    clock_gettime(CLOCK_REALTIME, &start_stat_time);
-    prev_stat_time = start_stat_time;
-    while (!finished)
-    {
-        ringloop->loop();
-        if (!finished)
-            ringloop->wait();
-    }
-    if (stat_timer_id >= 0)
-        epmgr->tfd->clear_timer(stat_timer_id);
-    ringloop->unregister_consumer(&consumer);
-    // Print total stats
-    print_total_stats();
-    // Destroy the client
-    delete db;
-    db = NULL;
-    cli->flush();
-    delete cli;
-    delete epmgr;
-    delete ringloop;
-    cli = NULL;
-    epmgr = NULL;
-    ringloop = NULL;
-}
-
-static const char *base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@+/";
-
-std::string random_str(int len)
-{
-    std::string str;
-    str.resize(len);
-    for (int i = 0; i < len; i++)
-    {
-        str[i] = base64_chars[lrand48() % 64];
-    }
-    return str;
-}
-
-void kv_test_t::loop()
-{
-    if (reopening)
-    {
-        return;
-    }
-    if (ops_done >= op_count)
-    {
-        finished = true;
-    }
-    while (!finished && ops_sent < op_count && in_progress < parallelism)
-    {
-        uint64_t dice = (lrand48() % total_prob);
-        if (dice < reopen_prob)
-        {
-            reopening = true;
-            db->close([this]()
-            {
-                if (trace)
-                    printf("Index closed\n");
-                db->open(inode_id, kv_cfg, [this](int res)
-                {
-                    reopening = false;
-                    if (res < 0)
-                    {
-                        fprintf(stderr, "ERROR: Reopen index: %d (%s)\n", res, strerror(-res));
-                        finished = true;
-                        return;
-                    }
-                    if (trace)
-                        printf("Index reopened\n");
-                    ringloop->wakeup();
-                });
-            });
-            return;
-        }
-        else if (dice < reopen_prob+get_prob)
-        {
-            // get existing
-            auto key = random_str(max_key_len);
-            auto k_it = values.lower_bound(key);
-            if (k_it == values.end())
-                continue;
-            key = k_it->first;
-            if (changing_keys.find(key) != changing_keys.end())
-                continue;
-            in_progress++;
-            ops_sent++;
-            if (trace)
-                printf("get %s\n", key.c_str());
-            timespec tv_begin;
-            clock_gettime(CLOCK_REALTIME, &tv_begin);
-            db->get(key, [this, key, tv_begin](int res, const std::string & value)
-            {
-                add_stat(stat.get, tv_begin);
-                ops_done++;
-                in_progress--;
-                auto it = values.find(key);
-                if (res != (it == values.end() ? -ENOENT : 0))
-                {
-                    fprintf(stderr, "ERROR: get %s: %d (%s)\n", key.c_str(), res, strerror(-res));
-                    if (stop_on_error)
-                        exit(1);
-                }
-                else if (it != values.end() && value != it->second)
-                {
-                    fprintf(stderr, "ERROR: get %s: mismatch: %s vs %s\n", key.c_str(), value.c_str(), it->second.c_str());
-                    if (stop_on_error)
-                        exit(1);
-                }
-                ringloop->wakeup();
-            });
-        }
-        else if (dice < reopen_prob+get_prob+add_prob+update_prob)
-        {
-            bool is_add = false;
-            std::string key;
-            if (dice < reopen_prob+get_prob+add_prob)
-            {
-                // add
-                is_add = true;
-                uint64_t key_len = min_key_len + (max_key_len > min_key_len ? lrand48() % (max_key_len-min_key_len) : 0);
-                key = key_prefix + random_str(key_len) + key_suffix;
-            }
-            else
-            {
-                // update
-                key = random_str(max_key_len);
-                auto k_it = values.lower_bound(key);
-                if (k_it == values.end())
-                    continue;
-                key = k_it->first;
-            }
-            if (changing_keys.find(key) != changing_keys.end())
-                continue;
-            uint64_t value_len = min_value_len + (max_value_len > min_value_len ? lrand48() % (max_value_len-min_value_len) : 0);
-            auto value = random_str(value_len);
-            start_change(key);
-            ops_sent++;
-            in_progress++;
-            if (trace)
-                printf("set %s = %s\n", key.c_str(), value.c_str());
-            timespec tv_begin;
-            clock_gettime(CLOCK_REALTIME, &tv_begin);
-            db->set(key, value, [this, key, value, tv_begin, is_add](int res)
-            {
-                add_stat(is_add ? stat.add : stat.update, tv_begin);
-                stop_change(key);
-                ops_done++;
-                in_progress--;
-                if (res != 0)
-                {
-                    fprintf(stderr, "ERROR: set %s = %s: %d (%s)\n", key.c_str(), value.c_str(), res, strerror(-res));
-                    if (stop_on_error)
-                        exit(1);
-                }
-                else
-                {
-                    values[key] = value;
-                }
-                ringloop->wakeup();
-            }, NULL);
-        }
-        else if (dice < reopen_prob+get_prob+add_prob+update_prob+del_prob)
-        {
-            // delete
-            auto key = random_str(max_key_len);
-            auto k_it = values.lower_bound(key);
-            if (k_it == values.end())
-                continue;
-            key = k_it->first;
-            if (changing_keys.find(key) != changing_keys.end())
-                continue;
-            start_change(key);
-            ops_sent++;
-            in_progress++;
-            if (trace)
-                printf("del %s\n", key.c_str());
-            timespec tv_begin;
-            clock_gettime(CLOCK_REALTIME, &tv_begin);
-            db->del(key, [this, key, tv_begin](int res)
-            {
-                add_stat(stat.del, tv_begin);
-                stop_change(key);
-                ops_done++;
-                in_progress--;
-                if (res != 0)
-                {
-                    fprintf(stderr, "ERROR: del %s: %d (%s)\n", key.c_str(), res, strerror(-res));
-                    if (stop_on_error)
-                        exit(1);
-                }
-                else
-                {
-                    values.erase(key);
-                }
-                ringloop->wakeup();
-            }, NULL);
-        }
-        else if (dice < reopen_prob+get_prob+add_prob+update_prob+del_prob+list_prob)
-        {
-            // list
-            ops_sent++;
-            in_progress++;
-            auto key = random_str(max_key_len);
-            auto lst = new kv_test_listing_t;
-            auto k_it = values.lower_bound(key);
-            lst->count = min_list_count + (max_list_count > min_list_count ? lrand48() % (max_list_count-min_list_count) : 0);
-            lst->handle = db->list_start(k_it == values.begin() ? key_prefix : key);
-            lst->next_after = k_it == values.begin() ? key_prefix : key;
-            lst->inflights = changing_keys;
-            listings.insert(lst);
-            if (trace)
-                printf("list from %s\n", key.c_str());
-            clock_gettime(CLOCK_REALTIME, &lst->tv_begin);
-            db->list_next(lst->handle, [this, lst](int res, const std::string & key, const std::string & value)
-            {
-                if (log_level >= 11)
-                    printf("list: %s = %s\n", key.c_str(), value.c_str());
-                if (res >= 0 && key_prefix.size() && (key.size() < key_prefix.size() ||
-                    key.substr(0, key_prefix.size()) != key_prefix))
-                {
-                    // stop at this key
-                    res = -ENOENT;
-                }
-                if (res < 0 || (lst->count > 0 && lst->done >= lst->count))
-                {
-                    add_stat(stat.list, lst->tv_begin);
-                    if (res == 0)
-                    {
-                        // ok (done >= count)
-                    }
-                    else if (res != -ENOENT)
-                    {
-                        fprintf(stderr, "ERROR: list: %d (%s)\n", res, strerror(-res));
-                        lst->error = true;
-                    }
-                    else
-                    {
-                        auto k_it = lst->next_after == "" ? values.begin() : values.upper_bound(lst->next_after);
-                        while (k_it != values.end())
-                        {
-                            while (k_it != values.end() && lst->inflights.find(k_it->first) != lst->inflights.end())
-                                k_it++;
-                            if (k_it != values.end())
-                            {
-                                fprintf(stderr, "ERROR: list: missing key %s\n", (k_it++)->first.c_str());
-                                lst->error = true;
-                            }
-                        }
-                    }
-                    if (lst->error && stop_on_error)
-                        exit(1);
-                    ops_done++;
-                    in_progress--;
-                    db->list_close(lst->handle);
-                    delete lst;
-                    listings.erase(lst);
-                    ringloop->wakeup();
-                }
-                else
-                {
-                    stat.list_keys++;
-                    // Do not check modified keys in listing
-                    // Listing may return their old or new state
-                    if ((!key_suffix.size() || key.size() >= key_suffix.size() &&
-                        key.substr(key.size()-key_suffix.size()) == key_suffix) &&
-                        lst->inflights.find(key) == lst->inflights.end())
-                    {
-                        lst->done++;
-                        auto k_it = lst->next_after == "" ? values.begin() : values.upper_bound(lst->next_after);
-                        while (true)
-                        {
-                            while (k_it != values.end() && lst->inflights.find(k_it->first) != lst->inflights.end())
-                            {
-                                k_it++;
-                            }
-                            if (k_it == values.end() || k_it->first > key)
-                            {
-                                fprintf(stderr, "ERROR: list: extra key %s\n", key.c_str());
-                                lst->error = true;
-                                break;
-                            }
-                            else if (k_it->first < key)
-                            {
-                                fprintf(stderr, "ERROR: list: missing key %s\n", k_it->first.c_str());
-                                lst->error = true;
-                                lst->next_after = k_it->first;
-                                k_it++;
-                            }
-                            else
-                            {
-                                if (k_it->second != value)
-                                {
-                                    fprintf(stderr, "ERROR: list: mismatch: %s = %s but should be %s\n",
-                                        key.c_str(), value.c_str(), k_it->second.c_str());
-                                    lst->error = true;
-                                }
-                                lst->next_after = k_it->first;
-                                break;
-                            }
-                        }
-                    }
-                    db->list_next(lst->handle, NULL);
-                }
-            });
-        }
-    }
-}
-
-void kv_test_t::add_stat(kv_test_lat_t & stat, timespec tv_begin)
-{
-    timespec tv_end;
-    clock_gettime(CLOCK_REALTIME, &tv_end);
-    int64_t usec = (tv_end.tv_sec - tv_begin.tv_sec)*1000000 +
-        (tv_end.tv_nsec - tv_begin.tv_nsec)/1000;
-    if (usec > 0)
-    {
-        stat.usec += usec;
-        stat.count++;
-    }
-}
-
-void kv_test_t::print_stats(kv_test_stat_t & prev_stat, timespec & prev_stat_time)
-{
-    timespec cur_stat_time;
-    clock_gettime(CLOCK_REALTIME, &cur_stat_time);
-    int64_t usec = (cur_stat_time.tv_sec - prev_stat_time.tv_sec)*1000000 +
-        (cur_stat_time.tv_nsec - prev_stat_time.tv_nsec)/1000;
-    if (usec > 0)
-    {
-        kv_test_lat_t *lats[] = { &stat.get, &stat.add, &stat.update, &stat.del, &stat.list };
-        kv_test_lat_t *prev[] = { &prev_stat.get, &prev_stat.add, &prev_stat.update, &prev_stat.del, &prev_stat.list };
-        if (!json_output)
-        {
-            char buf[128] = { 0 };
-            for (int i = 0; i < sizeof(lats)/sizeof(lats[0]); i++)
-            {
-                snprintf(buf, sizeof(buf)-1, "%.1f %s/s (%lu us)", (lats[i]->count-prev[i]->count)*1000000.0/usec,
-                    lats[i]->name, (lats[i]->usec-prev[i]->usec)/(lats[i]->count-prev[i]->count > 0 ? lats[i]->count-prev[i]->count : 1));
-                int k;
-                for (k = strlen(buf); k < strlen(lats[i]->name)+21; k++)
-                    buf[k] = ' ';
-                buf[k] = 0;
-                printf("%s", buf);
-            }
-            printf("\n");
-        }
-        else
-        {
-            int64_t runtime = (cur_stat_time.tv_sec - start_stat_time.tv_sec)*1000000 +
-                (cur_stat_time.tv_nsec - start_stat_time.tv_nsec)/1000;
-            printf("{\"runtime\":%.1f", (double)runtime/1000000.0);
-            for (int i = 0; i < sizeof(lats)/sizeof(lats[0]); i++)
-            {
-                if (lats[i]->count > prev[i]->count)
-                {
-                    printf(
-                        ",\"%s\":{\"avg\":{\"iops\":%.1f,\"usec\":%lu},\"total\":{\"count\":%lu,\"usec\":%lu}}",
-                        lats[i]->name, (lats[i]->count-prev[i]->count)*1000000.0/usec,
-                        (lats[i]->usec-prev[i]->usec)/(lats[i]->count-prev[i]->count),
-                        lats[i]->count, lats[i]->usec
-                    );
-                }
-            }
-            printf("}\n");
-        }
-    }
-    prev_stat = stat;
-    prev_stat_time = cur_stat_time;
-}
-
-void kv_test_t::print_total_stats()
-{
-    if (!json_output)
-        printf("Total:\n");
-    kv_test_stat_t start_stats;
-    timespec start_stat_time = this->start_stat_time;
-    print_stats(start_stats, start_stat_time);
-}
-
-void kv_test_t::start_change(const std::string & key)
-{
-    changing_keys.insert(key);
-    for (auto lst: listings)
-    {
-        lst->inflights.insert(key);
-    }
-}
-
-void kv_test_t::stop_change(const std::string & key)
-{
-    changing_keys.erase(key);
-}
-
-int main(int narg, const char *args[])
-{
-    setvbuf(stdout, NULL, _IONBF, 0);
-    setvbuf(stderr, NULL, _IONBF, 0);
-    exe_name = args[0];
-    kv_test_t *p = new kv_test_t();
-    p->run(kv_test_t::parse_args(narg, args));
-    delete p;
-    return 0;
-}

src/nbd_proxy.cpp

@@ -30,7 +30,7 @@ protected:
     std::string image_name;
     uint64_t inode = 0;
     uint64_t device_size = 0;
-    int nbd_timeout = 30;
+    int nbd_timeout = 300;
     int nbd_max_devices = 64;
     int nbd_max_part = 3;
     inode_watch_t *watch = NULL;
@@ -135,14 +135,16 @@ public:
             "  %s unmap /dev/nbd0\n"
             "  %s ls [--json]\n"
             "OPTIONS:\n"
-            "  All usual Vitastor config options like --etcd_address <etcd_address> plus NBD-specific:\n"
-            "  --nbd_timeout 30\n"
+            "  All usual Vitastor config options like --config_file <path_to_config> plus NBD-specific:\n"
+            "  --nbd_timeout 300\n"
             "    Timeout for I/O operations in seconds after exceeding which the kernel stops\n"
             "    the device. You can set it to 0 to disable the timeout, but beware that you\n"
             "    won't be able to stop the device at all if vitastor-nbd process dies.\n"
             "  --nbd_max_devices 64 --nbd_max_part 3\n"
             "    Options for the \"nbd\" kernel module when modprobing it (nbds_max and max_part).\n"
             "    note that maximum allowed (nbds_max)*(1+max_part) is 256.\n"
+            "    Note that nbd_timeout, nbd_max_devices and nbd_max_part options may also be specified\n"
+            "    in /etc/vitastor/vitastor.conf or in other configuration file specified with --config_file.\n"
             "  --logfile /path/to/log/file.txt\n"
             "    Wite log messages to the specified file instead of dropping them (in background mode)\n"
             "    or printing them to the standard output (in foreground mode).\n"
@@ -204,17 +206,18 @@ public:
                 exit(1);
             }
         }
-        if (cfg["nbd_max_devices"].is_number() || cfg["nbd_max_devices"].is_string())
+        auto file_config = osd_messenger_t::read_config(cfg);
+        if (file_config["nbd_max_devices"].is_number() || file_config["nbd_max_devices"].is_string())
         {
-            nbd_max_devices = cfg["nbd_max_devices"].uint64_value();
+            nbd_max_devices = file_config["nbd_max_devices"].uint64_value();
         }
-        if (cfg["nbd_max_part"].is_number() || cfg["nbd_max_part"].is_string())
+        if (file_config["nbd_max_part"].is_number() || file_config["nbd_max_part"].is_string())
         {
-            nbd_max_part = cfg["nbd_max_part"].uint64_value();
+            nbd_max_part = file_config["nbd_max_part"].uint64_value();
         }
-        if (cfg["nbd_timeout"].is_number() || cfg["nbd_timeout"].is_string())
+        if (file_config["nbd_timeout"].is_number() || file_config["nbd_timeout"].is_string())
         {
-            nbd_timeout = cfg["nbd_timeout"].uint64_value();
+            nbd_timeout = file_config["nbd_timeout"].uint64_value();
         }
         if (cfg["client_writeback_allowed"].is_null())
         {
@@ -272,7 +275,7 @@ public:
             int i = 0;
             while (true)
             {
-                int r = run_nbd(sockfd, i, device_size, NBD_FLAG_SEND_FLUSH, 30, bg);
+                int r = run_nbd(sockfd, i, device_size, NBD_FLAG_SEND_FLUSH, nbd_timeout, bg);
                 if (r == 0)
                 {
                     printf("/dev/nbd%d\n", i);

src/nfs_proxy.cpp

@@ -56,7 +56,7 @@ json11::Json::object nfs_proxy_t::parse_args(int narg, const char *args[])
                 "(c) Vitaliy Filippov, 2021-2022 (VNPL-1.1)\n"
                 "\n"
                 "USAGE:\n"
-                "  %s [--etcd_address ADDR] [OTHER OPTIONS]\n"
+                "  %s [STANDARD OPTIONS] [OTHER OPTIONS]\n"
                 "  --subdir <DIR>    export images prefixed <DIR>/ (default empty - export all images)\n"
                 "  --portmap 0       do not listen on port 111 (portmap/rpcbind, requires root)\n"
                 "  --bind <IP>       bind service to <IP> address (default 0.0.0.0)\n"

src/osd.cpp

@@ -68,14 +68,21 @@ osd_t::osd_t(const json11::Json & config, ring_loop_t *ringloop)
         }
     }
 
-    print_stats_timer_id = this->tfd->set_timer(print_stats_interval*1000, true, [this](int timer_id)
+    if (print_stats_timer_id == -1)
     {
-        print_stats();
-    });
-    slow_log_timer_id = this->tfd->set_timer(slow_log_interval*1000, true, [this](int timer_id)
+        print_stats_timer_id = this->tfd->set_timer(print_stats_interval*1000, true, [this](int timer_id)
+        {
+            print_stats();
+        });
+    }
+    if (slow_log_timer_id == -1)
     {
-        print_slow();
-    });
+        slow_log_timer_id = this->tfd->set_timer(slow_log_interval*1000, true, [this](int timer_id)
+        {
+            print_slow();
+        });
+    }
+    apply_recovery_tune_interval();
 
     msgr.tfd = this->tfd;
     msgr.ringloop = this->ringloop;
@@ -97,6 +104,11 @@ osd_t::~osd_t()
         tfd->clear_timer(slow_log_timer_id);
         slow_log_timer_id = -1;
     }
+    if (rtune_timer_id >= 0)
+    {
+        tfd->clear_timer(rtune_timer_id);
+        rtune_timer_id = -1;
+    }
     if (print_stats_timer_id >= 0)
     {
         tfd->clear_timer(print_stats_timer_id);
@@ -196,6 +208,22 @@ void osd_t::parse_config(bool init)
     recovery_queue_depth = config["recovery_queue_depth"].uint64_value();
     if (recovery_queue_depth < 1 || recovery_queue_depth > MAX_RECOVERY_QUEUE)
         recovery_queue_depth = DEFAULT_RECOVERY_QUEUE;
+    recovery_sleep_us = config["recovery_sleep_us"].uint64_value();
+    recovery_tune_min_util = config["recovery_tune_min_util"].is_null()
+        ? 0.1 : config["recovery_tune_min_util"].number_value();
+    recovery_tune_max_util = config["recovery_tune_max_util"].is_null()
+        ? 1.0 : config["recovery_tune_max_util"].number_value();
+    recovery_tune_min_client_util = config["recovery_tune_min_client_util"].is_null()
+        ? 0 : config["recovery_tune_min_client_util"].number_value();
+    recovery_tune_max_client_util = config["recovery_tune_max_client_util"].is_null()
+        ? 0.5 : config["recovery_tune_max_client_util"].number_value();
+    auto old_recovery_tune_interval = recovery_tune_interval;
+    recovery_tune_interval = config["recovery_tune_interval"].is_null()
+        ? 1 : config["recovery_tune_interval"].uint64_value();
+    recovery_tune_ewma_rate = config["recovery_tune_ewma_rate"].is_null()
+        ? 0.5 : config["recovery_tune_ewma_rate"].number_value();
+    recovery_tune_sleep_min_us = config["recovery_tune_sleep_min_us"].is_null()
+        ? 10 : config["recovery_tune_sleep_min_us"].uint64_value();
     recovery_pg_switch = config["recovery_pg_switch"].uint64_value();
     if (recovery_pg_switch < 1)
         recovery_pg_switch = DEFAULT_RECOVERY_PG_SWITCH;
@@ -274,6 +302,10 @@ void osd_t::parse_config(bool init)
             print_slow();
         });
     }
+    if (old_recovery_tune_interval != recovery_tune_interval)
+    {
+        apply_recovery_tune_interval();
+    }
 }
 
 void osd_t::bind_socket()
@@ -421,14 +453,6 @@ void osd_t::exec_op(osd_op_t *cur_op)
     }
 }
 
-void osd_t::reset_stats()
-{
-    msgr.stats = {};
-    prev_stats = {};
-    memset(recovery_stat_count, 0, sizeof(recovery_stat_count));
-    memset(recovery_stat_bytes, 0, sizeof(recovery_stat_bytes));
-}
-
 void osd_t::print_stats()
 {
     for (int i = OSD_OP_MIN; i <= OSD_OP_MAX; i++)
@@ -466,19 +490,19 @@ void osd_t::print_stats()
     }
     for (int i = 0; i < 2; i++)
     {
-        if (recovery_stat_count[0][i] != recovery_stat_count[1][i])
+        if (recovery_stat[i].count > recovery_print_prev[i].count)
         {
-            uint64_t bw = (recovery_stat_bytes[0][i] - recovery_stat_bytes[1][i]) / print_stats_interval;
+            uint64_t bw = (recovery_stat[i].bytes - recovery_print_prev[i].bytes) / print_stats_interval;
             printf(
-                "[OSD %lu] %s recovery: %.1f op/s, B/W: %.2f %s\n", osd_num, recovery_stat_names[i],
-                (recovery_stat_count[0][i] - recovery_stat_count[1][i]) * 1.0 / print_stats_interval,
+                "[OSD %lu] %s recovery: %.1f op/s, B/W: %.2f %s, avg lat %ld us\n", osd_num, recovery_stat_names[i],
+                (recovery_stat[i].count - recovery_print_prev[i].count) * 1.0 / print_stats_interval,
                 (bw > 1024*1024*1024 ? bw/1024.0/1024/1024 : (bw > 1024*1024 ? bw/1024.0/1024 : bw/1024.0)),
-                (bw > 1024*1024*1024 ? "GB/s" : (bw > 1024*1024 ? "MB/s" : "KB/s"))
+                (bw > 1024*1024*1024 ? "GB/s" : (bw > 1024*1024 ? "MB/s" : "KB/s")),
+                (recovery_stat[i].usec - recovery_print_prev[i].usec) / (recovery_stat[i].count - recovery_print_prev[i].count)
             );
-            recovery_stat_count[1][i] = recovery_stat_count[0][i];
-            recovery_stat_bytes[1][i] = recovery_stat_bytes[0][i];
         }
     }
+    memcpy(recovery_print_prev, recovery_stat, sizeof(recovery_stat));
     if (corrupted_objects > 0)
     {
         printf("[OSD %lu] %lu object(s) corrupted\n", osd_num, corrupted_objects);

src/osd.h

@@ -34,7 +34,7 @@
 #define DEFAULT_AUTOSYNC_INTERVAL 5
 #define DEFAULT_AUTOSYNC_WRITES 128
 #define MAX_RECOVERY_QUEUE 2048
-#define DEFAULT_RECOVERY_QUEUE 4
+#define DEFAULT_RECOVERY_QUEUE 1
 #define DEFAULT_RECOVERY_PG_SWITCH 128
 #define DEFAULT_RECOVERY_BATCH 16
 
@@ -87,6 +87,11 @@ struct osd_chain_read_t
 
 struct osd_rmw_stripe_t;
 
+struct recovery_stat_t
+{
+    uint64_t count, usec, bytes;
+};
+
 class osd_t
 {
     // config
@@ -111,7 +116,15 @@ class osd_t
     int immediate_commit = IMMEDIATE_NONE;
     int autosync_interval = DEFAULT_AUTOSYNC_INTERVAL; // "emergency" sync every 5 seconds
     int autosync_writes = DEFAULT_AUTOSYNC_WRITES;
-    int recovery_queue_depth = DEFAULT_RECOVERY_QUEUE;
+    uint64_t recovery_queue_depth = 1;
+    uint64_t recovery_sleep_us = 0;
+    double recovery_tune_min_util = 0.1;
+    double recovery_tune_min_client_util = 0;
+    double recovery_tune_max_util = 1.0;
+    double recovery_tune_max_client_util = 0.5;
+    int recovery_tune_interval = 1;
+    double recovery_tune_ewma_rate = 0.5;
+    int recovery_tune_sleep_min_us = 10;
     int recovery_pg_switch = DEFAULT_RECOVERY_PG_SWITCH;
     int recovery_sync_batch = DEFAULT_RECOVERY_BATCH;
     int inode_vanish_time = 60;
@@ -189,8 +202,17 @@ class osd_t
     std::map<uint64_t, inode_stats_t> inode_stats;
     std::map<uint64_t, timespec> vanishing_inodes;
     const char* recovery_stat_names[2] = { "degraded", "misplaced" };
-    uint64_t recovery_stat_count[2][2] = {};
-    uint64_t recovery_stat_bytes[2][2] = {};
+    recovery_stat_t recovery_stat[2];
+    recovery_stat_t recovery_print_prev[2];
+
+    // recovery auto-tuning
+    int rtune_timer_id = -1;
+    uint64_t rtune_avg_lat = 0;
+    double rtune_client_util = 0, rtune_target_util = 1;
+    osd_op_stats_t rtune_prev_stats;
+    recovery_stat_t rtune_prev_recovery[2];
+    uint64_t recovery_target_queue_depth = 1;
+    uint64_t recovery_target_sleep_us = 0;
 
     // cluster connection
     void parse_config(bool init);
@@ -208,8 +230,9 @@ class osd_t
     void create_osd_state();
     void renew_lease(bool reload);
     void print_stats();
+    void tune_recovery();
+    void apply_recovery_tune_interval();
     void print_slow();
-    void reset_stats();
     json11::Json get_statistics();
     void report_statistics();
     void report_pg_state(pg_t & pg);
@@ -238,6 +261,7 @@ class osd_t
     bool submit_flush_op(pool_id_t pool_id, pg_num_t pg_num, pg_flush_batch_t *fb, bool rollback, osd_num_t peer_osd, int count, obj_ver_id *data);
     bool pick_next_recovery(osd_recovery_op_t &op);
     void submit_recovery_op(osd_recovery_op_t *op);
+    void finish_recovery_op(osd_recovery_op_t *op);
     bool continue_recovery();
     pg_osd_set_state_t* change_osd_set(pg_osd_set_state_t *st, pg_t *pg);
 

src/osd_cluster.cpp

@@ -213,12 +213,14 @@ json11::Json osd_t::get_statistics()
     st["subop_stats"] = subop_stats;
     st["recovery_stats"] = json11::Json::object {
         { recovery_stat_names[0], json11::Json::object {
-            { "count", recovery_stat_count[0][0] },
-            { "bytes", recovery_stat_bytes[0][0] },
+            { "count", recovery_stat[0].count },
+            { "bytes", recovery_stat[0].bytes },
+            { "usec", recovery_stat[0].usec },
         } },
         { recovery_stat_names[1], json11::Json::object {
-            { "count", recovery_stat_count[0][1] },
-            { "bytes", recovery_stat_bytes[0][1] },
+            { "count", recovery_stat[1].count },
+            { "bytes", recovery_stat[1].bytes },
+            { "usec", recovery_stat[1].usec },
         } },
     };
     return st;

src/osd_flush.cpp

@@ -325,30 +325,113 @@ void osd_t::submit_recovery_op(osd_recovery_op_t *op)
         {
             printf("Recovery operation done for %lx:%lx\n", op->oid.inode, op->oid.stripe);
         }
-        // CAREFUL! op = &recovery_ops[op->oid]. Don't access op->* after recovery_ops.erase()
-        op->osd_op = NULL;
-        recovery_ops.erase(op->oid);
-        delete osd_op;
-        if (immediate_commit != IMMEDIATE_ALL)
+        if (recovery_target_sleep_us)
         {
-            recovery_done++;
-            if (recovery_done >= recovery_sync_batch)
+            this->tfd->set_timer_us(recovery_target_sleep_us, false, [this, op](int timer_id)
             {
-                // Force sync every <recovery_sync_batch> operations
-                // This is required not to pile up an excessive amount of delete operations
-                autosync();
-                recovery_done = 0;
-            }
+                finish_recovery_op(op);
+            });
+        }
+        else
+        {
+            finish_recovery_op(op);
         }
-        continue_recovery();
     };
     exec_op(op->osd_op);
 }
 
+void osd_t::apply_recovery_tune_interval()
+{
+    if (rtune_timer_id >= 0)
+    {
+        tfd->clear_timer(rtune_timer_id);
+        rtune_timer_id = -1;
+    }
+    if (recovery_tune_interval != 0)
+    {
+        rtune_timer_id = this->tfd->set_timer(recovery_tune_interval*1000, true, [this](int timer_id)
+        {
+            tune_recovery();
+        });
+    }
+    else
+    {
+        recovery_target_queue_depth = recovery_queue_depth;
+        recovery_target_sleep_us = recovery_sleep_us;
+    }
+}
+
+void osd_t::finish_recovery_op(osd_recovery_op_t *op)
+{
+    // CAREFUL! op = &recovery_ops[op->oid]. Don't access op->* after recovery_ops.erase()
+    delete op->osd_op;
+    op->osd_op = NULL;
+    recovery_ops.erase(op->oid);
+    if (immediate_commit != IMMEDIATE_ALL)
+    {
+        recovery_done++;
+        if (recovery_done >= recovery_sync_batch)
+        {
+            // Force sync every <recovery_sync_batch> operations
+            // This is required not to pile up an excessive amount of delete operations
+            autosync();
+            recovery_done = 0;
+        }
+    }
+    continue_recovery();
+}
+
+void osd_t::tune_recovery()
+{
+    static int total_client_ops[] = { OSD_OP_READ, OSD_OP_WRITE, OSD_OP_SYNC, OSD_OP_DELETE };
+    uint64_t total_client_usec = 0;
+    for (int i = 0; i < sizeof(total_client_ops)/sizeof(total_client_ops[0]); i++)
+    {
+        total_client_usec += (msgr.stats.op_stat_sum[total_client_ops[i]] - rtune_prev_stats.op_stat_sum[total_client_ops[i]]);
+        rtune_prev_stats.op_stat_sum[total_client_ops[i]] = msgr.stats.op_stat_sum[total_client_ops[i]];
+    }
+    uint64_t total_recovery_usec = 0, recovery_count = 0;
+    total_recovery_usec += recovery_stat[0].usec-rtune_prev_recovery[0].usec;
+    total_recovery_usec += recovery_stat[1].usec-rtune_prev_recovery[1].usec;
+    recovery_count += recovery_stat[0].count-rtune_prev_recovery[0].count;
+    recovery_count += recovery_stat[1].count-rtune_prev_recovery[1].count;
+    memcpy(rtune_prev_recovery, recovery_stat, sizeof(recovery_stat));
+    if (recovery_count == 0)
+    {
+        return;
+    }
+    rtune_avg_lat = total_recovery_usec/recovery_count*recovery_tune_ewma_rate +
+        rtune_avg_lat*(1-recovery_tune_ewma_rate);
+    // client_util = count/interval * usec/1000000.0/count = usec/1000000.0/interval :-)
+    double client_util = total_client_usec/1000000.0/recovery_tune_interval;
+    rtune_client_util = rtune_client_util*(1-recovery_tune_ewma_rate) + client_util*recovery_tune_ewma_rate;
+    rtune_target_util = (rtune_client_util < recovery_tune_min_client_util
+        ? recovery_tune_max_util
+        : recovery_tune_min_util + (rtune_client_util >= recovery_tune_max_client_util
+            ? 0 : (recovery_tune_max_util-recovery_tune_min_util)*
+                (recovery_tune_max_client_util-rtune_client_util)/(recovery_tune_max_client_util-recovery_tune_min_client_util)
+        )
+    );
+    recovery_target_queue_depth = (int)rtune_target_util + (rtune_target_util < 1 || rtune_target_util-(int)rtune_target_util >= 0.1 ? 1 : 0);
+    // ideal_iops = 1s / real_latency
+    // ;; target_iops = target_util * ideal_iops
+    // => target_lat = target_queue * 1s / target_iops
+    // => target_lat = target_queue / target_util * real_latency
+    uint64_t target_lat = recovery_target_queue_depth/rtune_target_util * rtune_avg_lat;
+    recovery_target_sleep_us = target_lat > rtune_avg_lat+recovery_tune_sleep_min_us ? target_lat-rtune_avg_lat : 0;
+    if (log_level > 3)
+    {
+        printf(
+            "recovery tune: client util %.2f (ewma %.2f), target util %.2f -> queue %ld, lat %lu us, real %lu us, pause %lu us\n",
+            client_util, rtune_client_util, rtune_target_util, recovery_target_queue_depth, target_lat, rtune_avg_lat, recovery_target_sleep_us
+        );
+    }
+}
+
 // Just trigger write requests for degraded objects. They'll be recovered during writing
 bool osd_t::continue_recovery()
 {
-    while (recovery_ops.size() < recovery_queue_depth)
+    while (recovery_ops.size() < recovery_target_queue_depth)
     {
         osd_recovery_op_t op;
         if (pick_next_recovery(op))

src/osd_primary_subops.cpp

@@ -3,13 +3,15 @@
 
 #include "osd_primary.h"
 
+#define SELF_FD -1
+
 void osd_t::autosync()
 {
     if (immediate_commit != IMMEDIATE_ALL && !autosync_op)
     {
         autosync_op = new osd_op_t();
         autosync_op->op_type = OSD_OP_IN;
-        autosync_op->peer_fd = -1;
+        autosync_op->peer_fd = SELF_FD;
         autosync_op->req = (osd_any_op_t){
             .sync = {
                 .header = {
@@ -85,9 +87,13 @@ void osd_t::finish_op(osd_op_t *cur_op, int retval)
     cur_op->reply.hdr.id = cur_op->req.hdr.id;
     cur_op->reply.hdr.opcode = cur_op->req.hdr.opcode;
     cur_op->reply.hdr.retval = retval;
-    if (cur_op->peer_fd == -1)
+    if (cur_op->peer_fd == SELF_FD)
     {
-        msgr.measure_exec(cur_op);
+        // Do not include internal primary writes (recovery/rebalance) into client op statistics
+        if (cur_op->req.hdr.opcode != OSD_OP_WRITE)
+        {
+            msgr.measure_exec(cur_op);
+        }
         // Copy lambda to be unaffected by `delete op`
         std::function<void(osd_op_t*)>(cur_op->callback)(cur_op);
     }

src/osd_primary_write.cpp

@@ -292,16 +292,27 @@ resume_7:
     {
         {
             int recovery_type = op_data->object_state->state & (OBJ_DEGRADED|OBJ_INCOMPLETE) ? 0 : 1;
-            recovery_stat_count[0][recovery_type]++;
-            if (!recovery_stat_count[0][recovery_type])
+            recovery_stat[recovery_type].count++;
+            if (!recovery_stat[recovery_type].count) // wrapped
             {
-                recovery_stat_count[0][recovery_type]++;
-                recovery_stat_bytes[0][recovery_type] = 0;
+                memset(&recovery_print_prev[recovery_type], 0, sizeof(recovery_print_prev[recovery_type]));
+                memset(&rtune_prev_recovery[recovery_type], 0, sizeof(rtune_prev_recovery[recovery_type]));
+                memset(&recovery_stat[recovery_type], 0, sizeof(recovery_stat[recovery_type]));
+                recovery_stat[recovery_type].count++;
             }
             for (int role = 0; role < (op_data->scheme == POOL_SCHEME_REPLICATED ? 1 : pg.pg_size); role++)
             {
-                recovery_stat_bytes[0][recovery_type] += op_data->stripes[role].write_end - op_data->stripes[role].write_start;
+                recovery_stat[recovery_type].bytes += op_data->stripes[role].write_end - op_data->stripes[role].write_start;
             }
+            if (!cur_op->tv_end.tv_sec)
+            {
+                clock_gettime(CLOCK_REALTIME, &cur_op->tv_end);
+            }
+            uint64_t usec = (
+                (cur_op->tv_end.tv_sec - cur_op->tv_begin.tv_sec)*1000000 +
+                (cur_op->tv_end.tv_nsec - cur_op->tv_begin.tv_nsec)/1000
+            );
+            recovery_stat[recovery_type].usec += usec;
         }
         // Any kind of a non-clean object can have extra chunks, because we don't record objects
         // as degraded & misplaced or incomplete & misplaced at the same time. So try to remove extra chunks

src/qemu_driver.c

@@ -196,10 +196,11 @@ static void vitastor_parse_filename(const char *filename, QDict *options, Error
             !strcmp(name, "rdma-gid-index") ||
             !strcmp(name, "rdma-mtu"))
         {
-            unsigned long long num_val;
 #if QEMU_VERSION_MAJOR < 8 || QEMU_VERSION_MAJOR == 8 && QEMU_VERSION_MINOR < 1
+            unsigned long long num_val;
             if (parse_uint_full(value, &num_val, 0))
 #else
+            uint64_t num_val;
             if (parse_uint_full(value, 0, &num_val))
 #endif
             {

src/vitastor.pc.in

@@ -6,7 +6,7 @@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 
 Name: Vitastor
 Description: Vitastor client library
-Version: 1.2.0
+Version: 1.3.1
 Libs: -L${libdir} -lvitastor_client
 Cflags: -I${includedir}