Release 2.2.3

- Support Ubuntu 24.04 Noble
- Fix clients hanging on online PG count change with in-flight operations
- Fix volume_size_info in PVE VitastorPlugin
- Implement bdrv_refresh_filename for the QEMU driver
- Fix RDMA-CM broken in 2.2.0
- Fix possible "invalid %N$ use detected" OSD crashes
- Fix vitastor-nfs build without RDMA
- Fix docker build by adding the forgotten apt/preferences
- Fix libfio_blockstore.so
- Fix "trigger event loop automatically" API version check in the QEMU driver
- Add Content-Type header for prometheus metrics
- Add a patch for libvirt 11.5

.gitea/workflows/test.yml

@@ -144,6 +144,24 @@ jobs:
           echo ""
         done
 
+  test_change_pg_count_online:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: /root/vitastor/tests/test_change_pg_count_online.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
   test_change_pg_size:
     runs-on: ubuntu-latest
     needs: build
@@ -684,6 +702,24 @@ jobs:
           echo ""
         done
 
+  test_write_iothreads:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: TEST_NAME=iothreads GLOBAL_CONFIG=',"client_iothread_count":4' /root/vitastor/tests/test_write.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
   test_write_no_same:
     runs-on: ubuntu-latest
     needs: build
@@ -720,6 +756,24 @@ jobs:
           echo ""
         done
 
+  test_heal_local_read:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 10
+      run: TEST_NAME=local_read POOLCFG='"local_reads":"random",' /root/vitastor/tests/test_heal.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
   test_heal_ec:
     runs-on: ubuntu-latest
     needs: build

CMakeLists.txt

@@ -2,6 +2,6 @@ cmake_minimum_required(VERSION 2.8.12)
 
 project(vitastor)
 
-set(VITASTOR_VERSION "2.1.0")
+set(VITASTOR_VERSION "2.2.3")
 
 add_subdirectory(src)

csi/Makefile

@@ -1,4 +1,4 @@
-VITASTOR_VERSION ?= v2.1.0
+VITASTOR_VERSION ?= v2.2.3
 
 all: build push
 

csi/deploy/004-csi-nodeplugin.yaml

@@ -49,7 +49,7 @@ spec:
             capabilities:
               add: ["SYS_ADMIN"]
             allowPrivilegeEscalation: true
-          image: vitalif/vitastor-csi:v2.1.0
+          image: vitalif/vitastor-csi:v2.2.3
           args:
             - "--node=$(NODE_ID)"
             - "--endpoint=$(CSI_ENDPOINT)"

csi/deploy/007-csi-provisioner.yaml

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

csi/src/config.go

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

debian/build-vitastor-bookworm.sh

@@ -1,7 +1,4 @@
 #!/bin/bash
 
-cat < vitastor.Dockerfile > ../Dockerfile
-cd ..
-mkdir -p packages
-sudo podman build --build-arg DISTRO=debian --build-arg REL=bookworm -v `pwd`/packages:/root/packages -f Dockerfile .
-rm Dockerfile
+docker build --build-arg DISTRO=debian --build-arg REL=bookworm -t vitastor-buildenv:bookworm -f vitastor-buildenv.Dockerfile .
+docker run -i --rm -e REL=bookworm -v `dirname $0`/../:/root/vitastor vitastor-buildenv:bookworm /root/vitastor/debian/vitastor-build.sh

debian/build-vitastor-bullseye.sh

@@ -1,7 +1,4 @@
 #!/bin/bash
 
-cat < vitastor.Dockerfile > ../Dockerfile
-cd ..
-mkdir -p packages
-sudo podman build --build-arg DISTRO=debian --build-arg REL=bullseye -v `pwd`/packages:/root/packages -f Dockerfile .
-rm Dockerfile
+docker build --build-arg DISTRO=debian --build-arg REL=bullseye -t vitastor-buildenv:bullseye -f vitastor-buildenv.Dockerfile .
+docker run -i --rm -e REL=bullseye -v `dirname $0`/../:/root/vitastor vitastor-buildenv:bullseye /root/vitastor/debian/vitastor-build.sh

debian/build-vitastor-buster.sh

@@ -1,7 +1,4 @@
 #!/bin/bash
 
-cat < vitastor.Dockerfile > ../Dockerfile
-cd ..
-mkdir -p packages
-sudo podman build --build-arg DISTRO=debian --build-arg REL=buster -v `pwd`/packages:/root/packages -f Dockerfile .
-rm Dockerfile
+docker build --build-arg DISTRO=debian --build-arg REL=buster -t vitastor-buildenv:buster -f vitastor-buildenv.Dockerfile .
+docker run -i --rm -e REL=buster -v `dirname $0`/../:/root/vitastor vitastor-buildenv:buster /root/vitastor/debian/vitastor-build.sh

debian/build-vitastor-ubuntu-jammy.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
+# Ubuntu 22.04 Jammy Jellyfish
 
-cat < vitastor.Dockerfile > ../Dockerfile
-cd ..
-mkdir -p packages
-sudo podman build --build-arg DISTRO=ubuntu --build-arg REL=jammy -v `pwd`/packages:/root/packages -f Dockerfile .
-rm Dockerfile
+docker build --build-arg DISTRO=ubuntu --build-arg REL=jammy -t vitastor-buildenv:jammy -f vitastor-buildenv.Dockerfile .
+docker run -i --rm -e REL=jammy -v `dirname $0`/../:/root/vitastor vitastor-buildenv:jammy /root/vitastor/debian/vitastor-build.sh

debian/build-vitastor-ubuntu-noble.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# 24.04 Noble Numbat
+
+docker build --build-arg DISTRO=ubuntu --build-arg REL=noble -t vitastor-buildenv:noble -f vitastor-buildenv.Dockerfile .
+docker run -i --rm -e REL=noble -v `dirname $0`/../:/root/vitastor vitastor-buildenv:noble /root/vitastor/debian/vitastor-build.sh

debian/changelog

@@ -1,4 +1,4 @@
-vitastor (2.1.0-1) unstable; urgency=medium
+vitastor (2.2.3-1) unstable; urgency=medium
 
   * Bugfixes
 

debian/vitastor-build.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# To be ran inside buildenv docker
+
+set -e -x
+
+[ -e /usr/lib/x86_64-linux-gnu/pkgconfig/libisal.pc ] || cp /root/vitastor/debian/libisal.pc /usr/lib/x86_64-linux-gnu/pkgconfig
+
+mkdir -p /root/fio-build/
+cd /root/fio-build/
+rm -rf /root/fio-build/*
+dpkg-source -x /root/fio*.dsc
+
+FULLVER=`head -n1 /root/vitastor/debian/changelog | perl -pe 's/^.*\((.*?)\).*$/$1/'`
+VER=${FULLVER%%-*}
+rm -rf /root/vitastor-$VER
+mkdir /root/vitastor-$VER
+cd /root/vitastor
+cp -a $(ls | grep -v packages) /root/vitastor-$VER
+
+rm -rf /root/vitastor/packages/vitastor-$REL
+mkdir -p /root/vitastor/packages/vitastor-$REL
+mv /root/vitastor-$VER /root/vitastor/packages/vitastor-$REL/
+
+cd /root/vitastor/packages/vitastor-$REL/vitastor-$VER
+
+rm -rf fio
+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
+sh copy-fio-includes.sh
+rm fio
+mkdir -p a b debian/patches
+mv fio-copy b/fio
+diff -NaurpbB a b > debian/patches/fio-headers.patch || true
+echo fio-headers.patch >> debian/patches/series
+rm -rf a b
+
+echo "dep:fio=$FIO" > debian/fio_version
+
+cd /root/vitastor/packages/vitastor-$REL/vitastor-$VER
+mkdir mon/node_modules
+cd mon/node_modules
+curl -s https://git.yourcmc.ru/vitalif/antietcd/archive/master.tar.gz | tar -zx
+curl -s https://git.yourcmc.ru/vitalif/tinyraft/archive/master.tar.gz | tar -zx
+
+cd /root/vitastor/packages/vitastor-$REL
+tar --sort=name --mtime='2020-01-01' --owner=0 --group=0 --exclude=debian -cJf vitastor_$VER.orig.tar.xz vitastor-$VER
+cd vitastor-$VER
+DEBEMAIL="Vitaliy Filippov <vitalif@yourcmc.ru>" dch -D $REL -v "$FULLVER""$REL" "Rebuild for $REL"
+DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage --jobs=auto -sa
+rm -rf /root/vitastor/packages/vitastor-$REL/vitastor-*/
+
+# Why does ubuntu rename debug packages to *.ddeb?
+if ls *.ddeb >/dev/null; then
+    perl -i -pe 's/\.ddeb/.deb/' *.buildinfo *.changes
+    for i in *.ddeb; do
+        mv $i ${i%%.ddeb}.deb
+    done
+fi

debian/vitastor-buildenv.Dockerfile

@@ -0,0 +1,31 @@
+# Build environment for building Vitastor packages for Debian inside a container
+# cd ..
+# docker build --build-arg DISTRO=debian --build-arg REL=bullseye -f debian/vitastor.Dockerfile -t vitastor-buildenv:bullseye .
+# docker run --rm -e REL=bullseye -v ./:/root/vitastor /root/vitastor/debian/vitastor-build.sh
+
+ARG DISTRO=debian
+ARG REL=
+FROM $DISTRO:$REL
+ARG DISTRO=debian
+ARG REL=
+
+WORKDIR /root
+
+RUN set -e -x; \
+    if [ "$REL" = "buster" ]; then \
+        perl -i -pe 's/deb.debian.org/archive.debian.org/' /etc/apt/sources.list; \
+        apt-get update; \
+        apt-get -y install wget; \
+        wget https://vitastor.io/debian/pubkey.gpg -O /etc/apt/trusted.gpg.d/vitastor.gpg; \
+        echo "deb https://vitastor.io/debian $REL main" >> /etc/apt/sources.list; \
+    fi; \
+    grep '^deb ' /etc/apt/sources.list | perl -pe 's/^deb/deb-src/' >> /etc/apt/sources.list; \
+    perl -i -pe 's/Types: deb$/Types: deb deb-src/' /etc/apt/sources.list.d/*.sources || true; \
+    echo 'APT::Install-Recommends false;' >> /etc/apt/apt.conf; \
+    echo 'APT::Install-Suggests false;' >> /etc/apt/apt.conf
+
+RUN apt-get update && \
+    apt-get -y install fio liburing-dev libgoogle-perftools-dev devscripts libjerasure-dev cmake \
+        libibverbs-dev librdmacm-dev libisal-dev libnl-3-dev libnl-genl-3-dev curl nodejs npm node-nan node-bindings && \
+    apt-get -y build-dep fio && \
+    apt-get --download-only source fio

debian/vitastor.Dockerfile

@@ -1,65 +0,0 @@
-# Build Vitastor packages for Debian inside a container
-# cd ..; podman build --build-arg DISTRO=debian --build-arg REL=bullseye -v `pwd`/packages:/root/packages -f debian/vitastor.Dockerfile .
-
-ARG DISTRO=debian
-ARG REL=
-FROM $DISTRO:$REL
-ARG DISTRO=debian
-ARG REL=
-
-WORKDIR /root
-
-RUN set -e -x; \
-    if [ "$REL" = "buster" ]; then \
-        apt-get update; \
-        apt-get -y install wget; \
-        wget https://vitastor.io/debian/pubkey.gpg -O /etc/apt/trusted.gpg.d/vitastor.gpg; \
-        echo "deb https://vitastor.io/debian $REL main" >> /etc/apt/sources.list; \
-    fi; \
-    grep '^deb ' /etc/apt/sources.list | perl -pe 's/^deb/deb-src/' >> /etc/apt/sources.list; \
-    perl -i -pe 's/Types: deb$/Types: deb deb-src/' /etc/apt/sources.list.d/debian.sources || true; \
-    echo 'APT::Install-Recommends false;' >> /etc/apt/apt.conf; \
-    echo 'APT::Install-Suggests false;' >> /etc/apt/apt.conf
-
-RUN apt-get update && \
-    apt-get -y install fio liburing-dev libgoogle-perftools-dev devscripts libjerasure-dev cmake \
-        libibverbs-dev librdmacm-dev libisal-dev libnl-3-dev libnl-genl-3-dev curl nodejs npm node-nan node-bindings && \
-    apt-get -y build-dep fio && \
-    apt-get --download-only source fio
-
-ADD . /root/vitastor
-RUN set -e -x; \
-    [ -e /usr/lib/x86_64-linux-gnu/pkgconfig/libisal.pc ] || cp /root/vitastor/debian/libisal.pc /usr/lib/x86_64-linux-gnu/pkgconfig; \
-    mkdir -p /root/fio-build/; \
-    cd /root/fio-build/; \
-    rm -rf /root/fio-build/*; \
-    dpkg-source -x /root/fio*.dsc; \
-    mkdir -p /root/packages/vitastor-$REL; \
-    rm -rf /root/packages/vitastor-$REL/*; \
-    cd /root/packages/vitastor-$REL; \
-    FULLVER=$(head -n1 /root/vitastor/debian/changelog | perl -pe 's/^.*\((.*?)\).*$/$1/'); \
-    VER=${FULLVER%%-*}; \
-    cp -r /root/vitastor vitastor-$VER; \
-    cd vitastor-$VER; \
-    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; \
-    sh copy-fio-includes.sh; \
-    rm fio; \
-    mkdir -p a b debian/patches; \
-    mv fio-copy b/fio; \
-    diff -NaurpbB a b > debian/patches/fio-headers.patch || true; \
-    echo fio-headers.patch >> debian/patches/series; \
-    rm -rf a b; \
-    echo "dep:fio=$FIO" > debian/fio_version; \
-    cd /root/packages/vitastor-$REL/vitastor-$VER; \
-    mkdir mon/node_modules; \
-    cd mon/node_modules; \
-    curl -s https://git.yourcmc.ru/vitalif/antietcd/archive/master.tar.gz | tar -zx; \
-    curl -s https://git.yourcmc.ru/vitalif/tinyraft/archive/master.tar.gz | tar -zx; \
-    cd /root/packages/vitastor-$REL; \
-    tar --sort=name --mtime='2020-01-01' --owner=0 --group=0 --exclude=debian -cJf vitastor_$VER.orig.tar.xz vitastor-$VER; \
-    cd vitastor-$VER; \
-    DEBFULLNAME="Vitaliy Filippov <vitalif@yourcmc.ru>" dch -D $REL -v "$FULLVER""$REL" "Rebuild for $REL"; \
-    DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage --jobs=auto -sa; \
-    rm -rf /root/packages/vitastor-$REL/vitastor-*/

docker/Makefile

@@ -1,9 +1,9 @@
-VITASTOR_VERSION ?= v2.1.0
+VITASTOR_VERSION ?= v2.2.3
 
 all: build push
 
 build:
-	@docker build --rm -t vitalif/vitastor:$(VITASTOR_VERSION) .
+	@docker build --no-cache --rm -t vitalif/vitastor:$(VITASTOR_VERSION) .
 
 push:
 	@docker push vitalif/vitastor:$(VITASTOR_VERSION)

docker/etc/apt/preferences

@@ -0,0 +1,3 @@
+Package: *
+Pin: release n=bookworm-backports
+Pin-Priority: 500

docker/etc/apt/sources.list.d/vitastor.list

@@ -1 +1,2 @@
 deb http://vitastor.io/debian bookworm main
+deb http://http.debian.net/debian/ bookworm-backports main

docker/etc/vitastor/docker.conf

@@ -4,7 +4,7 @@
 #
 
 # Desired Vitastor version
-VITASTOR_VERSION=v2.1.0
+VITASTOR_VERSION=v2.2.3
 
 # Additional arguments for all containers
 # For example, you may want to specify a custom logging driver here

docs/config/client.en.md

@@ -24,6 +24,7 @@ affect their interaction with the cluster.
 - [nbd_max_devices](#nbd_max_devices)
 - [nbd_max_part](#nbd_max_part)
 - [osd_nearfull_ratio](#osd_nearfull_ratio)
+- [hostname](#hostname)
 
 ## client_iothread_count
 
@@ -215,3 +216,12 @@ just one OSD becomes 100 % full!
 However, unlike in Ceph, 100 % full Vitastor OSDs don't crash (in Ceph they're
 unable to start at all), so you'll be able to recover from "out of space" errors
 without destroying and recreating OSDs.
+
+## hostname
+
+- Type: string
+- Can be changed online: yes
+
+Clients use host name to find their distance to OSDs when [localized reads](pool.en.md#local_reads)
+are enabled. By default, standard [gethostname](https://man7.org/linux/man-pages/man2/gethostname.2.html)
+function is used to determine host name, but you can also override it with this parameter.

docs/config/client.ru.md

@@ -24,6 +24,7 @@
 - [nbd_max_devices](#nbd_max_devices)
 - [nbd_max_part](#nbd_max_part)
 - [osd_nearfull_ratio](#osd_nearfull_ratio)
+- [hostname](#hostname)
 
 ## client_iothread_count
 
@@ -219,3 +220,13 @@ RDMA и хотите повысить пиковую производитель
 заполненные на 100% OSD вообще не могут стартовать), так что вы сможете
 восстановить работу кластера после ошибок отсутствия свободного места
 без уничтожения и пересоздания OSD.
+
+## hostname
+
+- Тип: строка
+- Можно менять на лету: да
+
+Клиенты используют имя хоста для определения расстояния до OSD, когда включены
+[локальные чтения](pool.ru.md#local_reads). По умолчанию для определения имени
+хоста используется стандартная функция [gethostname](https://man7.org/linux/man-pages/man2/gethostname.2.html),
+но вы также можете задать имя хоста вручную данным параметром.

docs/config/network.en.md

@@ -34,6 +34,7 @@ between clients, OSDs and etcd.
 - [etcd_ws_keepalive_interval](#etcd_ws_keepalive_interval)
 - [etcd_min_reload_interval](#etcd_min_reload_interval)
 - [tcp_header_buffer_size](#tcp_header_buffer_size)
+- [min_zerocopy_send_size](#min_zerocopy_send_size)
 - [use_sync_send_recv](#use_sync_send_recv)
 
 ## osd_network
@@ -73,7 +74,7 @@ Consider `use_rdmacm` for such networks.
 ## use_rdmacm
 
 - Type: boolean
-- Default: true
+- Default: false
 
 Use an alternative implementation of RDMA through RDMA-CM (Connection
 Manager). Works with all RDMA networks: Infiniband, iWARP and
@@ -313,6 +314,34 @@ is received without an additional copy. You can try to play with this
 parameter and see how it affects random iops and linear bandwidth if you
 want.
 
+## min_zerocopy_send_size
+
+- Type: integer
+- Default: 32768
+
+OSDs and clients will attempt to use io_uring-based zero-copy TCP send
+for buffers larger than this number of bytes. Zero-copy send with io_uring is
+supported since Linux kernel version 6.1. Support is auto-detected and disabled
+automatically when not available. It can also be disabled explicitly by setting
+this parameter to a negative value.
+
+⚠️ Warning! Zero-copy send performance may vary greatly from CPU to CPU and from
+one kernel version to another. Generally, it tends to only make benefit with larger
+messages. With smaller messages (say, 4 KB), it may actually be slower. 32 KB is
+enough for almost all CPUs, but even smaller values are optimal for some of them.
+For example, 4 KB is OK for EPYC Milan/Genoa and 12 KB is OK for Xeon Ice Lake
+(but verify it yourself please).
+
+Verification instructions:
+1. Add `iommu=pt` into your Linux kernel command line and reboot.
+2. Upgrade your kernel. For example, it's very important to use 6.11+ with recent AMD EPYCs.
+3. Run some tests with the [send-zerocopy liburing example](https://github.com/axboe/liburing/blob/master/examples/send-zerocopy.c)
+   to find the minimal message size for which zero-copy is optimal.
+   Use `./send-zerocopy tcp -4 -R` at the server side and
+   `time ./send-zerocopy tcp -4 -b 0 -s BUFFER_SIZE -D SERVER_IP` at the client side with
+   `-z 0` (no zero-copy) and `-z 1` (zero-copy), and compare MB/s and used CPU time
+   (user+system).
+
 ## use_sync_send_recv
 
 - Type: boolean

docs/config/network.ru.md

@@ -34,6 +34,7 @@
 - [etcd_ws_keepalive_interval](#etcd_ws_keepalive_interval)
 - [etcd_min_reload_interval](#etcd_min_reload_interval)
 - [tcp_header_buffer_size](#tcp_header_buffer_size)
+- [min_zerocopy_send_size](#min_zerocopy_send_size)
 - [use_sync_send_recv](#use_sync_send_recv)
 
 ## osd_network
@@ -73,7 +74,7 @@ RDMA-устройства, но они не имеют соединения с
 ## use_rdmacm
 
 - Тип: булево (да/нет)
-- Значение по умолчанию: true
+- Значение по умолчанию: false
 
 Использовать альтернативную реализацию RDMA на основе RDMA-CM (Connection
 Manager). Работает со всеми типами RDMA-сетей: Infiniband, iWARP и
@@ -321,6 +322,34 @@ Vitastor содержат 128-байтные заголовки, за котор
 поменять этот параметр и посмотреть, как он влияет на производительность
 случайного и линейного доступа.
 
+## min_zerocopy_send_size
+
+- Тип: целое число
+- Значение по умолчанию: 32768
+
+OSD и клиенты будут пробовать использовать TCP-отправку без копирования (zero-copy) на
+основе io_uring для буферов, больших, чем это число байт. Отправка без копирования
+поддерживается в io_uring, начиная с версии ядра Linux 6.1. Наличие поддержки
+проверяется автоматически и zero-copy отключается, когда поддержки нет. Также
+её можно отключить явно, установив данный параметр в отрицательное значение.
+
+⚠️ Внимание! Производительность данной функции может сильно отличаться на разных
+процессорах и на разных версиях ядра Linux. В целом, zero-copy обычно быстрее с
+большими сообщениями, а с мелкими (например, 4 КБ) zero-copy может быть даже
+медленнее. 32 КБ достаточно почти для всех процессоров, но для каких-то можно
+использовать даже меньшие значения. Например, для EPYC Milan/Genoa подходит 4 КБ,
+а для Xeon Ice Lake - 12 КБ (но, пожалуйста, перепроверьте это сами).
+
+Инструкция по проверке:
+1. Добавьте `iommu=pt` в командную строку загрузки вашего ядра Linux и перезагрузитесь.
+2. Обновите ядро. Например, для AMD EPYC очень важно использовать версию 6.11+.
+3. Позапускайте тесты с помощью [send-zerocopy из примеров liburing](https://github.com/axboe/liburing/blob/master/examples/send-zerocopy.c),
+   чтобы найти минимальный размер сообщения, для которого zero-copy отправка оптимальна.
+   Запускайте `./send-zerocopy tcp -4 -R` на стороне сервера и
+   `time ./send-zerocopy tcp -4 -b 0 -s РАЗМЕР_БУФЕРА -D АДРЕС_СЕРВЕРА` на стороне клиента
+   с опцией `-z 0` (обычная отправка) и `-z 1` (отправка без копирования), и сравнивайте
+   скорость в МБ/с и занятое процессорное время (user+system).
+
 ## use_sync_send_recv
 
 - Тип: булево (да/нет)

docs/config/osd.en.md

@@ -63,6 +63,8 @@ with an OSD restart or, for some of them, even without restarting by updating co
 - [discard_on_start](#discard_on_start)
 - [min_discard_size](#min_discard_size)
 - [allow_net_split](#allow_net_split)
+- [enable_pg_locks](#enable_pg_locks)
+- [pg_lock_retry_interval_ms](#pg_lock_retry_interval_ms)
 
 ## bind_address
 
@@ -647,3 +649,20 @@ The downside is that it increases the probability of writing data into just pg_m
 OSDs during failover which can lead to PGs becoming incomplete after additional outages.
 
 The old behaviour in versions up to 2.0.0 was equal to enabled allow_net_split.
+
+## enable_pg_locks
+
+- Type: boolean
+
+Vitastor 2.2.0 introduces a new layer of split-brain prevention mechanism in
+addition to etcd: PG locks. They prevent split-brain even in abnormal theoretical cases
+when etcd is extremely laggy. As a new feature, by default, PG locks are only enabled
+for pools where they're required - pools with [localized reads](pool.en.md#local_reads).
+Use this parameter to enable or disable this function for all pools.
+
+## pg_lock_retry_interval_ms
+
+- Type: milliseconds
+- Default: 100
+
+Retry interval for failed PG lock attempts.

docs/config/osd.ru.md

@@ -64,6 +64,8 @@
 - [discard_on_start](#discard_on_start)
 - [min_discard_size](#min_discard_size)
 - [allow_net_split](#allow_net_split)
+- [enable_pg_locks](#enable_pg_locks)
+- [pg_lock_retry_interval_ms](#pg_lock_retry_interval_ms)
 
 ## bind_address
 
@@ -679,3 +681,21 @@ pg_minsize OSD во время переключений, что может по
 неполными (incomplete), если упадут ещё какие-то OSD.
 
 Старое поведение в версиях до 2.0.0 было идентично включённому allow_net_split.
+
+## enable_pg_locks
+
+- Тип: булево (да/нет)
+
+В Vitastor 2.2.0 появился новый слой защиты от сплитбрейна в дополнение к etcd -
+блокировки PG. Они гарантируют порядок даже в теоретических ненормальных случаях,
+когда etcd очень сильно тормозит. Так как функция новая, по умолчанию она включается
+только для пулов, в которых она необходима - а именно, в пулах с включёнными
+[локальными чтениями](pool.ru.md#local_reads). Ну а с помощью данного параметра
+можно включить блокировки PG для всех пулов.
+
+## pg_lock_retry_interval_ms
+
+- Тип: миллисекунды
+- Значение по умолчанию: 100
+
+Интервал повтора неудачных попыток блокировки PG.

docs/config/pool.en.md

@@ -34,6 +34,7 @@ Parameters:
 - [failure_domain](#failure_domain)
 - [level_placement](#level_placement)
 - [raw_placement](#raw_placement)
+- [local_reads](#local_reads)
 - [max_osd_combinations](#max_osd_combinations)
 - [block_size](#block_size)
 - [bitmap_granularity](#bitmap_granularity)
@@ -133,8 +134,8 @@ Pool name.
 ## scheme
 
 - Type: string
-- Required
 - One of: "replicated", "xor", "ec" or "jerasure"
+- Required
 
 Redundancy scheme used for data in this pool. "jerasure" is an alias for "ec",
 both use Reed-Solomon-Vandermonde codes based on ISA-L or jerasure libraries.
@@ -289,6 +290,30 @@ Examples:
 - EC 4+2 in 3 DC: `any, dc=1 host!=1, dc!=1, dc=3 host!=3, dc!=(1,3), dc=5 host!=5`
 - 1 replica in fixed DC + 2 in random DCs: `dc?=meow, dc!=1, dc!=(1,2)`
 
+## local_reads
+
+- Type: string
+- One of: "primary", "nearest" or "random"
+- Default: primary
+
+By default, Vitastor serves all read and write requests from the primary OSD of each PG.
+But it can also serve read requests for replicated pools from secondary OSDs in clean PGs
+(active or active+left_on_dead) which may be useful if you have OSDs with different network
+latency to the client - for example, if you have a cross-datacenter setup.
+
+If you set this parameter to "nearest", clients will try to read from the nearest OSD
+in the [Placement Tree](#placement-tree), i.e. from an OSD from the same host or datacenter.
+Distance to different OSDs will be calculated based on client hostname, determined
+automatically or set manually in the [hostname](client.en.md#hostname) parameter.
+
+If you set this parameter to "random", clients will try to distribute read requests over
+all available secondary OSDs. This mode is mainly useful for tests, but, probably, not
+really required in production setups.
+
+[PG locks](osd.en.md#enable_pg_locks) are required for local reads to function. However,
+PG locks are enabled automatically by default for pools with enabled local reads, so you
+don't have to enable them explicitly.
+
 ## max_osd_combinations
 
 - Type: integer
@@ -324,7 +349,8 @@ Read more about this parameter in [Cluster-Wide Disk Layout Parameters](layout-c
 
 ## immediate_commit
 
-- Type: string, one of "all", "small" and "none"
+- Type: string
+- One of: "all", "small" or "none"
 - Default: none
 
 Immediate commit setting for this pool. The value from /vitastor/config/global

docs/config/pool.ru.md

@@ -33,6 +33,7 @@
 - [failure_domain](#failure_domain)
 - [level_placement](#level_placement)
 - [raw_placement](#raw_placement)
+- [local_reads](#local_reads)
 - [max_osd_combinations](#max_osd_combinations)
 - [block_size](#block_size)
 - [bitmap_granularity](#bitmap_granularity)
@@ -133,8 +134,8 @@ OSD игнорируется и OSD не удаляется из распред
 ## scheme
 
 - Тип: строка
-- Обязательный
 - Возможные значения: "replicated", "xor", "ec" или "jerasure"
+- Обязательный
 
 Схема избыточности, используемая в данном пуле. "jerasure" - синоним для "ec",
 в обеих схемах используются коды Рида-Соломона-Вандермонда, реализованные на
@@ -287,6 +288,30 @@ meow недоступен".
 - EC 4+2 в 3 датацентрах: `any, dc=1 host!=1, dc!=1, dc=3 host!=3, dc!=(1,3), dc=5 host!=5`
 - 1 копия в фиксированном ДЦ + 2 в других ДЦ: `dc?=meow, dc!=1, dc!=(1,2)`
 
+## local_reads
+
+- Тип: строка
+- Возможные значения: "primary", "nearest" или "random"
+- По умолчанию: primary
+
+По умолчанию Vitastor обслуживает все запросы чтения и записи с первичного OSD каждой PG.
+Однако, в чистых PG (active или active+left_on_dead) реплицированных пулов также есть
+возможность обслуживать запросы чтения с вторичных OSD, что может быть полезно, если
+у вас сильно отличается время сетевого обращения от клиента к разным OSD - например,
+если у вас несколько дата-центров.
+
+Если данный параметр установлен в значение "nearest", клиенты будут стараться читать с
+ближайших по [Дереву размещения](#дерево-размещения) OSD, то есть, с OSD с того же хоста
+или датацентра. Расстояние до разных OSD будет рассчитываться с помощью имени хоста клиента,
+определяемого автоматически или заданного вручную параметром [hostname](client.ru.md#hostname).
+
+Если данный параметр установлен в значение "random", клиенты будут стараться распределять
+запросы чтения по всем доступным вторичным OSD. Этот режим в основном полезен для тестов,
+но, скорее всего, редко нужен в реальных инсталляциях.
+
+Для работы локальных чтений требуются [блокировки PG](osd.ru.md#enable_pg_locks). Включать
+их явно не нужно - они включаются автоматически для пулов с включёнными локальными чтениями.
+
 ## max_osd_combinations
 
 - Тип: целое число
@@ -324,7 +349,8 @@ meow недоступен".
 
 ## immediate_commit
 
-- Тип: строка "all", "small" или "none"
+- Тип: строка
+- Возможные значения: "all", "small" или "none"
 - По умолчанию: none
 
 Настройка мгновенного коммита для данного пула. Если не задана, используется

docs/config/src/client.yml

@@ -271,3 +271,15 @@
     заполненные на 100% OSD вообще не могут стартовать), так что вы сможете
     восстановить работу кластера после ошибок отсутствия свободного места
     без уничтожения и пересоздания OSD.
+- name: hostname
+  type: string
+  online: true
+  info: |
+    Clients use host name to find their distance to OSDs when [localized reads](pool.en.md#local_reads)
+    are enabled. By default, standard [gethostname](https://man7.org/linux/man-pages/man2/gethostname.2.html)
+    function is used to determine host name, but you can also override it with this parameter.
+  info_ru: |
+    Клиенты используют имя хоста для определения расстояния до OSD, когда включены
+    [локальные чтения](pool.ru.md#local_reads). По умолчанию для определения имени
+    хоста используется стандартная функция [gethostname](https://man7.org/linux/man-pages/man2/gethostname.2.html),
+    но вы также можете задать имя хоста вручную данным параметром.

docs/config/src/network.yml

@@ -51,7 +51,7 @@
     Рассмотрите включение `use_rdmacm` для таких сетей.
 - name: use_rdmacm
   type: bool
-  default: true
+  default: false
   info: |
     Use an alternative implementation of RDMA through RDMA-CM (Connection
     Manager). Works with all RDMA networks: Infiniband, iWARP and
@@ -373,6 +373,55 @@
     параметра читается без дополнительного копирования. Вы можете попробовать
     поменять этот параметр и посмотреть, как он влияет на производительность
     случайного и линейного доступа.
+- name: min_zerocopy_send_size
+  type: int
+  default: 32768
+  info: |
+    OSDs and clients will attempt to use io_uring-based zero-copy TCP send
+    for buffers larger than this number of bytes. Zero-copy send with io_uring is
+    supported since Linux kernel version 6.1. Support is auto-detected and disabled
+    automatically when not available. It can also be disabled explicitly by setting
+    this parameter to a negative value.
+
+    ⚠️ Warning! Zero-copy send performance may vary greatly from CPU to CPU and from
+    one kernel version to another. Generally, it tends to only make benefit with larger
+    messages. With smaller messages (say, 4 KB), it may actually be slower. 32 KB is
+    enough for almost all CPUs, but even smaller values are optimal for some of them.
+    For example, 4 KB is OK for EPYC Milan/Genoa and 12 KB is OK for Xeon Ice Lake
+    (but verify it yourself please).
+
+    Verification instructions:
+    1. Add `iommu=pt` into your Linux kernel command line and reboot.
+    2. Upgrade your kernel. For example, it's very important to use 6.11+ with recent AMD EPYCs.
+    3. Run some tests with the [send-zerocopy liburing example](https://github.com/axboe/liburing/blob/master/examples/send-zerocopy.c)
+       to find the minimal message size for which zero-copy is optimal.
+       Use `./send-zerocopy tcp -4 -R` at the server side and
+       `time ./send-zerocopy tcp -4 -b 0 -s BUFFER_SIZE -D SERVER_IP` at the client side with
+       `-z 0` (no zero-copy) and `-z 1` (zero-copy), and compare MB/s and used CPU time
+       (user+system).
+  info_ru: |
+    OSD и клиенты будут пробовать использовать TCP-отправку без копирования (zero-copy) на
+    основе io_uring для буферов, больших, чем это число байт. Отправка без копирования
+    поддерживается в io_uring, начиная с версии ядра Linux 6.1. Наличие поддержки
+    проверяется автоматически и zero-copy отключается, когда поддержки нет. Также
+    её можно отключить явно, установив данный параметр в отрицательное значение.
+
+    ⚠️ Внимание! Производительность данной функции может сильно отличаться на разных
+    процессорах и на разных версиях ядра Linux. В целом, zero-copy обычно быстрее с
+    большими сообщениями, а с мелкими (например, 4 КБ) zero-copy может быть даже
+    медленнее. 32 КБ достаточно почти для всех процессоров, но для каких-то можно
+    использовать даже меньшие значения. Например, для EPYC Milan/Genoa подходит 4 КБ,
+    а для Xeon Ice Lake - 12 КБ (но, пожалуйста, перепроверьте это сами).
+
+    Инструкция по проверке:
+    1. Добавьте `iommu=pt` в командную строку загрузки вашего ядра Linux и перезагрузитесь.
+    2. Обновите ядро. Например, для AMD EPYC очень важно использовать версию 6.11+.
+    3. Позапускайте тесты с помощью [send-zerocopy из примеров liburing](https://github.com/axboe/liburing/blob/master/examples/send-zerocopy.c),
+       чтобы найти минимальный размер сообщения, для которого zero-copy отправка оптимальна.
+       Запускайте `./send-zerocopy tcp -4 -R` на стороне сервера и
+       `time ./send-zerocopy tcp -4 -b 0 -s РАЗМЕР_БУФЕРА -D АДРЕС_СЕРВЕРА` на стороне клиента
+       с опцией `-z 0` (обычная отправка) и `-z 1` (отправка без копирования), и сравнивайте
+       скорость в МБ/с и занятое процессорное время (user+system).
 - name: use_sync_send_recv
   type: bool
   default: false

docs/config/src/osd.yml

@@ -781,3 +781,23 @@
     неполными (incomplete), если упадут ещё какие-то OSD.
 
     Старое поведение в версиях до 2.0.0 было идентично включённому allow_net_split.
+- name: enable_pg_locks
+  type: bool
+  info: |
+    Vitastor 2.2.0 introduces a new layer of split-brain prevention mechanism in
+    addition to etcd: PG locks. They prevent split-brain even in abnormal theoretical cases
+    when etcd is extremely laggy. As a new feature, by default, PG locks are only enabled
+    for pools where they're required - pools with [localized reads](pool.en.md#local_reads).
+    Use this parameter to enable or disable this function for all pools.
+  info_ru: |
+    В Vitastor 2.2.0 появился новый слой защиты от сплитбрейна в дополнение к etcd -
+    блокировки PG. Они гарантируют порядок даже в теоретических ненормальных случаях,
+    когда etcd очень сильно тормозит. Так как функция новая, по умолчанию она включается
+    только для пулов, в которых она необходима - а именно, в пулах с включёнными
+    [локальными чтениями](pool.ru.md#local_reads). Ну а с помощью данного параметра
+    можно включить блокировки PG для всех пулов.
+- name: pg_lock_retry_interval_ms
+  type: ms
+  default: 100
+  info: Retry interval for failed PG lock attempts.
+  info_ru: Интервал повтора неудачных попыток блокировки PG.

docs/installation/docker.en.md

@@ -26,9 +26,9 @@ at Vitastor Kubernetes operator: https://github.com/Antilles7227/vitastor-operat
 The instruction is very simple.
 
 1. Download a Docker image of the desired version: \
-   `docker pull vitastor:2.1.0`
+   `docker pull vitalif/vitastor:v2.2.3`
 2. Install scripts to the host system: \
-   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitastor:2.1.0 install.sh`
+   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v2.2.3 install.sh`
 3. Reload udev rules: \
    `udevadm control --reload-rules`
 

docs/installation/docker.ru.md

@@ -25,9 +25,9 @@ Vitastor можно установить в Docker/Podman. При этом etcd,
 Инструкция по установке максимально простая.
 
 1. Скачайте Docker-образ желаемой версии: \
-   `docker pull vitastor:2.1.0`
+   `docker pull vitalif/vitastor:v2.2.3`
 2. Установите скрипты в хост-систему командой: \
-   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitastor:2.1.0 install.sh`
+   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v2.2.3 install.sh`
 3. Перезагрузите правила udev: \
    `udevadm control --reload-rules`
 

docs/installation/packages.en.md

@@ -15,6 +15,7 @@
   - Debian 11 (Bullseye): `deb https://vitastor.io/debian bullseye main`
   - Debian 10 (Buster): `deb https://vitastor.io/debian buster main`
   - Ubuntu 22.04 (Jammy): `deb https://vitastor.io/debian jammy main`
+  - Ubuntu 24.04 (Noble): `deb https://vitastor.io/debian noble main`
   - Add `-oldstable` to bookworm/bullseye/buster in this line to install the last
     stable version from 0.9.x branch instead of 1.x
 - Install packages: `apt update; apt install vitastor lp-solve etcd linux-image-amd64 qemu-system-x86`

docs/installation/packages.ru.md

@@ -15,6 +15,7 @@
   - Debian 11 (Bullseye): `deb https://vitastor.io/debian bullseye main`
   - Debian 10 (Buster): `deb https://vitastor.io/debian buster main`
   - Ubuntu 22.04 (Jammy): `deb https://vitastor.io/debian jammy main`
+  - Ubuntu 24.04 (Noble): `deb https://vitastor.io/debian noble main`
   - Добавьте `-oldstable` к слову bookworm/bullseye/buster в этой строке, чтобы
     установить последнюю стабильную версию из ветки 0.9.x вместо 1.x
 - Установите пакеты: `apt update; apt install vitastor lp-solve etcd linux-image-amd64 qemu-system-x86`

docs/installation/proxmox.en.md

@@ -6,10 +6,10 @@
 
 # Proxmox VE
 
-To enable Vitastor support in Proxmox Virtual Environment (6.4-8.1 are supported):
+To enable Vitastor support in Proxmox Virtual Environment (6.4-8.x are supported):
 
 - Add the corresponding Vitastor Debian repository into sources.list on Proxmox hosts:
-  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
+  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.1):
+Чтобы подключить Vitastor к Proxmox Virtual Environment (поддерживаются версии 6.4-8.x):
 
 - Добавьте соответствующий Debian-репозиторий Vitastor в sources.list на хостах Proxmox:
-  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
+  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.en.md

@@ -125,6 +125,13 @@ All other client-side components are based on the client library:
   all current read/write operations to it fail with EPIPE error and are retried by clients.
 - After completing all secondary read/write requests, primary OSD sends the response to
   the client.
+- When [localized reads](../config/pool.en.md#local_reads) are enabled for a PG in a
+  replicated pool, and the PG is in an active and clean state (active or
+  active+left_on_dead), the client can send the request to one of secondary OSDs instead
+  of the primary. Secondary OSD checks the [PG lock](../config/osd.en.md#enable_pg_locks)
+  and handles the request locally without communicating to the primary. PG lock is required
+  for the secondary OSD to know for sure that the PG is in clean state and not switching
+  primary at the moment.
 
 ### Nuances of request handling
 

docs/intro/architecture.ru.md

@@ -125,6 +125,12 @@
   и если любое из этих соединений отключается, PG перезапускается, а все текущие запросы чтения
   и записи в неё завершаются с ошибкой EPIPE, после чего повторяются клиентами.
 - После завершения всех вторичных операций чтения/записи первичный OSD отправляет ответ клиенту.
+- Если в реплицированном пуле включены [локализованные чтения](../config/pool.ru.md#local_reads),
+  а PG находится в чистом активном состоянии (active или active+left_on_dead), клиент может
+  послать запрос к одному из вторичных OSD вместо первичного. Вторичный OSD проверяет
+  [блокировку PG](../config/osd.ru.md#enable_pg_locks) и обрабатывает запрос локально, не
+  обращаясь к первичному. Блокировка PG здесь нужна, чтобы вторичный OSD мог точно знать,
+  что PG находится в чистом состоянии и не переключается на другой первичный OSD.
 
 ### Особенности обработки запросов
 

docs/intro/author.en.md

@@ -10,8 +10,17 @@ Copyright (c) Vitaliy Filippov (vitalif [at] yourcmc.ru), 2019+
 
 Join Vitastor Telegram Chat: https://t.me/vitastor
 
-All server-side code (OSD, Monitor and so on) is licensed under the terms of
-Vitastor Network Public License 1.1 (VNPL 1.1), a copyleft license based on
+License: VNPL 1.1 for server-side code and dual VNPL 1.1 + GPL 2.0+ for client tools.
+
+Server-side code is licensed only under the terms of VNPL.
+
+Client libraries (cluster_client and so on) are dual-licensed under the same
+VNPL 1.1 and also GNU GPL 2.0 or later to allow for compatibility with GPLed
+software like QEMU and fio.
+
+## VNPL
+
+Vitastor Network Public License 1.1 (VNPL 1.1) is a copyleft license based on
 GNU GPLv3.0 with the additional "Network Interaction" clause which requires
 opensourcing all programs directly or indirectly interacting with Vitastor
 through a computer network and expressly designed to be used in conjunction
@@ -20,18 +29,83 @@ the terms of the same license, but also under the terms of any GPL-Compatible
 Free Software License, as listed by the Free Software Foundation.
 This is a stricter copyleft license than the Affero GPL.
 
-Please note that VNPL doesn't require you to open the code of proprietary
-software running inside a VM if it's not specially designed to be used with
-Vitastor.
+The idea of VNPL is, in addition to modules linked to Vitastor code in a single
+binary file, to extend copyleft action to micro-service modules only interacting
+with it over the network.
 
 Basically, you can't use the software in a proprietary environment to provide
 its functionality to users without opensourcing all intermediary components
 standing between the user and Vitastor or purchasing a commercial license
 from the author 😀.
 
-Client libraries (cluster_client and so on) are dual-licensed under the same
-VNPL 1.1 and also GNU GPL 2.0 or later to allow for compatibility with GPLed
-software like QEMU and fio.
+At the same time, VNPL doesn't impose any restrictions on software *not specially designed*
+to be used with Vitastor, for example, on Windows running inside a VM with a Vitastor disk.
 
-You can find the full text of VNPL-1.1 in the file [VNPL-1.1.txt](../../VNPL-1.1.txt).
-GPL 2.0 is also included in this repository as [GPL-2.0.txt](../../GPL-2.0.txt).
+## Explanation
+
+Network copyleft is governed by the clause **13. Remote Network Interaction** of VNPL.
+
+A program is considered to be a "Proxy Program" if it meets both conditions:
+- It is specially designed to be used with Vitastor. Basically, it means that the program
+  has any functionality specific to Vitastor and thus "knows" that it works with Vitastor,
+  not with something random.
+- It interacts with Vitastor directly or indirectly through any programming interface,
+  including API, CLI, network or any wrapper (also considered a Proxy Program itself).
+
+If, in addition to that:
+- You give any user an apportunity to interact with Vitastor directly or indirectly through
+  any computer interface including the network or any number of wrappers (Proxy Programs).
+
+Then VNPL requires you to publish the code of all above Proxy Programs to all above users
+under the terms of any GPL-compatible license - that is, GPL, LGPL, MIT/BSD or Apache 2,
+because "GPL compatibility" is treated as an ability to legally include licensed code in
+a GPL application.
+
+So, if you have a "Proxy Program", but it's not open to the user who directly or indirectly
+interacts with Vitastor - you are forbidden to use Vitastor under the terms of VNPL and you
+need a commercial license which doesn't contain open-source requirements.
+
+## Examples
+
+- Vitastor Kubernetes CSI driver which creates PersistentVolumes by calling `vitastor-cli create`.
+  - Yes, it interacts with Vitastor through vitastor-cli.
+  - Yes, it is designed specially for use with Vitastor (it has no sense otherwise).
+  - So, CSI driver **definitely IS** a Proxy Program and must be published under the terms of
+    a free software license.
+- Windows, installed in a VM with the system disk on Vitastor storage.
+  - Yes, it interacts with Vitastor indirectly - it reads and writes data through the block
+    device interface, emulated by QEMU.
+  - No, it definitely isn't designed specially for use with Vitastor - Windows was created long
+    ago before Vitastor and doesn't know anything about it.
+  - So, Windows **definitely IS NOT** a Proxy Program and VNPL doesn't require to open it.
+- Cloud control panel which makes requests to Vitastor Kubernetes CSI driver.
+  - Yes, it interacts with Vitastor indirectly through the CSI driver, which is a Proxy Program.
+  - May or may not be designed specially for use with Vitastor. How to determine exactly?
+    Imagine that Vitastor is replaced with any other storage (for example, with a proprietary).
+    Do control panel functions change in any way? If they do (for example, if snapshots stop working),
+    then the panel contains specific functionality and thus is designed specially for use with Vitastor.
+    Otherwise, the panel is universal and isn't designed specially for Vitastor.
+  - So, whether you are required to open-source the panel also **depends** on whether it
+    contains specific functionality or not.
+
+## Why?
+
+Because I believe into the spirit of copyleft (Linux wouldn't become so popular without GPL!)
+and, at the same time, I want to have a way to monetize the product.
+
+Existing licenses including AGPL are useless for it with an SDS - SDS is a very deeply
+internal software which is almost definitely invisible to the user and thus AGPL doesn't
+require anyone to open the code even if they make a proprietary fork.
+
+And, in fact, the current situation in the world where GPL is though to only restrict direct
+linking of programs into a single executable file, isn't much correct. Nowadays, programs
+are more often linked with network API calls, not with /usr/bin/ld, and a software product
+may consist of dozens of microservices interacting with each other over the network.
+
+That's why we need VNPL to keep the license sufficiently copyleft.
+
+## License Texts
+
+- VNPL 1.1 in English: [VNPL-1.1.txt](../../VNPL-1.1.txt)
+- VNPL 1.1 in Russian: [VNPL-1.1-RU.txt](../../VNPL-1.1-RU.txt)
+- GPL 2.0: [GPL-2.0.txt](../../GPL-2.0.txt)

docs/intro/author.ru.md

@@ -12,6 +12,14 @@
 
 Лицензия: VNPL 1.1 на серверный код и двойная VNPL 1.1 + GPL 2.0+ на клиентский.
 
+Серверные компоненты распространяются только на условиях VNPL.
+
+Клиентские библиотеки распространяются на условиях двойной лицензии VNPL 1.0
+и также на условиях GNU GPL 2.0 или более поздней версии. Так сделано в целях
+совместимости с таким ПО, как QEMU и fio.
+
+## VNPL
+
 VNPL - "сетевой копилефт", собственная свободная копилефт-лицензия
 Vitastor Network Public License 1.1, основанная на GNU GPL 3.0 с дополнительным
 условием "Сетевого взаимодействия", требующим распространять все программы,
@@ -29,9 +37,70 @@ Vitastor Network Public License 1.1, основанная на GNU GPL 3.0 с д
 На Windows и любое другое ПО, не разработанное *специально* для использования
 вместе с Vitastor, никакие ограничения не накладываются.
 
-Клиентские библиотеки распространяются на условиях двойной лицензии VNPL 1.0
-и также на условиях GNU GPL 2.0 или более поздней версии. Так сделано в целях
-совместимости с таким ПО, как QEMU и fio.
+## Пояснение
 
-Вы можете найти полный текст VNPL 1.1 на английском языке в файле [VNPL-1.1.txt](../../VNPL-1.1.txt),
-VNPL 1.1 на русском языке в файле [VNPL-1.1-RU.txt](../../VNPL-1.1-RU.txt), а GPL 2.0 в файле [GPL-2.0.txt](../../GPL-2.0.txt).
+Сетевой копилефт регулируется пунктом лицензии **13. Удалённое сетевое взаимодействие**.
+
+Программа считается "прокси-программой", если верны оба условия:
+- Она создана специально для работы вместе с Vitastor. По сути это означает, что программа
+  должна иметь специфичный для Vitastor функционал, то есть, "знать", что она взаимодействует
+  именно с Vitastor.
+- Она прямо или косвенно взаимодействует с Vitastor через абсолютно любой программный
+  интерфейс, включая любые способы вызова: API, CLI, сеть или через какую-то обёртку (в
+  свою очередь тоже являющуюся прокси-программой).
+
+Если в дополнение к этому также:
+- Вы предоставляете любому пользователю возможность взаимодействовать с Vitastor по сети,
+  опять-таки, через любой интерфейс или любую серию "обёрток" (прокси-программ)
+
+То, согласно VNPL, вы должны открыть код "прокси-программ" **таким пользователям** на условиях
+любой GPL-совместимой лицензии - то есть, GPL, LGPL, MIT/BSD или Apache 2 - "совместимость с GPL"
+понимается как возможность включать лицензируемый код в GPL-приложение.
+
+Соответственно, если у вас есть "прокси-программа", но её код не открыт пользователю,
+который прямо или косвенно взаимодействует с Vitastor - вам запрещено использовать Vitastor
+на условиях VNPL и вам нужна коммерческая лицензия, не содержащая требований об открытии кода.
+
+## Примеры
+
+- Kubernetes CSI-драйвер Vitastor, создающий PersistentVolume с помощью вызова `vitastor-cli create`.
+  - Да, взаимодействует с Vitastor через vitastor-cli.
+  - Да, создавался специально для работы с Vitastor (иначе в чём же ещё его смысл).
+  - Значит, CSI-драйвер **точно считается** "прокси-программой" и должен быть открыт под свободной
+    лицензией.
+- Windows, установленный в виртуальную машину на диске Vitastor.
+  - Да, взаимодействует с Vitastor "прямо или косвенно" - пишет и читает данные через интерфейс
+    блочного устройства, эмулируемый QEMU.
+  - Нет, точно не создан *специально для работы с Vitastor* - когда его создавали, никакого
+    Vitastor ещё и в помине не было.
+  - Значит, Windows **точно не считается** "прокси-программой" и на него требования VNPL не распространяются.
+- Панель управления облака, делающая запросы к Kubernetes CSI-драйверу Vitastor.
+  - Да, взаимодействует с Vitastor косвенно через CSI-драйвер, являющийся "прокси-программой".
+  - Сходу не известно, создавалась ли конкретно для работы с Vitastor. Как понять, да или нет?
+    Представьте, что Vitastor заменён на любую другую систему хранения (например, на проприетарную).
+    Работа панели управления изменится? Если да (например, перестанут работать снапшоты) - значит,
+    панель содержит специфичный функционал и "создана специально для работы с Vitastor".
+    Если нет - значит, специфичного функционала панель не содержит и в принципе она универсальна.
+  - Нужно ли открывать панель - **зависит** от того, содержит она специфичный функционал или нет.
+
+## Почему так?
+
+Потому что я одновременно верю в дух копилефт-лицензий (Linux не стал бы так популярен,
+если бы не GPL!) и хочу иметь возможность монетизации продукта.
+
+При этом использовать даже AGPL для программной СХД бессмысленно - это глубоко внутреннее
+ПО, которое пользователь почти наверняка не увидит вообще, поэтому и открывать код никому
+никогда не придётся, даже при создании производного продукта.
+
+Да и в целом сложившаяся в мире ситуация, при которой действие GPL ограничивается только
+прямым связыванием в один исполняемый файл, не очень корректна. В настоящее время программы
+гораздо чаще интегрируют сетевыми вызовами, а не с помощью /usr/bin/ld, и общий программный
+продукт может состоять из нескольких десятков микросервисов, взаимодействующих по сети.
+
+Поэтому для сохранения достаточной "копилефтности" и придумана VNPL.
+
+## Тексты лицензий
+
+- VNPL 1.1 на английском языке: [VNPL-1.1.txt](../../VNPL-1.1.txt)
+- VNPL 1.1 на русском языке: [VNPL-1.1-RU.txt](../../VNPL-1.1-RU.txt)
+- GPL 2.0: [GPL-2.0.txt](../../GPL-2.0.txt)

docs/intro/features.en.md

@@ -25,6 +25,7 @@
 - Recovery of degraded blocks
 - Rebalancing (data movement between OSDs)
 - [Lazy fsync support](../config/layout-cluster.en.md#immediate_commit)
+- [Localized read support](../config/pool.en.md#local_reads) for cross-datacenter setup optimization
 - Per-OSD and per-image I/O and space usage statistics in etcd
 - Snapshots and copy-on-write image clones
 - [Write throttling to smooth random write workloads in SSD+HDD configurations](../config/osd.en.md#throttle_small_writes)

docs/intro/features.ru.md

@@ -25,6 +25,7 @@
 - Восстановление деградированных блоков
 - Ребаланс, то есть перемещение данных между OSD (дисками)
 - [Поддержка "ленивого" fsync (fsync не на каждую операцию)](../config/layout-cluster.ru.md#immediate_commit)
+- [Локальные чтения](../config/pool.ru.md#local_reads) для оптимизации при нескольких датацентрах
 - Сбор статистики ввода/вывода в etcd
 - Статистика операций ввода/вывода и занятого места в разрезе инодов
 - Именование инодов через хранение их метаданных в etcd

docs/usage/admin.en.md

@@ -14,6 +14,7 @@
 - [Removing a failed disk](#removing-a-failed-disk)
 - [Adding a disk](#adding-a-disk)
 - [Restoring from lost pool configuration](#restoring-from-lost-pool-configuration)
+- [Incompatibility problems](#Incompatibility-problems)
 - [Upgrading Vitastor](#upgrading-vitastor)
 - [OSD memory usage](#osd-memory-usage)
 
@@ -166,6 +167,17 @@ done
 
 After that all PGs should peer and find all previous data.
 
+## Incompatibility problems
+
+### ISA-L 2.31
+
+⚠ It is FORBIDDEN to use Vitastor 2.1.0 and earlier versions with ISA-L 2.31 and newer if
+you use EC N+K pools and K > 1 on a CPU with GF-NI instruction support, because it WILL
+lead to **data loss** during EC recovery.
+
+If you accidentally upgraded ISA-L to 2.31 but didn't upgrade Vitastor and restarted OSDs,
+then stop them as soon as possible and either update Vitastor or roll back ISA-L.
+
 ## Upgrading Vitastor
 
 Every upcoming Vitastor version is usually compatible with previous both forward

docs/usage/admin.ru.md

@@ -14,6 +14,7 @@
 - [Удаление неисправного диска](#удаление-неисправного-диска)
 - [Добавление диска](#добавление-диска)
 - [Восстановление потерянной конфигурации пулов](#восстановление-потерянной-конфигурации-пулов)
+- [Проблемы несовместимости](#проблемы-несовместимости)
 - [Обновление Vitastor](#обновление-vitastor)
 - [Потребление памяти OSD](#потребление-памяти-osd)
 
@@ -163,6 +164,17 @@ done
 
 После этого все PG должны пройти peering и найти все предыдущие данные.
 
+## Проблемы несовместимости
+
+### ISA-L 2.31
+
+⚠ ЗАПРЕЩЕНО использовать Vitastor 2.1.0 и более ранних версий с библиотекой ISA-L версии 2.31
+или более новой, если вы используете EC-пулы N+K и K > 1 на CPU с поддержкой инструкций GF-NI,
+так как это приведёт к **потере данных** при восстановлении из EC.
+
+Если вы случайно обновили ISA-L до 2.31, но не обновили Vitastor, и успели перезапустить OSD,
+то как можно скорее остановите их все и либо обновите Vitastor, либо откатите ISA-L.
+
 ## Обновление Vitastor
 
 Обычно каждая следующая версия Vitastor совместима с предыдущими и "вперёд", и "назад"

docs/usage/cli.en.md

@@ -397,6 +397,7 @@ Optional parameters:
 | `--immediate_commit none`      | Put pool only on OSDs with this or larger immediate_commit (none < small < all) |
 | `--level_placement <rules>`    | Use additional failure domain rules (example: "dc=112233")                 |
 | `--raw_placement <rules>`      | Specify raw PG generation rules ([details](../config/pool.en.md#raw_placement)) |
+| `--local_reads primary`        | Local read policy for replicated pools: primary, nearest or random         |
 | `--primary_affinity_tags tags` | Prefer to put primary copies on OSDs with all specified tags               |
 | `--scrub_interval <time>`      | Enable regular scrubbing for this pool. Format: number + unit s/m/h/d/M/y  |
 | `--used_for_app fs:<name>`     | Mark pool as used for VitastorFS with metadata in image `<name>`           |

docs/usage/cli.ru.md

@@ -414,6 +414,7 @@ OSD  PARENT            UP    SIZE  USED%    TAGS          WEIGHT  BLOCK  BITMAP
 | `--immediate_commit none`      | ...только OSD с этим или большим immediate_commit (none < small < all)     |
 | `--level_placement <rules>`    | Задать правила дополнительных доменов отказа (пример: "dc=112233")         |
 | `--raw_placement <rules>`      | Задать низкоуровневые правила генерации PG ([детали](../config/pool.ru.md#raw_placement)) |
+| `--local_reads primary`        | Политика локальных чтений для реплик: primary, nearest или random          |
 | `--primary_affinity_tags tags` | Предпочитать OSD со всеми данными тегами для роли первичных                |
 | `--scrub_interval <time>`      | Включить скрабы с заданным интервалом времени (число + единица s/m/h/d/M/y) |
 | `--pg_stripe_size <number>`    | Увеличить блок группировки объектов по PG                                  |

docs/usage/nfs.en.md

@@ -14,6 +14,9 @@ Commands:
 - [upgrade](#upgrade)
 - [defrag](#defrag)
 
+⚠️ Important: follow the instructions from [Linux NFS write size](#linux-nfs-write-size)
+for optimal Vitastor NFS performance if you use EC and HDD and mount your NFS from Linux.
+
 ## Pseudo-FS
 
 Simplified pseudo-FS proxy is used for file-based image access emulation. It's not
@@ -100,6 +103,62 @@ Other notable missing features which should be addressed in the future:
   in the DB. The FS is implemented is such way that this garbage doesn't affect its
   function, but having a tool to clean it up still seems a right thing to do.
 
+## Linux NFS write size
+
+Linux NFS client (nfs/nfsv3/nfsv4 kernel modules) has a hard-coded maximum I/O size,
+currently set to 1 MB - see `rsize` and `wsize` in [man 5 nfs](https://linux.die.net/man/5/nfs).
+
+This means that when you write to a file in an FS mounted over NFS, the maximum write
+request size is 1 MB, even in the O_DIRECT mode and even if the original write request
+is larger.
+
+However, for optimal linear write performance in Vitastor EC (erasure-coded) pools,
+the size of write requests should be a multiple of [block_size](../config/layout-cluster.en.md#block_size),
+multiplied by the data chunk count of the pool ([pg_size](../config/pool.en.md#pg_size)-[parity_chunks](../config/pool.en.md#parity_chunks)).
+When write requests are smaller or not a multiple of this number, Vitastor has to first
+read paired data blocks from disks, calculate new parity blocks and only then write them
+back. Obviously this is 2-3 times slower than a simple disk write.
+
+Vitastor HDD setups use 1 MB block_size by default. So, for optimal performance, if
+you use EC 2+1 and HDD, you need your NFS client to send 2 MB write requests, if you
+use EC 4+1 - 4 MB and so on.
+
+But Linux NFS client only writes in 1 MB chunks. 😢
+
+The good news is that you can fix it by rebuilding Linux NFS kernel modules 😉 🤩!
+You need to change NFS_MAX_FILE_IO_SIZE in nfs_xdr.h and then rebuild and reload modules.
+
+The instruction, using Debian as an example (should be ran under root):
+
+```
+# download current Linux kernel headers required to build modules
+apt-get install linux-headers-`uname -r`
+
+# replace NFS_MAX_FILE_IO_SIZE with a desired number (here it's 4194304 - 4 MB)
+sed -i 's/NFS_MAX_FILE_IO_SIZE\s*.*/NFS_MAX_FILE_IO_SIZE\t(4194304U)/' /lib/modules/`uname -r`/source/include/linux/nfs_xdr.h
+
+# download current Linux kernel source
+mkdir linux_src
+cd linux_src
+apt-get source linux-image-`uname -r`-unsigned
+
+# build NFS modules
+cd linux-*/fs/nfs
+make -C /lib/modules/`uname -r`/build M=$PWD -j8 modules
+make -C /lib/modules/`uname -r`/build M=$PWD modules_install
+
+# move default NFS modules away
+mv /lib/modules/`uname -r`/kernel/fs/nfs ~/nfs_orig_`uname -r`
+depmod -a
+
+# unload old modules and load the new ones
+rmmod nfsv3 nfs
+modprobe nfsv3
+```
+
+After these (not much complicated 🙂) manipulations NFS begins to be mounted
+with new wsize and rsize by default and it fixes Vitastor-NFS linear write performance.
+
 ## Horizontal scaling
 
 Linux NFS 3.0 client doesn't support built-in scaling or failover, i.e. you can't

docs/usage/nfs.ru.md

@@ -14,6 +14,9 @@
 - [upgrade](#upgrade)
 - [defrag](#defrag)
 
+⚠️ Важно: для оптимальной производительности Vitastor NFS в Linux при использовании
+HDD и EC (erasure кодов) выполните инструкции из раздела [Размер записи Linux NFS](#размер-записи-linux-nfs).
+
 ## Псевдо-ФС
 
 Упрощённая реализация псевдо-ФС используется для эмуляции файлового доступа к блочным
@@ -104,6 +107,66 @@ JSON-формате :-). Для инспекции содержимого БД
   записи. ФС устроена так, что на работу они не влияют, но для порядка и их стоит
   уметь подчищать.
 
+## Размер записи Linux NFS
+
+Клиент Linux NFS (модули ядра nfs/nfsv3/nfsv4) имеет фиксированный в коде максимальный
+размер запроса ввода-вывода, равный 1 МБ - см. `rsize` и `wsize` в [man 5 nfs](https://linux.die.net/man/5/nfs).
+
+Это означает, что когда вы записываете в файл в примонтированной по NFS файловой системе,
+максимальный размер запроса записи составляет 1 МБ, даже в режиме O_DIRECT и даже если
+исходный запрос записи был больше.
+
+Однако для оптимальной скорости линейной записи в Vitastor при использовании EC-пулов
+(пулов с кодами коррекции ошибок) запросы записи должны быть по размеру кратны
+[block_size](../config/layout-cluster.ru.md#block_size), умноженному на число частей
+данных пула ([pg_size](../config/pool.ru.md#pg_size)-[parity_chunks](../config/pool.ru.md#parity_chunks)).
+Если запросы записи меньше или не кратны, то Vitastor приходится сначала прочитать
+с дисков старые версии парных блоков данных, рассчитать новые блоки чётности и только
+после этого записать их на диски. Естественно, это в 2-3 раза медленнее простой записи
+на диск.
+
+При этом block_size на жёстких дисках по умолчанию устанавливается равным 1 МБ.
+Таким образом, если вы используете EC 2+1 и HDD, для оптимальной скорости записи вам
+нужно, чтобы NFS-клиент писал по 2 МБ, если EC 4+1 и HDD - то по 4 МБ, и т.п.
+
+А Linux NFS-клиент пишет только по 1 МБ. 😢
+
+Но это можно исправить, пересобрав модули ядра Linux NFS 😉 🤩! Для этого нужно
+поменять значение переменной NFS_MAX_FILE_IO_SIZE в заголовочном файле nfs_xdr.h,
+после чего пересобрать модули NFS.
+
+Инструкция по пересборке на примере Debian (выполнять под root):
+
+```
+# скачиваем заголовки для сборки модулей для текущего ядра Linux
+apt-get install linux-headers-`uname -r`
+
+# заменяем в заголовках NFS_MAX_FILE_IO_SIZE на желаемый (здесь 4194304 - 4 МБ)
+sed -i 's/NFS_MAX_FILE_IO_SIZE\s*.*/NFS_MAX_FILE_IO_SIZE\t(4194304U)/' /lib/modules/`uname -r`/source/include/linux/nfs_xdr.h
+
+# скачиваем исходный код текущего ядра
+mkdir linux_src
+cd linux_src
+apt-get source linux-image-`uname -r`-unsigned
+
+# собираем модули NFS
+cd linux-*/fs/nfs
+make -C /lib/modules/`uname -r`/build M=$PWD -j8 modules
+make -C /lib/modules/`uname -r`/build M=$PWD modules_install
+
+# убираем в сторону штатные модули NFS
+mv /lib/modules/`uname -r`/kernel/fs/nfs ~/nfs_orig_`uname -r`
+depmod -a
+
+# выгружаем старые модули и загружаем новые
+rmmod nfsv3 nfs
+modprobe nfsv3
+```
+
+После такой (относительно нехитрой 🙂) манипуляции NFS начинает по умолчанию
+монтироваться с новыми wsize и rsize, и производительность линейной записи в Vitastor-NFS
+исправляется.
+
 ## Горизонтальное масштабирование
 
 Клиент Linux NFS 3.0 не поддерживает встроенное масштабирование или отказоустойчивость.

docs/usage/qemu.en.md

@@ -162,10 +162,12 @@ apt-get install linux-headers-`uname -r`
 apt-get build-dep linux-image-`uname -r`-unsigned
 apt-get source linux-image-`uname -r`-unsigned
 cd linux*/drivers/vdpa
-make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules modules_install
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m modules_install
 cat Module.symvers >> /lib/modules/`uname -r`/build/Module.symvers
 cd ../virtio
-make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules modules_install
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m modules_install
 depmod -a
 ```
 

docs/usage/qemu.ru.md

@@ -165,10 +165,12 @@ apt-get install linux-headers-`uname -r`
 apt-get build-dep linux-image-`uname -r`-unsigned
 apt-get source linux-image-`uname -r`-unsigned
 cd linux*/drivers/vdpa
-make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules modules_install
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m modules_install
 cat Module.symvers >> /lib/modules/`uname -r`/build/Module.symvers
 cd ../virtio
-make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules modules_install
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m -j8 modules
+make -C /lib/modules/`uname -r`/build M=$PWD CONFIG_VDPA=m CONFIG_VDPA_USER=m CONFIG_VIRTIO_VDPA=m modules_install
 depmod -a
 ```
 

mon/lp_optimizer/dsl_pgs.js

@@ -253,7 +253,7 @@ function random_custom_combinations(osd_tree, rules, count, ordered)
         for (let i = 1; i < rules.length; i++)
         {
             const filtered = filter_tree_by_rules(osd_tree, rules[i], selected);
-            const idx = select_murmur3(filtered.length, i => 'p:'+f.id+':'+filtered[i].id);
+            const idx = select_murmur3(filtered.length, i => 'p:'+f.id+':'+(filtered[i].name || filtered[i].id));
             selected.push(idx == null ? { levels: {}, id: null } : filtered[idx]);
         }
         const size = selected.filter(s => s.id !== null).length;
@@ -270,7 +270,7 @@ function random_custom_combinations(osd_tree, rules, count, ordered)
         for (const item_rules of rules)
         {
             const filtered = selected.length ? filter_tree_by_rules(osd_tree, item_rules, selected) : first;
-            const idx = select_murmur3(filtered.length, i => n+':'+filtered[i].id);
+            const idx = select_murmur3(filtered.length, i => n+':'+(filtered[i].name || filtered[i].id));
             selected.push(idx == null ? { levels: {}, id: null } : filtered[idx]);
         }
         const size = selected.filter(s => s.id !== null).length;
@@ -340,9 +340,9 @@ function filter_tree_by_rules(osd_tree, rules, selected)
 }
 
 // Convert from
-// node_list = { id: string|number, level: string, size?: number, parent?: string|number }[]
+// node_list = { id: string|number, name?: string, level: string, size?: number, parent?: string|number }[]
 // to
-// node_tree = { [node_id]: { id, level, size?, parent?, children?: child_node_id[], levels: { [level]: id, ... } } }
+// node_tree = { [node_id]: { id, name?, level, size?, parent?, children?: child_node[], levels: { [level]: id, ... } } }
 function index_tree(node_list)
 {
     const tree = { '': { children: [], levels: {} } };
@@ -357,7 +357,7 @@ function index_tree(node_list)
         tree[parent_id].children = tree[parent_id].children || [];
         tree[parent_id].children.push(tree[node.id]);
     }
-    const cur = tree[''].children;
+    const cur = [ ...tree[''].children ];
     for (let i = 0; i < cur.length; i++)
     {
         cur[i].levels[cur[i].level] = cur[i].id;

mon/lp_optimizer/fold.js

@@ -0,0 +1,244 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 (see README.md for details)
+
+// Extract OSDs from the lowest affected tree level into a separate (flat) map
+// to run PG optimisation on failure domains instead of individual OSDs
+//
+// node_list = same input as for index_tree()
+// rules = [ level, operator, value ][][]
+// returns { nodes: new_node_list, leaves: { new_folded_node_id: [ extracted_leaf_nodes... ] } }
+function fold_failure_domains(node_list, rules)
+{
+    const interest = {};
+    for (const level_rules of rules)
+    {
+        for (const rule of level_rules)
+            interest[rule[0]] = true;
+    }
+    const max_numeric_id = node_list.reduce((a, c) => a < (0|c.id) ? (0|c.id) : a, 0);
+    let next_id = max_numeric_id;
+    const node_map = node_list.reduce((a, c) => { a[c.id||''] = c; return a; }, {});
+    const old_ids_by_new = {};
+    const extracted_nodes = {};
+    let folded = true;
+    while (folded)
+    {
+        const per_parent = {};
+        for (const node_id in node_map)
+        {
+            const node = node_map[node_id];
+            const p = node.parent || '';
+            per_parent[p] = per_parent[p]||[];
+            per_parent[p].push(node);
+        }
+        folded = false;
+        for (const node_id in per_parent)
+        {
+            const fold_node = node_id !== '' && per_parent[node_id].length > 0 && per_parent[node_id].filter(child => per_parent[child.id||''] || interest[child.level]).length == 0;
+            if (fold_node)
+            {
+                const old_node = node_map[node_id];
+                const new_id = ++next_id;
+                node_map[new_id] = {
+                    ...old_node,
+                    id: new_id,
+                    name: node_id, // for use in murmur3 hashes
+                    size: per_parent[node_id].reduce((a, c) => a + (Number(c.size)||0), 0),
+                };
+                delete node_map[node_id];
+                old_ids_by_new[new_id] = node_id;
+                extracted_nodes[new_id] = [];
+                for (const child of per_parent[node_id])
+                {
+                    if (old_ids_by_new[child.id])
+                    {
+                        extracted_nodes[new_id].push(...extracted_nodes[child.id]);
+                        delete extracted_nodes[child.id];
+                    }
+                    else
+                        extracted_nodes[new_id].push(child);
+                    delete node_map[child.id];
+                }
+                folded = true;
+            }
+        }
+    }
+    return { nodes: Object.values(node_map), leaves: extracted_nodes };
+}
+
+// Distribute PGs mapped to "folded" nodes to individual OSDs according to their weights
+// folded_pgs = optimize_result.int_pgs before folding
+// prev_pgs = optional previous PGs from optimize_change() input
+// extracted_nodes = output from fold_failure_domains
+function unfold_failure_domains(folded_pgs, prev_pgs, extracted_nodes)
+{
+    const maps = {};
+    let found = false;
+    for (const new_id in extracted_nodes)
+    {
+        const weights = {};
+        for (const sub_node of extracted_nodes[new_id])
+        {
+            weights[sub_node.id] = sub_node.size;
+        }
+        maps[new_id] = { weights, prev: [], next: [], pos: 0 };
+        found = true;
+    }
+    if (!found)
+    {
+        return folded_pgs;
+    }
+    for (let i = 0; i < folded_pgs.length; i++)
+    {
+        for (let j = 0; j < folded_pgs[i].length; j++)
+        {
+            if (maps[folded_pgs[i][j]])
+            {
+                maps[folded_pgs[i][j]].prev.push(prev_pgs && prev_pgs[i] && prev_pgs[i][j] || 0);
+            }
+        }
+    }
+    for (const new_id in maps)
+    {
+        maps[new_id].next = adjust_distribution(maps[new_id].weights, maps[new_id].prev);
+    }
+    const mapped_pgs = [];
+    for (let i = 0; i < folded_pgs.length; i++)
+    {
+        mapped_pgs.push(folded_pgs[i].map(osd => (maps[osd] ? maps[osd].next[maps[osd].pos++] : osd)));
+    }
+    return mapped_pgs;
+}
+
+// Return the new array of items re-distributed as close as possible to weights in wanted_weights
+// wanted_weights = { [key]: weight }
+// cur_items = key[]
+function adjust_distribution(wanted_weights, cur_items)
+{
+    const item_map = {};
+    for (let i = 0; i < cur_items.length; i++)
+    {
+        const item = cur_items[i];
+        item_map[item] = (item_map[item] || { target: 0, cur: [] });
+        item_map[item].cur.push(i);
+    }
+    let total_weight = 0;
+    for (const item in wanted_weights)
+    {
+        total_weight += Number(wanted_weights[item]) || 0;
+    }
+    for (const item in wanted_weights)
+    {
+        const weight = wanted_weights[item] / total_weight * cur_items.length;
+        if (weight > 0)
+        {
+            item_map[item] = (item_map[item] || { target: 0, cur: [] });
+            item_map[item].target = weight;
+        }
+    }
+    const diff = (item) => (item_map[item].cur.length - item_map[item].target);
+    const most_underweighted = Object.keys(item_map)
+        .filter(item => item_map[item].target > 0)
+        .sort((a, b) => diff(a) - diff(b));
+    // Items with zero target weight MUST never be selected - remove them
+    // and remap each of them to a most underweighted item
+    for (const item in item_map)
+    {
+        if (!item_map[item].target)
+        {
+            const prev = item_map[item];
+            delete item_map[item];
+            for (const idx of prev.cur)
+            {
+                const move_to = most_underweighted[0];
+                item_map[move_to].cur.push(idx);
+                move_leftmost(most_underweighted, diff);
+            }
+        }
+    }
+    // Other over-weighted items are only moved if it improves the distribution
+    while (most_underweighted.length > 1)
+    {
+        const first = most_underweighted[0];
+        const last = most_underweighted[most_underweighted.length-1];
+        const first_diff = diff(first);
+        const last_diff = diff(last);
+        if (Math.abs(first_diff+1)+Math.abs(last_diff-1) < Math.abs(first_diff)+Math.abs(last_diff))
+        {
+            item_map[first].cur.push(item_map[last].cur.pop());
+            move_leftmost(most_underweighted, diff);
+            move_rightmost(most_underweighted, diff);
+        }
+        else
+        {
+            break;
+        }
+    }
+    const new_items = new Array(cur_items.length);
+    for (const item in item_map)
+    {
+        for (const idx of item_map[item].cur)
+        {
+            new_items[idx] = item;
+        }
+    }
+    return new_items;
+}
+
+function move_leftmost(sorted_array, diff)
+{
+    // Re-sort by moving the leftmost item to the right if it changes position
+    const first = sorted_array[0];
+    const new_diff = diff(first);
+    let r = 0;
+    while (r < sorted_array.length-1 && diff(sorted_array[r+1]) <= new_diff)
+        r++;
+    if (r > 0)
+    {
+        for (let i = 0; i < r; i++)
+            sorted_array[i] = sorted_array[i+1];
+        sorted_array[r] = first;
+    }
+}
+
+function move_rightmost(sorted_array, diff)
+{
+    // Re-sort by moving the rightmost item to the left if it changes position
+    const last = sorted_array[sorted_array.length-1];
+    const new_diff = diff(last);
+    let r = sorted_array.length-1;
+    while (r > 0 && diff(sorted_array[r-1]) > new_diff)
+        r--;
+    if (r < sorted_array.length-1)
+    {
+        for (let i = sorted_array.length-1; i > r; i--)
+            sorted_array[i] = sorted_array[i-1];
+        sorted_array[r] = last;
+    }
+}
+
+// map previous PGs to folded nodes
+function fold_prev_pgs(pgs, extracted_nodes)
+{
+    const unmap = {};
+    for (const new_id in extracted_nodes)
+    {
+        for (const sub_node of extracted_nodes[new_id])
+        {
+            unmap[sub_node.id] = new_id;
+        }
+    }
+    const mapped_pgs = [];
+    for (let i = 0; i < pgs.length; i++)
+    {
+        mapped_pgs.push(pgs[i].map(osd => (unmap[osd] || osd)));
+    }
+    return mapped_pgs;
+}
+
+module.exports = {
+    fold_failure_domains,
+    unfold_failure_domains,
+    adjust_distribution,
+    fold_prev_pgs,
+};

mon/lp_optimizer/lp_optimizer.js

@@ -98,6 +98,7 @@ async function optimize_initial({ osd_weights, combinator, pg_count, pg_size = 3
         score: lp_result.score,
         weights: lp_result.vars,
         int_pgs,
+        pg_effsize,
         space: eff * pg_effsize,
         total_space: total_weight,
     };
@@ -409,6 +410,7 @@ async function optimize_change({ prev_pgs: prev_int_pgs, osd_weights, combinator
         int_pgs: new_pgs,
         differs,
         osd_differs,
+        pg_effsize,
         space: pg_effsize * pg_list_space_efficiency(new_pgs, osd_weights, pg_minsize, parity_space),
         total_space: total_weight,
     };

mon/lp_optimizer/test-optimize-fold.js

@@ -0,0 +1,108 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 (see README.md for details)
+
+const assert = require('assert');
+const { fold_failure_domains, unfold_failure_domains, adjust_distribution } = require('./fold.js');
+const DSL = require('./dsl_pgs.js');
+const LPOptimizer = require('./lp_optimizer.js');
+const stableStringify = require('../stable-stringify.js');
+
+async function run()
+{
+    // Test run adjust_distribution
+    console.log('adjust_distribution');
+    const rand = [];
+    for (let i = 0; i < 100; i++)
+    {
+        rand.push(1 + Math.floor(10*Math.random()));
+        // or rand.push(0);
+    }
+    const adj = adjust_distribution({ 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1 }, rand);
+    //console.log(rand.join(' '));
+    console.log(rand.reduce((a, c) => { a[c] = (a[c]||0)+1; return a; }, {}));
+    //console.log(adj.join(' '));
+    console.log(adj.reduce((a, c) => { a[c] = (a[c]||0)+1; return a; }, {}));
+    console.log('Movement: '+rand.reduce((a, c, i) => a+(rand[i] != adj[i] ? 1 : 0), 0)+'/'+rand.length);
+
+    console.log('\nfold_failure_domains');
+    console.log(JSON.stringify(fold_failure_domains(
+        [
+            { id: 1,       level: 'osd',  size: 1, parent: 'disk1' },
+            { id: 2,       level: 'osd',  size: 2, parent: 'disk1' },
+            { id: 'disk1', level: 'disk', parent: 'host1' },
+            { id: 'host1', level: 'host', parent: 'dc1' },
+            { id: 'dc1',   level: 'dc' },
+        ],
+        [ [ [ 'dc' ], [ 'host' ] ] ]
+    ), 0, 2));
+
+    console.log('\nfold_failure_domains empty rules');
+    console.log(JSON.stringify(fold_failure_domains(
+        [
+            { id: 1,       level: 'osd',  size: 1, parent: 'disk1' },
+            { id: 2,       level: 'osd',  size: 2, parent: 'disk1' },
+            { id: 'disk1', level: 'disk', parent: 'host1' },
+            { id: 'host1', level: 'host', parent: 'dc1' },
+            { id: 'dc1',   level: 'dc' },
+        ],
+        []
+    ), 0, 2));
+
+    console.log('\noptimize_folded');
+    // 5 DCs, 2 hosts per DC, 10 OSD per host
+    const nodes = [];
+    for (let i = 1; i <= 100; i++)
+    {
+        nodes.push({ id: i, level: 'osd', size: 1, parent: 'host'+(1+(0|((i-1)/10))) });
+    }
+    for (let i = 1; i <= 10; i++)
+    {
+        nodes.push({ id: 'host'+i, level: 'host', parent: 'dc'+(1+(0|((i-1)/2))) });
+    }
+    for (let i = 1; i <= 5; i++)
+    {
+        nodes.push({ id: 'dc'+i, level: 'dc' });
+    }
+
+    // Check rules
+    const rules = DSL.parse_level_indexes({ dc: '112233', host: '123456' }, [ 'dc', 'host', 'osd' ]);
+    assert.deepEqual(rules, [[],[["dc","=",1],["host","!=",[1]]],[["dc","!=",[1]]],[["dc","=",3],["host","!=",[3]]],[["dc","!=",[1,3]]],[["dc","=",5],["host","!=",[5]]]]);
+
+    // Check tree folding
+    const { nodes: folded_nodes, leaves: folded_leaves } = fold_failure_domains(nodes, rules);
+    const expected_folded = [];
+    const expected_leaves = {};
+    for (let i = 1; i <= 10; i++)
+    {
+        expected_folded.push({ id: 100+i, name: 'host'+i, level: 'host', size: 10, parent: 'dc'+(1+(0|((i-1)/2))) });
+        expected_leaves[100+i] = [ ...new Array(10).keys() ].map(k => ({ id: 10*(i-1)+k+1, level: 'osd', size: 1, parent: 'host'+i }));
+    }
+    for (let i = 1; i <= 5; i++)
+    {
+        expected_folded.push({ id: 'dc'+i, level: 'dc' });
+    }
+    assert.equal(stableStringify(folded_nodes), stableStringify(expected_folded));
+    assert.equal(stableStringify(folded_leaves), stableStringify(expected_leaves));
+
+    // Now optimise it
+    console.log('1000 PGs, EC 112233');
+    const leaf_weights = folded_nodes.reduce((a, c) => { if (Number(c.id)) { a[c.id] = c.size; } return a; }, {});
+    let res = await LPOptimizer.optimize_initial({
+        osd_weights: leaf_weights,
+        combinator: new DSL.RuleCombinator(folded_nodes, rules, 10000, false),
+        pg_size: 6,
+        pg_count: 1000,
+        ordered: false,
+    });
+    LPOptimizer.print_change_stats(res, false);
+    assert.equal(res.space, 100, 'Initial distribution');
+
+    const unfolded_res = { ...res };
+    unfolded_res.int_pgs = unfold_failure_domains(res.int_pgs, null, folded_leaves);
+    const osd_weights = nodes.reduce((a, c) => { if (Number(c.id)) { a[c.id] = c.size; } return a; }, {});
+    unfolded_res.space = unfolded_res.pg_effsize * LPOptimizer.pg_list_space_efficiency(unfolded_res.int_pgs, osd_weights, 0, 1);
+    LPOptimizer.print_change_stats(unfolded_res, false);
+    assert.equal(res.space, 100, 'Initial distribution');
+}
+
+run().catch(console.error);

mon/mon.js

@@ -96,6 +96,7 @@ class Mon
                     }
                     else
                     {
+                        res.setHeader('Content-Type', 'text/plain; version=0.0.4; charset=utf-8');
                         res.write(export_prometheus_metrics(this.state));
                     }
                 }

mon/osd_tree.js

@@ -15,7 +15,7 @@ function get_osd_tree(global_config, state)
         const stat = state.osd.stats[osd_num];
         const osd_cfg = state.config.osd[osd_num];
         let reweight = osd_cfg == null ? 1 : Number(osd_cfg.reweight);
-        if (reweight < 0 || isNaN(reweight))
+        if (isNaN(reweight) || reweight < 0 || reweight > 0)
             reweight = 1;
         if (stat && stat.size && reweight && (state.osd.state[osd_num] || Number(stat.time) >= down_time ||
             osd_cfg && osd_cfg.noout))
@@ -87,7 +87,7 @@ function make_hier_tree(global_config, tree)
     tree[''] = { children: [] };
     for (const node_id in tree)
     {
-        if (node_id === '' || tree[node_id].level === 'osd' && (!tree[node_id].size || tree[node_id].size <= 0))
+        if (node_id === '' || !(tree[node_id].children||[]).length && (tree[node_id].size||0) <= 0)
         {
             continue;
         }
@@ -107,10 +107,10 @@ function make_hier_tree(global_config, tree)
         deleted = 0;
         for (const node_id in tree)
         {
-            if (tree[node_id].level !== 'osd' && (!tree[node_id].children || !tree[node_id].children.length))
+            if (!(tree[node_id].children||[]).length && (tree[node_id].size||0) <= 0)
             {
                 const parent = tree[node_id].parent;
-                if (parent)
+                if (parent && tree[parent])
                 {
                     tree[parent].children = tree[parent].children.filter(c => c != tree[node_id]);
                 }

mon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitastor-mon",
-  "version": "2.1.0",
+  "version": "2.2.3",
   "description": "Vitastor SDS monitor service",
   "main": "mon-main.js",
   "scripts": {
@@ -19,6 +19,6 @@
     "eslint-plugin-node": "^11.1.0"
   },
   "engines": {
-    "node": ">=12.1.0"
+    "node": ">=12.0.0"
   }
 }

mon/pg_gen.js

@@ -3,6 +3,7 @@
 
 const { RuleCombinator } = require('./lp_optimizer/dsl_pgs.js');
 const { SimpleCombinator, flatten_tree } = require('./lp_optimizer/simple_pgs.js');
+const { fold_failure_domains, unfold_failure_domains, fold_prev_pgs } = require('./lp_optimizer/fold.js');
 const { validate_pool_cfg, get_pg_rules } = require('./pool_config.js');
 const LPOptimizer = require('./lp_optimizer/lp_optimizer.js');
 const { scale_pg_count } = require('./pg_utils.js');
@@ -160,7 +161,6 @@ async function generate_pool_pgs(state, global_config, pool_id, osd_tree, levels
         pool_cfg.bitmap_granularity || global_config.bitmap_granularity || 4096,
         pool_cfg.immediate_commit || global_config.immediate_commit || 'all'
     );
-    pool_tree = make_hier_tree(global_config, pool_tree);
     // First try last_clean_pgs to minimize data movement
     let prev_pgs = [];
     for (const pg in ((state.history.last_clean_pgs.items||{})[pool_id]||{}))
@@ -175,14 +175,19 @@ async function generate_pool_pgs(state, global_config, pool_id, osd_tree, levels
             prev_pgs[pg-1] = [ ...state.pg.config.items[pool_id][pg].osd_set ];
         }
     }
+    const use_rules = !global_config.use_old_pg_combinator || pool_cfg.level_placement || pool_cfg.raw_placement;
+    const rules = use_rules ? get_pg_rules(pool_id, pool_cfg, global_config.placement_levels) : null;
+    const folded = fold_failure_domains(Object.values(pool_tree), use_rules ? rules : [ [ [ pool_cfg.failure_domain ] ] ]);
+    // FIXME: Remove/merge make_hier_tree() step somewhere, however it's needed to remove empty nodes
+    const folded_tree = make_hier_tree(global_config, folded.nodes);
     const old_pg_count = prev_pgs.length;
     const optimize_cfg = {
-        osd_weights: Object.values(pool_tree).filter(item => item.level === 'osd').reduce((a, c) => { a[c.id] = c.size; return a; }, {}),
-        combinator: !global_config.use_old_pg_combinator || pool_cfg.level_placement || pool_cfg.raw_placement
+        osd_weights: folded.nodes.reduce((a, c) => { if (Number(c.id)) { a[c.id] = c.size; } return a; }, {}),
+        combinator: use_rules
             // new algorithm:
-            ? new RuleCombinator(pool_tree, get_pg_rules(pool_id, pool_cfg, global_config.placement_levels), pool_cfg.max_osd_combinations)
+            ? new RuleCombinator(folded_tree, rules, pool_cfg.max_osd_combinations)
             // old algorithm:
-            : new SimpleCombinator(flatten_tree(pool_tree[''].children, levels, pool_cfg.failure_domain, 'osd'), pool_cfg.pg_size, pool_cfg.max_osd_combinations),
+            : new SimpleCombinator(flatten_tree(folded_tree[''].children, levels, pool_cfg.failure_domain, 'osd'), pool_cfg.pg_size, pool_cfg.max_osd_combinations),
         pg_count: pool_cfg.pg_count,
         pg_size: pool_cfg.pg_size,
         pg_minsize: pool_cfg.pg_minsize,
@@ -202,12 +207,11 @@ async function generate_pool_pgs(state, global_config, pool_id, osd_tree, levels
         for (const pg of prev_pgs)
         {
             while (pg.length < pool_cfg.pg_size)
-            {
                 pg.push(0);
-            }
         }
+        const folded_prev_pgs = fold_prev_pgs(prev_pgs, folded.leaves);
         optimize_result = await LPOptimizer.optimize_change({
-            prev_pgs,
+            prev_pgs: folded_prev_pgs,
             ...optimize_cfg,
         });
     }
@@ -215,6 +219,10 @@ async function generate_pool_pgs(state, global_config, pool_id, osd_tree, levels
     {
         optimize_result = await LPOptimizer.optimize_initial(optimize_cfg);
     }
+    optimize_result.int_pgs = unfold_failure_domains(optimize_result.int_pgs, prev_pgs, folded.leaves);
+    const osd_weights = Object.values(pool_tree).reduce((a, c) => { if (c.level === 'osd') { a[c.id] = c.size; } return a; }, {});
+    optimize_result.space = optimize_result.pg_effsize * LPOptimizer.pg_list_space_efficiency(optimize_result.int_pgs,
+        osd_weights, optimize_cfg.pg_minsize, 1);
     console.log(`Pool ${pool_id} (${pool_cfg.name || 'unnamed'}):`);
     LPOptimizer.print_change_stats(optimize_result);
     let pg_effsize = pool_cfg.pg_size;

mon/scripts/make-etcd

@@ -40,6 +40,11 @@ async function run()
         console.log("/etc/systemd/system/vitastor-etcd.service already exists");
         process.exit(1);
     }
+    if (!in_docker && fs.existsSync("/etc/systemd/system/etcd.service"))
+    {
+        console.log("/etc/systemd/system/etcd.service already exists");
+        process.exit(1);
+    }
     const config = JSON.parse(fs.readFileSync(config_path, { encoding: 'utf-8' }));
     if (!config.etcd_address)
     {
@@ -66,7 +71,7 @@ async function run()
         console.log('etcd for Vitastor configured. Run `systemctl enable --now vitastor-etcd` to start etcd');
         process.exit(0);
     }
-    await system(`mkdir -p /var/lib/etcd`);
+    await system(`mkdir -p /var/lib/etcd/vitastor`);
     fs.writeFileSync(
         "/etc/systemd/system/vitastor-etcd.service",
 `[Unit]
@@ -77,14 +82,14 @@ Wants=network-online.target local-fs.target time-sync.target
 [Service]
 Restart=always
 Environment=GOGC=50
-ExecStart=etcd --name ${etcd_name} --data-dir /var/lib/etcd \\
+ExecStart=etcd --name ${etcd_name} --data-dir /var/lib/etcd/vitastor \\
     --snapshot-count 10000 --advertise-client-urls http://${etcds[num]}:2379 --listen-client-urls http://${etcds[num]}:2379 \\
     --initial-advertise-peer-urls http://${etcds[num]}:2380 --listen-peer-urls http://${etcds[num]}:2380 \\
     --initial-cluster-token vitastor-etcd-1 --initial-cluster ${etcd_cluster} \\
     --initial-cluster-state new --max-txn-ops=100000 --max-request-bytes=104857600 \\
     --auto-compaction-retention=10 --auto-compaction-mode=revision
-WorkingDirectory=/var/lib/etcd
-ExecStartPre=+chown -R etcd /var/lib/etcd
+WorkingDirectory=/var/lib/etcd/vitastor
+ExecStartPre=+chown -R etcd /var/lib/etcd/vitastor
 User=etcd
 PrivateTmp=false
 TasksMax=infinity
@@ -97,8 +102,9 @@ WantedBy=multi-user.target
 `);
     await system(`useradd etcd`);
     await system(`systemctl daemon-reload`);
-    await system(`systemctl enable etcd`);
-    await system(`systemctl start etcd`);
+    // Disable distribution etcd unit and enable our one
+    await system(`systemctl disable --now etcd`);
+    await system(`systemctl enable --now vitastor-etcd`);
     process.exit(0);
 }
 

mon/stats.js

@@ -87,11 +87,25 @@ function sum_op_stats(all_osd, prev_stats)
                 for (const k in derived[type][op])
                 {
                     sum_diff[type][op] = sum_diff[type][op] || {};
-                    sum_diff[type][op][k] = (sum_diff[type][op][k] || 0n) + derived[type][op][k];
+                    if (k == 'lat')
+                        sum_diff[type][op].lat = (sum_diff[type][op].lat || 0n) + derived[type][op].lat*derived[type][op].iops;
+                    else
+                        sum_diff[type][op][k] = (sum_diff[type][op][k] || 0n) + derived[type][op][k];
                 }
             }
         }
     }
+    // Calculate average (weighted by iops) op latency across all OSDs
+    for (const type in sum_diff)
+    {
+        for (const op in sum_diff[type])
+        {
+            if (sum_diff[type][op].lat)
+            {
+                sum_diff[type][op].lat /= sum_diff[type][op].iops;
+            }
+        }
+    }
     return sum_diff;
 }
 
@@ -271,8 +285,7 @@ function sum_inode_stats(state, prev_stats)
                     const op_st = inode_stats[pool_id][inode_num][op];
                     op_st.bps += op_diff.bps;
                     op_st.iops += op_diff.iops;
-                    op_st.lat += op_diff.lat;
-                    op_st.n_osd = (op_st.n_osd || 0) + 1;
+                    op_st.lat += op_diff.lat*op_diff.iops;
                 }
             }
         }
@@ -285,11 +298,8 @@ function sum_inode_stats(state, prev_stats)
             for (const op of [ 'read', 'write', 'delete' ])
             {
                 const op_st = inode_stats[pool_id][inode_num][op];
-                if (op_st.n_osd)
-                {
-                    op_st.lat /= BigInt(op_st.n_osd);
-                    delete op_st.n_osd;
-                }
+                if (op_st.lat)
+                    op_st.lat /= op_st.iops;
                 if (op_st.bps > 0 || op_st.iops > 0)
                     nonzero = true;
             }

node-binding/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitastor",
-  "version": "2.1.0",
+  "version": "2.2.3",
   "description": "Low-level native bindings to Vitastor client library",
   "main": "index.js",
   "keywords": [

patches/VitastorPlugin.pm

@@ -410,8 +410,8 @@ sub volume_size_info
     my $prefix = defined $scfg->{vitastor_prefix} ? $scfg->{vitastor_prefix} : 'pve/';
     my ($vtype, $name, $vmid) = $class->parse_volname($volname);
     my $info = _process_list($scfg, $storeid, run_cli($scfg, [ 'ls', $prefix.$name ]))->[0];
-    #return wantarray ? ($size, $format, $used, $parent, $st->ctime) : $size;
-    return $info->{size};
+    # (size, format, used, parent, ctime)
+    return wantarray ? ($info->{size}, $info->{format}, $info->{size}, $info->{parent}, 0) : $info->{size};
 }
 
 sub volume_resize

patches/cinder-vitastor.py

@@ -50,7 +50,7 @@ from cinder.volume import configuration
 from cinder.volume import driver
 from cinder.volume import volume_utils
 
-VITASTOR_VERSION = '2.1.0'
+VITASTOR_VERSION = '2.2.3'
 
 LOG = logging.getLogger(__name__)
 

patches/libvirt-11.5-vitastor.diff

@@ -0,0 +1,637 @@
+diff --git a/include/libvirt/libvirt-storage.h b/include/libvirt/libvirt-storage.h
+index aaad4a3da1..5f5daa8341 100644
+--- a/include/libvirt/libvirt-storage.h
++++ b/include/libvirt/libvirt-storage.h
+@@ -326,6 +326,7 @@ typedef enum {
+     VIR_CONNECT_LIST_STORAGE_POOLS_ZFS           = 1 << 17, /* (Since: 1.2.8) */
+     VIR_CONNECT_LIST_STORAGE_POOLS_VSTORAGE      = 1 << 18, /* (Since: 3.1.0) */
+     VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI_DIRECT  = 1 << 19, /* (Since: 5.6.0) */
++    VIR_CONNECT_LIST_STORAGE_POOLS_VITASTOR      = 1 << 20, /* (Since: 5.0.0) */
+ } virConnectListAllStoragePoolsFlags;
+ 
+ int                     virConnectListAllStoragePools(virConnectPtr conn,
+diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
+index 1e24e41a48..ce359a4cf8 100644
+--- a/src/conf/domain_conf.c
++++ b/src/conf/domain_conf.c
+@@ -7435,7 +7435,8 @@ virDomainDiskSourceNetworkParse(xmlNodePtr node,
+     src->configFile = virXPathString("string(./config/@file)", ctxt);
+ 
+     if (src->protocol == VIR_STORAGE_NET_PROTOCOL_HTTP ||
+-        src->protocol == VIR_STORAGE_NET_PROTOCOL_HTTPS)
++        src->protocol == VIR_STORAGE_NET_PROTOCOL_HTTPS ||
++        src->protocol == VIR_STORAGE_NET_PROTOCOL_VITASTOR)
+         src->query = virXMLPropString(node, "query");
+ 
+     if (virDomainStorageNetworkParseHosts(node, ctxt, &src->hosts, &src->nhosts) < 0)
+@@ -31871,6 +31872,7 @@ virDomainStorageSourceTranslateSourcePool(virStorageSource *src,
+ 
+     case VIR_STORAGE_POOL_MPATH:
+     case VIR_STORAGE_POOL_RBD:
++    case VIR_STORAGE_POOL_VITASTOR:
+     case VIR_STORAGE_POOL_SHEEPDOG:
+     case VIR_STORAGE_POOL_GLUSTER:
+     case VIR_STORAGE_POOL_LAST:
+diff --git a/src/conf/domain_validate.c b/src/conf/domain_validate.c
+index b28af7fa56..d1aae6e43e 100644
+--- a/src/conf/domain_validate.c
++++ b/src/conf/domain_validate.c
+@@ -504,6 +504,7 @@ virDomainDiskDefValidateSourceChainOne(const virStorageSource *src)
+         case VIR_STORAGE_NET_PROTOCOL_RBD:
+             break;
+ 
++        case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+         case VIR_STORAGE_NET_PROTOCOL_NBD:
+         case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+         case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+@@ -576,7 +577,7 @@ virDomainDiskDefValidateSourceChainOne(const virStorageSource *src)
+         }
+     }
+ 
+-    /* internal snapshots and config files are currently supported only with rbd: */
++    /* internal snapshots are currently supported only with rbd: */
+     if (virStorageSourceGetActualType(src) != VIR_STORAGE_TYPE_NETWORK &&
+         src->protocol != VIR_STORAGE_NET_PROTOCOL_RBD) {
+         if (src->snapshot) {
+@@ -584,10 +585,14 @@ virDomainDiskDefValidateSourceChainOne(const virStorageSource *src)
+                            _("<snapshot> element is currently supported only with 'rbd' disks"));
+             return -1;
+         }
+-
++    }
++    /* config files are currently supported only with rbd and vitastor: */
++    if (virStorageSourceGetActualType(src) != VIR_STORAGE_TYPE_NETWORK &&
++        src->protocol != VIR_STORAGE_NET_PROTOCOL_RBD &&
++        src->protocol != VIR_STORAGE_NET_PROTOCOL_VITASTOR) {
+         if (src->configFile) {
+             virReportError(VIR_ERR_XML_ERROR, "%s",
+-                           _("<config> element is currently supported only with 'rbd' disks"));
++                           _("<config> element is currently supported only with 'rbd' and 'vitastor' disks"));
+             return -1;
+         }
+     }
+diff --git a/src/conf/schemas/domaincommon.rng b/src/conf/schemas/domaincommon.rng
+index 183dd5db5e..dcc0d1a778 100644
+--- a/src/conf/schemas/domaincommon.rng
++++ b/src/conf/schemas/domaincommon.rng
+@@ -2066,6 +2066,35 @@
+     </element>
+   </define>
+ 
++  <define name="diskSourceNetworkProtocolVitastor">
++    <element name="source">
++      <interleave>
++        <attribute name="protocol">
++          <value>vitastor</value>
++        </attribute>
++        <ref name="diskSourceCommon"/>
++        <optional>
++          <attribute name="name"/>
++        </optional>
++        <optional>
++          <attribute name="query"/>
++        </optional>
++        <zeroOrMore>
++          <ref name="diskSourceNetworkHost"/>
++        </zeroOrMore>
++        <optional>
++          <element name="config">
++            <attribute name="file">
++              <ref name="absFilePath"/>
++            </attribute>
++            <empty/>
++          </element>
++        </optional>
++        <empty/>
++      </interleave>
++    </element>
++  </define>
++
+   <define name="diskSourceNetworkProtocolISCSI">
+     <element name="source">
+       <attribute name="protocol">
+@@ -2416,6 +2445,7 @@
+       <ref name="diskSourceNetworkProtocolSimple"/>
+       <ref name="diskSourceNetworkProtocolVxHS"/>
+       <ref name="diskSourceNetworkProtocolNFS"/>
++      <ref name="diskSourceNetworkProtocolVitastor"/>
+     </choice>
+   </define>
+ 
+diff --git a/src/conf/storage_conf.c b/src/conf/storage_conf.c
+index 1dc9365bf2..a8a736be81 100644
+--- a/src/conf/storage_conf.c
++++ b/src/conf/storage_conf.c
+@@ -56,7 +56,7 @@ VIR_ENUM_IMPL(virStoragePool,
+               "logical", "disk", "iscsi",
+               "iscsi-direct", "scsi", "mpath",
+               "rbd", "sheepdog", "gluster",
+-              "zfs", "vstorage",
++              "zfs", "vstorage", "vitastor",
+ );
+ 
+ VIR_ENUM_IMPL(virStoragePoolFormatFileSystem,
+@@ -242,6 +242,18 @@ static virStoragePoolTypeInfo poolTypeInfo[] = {
+           .formatToString = virStorageFileFormatTypeToString,
+       }
+     },
++    {.poolType = VIR_STORAGE_POOL_VITASTOR,
++     .poolOptions = {
++         .flags = (VIR_STORAGE_POOL_SOURCE_HOST |
++                   VIR_STORAGE_POOL_SOURCE_NETWORK |
++                   VIR_STORAGE_POOL_SOURCE_NAME),
++      },
++      .volOptions = {
++          .defaultFormat = VIR_STORAGE_FILE_RAW,
++          .formatFromString = virStorageVolumeFormatFromString,
++          .formatToString = virStorageFileFormatTypeToString,
++      }
++    },
+     {.poolType = VIR_STORAGE_POOL_SHEEPDOG,
+      .poolOptions = {
+          .flags = (VIR_STORAGE_POOL_SOURCE_HOST |
+@@ -538,6 +550,11 @@ virStoragePoolDefParseSource(xmlXPathContextPtr ctxt,
+                        _("element 'name' is mandatory for RBD pool"));
+         return -1;
+     }
++    if (pool_type == VIR_STORAGE_POOL_VITASTOR && source->name == NULL) {
++        virReportError(VIR_ERR_XML_ERROR, "%s",
++                       _("element 'name' is mandatory for Vitastor pool"));
++        return -1;
++    }
+ 
+     if (options->formatFromString) {
+         g_autofree char *format = NULL;
+@@ -1127,6 +1144,7 @@ virStoragePoolDefFormatBuf(virBuffer *buf,
+     /* RBD, Sheepdog, Gluster and Iscsi-direct devices are not local block devs nor
+      * files, so they don't have a target */
+     if (def->type != VIR_STORAGE_POOL_RBD &&
++        def->type != VIR_STORAGE_POOL_VITASTOR &&
+         def->type != VIR_STORAGE_POOL_SHEEPDOG &&
+         def->type != VIR_STORAGE_POOL_GLUSTER &&
+         def->type != VIR_STORAGE_POOL_ISCSI_DIRECT) {
+diff --git a/src/conf/storage_conf.h b/src/conf/storage_conf.h
+index fc67957cfe..720c07ef74 100644
+--- a/src/conf/storage_conf.h
++++ b/src/conf/storage_conf.h
+@@ -103,6 +103,7 @@ typedef enum {
+     VIR_STORAGE_POOL_GLUSTER,  /* Gluster device */
+     VIR_STORAGE_POOL_ZFS,      /* ZFS */
+     VIR_STORAGE_POOL_VSTORAGE, /* Virtuozzo Storage */
++    VIR_STORAGE_POOL_VITASTOR, /* Vitastor */
+ 
+     VIR_STORAGE_POOL_LAST,
+ } virStoragePoolType;
+@@ -454,6 +455,7 @@ VIR_ENUM_DECL(virStoragePartedFs);
+                  VIR_CONNECT_LIST_STORAGE_POOLS_SCSI     | \
+                  VIR_CONNECT_LIST_STORAGE_POOLS_MPATH    | \
+                  VIR_CONNECT_LIST_STORAGE_POOLS_RBD      | \
++                 VIR_CONNECT_LIST_STORAGE_POOLS_VITASTOR | \
+                  VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG | \
+                  VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER  | \
+                  VIR_CONNECT_LIST_STORAGE_POOLS_ZFS      | \
+diff --git a/src/conf/storage_source_conf.c b/src/conf/storage_source_conf.c
+index 8a063be244..dd9c7f11a2 100644
+--- a/src/conf/storage_source_conf.c
++++ b/src/conf/storage_source_conf.c
+@@ -89,6 +89,7 @@ VIR_ENUM_IMPL(virStorageNetProtocol,
+               "ssh",
+               "vxhs",
+               "nfs",
++              "vitastor",
+ );
+ 
+ 
+@@ -1314,6 +1315,7 @@ virStorageSourceNetworkDefaultPort(virStorageNetProtocol protocol)
+         case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+             return 24007;
+ 
++        case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+         case VIR_STORAGE_NET_PROTOCOL_RBD:
+             /* we don't provide a default for RBD */
+             return 0;
+diff --git a/src/conf/storage_source_conf.h b/src/conf/storage_source_conf.h
+index ebddf28cd6..873a2be65c 100644
+--- a/src/conf/storage_source_conf.h
++++ b/src/conf/storage_source_conf.h
+@@ -130,6 +130,7 @@ typedef enum {
+     VIR_STORAGE_NET_PROTOCOL_SSH,
+     VIR_STORAGE_NET_PROTOCOL_VXHS,
+     VIR_STORAGE_NET_PROTOCOL_NFS,
++    VIR_STORAGE_NET_PROTOCOL_VITASTOR,
+ 
+     VIR_STORAGE_NET_PROTOCOL_LAST
+ } virStorageNetProtocol;
+diff --git a/src/conf/virstorageobj.c b/src/conf/virstorageobj.c
+index 59fa5da372..4739167f5f 100644
+--- a/src/conf/virstorageobj.c
++++ b/src/conf/virstorageobj.c
+@@ -1438,6 +1438,7 @@ virStoragePoolObjSourceFindDuplicateCb(const void *payload,
+             return 1;
+         break;
+ 
++    case VIR_STORAGE_POOL_VITASTOR:
+     case VIR_STORAGE_POOL_ISCSI_DIRECT:
+     case VIR_STORAGE_POOL_RBD:
+     case VIR_STORAGE_POOL_LAST:
+@@ -1921,6 +1922,8 @@ virStoragePoolObjMatch(virStoragePoolObj *obj,
+                (obj->def->type == VIR_STORAGE_POOL_MPATH))   ||
+               (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_RBD) &&
+                (obj->def->type == VIR_STORAGE_POOL_RBD))     ||
++              (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_VITASTOR) &&
++               (obj->def->type == VIR_STORAGE_POOL_VITASTOR)) ||
+               (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG) &&
+                (obj->def->type == VIR_STORAGE_POOL_SHEEPDOG)) ||
+               (MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER) &&
+diff --git a/src/libvirt-storage.c b/src/libvirt-storage.c
+index db7660aac4..561df34709 100644
+--- a/src/libvirt-storage.c
++++ b/src/libvirt-storage.c
+@@ -94,6 +94,7 @@ virStoragePoolGetConnect(virStoragePoolPtr pool)
+  * VIR_CONNECT_LIST_STORAGE_POOLS_SCSI
+  * VIR_CONNECT_LIST_STORAGE_POOLS_MPATH
+  * VIR_CONNECT_LIST_STORAGE_POOLS_RBD
++ * VIR_CONNECT_LIST_STORAGE_POOLS_VITASTOR
+  * VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG
+  * VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER
+  * VIR_CONNECT_LIST_STORAGE_POOLS_ZFS
+diff --git a/src/libxl/libxl_conf.c b/src/libxl/libxl_conf.c
+index bdd30dd65a..5353e00b4a 100644
+--- a/src/libxl/libxl_conf.c
++++ b/src/libxl/libxl_conf.c
+@@ -1081,6 +1081,7 @@ libxlMakeNetworkDiskSrcStr(virStorageSource *src,
+     case VIR_STORAGE_NET_PROTOCOL_SSH:
+     case VIR_STORAGE_NET_PROTOCOL_VXHS:
+     case VIR_STORAGE_NET_PROTOCOL_NFS:
++    case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+     case VIR_STORAGE_NET_PROTOCOL_LAST:
+     case VIR_STORAGE_NET_PROTOCOL_NONE:
+         virReportError(VIR_ERR_NO_SUPPORT,
+diff --git a/src/libxl/xen_xl.c b/src/libxl/xen_xl.c
+index ec8de30c01..61eab9606d 100644
+--- a/src/libxl/xen_xl.c
++++ b/src/libxl/xen_xl.c
+@@ -1461,6 +1461,7 @@ xenFormatXLDiskSrcNet(virStorageSource *src)
+     case VIR_STORAGE_NET_PROTOCOL_SSH:
+     case VIR_STORAGE_NET_PROTOCOL_VXHS:
+     case VIR_STORAGE_NET_PROTOCOL_NFS:
++    case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+     case VIR_STORAGE_NET_PROTOCOL_LAST:
+     case VIR_STORAGE_NET_PROTOCOL_NONE:
+         virReportError(VIR_ERR_NO_SUPPORT,
+diff --git a/src/qemu/qemu_block.c b/src/qemu/qemu_block.c
+index 32568d4ae6..e625fa0720 100644
+--- a/src/qemu/qemu_block.c
++++ b/src/qemu/qemu_block.c
+@@ -731,6 +731,38 @@ qemuBlockStorageSourceGetRBDProps(virStorageSource *src,
+ }
+ 
+ 
++static virJSONValue *
++qemuBlockStorageSourceGetVitastorProps(virStorageSource *src)
++{
++    virJSONValue *ret = NULL;
++    virStorageNetHostDef *host;
++    size_t i;
++    g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
++    g_autofree char *etcd = NULL;
++
++    for (i = 0; i < src->nhosts; i++) {
++        host = src->hosts + i;
++        if ((virStorageNetHostTransport)host->transport != VIR_STORAGE_NET_HOST_TRANS_TCP) {
++            return NULL;
++        }
++        virBufferAsprintf(&buf, i > 0 ? ",%s:%u" : "%s:%u", host->name, host->port);
++    }
++    if (src->nhosts > 0) {
++        etcd = virBufferContentAndReset(&buf);
++    }
++
++    if (virJSONValueObjectAdd(&ret,
++                              "S:etcd-host", etcd,
++                              "S:etcd-prefix", src->query,
++                              "S:config-path", src->configFile,
++                              "s:image", src->path,
++                              NULL) < 0)
++        return NULL;
++
++    return ret;
++}
++
++
+ static virJSONValue *
+ qemuBlockStorageSourceGetSshProps(virStorageSource *src)
+ {
+@@ -1082,6 +1114,12 @@ qemuBlockStorageSourceGetBackendProps(virStorageSource *src,
+                 return NULL;
+             break;
+ 
++        case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
++            driver = "vitastor";
++            if (!(fileprops = qemuBlockStorageSourceGetVitastorProps(src)))
++                return NULL;
++            break;
++
+         case VIR_STORAGE_NET_PROTOCOL_SSH:
+             driver = "ssh";
+             if (!(fileprops = qemuBlockStorageSourceGetSshProps(src)))
+@@ -1985,6 +2023,7 @@ qemuBlockGetBackingStoreString(virStorageSource *src,
+ 
+             case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+             case VIR_STORAGE_NET_PROTOCOL_RBD:
++            case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+             case VIR_STORAGE_NET_PROTOCOL_VXHS:
+             case VIR_STORAGE_NET_PROTOCOL_NFS:
+             case VIR_STORAGE_NET_PROTOCOL_SSH:
+@@ -2365,6 +2404,12 @@ qemuBlockStorageSourceCreateGetStorageProps(virStorageSource *src,
+                 return -1;
+             break;
+ 
++        case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
++            driver = "vitastor";
++            if (!(location = qemuBlockStorageSourceGetVitastorProps(src)))
++                return -1;
++            break;
++
+         case VIR_STORAGE_NET_PROTOCOL_SSH:
+             if (srcPriv->nbdkitProcess) {
+                 /* disk creation not yet supported with nbdkit, and even if it
+diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
+index 0d2548d8d4..91121d6e1f 100644
+--- a/src/qemu/qemu_domain.c
++++ b/src/qemu/qemu_domain.c
+@@ -4526,7 +4526,8 @@ qemuDomainValidateStorageSource(virStorageSource *src,
+     if (src->query &&
+         (actualType != VIR_STORAGE_TYPE_NETWORK ||
+          (src->protocol != VIR_STORAGE_NET_PROTOCOL_HTTPS &&
+-          src->protocol != VIR_STORAGE_NET_PROTOCOL_HTTP))) {
++          src->protocol != VIR_STORAGE_NET_PROTOCOL_HTTP &&
++          src->protocol != VIR_STORAGE_NET_PROTOCOL_VITASTOR))) {
+         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                        _("query is supported only with HTTP(S) protocols"));
+         return -1;
+@@ -8954,6 +8955,7 @@ qemuDomainPrepareStorageSourceTLS(virStorageSource *src,
+         break;
+ 
+     case VIR_STORAGE_NET_PROTOCOL_RBD:
++    case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+     case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+     case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+     case VIR_STORAGE_NET_PROTOCOL_ISCSI:
+diff --git a/src/qemu/qemu_snapshot.c b/src/qemu/qemu_snapshot.c
+index 8128154749..afb339b9b0 100644
+--- a/src/qemu/qemu_snapshot.c
++++ b/src/qemu/qemu_snapshot.c
+@@ -662,6 +662,7 @@ qemuSnapshotPrepareDiskExternalInactive(virDomainSnapshotDiskDef *snapdisk,
+         case VIR_STORAGE_NET_PROTOCOL_NONE:
+         case VIR_STORAGE_NET_PROTOCOL_NBD:
+         case VIR_STORAGE_NET_PROTOCOL_RBD:
++        case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+         case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+         case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+         case VIR_STORAGE_NET_PROTOCOL_ISCSI:
+@@ -887,6 +888,7 @@ qemuSnapshotPrepareDiskInternal(virDomainDiskDef *disk,
+         case VIR_STORAGE_NET_PROTOCOL_NONE:
+         case VIR_STORAGE_NET_PROTOCOL_NBD:
+         case VIR_STORAGE_NET_PROTOCOL_RBD:
++        case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
+         case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+         case VIR_STORAGE_NET_PROTOCOL_GLUSTER:
+         case VIR_STORAGE_NET_PROTOCOL_ISCSI:
+diff --git a/src/storage/storage_driver.c b/src/storage/storage_driver.c
+index e19e032427..59f91f4710 100644
+--- a/src/storage/storage_driver.c
++++ b/src/storage/storage_driver.c
+@@ -1626,6 +1626,7 @@ storageVolLookupByPathCallback(virStoragePoolObj *obj,
+ 
+         case VIR_STORAGE_POOL_GLUSTER:
+         case VIR_STORAGE_POOL_RBD:
++        case VIR_STORAGE_POOL_VITASTOR:
+         case VIR_STORAGE_POOL_SHEEPDOG:
+         case VIR_STORAGE_POOL_ZFS:
+         case VIR_STORAGE_POOL_LAST:
+diff --git a/src/storage_file/storage_source_backingstore.c b/src/storage_file/storage_source_backingstore.c
+index 80681924ea..8a3ade9ec0 100644
+--- a/src/storage_file/storage_source_backingstore.c
++++ b/src/storage_file/storage_source_backingstore.c
+@@ -287,6 +287,75 @@ virStorageSourceParseRBDColonString(const char *rbdstr,
+ }
+ 
+ 
++static int
++virStorageSourceParseVitastorColonString(const char *colonstr,
++                                         virStorageSource *src)
++{
++    char *p, *e, *next;
++    g_autofree char *options = NULL;
++
++    /* optionally skip the "vitastor:" prefix if provided */
++    if (STRPREFIX(colonstr, "vitastor:"))
++        colonstr += strlen("vitastor:");
++
++    options = g_strdup(colonstr);
++
++    p = options;
++    while (*p) {
++        /* find : delimiter or end of string */
++        for (e = p; *e && *e != ':'; ++e) {
++            if (*e == '\\') {
++                e++;
++                if (*e == '\0')
++                    break;
++            }
++        }
++        if (*e == '\0') {
++            next = e;    /* last kv pair */
++        } else {
++            next = e + 1;
++            *e = '\0';
++        }
++
++        if (STRPREFIX(p, "image=")) {
++            src->path = g_strdup(p + strlen("image="));
++        } else if (STRPREFIX(p, "etcd-prefix=")) {
++            src->query = g_strdup(p + strlen("etcd-prefix="));
++        } else if (STRPREFIX(p, "config-path=")) {
++            src->configFile = g_strdup(p + strlen("config-path="));
++        } else if (STRPREFIX(p, "etcd-host=")) {
++            char *h, *sep;
++
++            h = p + strlen("etcd-host=");
++            while (h < e) {
++                for (sep = h; sep < e; ++sep) {
++                    if (*sep == '\\' && (sep[1] == ',' ||
++                                         sep[1] == ';' ||
++                                         sep[1] == ' ')) {
++                        *sep = '\0';
++                        sep += 2;
++                        break;
++                    }
++                }
++
++                if (virStorageSourceRBDAddHost(src, h) < 0)
++                    return -1;
++
++                h = sep;
++            }
++        }
++
++        p = next;
++    }
++
++    if (!src->path) {
++        return -1;
++    }
++
++    return 0;
++}
++
++
+ static int
+ virStorageSourceParseNBDColonString(const char *nbdstr,
+                                     virStorageSource *src)
+@@ -399,6 +468,11 @@ virStorageSourceParseBackingColon(virStorageSource *src,
+             return -1;
+         break;
+ 
++    case VIR_STORAGE_NET_PROTOCOL_VITASTOR:
++        if (virStorageSourceParseVitastorColonString(path, src) < 0)
++            return -1;
++        break;
++
+     case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
+     case VIR_STORAGE_NET_PROTOCOL_LAST:
+     case VIR_STORAGE_NET_PROTOCOL_NONE:
+@@ -975,6 +1049,54 @@ virStorageSourceParseBackingJSONRBD(virStorageSource *src,
+     return 0;
+ }
+ 
++static int
++virStorageSourceParseBackingJSONVitastor(virStorageSource *src,
++                                         virJSONValue *json,
++                                         const char *jsonstr G_GNUC_UNUSED,
++                                         int opaque G_GNUC_UNUSED)
++{
++    const char *filename;
++    const char *image = virJSONValueObjectGetString(json, "image");
++    const char *conf = virJSONValueObjectGetString(json, "config-path");
++    const char *etcd_prefix = virJSONValueObjectGetString(json, "etcd-prefix");
++    virJSONValue *servers = virJSONValueObjectGetArray(json, "server");
++    size_t nservers;
++    size_t i;
++
++    src->type = VIR_STORAGE_TYPE_NETWORK;
++    src->protocol = VIR_STORAGE_NET_PROTOCOL_VITASTOR;
++
++    /* legacy syntax passed via 'filename' option */
++    if ((filename = virJSONValueObjectGetString(json, "filename")))
++        return virStorageSourceParseVitastorColonString(filename, src);
++
++    if (!image) {
++        virReportError(VIR_ERR_INVALID_ARG, "%s",
++                       _("missing image name in Vitastor backing volume "
++                         "JSON specification"));
++        return -1;
++    }
++
++    src->path = g_strdup(image);
++    src->configFile = g_strdup(conf);
++    src->query = g_strdup(etcd_prefix);
++
++    if (servers) {
++        nservers = virJSONValueArraySize(servers);
++
++        src->hosts = g_new0(virStorageNetHostDef, nservers);
++        src->nhosts = nservers;
++
++        for (i = 0; i < nservers; i++) {
++            if (virStorageSourceParseBackingJSONInetSocketAddress(src->hosts + i,
++                                                                  virJSONValueArrayGet(servers, i)) < 0)
++                return -1;
++        }
++    }
++
++    return 0;
++}
++
+ static int
+ virStorageSourceParseBackingJSONRaw(virStorageSource *src,
+                                     virJSONValue *json,
+@@ -1152,6 +1274,7 @@ static const struct virStorageSourceJSONDriverParser jsonParsers[] = {
+     {"sheepdog", false, virStorageSourceParseBackingJSONSheepdog, 0},
+     {"ssh", false, virStorageSourceParseBackingJSONSSH, 0},
+     {"rbd", false, virStorageSourceParseBackingJSONRBD, 0},
++    {"vitastor", false, virStorageSourceParseBackingJSONVitastor, 0},
+     {"raw", true, virStorageSourceParseBackingJSONRaw, 0},
+     {"nfs", false, virStorageSourceParseBackingJSONNFS, 0},
+     {"vxhs", false, virStorageSourceParseBackingJSONVxHS, 0},
+diff --git a/src/test/test_driver.c b/src/test/test_driver.c
+index 25335d9002..cf54069fbe 100644
+--- a/src/test/test_driver.c
++++ b/src/test/test_driver.c
+@@ -7340,6 +7340,7 @@ testStorageVolumeTypeForPool(int pooltype)
+     case VIR_STORAGE_POOL_ISCSI_DIRECT:
+     case VIR_STORAGE_POOL_GLUSTER:
+     case VIR_STORAGE_POOL_RBD:
++    case VIR_STORAGE_POOL_VITASTOR:
+         return VIR_STORAGE_VOL_NETWORK;
+     case VIR_STORAGE_POOL_LOGICAL:
+     case VIR_STORAGE_POOL_DISK:
+diff --git a/tests/storagepoolcapsschemadata/poolcaps-fs.xml b/tests/storagepoolcapsschemadata/poolcaps-fs.xml
+index eee75af746..8bd0a57bdd 100644
+--- a/tests/storagepoolcapsschemadata/poolcaps-fs.xml
++++ b/tests/storagepoolcapsschemadata/poolcaps-fs.xml
+@@ -204,4 +204,11 @@
+       </enum>
+     </volOptions>
+   </pool>
++  <pool type='vitastor' supported='no'>
++    <volOptions>
++      <defaultFormat type='raw'/>
++      <enum name='targetFormatType'>
++      </enum>
++    </volOptions>
++  </pool>
+ </storagepoolCapabilities>
+diff --git a/tests/storagepoolcapsschemadata/poolcaps-full.xml b/tests/storagepoolcapsschemadata/poolcaps-full.xml
+index 805950a937..852df0de16 100644
+--- a/tests/storagepoolcapsschemadata/poolcaps-full.xml
++++ b/tests/storagepoolcapsschemadata/poolcaps-full.xml
+@@ -204,4 +204,11 @@
+       </enum>
+     </volOptions>
+   </pool>
++  <pool type='vitastor' supported='yes'>
++    <volOptions>
++      <defaultFormat type='raw'/>
++      <enum name='targetFormatType'>
++      </enum>
++    </volOptions>
++  </pool>
+ </storagepoolCapabilities>
+diff --git a/tests/storagepoolxml2argvtest.c b/tests/storagepoolxml2argvtest.c
+index d5c2531ab8..b19308ac38 100644
+--- a/tests/storagepoolxml2argvtest.c
++++ b/tests/storagepoolxml2argvtest.c
+@@ -57,6 +57,7 @@ testCompareXMLToArgvFiles(bool shouldFail,
+     case VIR_STORAGE_POOL_GLUSTER:
+     case VIR_STORAGE_POOL_ZFS:
+     case VIR_STORAGE_POOL_VSTORAGE:
++    case VIR_STORAGE_POOL_VITASTOR:
+     case VIR_STORAGE_POOL_LAST:
+     default:
+         VIR_TEST_DEBUG("pool type '%s' has no xml2argv test", defTypeStr);
+diff --git a/tools/virsh-pool.c b/tools/virsh-pool.c
+index 2010ef1356..072e2ff9e8 100644
+--- a/tools/virsh-pool.c
++++ b/tools/virsh-pool.c
+@@ -1187,6 +1187,9 @@ cmdPoolList(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
+             case VIR_STORAGE_POOL_VSTORAGE:
+                 flags |= VIR_CONNECT_LIST_STORAGE_POOLS_VSTORAGE;
+                 break;
++            case VIR_STORAGE_POOL_VITASTOR:
++                flags |= VIR_CONNECT_LIST_STORAGE_POOLS_VITASTOR;
++                break;
+             case VIR_STORAGE_POOL_LAST:
+                 break;
+             }

rpm/build-tarball.sh

@@ -7,22 +7,24 @@ set -e
 VITASTOR=$(dirname $0)
 VITASTOR=$(realpath "$VITASTOR/..")
 
-EL=$(rpm --eval '%dist')
-if [ "$EL" = ".el8" ]; then
+REL=$(rpm --eval '%dist')
+REL=${REL##.}
+if [ "$REL" = "el8" ]; then
     # CentOS 8
     . /opt/rh/gcc-toolset-9/enable
-elif [ "$EL" = ".el7" ]; then
+elif [ "$REL" = "el7" ]; then
     # CentOS 7
     . /opt/rh/devtoolset-9/enable
 fi
 cd ~/rpmbuild/SPECS
 rpmbuild -bp fio.spec
 cd $VITASTOR
-VER=$(grep ^Version: rpm/vitastor-el7.spec | awk '{print $2}')
+VER=$(grep ^Version: rpm/vitastor-$REL.spec | awk '{print $2}')
+rm -rf fio
 ln -s ~/rpmbuild/BUILD/fio*/ fio
 sh copy-fio-includes.sh
 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-$VER/#" --exclude 'rpm/*.rpm' -czf $VITASTOR/../vitastor-$VER$(rpm --eval '%dist').tar.gz *
+perl -i -pe 's/(Requires:\s*fio)([^\n]+)?/$1 = '$FIO'/' $VITASTOR/rpm/vitastor-$REL.spec
+tar --transform "s#^#vitastor-$VER/#" --exclude 'rpm/*.rpm' -czf $VITASTOR/../vitastor-$VER.$REL.tar.gz $(ls | grep -v packages)

rpm/vitastor-build.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+set -e -x
+REL=$(rpm --eval '%dist')
+REL=${REL##.}
+cd /root/vitastor/rpm
+./build-tarball.sh
+VER=$(grep ^Version: vitastor-$REL.spec | awk '{print $2}')
+cp /root/vitastor-$VER.$REL.tar.gz ~/rpmbuild/SOURCES
+cp vitastor-$REL.spec ~/rpmbuild/SPECS/vitastor.spec
+cd ~/rpmbuild/SPECS/
+rpmbuild -ba vitastor.spec
+mkdir -p /root/vitastor/packages/vitastor-$REL
+rm -rf /root/vitastor/packages/vitastor-$REL/*
+cp ~/rpmbuild/RPMS/*/*vitastor* /root/vitastor/packages/vitastor-$REL/
+cp ~/rpmbuild/SRPMS/vitastor* /root/vitastor/packages/vitastor-$REL/

rpm/vitastor-el7.Dockerfile

@@ -1,5 +1,8 @@
 # Build packages for CentOS 7 inside a container
-# cd ..; podman build -t vitastor-el7 -v `pwd`/packages:/root/packages -f rpm/vitastor-el7.Dockerfile .
+# cd ..
+# docker build -t vitastor-buildenv:el7 -f rpm/vitastor-el7.Dockerfile .
+# docker run -i --rm -v ./:/root/vitastor vitastor-buildenv:el7 /root/vitastor/rpm/vitastor-build.sh
+
 # localedef -i ru_RU -f UTF-8 ru_RU.UTF-8
 
 FROM centos:7
@@ -7,7 +10,9 @@ FROM centos:7
 WORKDIR /root
 
 RUN rm -f /etc/yum.repos.d/CentOS-Media.repo
+RUN sed -i 's/^mirrorlist=/#mirrorlist=/; s!#baseurl=http://mirror.centos.org/centos/\$releasever!baseurl=http://vault.centos.org/7.9.2009!' /etc/yum.repos.d/*.repo
 RUN yum -y --enablerepo=extras install centos-release-scl epel-release yum-utils rpm-build
+RUN perl -i -pe 's!mirrorlist=!#mirrorlist=!s; s!#\s*baseurl=http://mirror.centos.org!baseurl=http://vault.centos.org!' /etc/yum.repos.d/CentOS-SCLo-scl*.repo
 RUN yum -y install https://vitastor.io/rpms/centos/7/vitastor-release-1.0-1.el7.noarch.rpm
 RUN yum -y install devtoolset-9-gcc-c++ devtoolset-9-libatomic-devel gcc make cmake gperftools-devel \
     fio rh-nodejs12 jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libnl3-devel
@@ -30,18 +35,3 @@ RUN set -e; \
     cp ~/rpmbuild/SRPMS/liburing* /root/packages/liburing-el7/
 
 RUN rpm -i `ls /root/packages/liburing-el7/liburing-*.x86_64.rpm | grep -v debug`
-
-ADD . /root/vitastor
-
-RUN set -e; \
-    cd /root/vitastor/rpm; \
-    sh build-tarball.sh; \
-    VER=$(grep ^Version: vitastor-el7.spec | awk '{print $2}'); \
-    cp /root/vitastor-$VER.el7.tar.gz ~/rpmbuild/SOURCES; \
-    cp vitastor-el7.spec ~/rpmbuild/SPECS/vitastor.spec; \
-    cd ~/rpmbuild/SPECS/; \
-    rpmbuild -ba vitastor.spec; \
-    mkdir -p /root/packages/vitastor-el7; \
-    rm -rf /root/packages/vitastor-el7/*; \
-    cp ~/rpmbuild/RPMS/*/*vitastor* /root/packages/vitastor-el7/; \
-    cp ~/rpmbuild/SRPMS/vitastor* /root/packages/vitastor-el7/

rpm/vitastor-el7.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        2.1.0
+Version:        2.2.3
 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-2.1.0.el7.tar.gz
+Source0:        vitastor-2.2.3.el7.tar.gz
 
 BuildRequires:  liburing-devel >= 0.6
 BuildRequires:  gperftools-devel
@@ -82,7 +82,7 @@ Vitastor library headers for development.
 Summary:        Vitastor - fio drivers
 Group:          Development/Libraries
 Requires:       vitastor-client = %{version}-%{release}
-Requires:       fio = 3.7-1.el7
+Requires:       fio = 3.7-2.el7
 
 
 %description -n vitastor-fio

rpm/vitastor-el8.Dockerfile

@@ -1,5 +1,7 @@
 # Build packages for CentOS 8 inside a container
-# cd ..; podman build -t vitastor-el8 -v `pwd`/packages:/root/packages -f rpm/vitastor-el8.Dockerfile .
+# cd ..
+# docker build -t vitastor-buildenv:el8 -f rpm/vitastor-el8.Dockerfile .
+# docker run -i --rm -v ./:/root/vitastor vitastor-buildenv:el8 /root/vitastor/rpm/vitastor-build.sh
 
 FROM centos:8
 
@@ -29,18 +31,3 @@ RUN set -e; \
     cp ~/rpmbuild/SRPMS/liburing* /root/packages/liburing-el8/
 
 RUN rpm -i `ls /root/packages/liburing-el8/liburing-*.x86_64.rpm | grep -v debug`
-
-ADD . /root/vitastor
-
-RUN set -e; \
-    cd /root/vitastor/rpm; \
-    sh build-tarball.sh; \
-    VER=$(grep ^Version: vitastor-el8.spec | awk '{print $2}'); \
-    cp /root/vitastor-$VER.el8.tar.gz ~/rpmbuild/SOURCES; \
-    cp vitastor-el8.spec ~/rpmbuild/SPECS/vitastor.spec; \
-    cd ~/rpmbuild/SPECS/; \
-    rpmbuild -ba vitastor.spec; \
-    mkdir -p /root/packages/vitastor-el8; \
-    rm -rf /root/packages/vitastor-el8/*; \
-    cp ~/rpmbuild/RPMS/*/*vitastor* /root/packages/vitastor-el8/; \
-    cp ~/rpmbuild/SRPMS/vitastor* /root/packages/vitastor-el8/

rpm/vitastor-el8.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        2.1.0
+Version:        2.2.3
 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-2.1.0.el8.tar.gz
+Source0:        vitastor-2.2.3.el8.tar.gz
 
 BuildRequires:  liburing-devel >= 0.6
 BuildRequires:  gperftools-devel
@@ -80,7 +80,7 @@ Vitastor library headers for development.
 Summary:        Vitastor - fio drivers
 Group:          Development/Libraries
 Requires:       vitastor-client = %{version}-%{release}
-Requires:       fio = 3.7-3.el8
+Requires:       fio = 3.19-3.el8
 
 
 %description -n vitastor-fio

rpm/vitastor-el9.Dockerfile

@@ -1,5 +1,7 @@
 # Build packages for AlmaLinux 9 inside a container
-# cd ..; podman build -t vitastor-el9 -v `pwd`/packages:/root/packages -f rpm/vitastor-el9.Dockerfile .
+# cd ..
+# docker build -t vitastor-buildenv:el9 -f rpm/vitastor-el9.Dockerfile .
+# docker run -i --rm -v ./:/root/vitastor vitastor-buildenv:el9 /root/vitastor/rpm/vitastor-build.sh
 
 FROM almalinux:9
 
@@ -12,18 +14,3 @@ RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel
 RUN dnf download --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN cd ~/rpmbuild/SPECS && dnf builddep -y --spec fio.spec
-
-ADD . /root/vitastor
-
-RUN set -e; \
-    cd /root/vitastor/rpm; \
-    sh build-tarball.sh; \
-    VER=$(grep ^Version: vitastor-el9.spec | awk '{print $2}'); \
-    cp /root/vitastor-$VER.el9.tar.gz ~/rpmbuild/SOURCES; \
-    cp vitastor-el9.spec ~/rpmbuild/SPECS/vitastor.spec; \
-    cd ~/rpmbuild/SPECS/; \
-    rpmbuild -ba vitastor.spec; \
-    mkdir -p /root/packages/vitastor-el9; \
-    rm -rf /root/packages/vitastor-el9/*; \
-    cp ~/rpmbuild/RPMS/*/*vitastor* /root/packages/vitastor-el9/; \
-    cp ~/rpmbuild/SRPMS/vitastor* /root/packages/vitastor-el9/

rpm/vitastor-el9.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        2.1.0
+Version:        2.2.3
 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-2.1.0.el9.tar.gz
+Source0:        vitastor-2.2.3.el9.tar.gz
 
 BuildRequires:  liburing-devel >= 0.6
 BuildRequires:  gperftools-devel

src/CMakeLists.txt

@@ -19,7 +19,7 @@ if("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/local/?$")
 	set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
 endif()
 
-add_definitions(-DVITASTOR_VERSION="2.1.0")
+add_definitions(-DVITASTOR_VERSION="2.2.3")
 add_definitions(-D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -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})

src/blockstore/blockstore.h

@@ -42,8 +42,7 @@
 #define BS_OP_DELETE 6
 #define BS_OP_LIST 7
 #define BS_OP_ROLLBACK 8
-#define BS_OP_SYNC_STAB_ALL 9
-#define BS_OP_MAX 9
+#define BS_OP_MAX 8
 
 #define BS_OP_PRIVATE_DATA_SIZE 256
 
@@ -113,14 +112,6 @@ Input:
 Output:
 - retval = 0 or negative error number (-ENOENT if no such version for stabilize)
 
-## BS_OP_SYNC_STAB_ALL
-
-ONLY FOR TESTS! Sync and mark all unstable object versions as stable, at once.
-
-Input: Nothing except opcode
-Output:
-- retval = 0 or negative error number (-EINVAL)
-
 ## BS_OP_LIST
 
 Get a list of all objects in this Blockstore.
@@ -147,7 +138,7 @@ Output:
 struct blockstore_op_t
 {
     // operation
-    uint64_t opcode;
+    uint64_t opcode = 0;
     // finish callback
     std::function<void (blockstore_op_t*)> callback;
     union __attribute__((__packed__))
@@ -171,9 +162,9 @@ struct blockstore_op_t
             uint32_t list_stable_limit;
         };
     };
-    void *buf;
-    void *bitmap;
-    int retval;
+    void *buf = NULL;
+    void *bitmap = NULL;
+    int retval = 0;
 
     uint8_t private_data[BS_OP_PRIVATE_DATA_SIZE];
 };

src/blockstore/blockstore_impl.cpp

@@ -343,44 +343,6 @@ void blockstore_impl_t::enqueue_op(blockstore_op_t *op)
         ringloop->set_immediate([op]() { std::function<void (blockstore_op_t*)>(op->callback)(op); });
         return;
     }
-    if (op->opcode == BS_OP_SYNC_STAB_ALL)
-    {
-        std::function<void(blockstore_op_t*)> *old_callback = new std::function<void(blockstore_op_t*)>(op->callback);
-        op->opcode = BS_OP_SYNC;
-        op->callback = [this, old_callback](blockstore_op_t *op)
-        {
-            if (op->retval >= 0 && unstable_writes.size() > 0)
-            {
-                op->opcode = BS_OP_STABLE;
-                op->len = unstable_writes.size();
-                obj_ver_id *vers = new obj_ver_id[op->len];
-                op->buf = vers;
-                int i = 0;
-                for (auto it = unstable_writes.begin(); it != unstable_writes.end(); it++, i++)
-                {
-                    vers[i] = {
-                        .oid = it->first,
-                        .version = it->second,
-                    };
-                }
-                unstable_writes.clear();
-                op->callback = [old_callback](blockstore_op_t *op)
-                {
-                    obj_ver_id *vers = (obj_ver_id*)op->buf;
-                    delete[] vers;
-                    op->buf = NULL;
-                    (*old_callback)(op);
-                    delete old_callback;
-                };
-                this->enqueue_op(op);
-            }
-            else
-            {
-                (*old_callback)(op);
-                delete old_callback;
-            }
-        };
-    }
     if ((op->opcode == BS_OP_WRITE || op->opcode == BS_OP_WRITE_STABLE || op->opcode == BS_OP_DELETE) && !enqueue_write(op))
     {
         ringloop->set_immediate([op]() { std::function<void (blockstore_op_t*)>(op->callback)(op); });

src/blockstore/blockstore_impl.h

@@ -266,6 +266,8 @@ class blockstore_impl_t
     int throttle_threshold_us = 50;
     // Maximum writes between automatically added fsync operations
     uint64_t autosync_writes = 128;
+    // Log level (0-10)
+    int log_level = 0;
     /******* END OF OPTIONS *******/
 
     struct ring_consumer_t ring_consumer;

src/blockstore/blockstore_journal.cpp

@@ -113,10 +113,13 @@ int blockstore_journal_check_t::check_available(blockstore_op_t *op, int entries
     if (!right_dir && next_pos >= bs->journal.used_start-bs->journal.block_size)
     {
         // No space in the journal. Wait until used_start changes.
-        printf(
-            "Ran out of journal space (used_start=%08jx, next_free=%08jx, dirty_start=%08jx)\n",
-            bs->journal.used_start, bs->journal.next_free, bs->journal.dirty_start
-        );
+        if (bs->log_level > 5)
+        {
+            printf(
+                "Ran out of journal space (used_start=%08jx, next_free=%08jx, dirty_start=%08jx)\n",
+                bs->journal.used_start, bs->journal.next_free, bs->journal.dirty_start
+            );
+        }
         PRIV(op)->wait_for = WAIT_JOURNAL;
         bs->flusher->request_trim();
         PRIV(op)->wait_detail = bs->journal.used_start;

src/blockstore/blockstore_open.cpp

@@ -101,6 +101,7 @@ void blockstore_impl_t::parse_config(blockstore_config_t & config, bool init)
         config["journal_no_same_sector_overwrites"] == "1" || config["journal_no_same_sector_overwrites"] == "yes";
     journal.inmemory = config["inmemory_journal"] != "false" && config["inmemory_journal"] != "0" &&
         config["inmemory_journal"] != "no";
+    log_level = strtoull(config["log_level"].c_str(), NULL, 10);
     // Validate
     if (journal.sector_count < 2)
     {

src/blockstore/fio_engine.cpp

@@ -5,14 +5,14 @@
 //
 // Initialize storage for tests:
 //
-// dd if=/dev/zero of=test_data.bin bs=1024 count=1048576
-// dd if=/dev/zero of=test_meta.bin bs=1024 count=256
-// dd if=/dev/zero of=test_journal.bin bs=1024 count=4096
+// dd if=/dev/zero of=test_data.bin bs=1M count=1024
 //
 // Random write:
 //
-// fio -thread -ioengine=./libfio_blockstore.so -name=test -bs=4k -direct=1 -fsync=16 -iodepth=16 -rw=randwrite \
-//     -bs_config='{"data_device":"./test_data.bin"}' -size=1000M
+// [LD_PRELOAD=libasan.so.8] \
+// fio -name=test -thread -ioengine=../build/src/blockstore/libfio_vitastor_blk.so \
+//     -bs=4k -direct=1 -rw=randwrite -iodepth=16 -size=900M -loops=10 \
+//     -bs_config='{"data_device":"./test_data.bin","meta_offset":0,"journal_offset":16777216,"data_offset":33554432,"disable_data_fsync":true,"immediate_commit":"all","journal_no_same_sector_overwrites":true}'
 //
 // Linear write:
 //
@@ -38,12 +38,14 @@ struct bs_data
     std::vector<io_u*> completed;
     int op_n = 0, inflight = 0;
     bool last_sync = false;
+    bool trace = false;
 };
 
 struct bs_options
 {
     int __pad;
     char *json_config = NULL;
+    int trace = 0;
 };
 
 static struct fio_option options[] = {
@@ -56,6 +58,16 @@ static struct fio_option options[] = {
         .category = FIO_OPT_C_ENGINE,
         .group  = FIO_OPT_G_FILENAME,
     },
+    {
+        .name   = "bs_trace",
+        .lname  = "trace",
+        .type   = FIO_OPT_BOOL,
+        .off1   = offsetof(struct bs_options, trace),
+        .help   = "Trace operations",
+        .def    = "0",
+        .category = FIO_OPT_C_ENGINE,
+        .group  = FIO_OPT_G_FILENAME,
+    },
     {
         .name = NULL,
     },
@@ -63,6 +75,7 @@ static struct fio_option options[] = {
 
 static int bs_setup(struct thread_data *td)
 {
+    bs_options *o = (bs_options*)td->eo;
     bs_data *bsd;
     //fio_file *f;
     //int r;
@@ -83,6 +96,8 @@ static int bs_setup(struct thread_data *td)
         td->o.open_files++;
     }
 
+    bsd->trace = o->trace ? true : false;
+
     //f = td->files[0];
     //f->real_file_size = size;
     return 0;
@@ -176,20 +191,19 @@ static enum fio_q_status bs_queue(struct thread_data *td, struct io_u *io)
         op->version = UINT64_MAX; // last unstable
         op->offset = io->offset % bsd->bs->get_block_size();
         op->len = io->xfer_buflen;
-        op->callback = [io](blockstore_op_t *op)
+        op->callback = [io, n = bsd->op_n](blockstore_op_t *op)
         {
             io->error = op->retval < 0 ? -op->retval : 0;
             bs_data *bsd = (bs_data*)io->engine_data;
             bsd->inflight--;
             bsd->completed.push_back(io);
-#ifdef BLOCKSTORE_DEBUG
-            printf("--- OP_READ %llx n=%d retval=%d\n", io, n, op->retval);
-#endif
+            if (bsd->trace)
+                printf("--- OP_READ %zx n=%d retval=%d\n", (size_t)op, n, op->retval);
             delete op;
         };
         break;
     case DDIR_WRITE:
-        op->opcode = BS_OP_WRITE;
+        op->opcode = BS_OP_WRITE_STABLE;
         op->buf = io->xfer_buf;
         op->oid = {
             .inode = 1,
@@ -198,30 +212,28 @@ static enum fio_q_status bs_queue(struct thread_data *td, struct io_u *io)
         op->version = 0; // assign automatically
         op->offset = io->offset % bsd->bs->get_block_size();
         op->len = io->xfer_buflen;
-        op->callback = [io](blockstore_op_t *op)
+        op->callback = [io, n = bsd->op_n](blockstore_op_t *op)
         {
             io->error = op->retval < 0 ? -op->retval : 0;
             bs_data *bsd = (bs_data*)io->engine_data;
             bsd->inflight--;
             bsd->completed.push_back(io);
-#ifdef BLOCKSTORE_DEBUG
-            printf("--- OP_WRITE %llx n=%d retval=%d\n", io, n, op->retval);
-#endif
+            if (bsd->trace)
+                printf("--- OP_WRITE %zx n=%d retval=%d\n", (size_t)op, n, op->retval);
             delete op;
         };
         bsd->last_sync = false;
         break;
     case DDIR_SYNC:
-        op->opcode = BS_OP_SYNC_STAB_ALL;
-        op->callback = [io](blockstore_op_t *op)
+        op->opcode = BS_OP_SYNC;
+        op->callback = [io, n = bsd->op_n](blockstore_op_t *op)
         {
             bs_data *bsd = (bs_data*)io->engine_data;
             io->error = op->retval < 0 ? -op->retval : 0;
             bsd->completed.push_back(io);
             bsd->inflight--;
-#ifdef BLOCKSTORE_DEBUG
-            printf("--- OP_SYNC %llx n=%d retval=%d\n", io, n, op->retval);
-#endif
+            if (bsd->trace)
+                printf("--- OP_SYNC %zx n=%d retval=%d\n", (size_t)op, n, op->retval);
             delete op;
         };
         bsd->last_sync = true;
@@ -232,9 +244,8 @@ static enum fio_q_status bs_queue(struct thread_data *td, struct io_u *io)
         return FIO_Q_COMPLETED;
     }
 
-#ifdef BLOCKSTORE_DEBUG
-    printf("+++ %s %llx n=%d\n", op->opcode == OP_READ ? "OP_READ" : (op->opcode == OP_WRITE ? "OP_WRITE" : "OP_SYNC"), io, n);
-#endif
+    if (bsd->trace)
+        printf("+++ %s %zx n=%d\n", op->opcode == BS_OP_READ ? "OP_READ" : (op->opcode == BS_OP_WRITE_STABLE ? "OP_WRITE" : "OP_SYNC"), (size_t)op, bsd->op_n);
     io->error = 0;
     bsd->inflight++;
     bsd->bs->enqueue_op(op);

src/client/CMakeLists.txt

@@ -93,7 +93,7 @@ add_executable(test_cluster_client
 	EXCLUDE_FROM_ALL
 	../test/test_cluster_client.cpp
 	pg_states.cpp osd_ops.cpp cluster_client.cpp cluster_client_list.cpp cluster_client_wb.cpp msgr_op.cpp ../test/mock/messenger.cpp msgr_stop.cpp
-	etcd_state_client.cpp ../util/timerfd_manager.cpp ../util/str_util.cpp ../util/json_util.cpp ../../json11/json11.cpp
+	etcd_state_client.cpp ../util/timerfd_manager.cpp ../util/addr_util.cpp ../util/str_util.cpp ../util/json_util.cpp ../../json11/json11.cpp
 )
 target_compile_definitions(test_cluster_client PUBLIC -D__MOCK__)
 target_include_directories(test_cluster_client BEFORE PUBLIC ${CMAKE_SOURCE_DIR}/src/test/mock)

src/client/cluster_client.cpp

@@ -3,6 +3,7 @@
 
 #include <stdexcept>
 #include <assert.h>
+#include "pg_states.h"
 #include "cluster_client_impl.h"
 #include "json_util.h"
 
@@ -56,7 +57,9 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
     st_cli.on_load_config_hook = [this](json11::Json::object & cfg) { on_load_config_hook(cfg); };
     st_cli.on_change_osd_state_hook = [this](uint64_t peer_osd) { on_change_osd_state_hook(peer_osd); };
     st_cli.on_change_pool_config_hook = [this]() { on_change_pool_config_hook(); };
+    st_cli.on_change_pg_config_hook = [this]() { on_change_pool_config_hook(); };
     st_cli.on_change_pg_state_hook = [this](pool_id_t pool_id, pg_num_t pg_num, osd_num_t prev_primary) { on_change_pg_state_hook(pool_id, pg_num, prev_primary); };
+    st_cli.on_change_node_placement_hook = [this]() { on_change_node_placement_hook(); };
     st_cli.on_load_pgs_hook = [this](bool success) { on_load_pgs_hook(success); };
     st_cli.on_reload_hook = [this]() { st_cli.load_global_config(); };
 
@@ -470,14 +473,98 @@ void cluster_client_t::on_load_config_hook(json11::Json::object & etcd_global_co
     }
     // log_level
     log_level = config["log_level"].uint64_value();
+    // hostname
+    conf_hostname = config["hostname"].string_value();
+    auto new_hostname = conf_hostname != "" ? conf_hostname : gethostname_str();
+    if (new_hostname != client_hostname)
+    {
+        self_tree_metrics.clear();
+        client_hostname = new_hostname;
+    }
     msgr.parse_config(config);
     st_cli.parse_config(config);
     st_cli.load_pgs();
 }
 
+osd_num_t cluster_client_t::select_random_osd(const std::vector<osd_num_t> & osds)
+{
+    osd_num_t alive_set[osds.size()];
+    int alive_count = 0;
+    for (auto & osd_num: osds)
+    {
+        if (!st_cli.peer_states[osd_num].is_null())
+            alive_set[alive_count++] = osd_num;
+    }
+    if (!alive_count)
+        return 0;
+    return alive_set[lrand48() % alive_count];
+}
+
+osd_num_t cluster_client_t::select_nearest_osd(const std::vector<osd_num_t> & osds)
+{
+    if (!self_tree_metrics.size())
+    {
+        std::string cur_id = client_hostname;
+        int metric = 0;
+        while (self_tree_metrics.find(cur_id) == self_tree_metrics.end())
+        {
+            self_tree_metrics[cur_id] = metric++;
+            json11::Json cur_placement = st_cli.node_placement[cur_id];
+            cur_id = cur_placement["parent"].string_value();
+        }
+        if (cur_id != "")
+        {
+            self_tree_metrics[""] = metric++;
+        }
+    }
+    osd_num_t best_osd = 0;
+    int best_metric = -1;
+    for (auto & osd_num: osds)
+    {
+        int metric = -1;
+        auto met_it = osd_tree_metrics.find(osd_num);
+        if (met_it != osd_tree_metrics.end())
+        {
+            metric = met_it->second;
+        }
+        else
+        {
+            auto & peer_state = st_cli.peer_states[osd_num];
+            if (!peer_state.is_null())
+            {
+                metric = self_tree_metrics[""];
+                bool first = true;
+                std::string cur_id = std::to_string(osd_num);
+                std::set<std::string> seen;
+                while (seen.find(cur_id) == seen.end())
+                {
+                    seen.insert(cur_id);
+                    json11::Json cur_placement = st_cli.node_placement[cur_id];
+                    std::string cur_parent = cur_placement["parent"].string_value();
+                    cur_id = (!first || cur_parent != "" ? cur_parent : peer_state["host"].string_value());
+                    first = false;
+                    auto self_it = self_tree_metrics.find(cur_id);
+                    if (self_it != self_tree_metrics.end())
+                    {
+                        metric = self_it->second;
+                        break;
+                    }
+                }
+            }
+            osd_tree_metrics[osd_num] = metric;
+        }
+        if (metric >= 0 && (best_metric < 0 || metric < best_metric))
+        {
+            best_metric = metric;
+            best_osd = osd_num;
+        }
+    }
+    return best_osd;
+}
+
 void cluster_client_t::on_load_pgs_hook(bool success)
 {
-    for (auto pool_item: st_cli.pool_config)
+    for (auto & pool_item: st_cli.pool_config)
     {
         pg_counts[pool_item.first] = pool_item.second.real_pg_count;
     }
@@ -497,10 +584,15 @@ void cluster_client_t::on_load_pgs_hook(bool success)
 
 void cluster_client_t::on_change_pool_config_hook()
 {
-    for (auto pool_item: st_cli.pool_config)
+    for (auto & pool_item: st_cli.pool_config)
     {
         if (pg_counts[pool_item.first] != pool_item.second.real_pg_count)
         {
+            if (log_level > 2 && pg_counts[pool_item.first])
+            {
+                printf("Pool %u (%s) PG count changed from %lu to %lu\n", pool_item.first, pool_item.second.name.c_str(),
+                    pg_counts[pool_item.first], pool_item.second.real_pg_count);
+            }
             // At this point, all pool operations should have been suspended
             // And now they have to be resliced!
             for (auto op = op_queue_head; op; op = op->next)
@@ -546,6 +638,7 @@ bool cluster_client_t::get_immediate_commit(uint64_t inode)
 
 void cluster_client_t::on_change_osd_state_hook(uint64_t peer_osd)
 {
+    osd_tree_metrics.erase(peer_osd);
     if (msgr.wanted_peers.find(peer_osd) != msgr.wanted_peers.end())
     {
         msgr.connect_peer(peer_osd, st_cli.peer_states[peer_osd]);
@@ -553,6 +646,12 @@ void cluster_client_t::on_change_osd_state_hook(uint64_t peer_osd)
     }
 }
 
+void cluster_client_t::on_change_node_placement_hook()
+{
+    osd_tree_metrics.clear();
+    self_tree_metrics.clear();
+}
+
 bool cluster_client_t::is_ready()
 {
     return pgs_loaded;
@@ -1221,6 +1320,17 @@ int cluster_client_t::try_send(cluster_op_t *op, int i)
         !pg_it->second.pause && pg_it->second.cur_primary)
     {
         osd_num_t primary_osd = pg_it->second.cur_primary;
+        if (pool_cfg.local_reads != POOL_LOCAL_READ_PRIMARY &&
+            pool_cfg.scheme == POOL_SCHEME_REPLICATED &&
+            (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP) &&
+            (pg_it->second.cur_state == PG_ACTIVE || pg_it->second.cur_state == (PG_ACTIVE|PG_LEFT_ON_DEAD)))
+        {
+            osd_num_t nearest_osd = pool_cfg.local_reads == POOL_LOCAL_READ_NEAREST
+                ? select_nearest_osd(pg_it->second.target_set)
+                : select_random_osd(pg_it->second.target_set);
+            if (nearest_osd)
+                primary_osd = nearest_osd;
+        }
         part->osd_num = primary_osd;
         auto peer_it = msgr.osd_peer_fds.find(primary_osd);
         if (peer_it != msgr.osd_peer_fds.end())
@@ -1244,7 +1354,6 @@ int cluster_client_t::try_send(cluster_op_t *op, int i)
                 .req = { .rw = {
                     .header = {
                         .magic = SECONDARY_OSD_OP_MAGIC,
-                        .id = next_op_id(),
                         .opcode = op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP ? OSD_OP_READ : op->opcode,
                     },
                     .inode = op->cur_inode,
@@ -1353,7 +1462,6 @@ void cluster_client_t::send_sync(cluster_op_t *op, cluster_op_part_t *part)
         .req = {
             .hdr = {
                 .magic = SECONDARY_OSD_OP_MAGIC,
-                .id = next_op_id(),
                 .opcode = OSD_OP_SYNC,
             },
         },
@@ -1498,8 +1606,3 @@ void cluster_client_t::copy_part_bitmap(cluster_op_t *op, cluster_op_part_t *par
         part_len--;
     }
 }
-
-uint64_t cluster_client_t::next_op_id()
-{
-    return msgr.next_subop_id++;
-}

src/client/cluster_client.h

@@ -86,8 +86,8 @@ class cluster_client_t
 #ifdef __MOCK__
 public:
 #endif
-    timerfd_manager_t *tfd;
-    ring_loop_t *ringloop;
+    timerfd_manager_t *tfd = NULL;
+    ring_loop_t *ringloop = NULL;
 
     std::map<pool_id_t, uint64_t> pg_counts;
     std::map<pool_pg_num_t, osd_num_t> pg_primary;
@@ -100,6 +100,7 @@ public:
     uint64_t client_max_buffered_bytes = 0;
     uint64_t client_max_buffered_ops = 0;
     uint64_t client_max_writeback_iodepth = 0;
+    std::string conf_hostname;
 
     int log_level = 0;
     int client_retry_interval = 50; // ms
@@ -107,6 +108,10 @@ public:
     bool client_retry_enospc = true;
     int client_wait_up_timeout = 16; // sec (for listings)
 
+    std::string client_hostname;
+    std::map<std::string, int> self_tree_metrics;
+    std::map<osd_num_t, int> osd_tree_metrics;
+
     int retry_timeout_id = -1;
     int retry_timeout_duration = 0;
     std::vector<cluster_op_t*> offline_ops;
@@ -152,7 +157,6 @@ public:
 
     //inline uint32_t get_bs_bitmap_granularity() { return st_cli.global_bitmap_granularity; }
     //inline uint64_t get_bs_block_size() { return st_cli.global_block_size; }
-    uint64_t next_op_id();
 
 #ifndef __MOCK__
 protected:
@@ -162,11 +166,14 @@ protected:
 protected:
     bool affects_osd(uint64_t inode, uint64_t offset, uint64_t len, osd_num_t osd);
     bool affects_pg(uint64_t inode, uint64_t offset, uint64_t len, pool_id_t pool_id, pg_num_t pg_num);
+
     void on_load_config_hook(json11::Json::object & config);
     void on_load_pgs_hook(bool success);
     void on_change_pool_config_hook();
     void on_change_pg_state_hook(pool_id_t pool_id, pg_num_t pg_num, osd_num_t prev_primary);
     void on_change_osd_state_hook(uint64_t peer_osd);
+    void on_change_node_placement_hook();
+
     void execute_internal(cluster_op_t *op);
     void unshift_op(cluster_op_t *op);
     int continue_rw(cluster_op_t *op);
@@ -192,5 +199,8 @@ protected:
     bool check_finish_listing(inode_list_t *lst);
     void continue_raw_ops(osd_num_t peer_osd);
 
+    osd_num_t select_random_osd(const std::vector<osd_num_t> & osds);
+    osd_num_t select_nearest_osd(const std::vector<osd_num_t> & osds);
+
     friend class writeback_cache_t;
 };

src/client/cluster_client_list.cpp

@@ -342,7 +342,6 @@ void cluster_client_t::send_list(inode_list_osd_t *cur_list)
         .sec_list = {
             .header = {
                 .magic = SECONDARY_OSD_OP_MAGIC,
-                .id = next_op_id(),
                 .opcode = OSD_OP_SEC_LIST,
             },
             .list_pg = cur_list->pg->pg_num,

src/client/etcd_state_client.cpp

@@ -922,6 +922,19 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
                 pc.used_for_app = "fs:"+pc.used_for_app;
             else
                 pc.used_for_app = pool_item.second["used_for_app"].as_string();
+            // Local Read Configuration
+            std::string local_reads = pool_item.second["local_reads"].string_value();
+            if (local_reads == "nearest")
+                pc.local_reads = POOL_LOCAL_READ_NEAREST;
+            else if (local_reads == "random")
+                pc.local_reads = POOL_LOCAL_READ_RANDOM;
+            else if (local_reads == "" || local_reads == "primary")
+                pc.local_reads = POOL_LOCAL_READ_PRIMARY;
+            else
+            {
+                pc.local_reads = POOL_LOCAL_READ_PRIMARY;
+                fprintf(stderr, "Warning: Pool %u has invalid local_reads, using 'primary'\n", pool_id);
+            }
             // Immediate Commit Mode
             pc.immediate_commit = pool_item.second["immediate_commit"].is_string()
                 ? parse_immediate_commit(pool_item.second["immediate_commit"].string_value(), IMMEDIATE_ALL)
@@ -1043,6 +1056,10 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
             }
             pool_item.second.real_pg_count = n;
         }
+        if (on_change_pg_config_hook)
+        {
+            on_change_pg_config_hook();
+        }
     }
     else if (key.substr(0, etcd_prefix.length()+12) == etcd_prefix+"/pg/history/")
     {
@@ -1169,9 +1186,7 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
         osd_num_t peer_osd = std::stoull(key.substr(etcd_prefix.length()+11));
         if (peer_osd > 0)
         {
-            if (value.is_object() && value["state"] == "up" &&
-                value["addresses"].is_array() &&
-                value["port"].int64_value() > 0 && value["port"].int64_value() < 65536)
+            if (value.is_object() && value["state"] == "up")
             {
                 this->peer_states[peer_osd] = value;
                 this->seen_peers.insert(peer_osd);
@@ -1256,6 +1271,13 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
             }
         }
     }
+    else if (key == etcd_prefix+"/config/node_placement")
+    {
+        // <etcd_prefix>/config/node_placement
+        node_placement = value;
+        if (on_change_node_placement_hook)
+            on_change_node_placement_hook();
+    }
 }
 
 uint32_t etcd_state_client_t::parse_immediate_commit(const std::string & immediate_commit_str, uint32_t default_value)

src/client/etcd_state_client.h

@@ -25,6 +25,10 @@
 #define IMMEDIATE_ALL 2
 #endif
 
+#define POOL_LOCAL_READ_PRIMARY 0
+#define POOL_LOCAL_READ_NEAREST 1
+#define POOL_LOCAL_READ_RANDOM 2
+
 struct etcd_kv_t
 {
     std::string key;
@@ -48,21 +52,22 @@ struct pg_config_t
 
 struct pool_config_t
 {
-    bool exists;
-    pool_id_t id;
+    bool exists = false;
+    pool_id_t id = 0;
     std::string name;
-    uint64_t scheme;
-    uint64_t pg_size, pg_minsize, parity_chunks;
-    uint32_t data_block_size, bitmap_granularity, immediate_commit;
-    uint64_t pg_count;
-    uint64_t real_pg_count;
+    uint64_t scheme = 0;
+    uint64_t pg_size = 0, pg_minsize = 0, parity_chunks = 0;
+    uint32_t data_block_size = 0, bitmap_granularity = 0, immediate_commit = 0;
+    uint64_t pg_count = 0;
+    uint64_t real_pg_count = 0;
     std::string failure_domain;
-    uint64_t max_osd_combinations;
-    uint64_t pg_stripe_size;
+    uint64_t max_osd_combinations = 0;
+    uint64_t pg_stripe_size = 0;
     std::map<pg_num_t, pg_config_t> pg_config;
-    uint64_t scrub_interval;
+    uint64_t scrub_interval = 0;
     std::string used_for_app;
-    int backfillfull;
+    int backfillfull = 0;
+    int local_reads = 0;
 };
 
 struct inode_config_t
@@ -130,16 +135,19 @@ public:
     std::set<osd_num_t> seen_peers;
     std::map<inode_t, inode_config_t> inode_config;
     std::map<std::string, inode_t> inode_by_name;
+    json11::Json node_placement;
 
     std::function<void(std::map<std::string, etcd_kv_t> &)> on_change_hook;
     std::function<void(json11::Json::object &)> on_load_config_hook;
     std::function<json11::Json()> load_pgs_checks_hook;
     std::function<void(bool)> on_load_pgs_hook;
     std::function<void()> on_change_pool_config_hook;
+    std::function<void()> on_change_pg_config_hook;
     std::function<void(pool_id_t)> on_change_backfillfull_hook;
     std::function<void(pool_id_t, pg_num_t, osd_num_t)> on_change_pg_state_hook;
     std::function<void(pool_id_t, pg_num_t)> on_change_pg_history_hook;
     std::function<void(osd_num_t)> on_change_osd_state_hook;
+    std::function<void()> on_change_node_placement_hook;
     std::function<void()> on_reload_hook;
     std::function<void(inode_t, bool)> on_inode_change_hook;
     std::function<void(http_co_t *)> on_start_watcher_hook;

src/client/messenger.cpp

@@ -167,6 +167,10 @@ void osd_messenger_t::init()
         }
     }
 #endif
+    if (ringloop)
+    {
+        has_sendmsg_zc = ringloop->has_sendmsg_zc();
+    }
     if (ringloop && iothread_count > 0)
     {
         for (int i = 0; i < iothread_count; i++)
@@ -184,7 +188,7 @@ void osd_messenger_t::init()
             auto cl = cl_it->second;
             cl_it++;
             auto peer_fd = cl->peer_fd;
-            if (!cl->osd_num || cl->peer_state != PEER_CONNECTED && cl->peer_state != PEER_RDMA)
+            if (!cl->osd_num && !cl->in_osd_num || cl->peer_state != PEER_CONNECTED && cl->peer_state != PEER_RDMA)
             {
                 // Do not run keepalive on regular clients
                 continue;
@@ -195,7 +199,7 @@ void osd_messenger_t::init()
                 if (!cl->ping_time_remaining)
                 {
                     // Ping timed out, stop the client
-                    fprintf(stderr, "Ping timed out for OSD %ju (client %d), disconnecting peer\n", cl->osd_num, cl->peer_fd);
+                    fprintf(stderr, "Ping timed out for OSD %ju (client %d), disconnecting peer\n", cl->in_osd_num ? cl->in_osd_num : cl->osd_num, cl->peer_fd);
                     stop_client(peer_fd, true);
                     // Restart iterator because it may be invalidated
                     cl_it = clients.upper_bound(peer_fd);
@@ -213,7 +217,6 @@ void osd_messenger_t::init()
                     op->req = (osd_any_op_t){
                         .hdr = {
                             .magic = SECONDARY_OSD_OP_MAGIC,
-                            .id = this->next_subop_id++,
                             .opcode = OSD_OP_PING,
                         },
                     };
@@ -227,7 +230,7 @@ void osd_messenger_t::init()
                             return;
                         }
                         int fail_fd = (op->reply.hdr.retval != 0 ? op->peer_fd : -1);
-                        auto fail_osd_num = cl->osd_num;
+                        auto fail_osd_num = cl->in_osd_num ? cl->in_osd_num : cl->osd_num;
                         cl->ping_time_remaining = 0;
                         delete op;
                         if (fail_fd >= 0)
@@ -329,6 +332,9 @@ void osd_messenger_t::parse_config(const json11::Json & config)
         this->receive_buffer_size = 65536;
     this->use_sync_send_recv = config["use_sync_send_recv"].bool_value() ||
         config["use_sync_send_recv"].uint64_value();
+    this->min_zerocopy_send_size = config["min_zerocopy_send_size"].is_null()
+        ? DEFAULT_MIN_ZEROCOPY_SEND_SIZE
+        : (int)config["min_zerocopy_send_size"].int64_value();
     this->peer_connect_interval = config["peer_connect_interval"].uint64_value();
     if (!this->peer_connect_interval)
         this->peer_connect_interval = 5;
@@ -622,13 +628,19 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
         .show_conf = {
             .header = {
                 .magic = SECONDARY_OSD_OP_MAGIC,
-                .id = this->next_subop_id++,
                 .opcode = OSD_OP_SHOW_CONFIG,
             },
         },
     };
+    json11::Json::object payload;
+    if (osd_num)
+    {
+        // Inform that we're OSD <osd_num>
+        payload["osd_num"] = osd_num;
+    }
+    payload["features"] = json11::Json::object{ { "check_sequencing", true } };
 #ifdef WITH_RDMA
-    if (rdma_contexts.size())
+    if (!use_rdmacm && rdma_contexts.size())
     {
         // Choose the right context for the selected network
         msgr_rdma_context_t *selected_ctx = choose_rdma_context(cl);
@@ -642,19 +654,20 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
             cl->rdma_conn = msgr_rdma_connection_t::create(selected_ctx, rdma_max_send, rdma_max_recv, rdma_max_sge, rdma_max_msg);
             if (cl->rdma_conn)
             {
-                json11::Json payload = json11::Json::object {
-                    { "connect_rdma", cl->rdma_conn->addr.to_string() },
-                    { "rdma_max_msg", cl->rdma_conn->max_msg },
-                };
-                std::string payload_str = payload.dump();
-                op->req.show_conf.json_len = payload_str.size();
-                op->buf = malloc_or_die(payload_str.size());
-                op->iov.push_back(op->buf, payload_str.size());
-                memcpy(op->buf, payload_str.c_str(), payload_str.size());
+                payload["connect_rdma"] = cl->rdma_conn->addr.to_string();
+                payload["rdma_max_msg"] = cl->rdma_conn->max_msg;
             }
         }
     }
 #endif
+    if (payload.size())
+    {
+        std::string payload_str = json11::Json(payload).dump();
+        op->req.show_conf.json_len = payload_str.size();
+        op->buf = malloc_or_die(payload_str.size());
+        op->iov.push_back(op->buf, payload_str.size());
+        memcpy(op->buf, payload_str.c_str(), payload_str.size());
+    }
     op->callback = [this, cl](osd_op_t *op)
     {
         std::string json_err;
@@ -701,7 +714,7 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
             return;
         }
 #ifdef WITH_RDMA
-        if (cl->rdma_conn && config["rdma_address"].is_string())
+        if (!use_rdmacm && cl->rdma_conn && config["rdma_address"].is_string())
         {
             msgr_rdma_address_t addr;
             if (!msgr_rdma_address_t::from_string(config["rdma_address"].string_value().c_str(), &addr) ||
@@ -760,12 +773,15 @@ void osd_messenger_t::accept_connections(int listen_fd)
         fcntl(peer_fd, F_SETFL, fcntl(peer_fd, F_GETFL, 0) | O_NONBLOCK);
         int one = 1;
         setsockopt(peer_fd, SOL_TCP, TCP_NODELAY, &one, sizeof(one));
-        clients[peer_fd] = new osd_client_t();
-        clients[peer_fd]->peer_addr = addr;
-        clients[peer_fd]->peer_port = ntohs(((sockaddr_in*)&addr)->sin_port);
-        clients[peer_fd]->peer_fd = peer_fd;
-        clients[peer_fd]->peer_state = PEER_CONNECTED;
-        clients[peer_fd]->in_buf = malloc_or_die(receive_buffer_size);
+        auto cl = new osd_client_t();
+        clients[peer_fd] = cl;
+        cl->is_incoming = true;
+        cl->peer_addr = addr;
+        cl->peer_addr = addr;
+        cl->peer_port = ntohs(((sockaddr_in*)&addr)->sin_port);
+        cl->peer_fd = peer_fd;
+        cl->peer_state = PEER_CONNECTED;
+        cl->in_buf = malloc_or_die(receive_buffer_size);
         // Add FD to epoll
         tfd->set_fd_handler(peer_fd, false, [this](int peer_fd, int epoll_events)
         {
@@ -800,7 +816,8 @@ bool osd_messenger_t::is_rdma_enabled()
 {
     return rdma_contexts.size() > 0;
 }
-
+#endif
+#ifdef WITH_RDMACM
 bool osd_messenger_t::is_use_rdmacm()
 {
     return use_rdmacm;
@@ -896,6 +913,7 @@ static const char* local_only_params[] = {
     "tcp_header_buffer_size",
     "use_rdma",
     "use_sync_send_recv",
+    "min_zerocopy_send_size",
 };
 
 static const char **local_only_end = local_only_params + (sizeof(local_only_params)/sizeof(local_only_params[0]));

src/client/messenger.h

@@ -32,6 +32,8 @@
 
 #define VITASTOR_CONFIG_PATH "/etc/vitastor/vitastor.conf"
 
+#define DEFAULT_MIN_ZEROCOPY_SEND_SIZE 32*1024
+
 #define MSGR_SENDP_HDR 1
 #define MSGR_SENDP_FREE 2
 
@@ -58,6 +60,8 @@ struct osd_client_t
     int ping_time_remaining = 0;
     int idle_time_remaining = 0;
     osd_num_t osd_num = 0;
+    osd_num_t in_osd_num = 0;
+    bool is_incoming = false;
 
     void *in_buf = NULL;
 
@@ -73,12 +77,16 @@ struct osd_client_t
     int read_remaining = 0;
     int read_state = 0;
     osd_op_buf_list_t recv_list;
+    uint64_t read_op_id = 1;
+    bool check_sequencing = false;
+    bool enable_pg_locks = false;
 
     // Incoming operations
     std::vector<osd_op_t*> received_ops;
 
     // Outbound operations
     std::map<uint64_t, osd_op_t*> sent_ops;
+    uint64_t send_op_id = 0;
 
     // PGs dirtied by this client's primary-writes
     std::set<pool_pg_num_t> dirty_pgs;
@@ -88,8 +96,10 @@ struct osd_client_t
     int write_state = 0;
     std::vector<iovec> send_list, next_send_list;
     std::vector<msgr_sendp_t> outbox, next_outbox;
+    std::vector<osd_op_t*> zc_free_list;
 
     ~osd_client_t();
+    void cancel_ops();
 };
 
 struct osd_wanted_peer_t
@@ -97,6 +107,7 @@ struct osd_wanted_peer_t
     json11::Json raw_address_list;
     json11::Json address_list;
     int port = 0;
+    // FIXME: Remove separate WITH_RDMACM?
 #ifdef WITH_RDMACM
     int rdmacm_port = 0;
 #endif
@@ -175,6 +186,7 @@ protected:
     int osd_ping_timeout = 0;
     int log_level = 0;
     bool use_sync_send_recv = false;
+    int min_zerocopy_send_size = DEFAULT_MIN_ZEROCOPY_SEND_SIZE;
     int iothread_count = 0;
 
 #ifdef WITH_RDMA
@@ -201,11 +213,11 @@ protected:
     std::vector<osd_op_t*> set_immediate_ops;
 
 public:
-    timerfd_manager_t *tfd;
-    ring_loop_t *ringloop;
+    timerfd_manager_t *tfd = NULL;
+    ring_loop_t *ringloop = NULL;
+    bool has_sendmsg_zc = false;
     // osd_num_t is only for logging and asserts
     osd_num_t osd_num;
-    uint64_t next_subop_id = 1;
     std::map<int, osd_client_t*> clients;
     std::map<osd_num_t, osd_wanted_peer_t> wanted_peers;
     std::map<uint64_t, int> osd_peer_fds;
@@ -225,6 +237,7 @@ public:
     void outbox_push(osd_op_t *cur_op);
     std::function<void(osd_op_t*)> exec_op;
     std::function<void(osd_num_t)> repeer_pgs;
+    std::function<void(osd_num_t)> break_pg_locks;
     std::function<bool(osd_client_t*, json11::Json)> check_config_hook;
     void read_requests();
     void send_replies();
@@ -261,7 +274,7 @@ protected:
     void cancel_op(osd_op_t *op);
 
     bool try_send(osd_client_t *cl);
-    void handle_send(int result, osd_client_t *cl);
+    void handle_send(int result, bool prev, bool more, osd_client_t *cl);
 
     bool handle_read(int result, osd_client_t *cl);
     bool handle_read_buffer(osd_client_t *cl, void *curbuf, int remain);
@@ -286,6 +299,7 @@ protected:
     msgr_rdma_context_t* rdmacm_create_qp(rdma_cm_id *cmid);
     void rdmacm_accept(rdma_cm_event *ev);
     void rdmacm_try_connect_peer(uint64_t peer_osd, const std::string & addr, int rdmacm_port, int fallback_tcp_port);
+    void rdmacm_set_conn_timeout(rdmacm_connecting_t *conn);
     void rdmacm_on_connect_peer_error(rdma_cm_id *cmid, int res);
     void rdmacm_address_resolved(rdma_cm_event *ev);
     void rdmacm_route_resolved(rdma_cm_event *ev);

src/client/msgr_op.h

@@ -173,6 +173,7 @@ struct osd_op_t
     osd_op_buf_list_t iov;
 
     ~osd_op_t();
+    void cancel();
 
     bool is_recovery_related();
 };

src/client/msgr_rdma.cpp

@@ -70,6 +70,7 @@ msgr_rdma_context_t::~msgr_rdma_context_t()
 msgr_rdma_connection_t::~msgr_rdma_connection_t()
 {
     ctx->reserve_cqe(-max_send-max_recv);
+#ifdef WITH_RDMACM
     if (qp && !cmid)
         ibv_destroy_qp(qp);
     if (cmid)
@@ -79,6 +80,10 @@ msgr_rdma_connection_t::~msgr_rdma_connection_t()
             rdma_destroy_qp(cmid);
         rdma_destroy_id(cmid);
     }
+#else
+    if (qp)
+        ibv_destroy_qp(qp);
+#endif
     if (recv_buffers.size())
     {
         for (auto b: recv_buffers)
@@ -798,6 +803,9 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
             }
             if (!is_send)
             {
+                // Reset OSD ping state - client is obviously alive
+                cl->ping_time_remaining = 0;
+                cl->idle_time_remaining = osd_idle_timeout;
                 rc->cur_recv--;
                 if (!handle_read_buffer(cl, rc->recv_buffers[rc->next_recv_buf].buf, wc[i].byte_len))
                 {

src/client/msgr_rdmacm.cpp

@@ -70,7 +70,7 @@ void osd_messenger_t::rdmacm_destroy_listener(rdma_cm_id *listener)
 
 void osd_messenger_t::handle_rdmacm_events()
 {
-    // rdma_destroy_id infinitely waits for pthread_cond if called before all events are acked :-(
+    // rdma_destroy_id infinitely waits for pthread_cond if called before all events are acked :-(...
     std::vector<rdma_cm_event> events_copy;
     while (1)
     {
@@ -83,7 +83,15 @@ void osd_messenger_t::handle_rdmacm_events()
             fprintf(stderr, "Failed to get RDMA-CM event: %s (code %d)\n", strerror(errno), errno);
             exit(1);
         }
-        events_copy.push_back(*ev);
+        // ...so we save a copy of all events EXCEPT connection requests, otherwise they sometimes fail with EVENT_DISCONNECT
+        if (ev->event == RDMA_CM_EVENT_CONNECT_REQUEST)
+        {
+            rdmacm_accept(ev);
+        }
+        else
+        {
+            events_copy.push_back(*ev);
+        }
         r = rdma_ack_cm_event(ev);
         if (r != 0)
         {
@@ -96,7 +104,7 @@ void osd_messenger_t::handle_rdmacm_events()
         auto ev = &evl;
         if (ev->event == RDMA_CM_EVENT_CONNECT_REQUEST)
         {
-            rdmacm_accept(ev);
+            // Do nothing, handled above
         }
         else if (ev->event == RDMA_CM_EVENT_CONNECT_ERROR ||
             ev->event == RDMA_CM_EVENT_REJECTED ||
@@ -287,29 +295,34 @@ void osd_messenger_t::rdmacm_accept(rdma_cm_event *ev)
         rdma_destroy_id(ev->id);
         return;
     }
-    rdma_context->cm_refs++;
-    // Wrap into a new msgr_rdma_connection_t
-    msgr_rdma_connection_t *conn = new msgr_rdma_connection_t;
-    conn->ctx = rdma_context;
-    conn->max_send = rdma_max_send;
-    conn->max_recv = rdma_max_recv;
-    conn->max_sge = rdma_max_sge > rdma_context->attrx.orig_attr.max_sge
-        ? rdma_context->attrx.orig_attr.max_sge : rdma_max_sge;
-    conn->max_msg = rdma_max_msg;
+    // Wait for RDMA_CM_ESTABLISHED, and enable the connection only after it
+    auto conn = new rdmacm_connecting_t;
     conn->cmid = ev->id;
-    conn->qp = ev->id->qp;
-    auto cl = new osd_client_t();
-    cl->peer_fd = fake_fd;
-    cl->peer_state = PEER_RDMA;
-    cl->peer_addr = *(sockaddr_storage*)rdma_get_peer_addr(ev->id);
-    cl->in_buf = malloc_or_die(receive_buffer_size);
-    cl->rdma_conn = conn;
-    clients[fake_fd] = cl;
-    rdmacm_connections[ev->id] = cl;
-    // Add initial receive request(s)
-    try_recv_rdma(cl);
-    fprintf(stderr, "[OSD %ju] new client %d: connection from %s via RDMA-CM\n", this->osd_num, fake_fd,
-        addr_to_string(cl->peer_addr).c_str());
+    conn->peer_fd = fake_fd;
+    conn->parsed_addr = *(sockaddr_storage*)rdma_get_peer_addr(ev->id);
+    conn->rdma_context = rdma_context;
+    rdmacm_set_conn_timeout(conn);
+    rdmacm_connecting[ev->id] = conn;
+    fprintf(stderr, "[OSD %ju] new client %d: connection from %s via RDMA-CM\n", this->osd_num, conn->peer_fd,
+        addr_to_string(conn->parsed_addr).c_str());
+}
+
+void osd_messenger_t::rdmacm_set_conn_timeout(rdmacm_connecting_t *conn)
+{
+    conn->timeout_ms = peer_connect_timeout*1000;
+    if (peer_connect_timeout > 0)
+    {
+        conn->timeout_id = tfd->set_timer(1000*peer_connect_timeout, false, [this, cmid = conn->cmid](int timer_id)
+        {
+            auto conn = rdmacm_connecting.at(cmid);
+            conn->timeout_id = -1;
+            if (conn->peer_osd)
+                fprintf(stderr, "RDMA-CM connection to %s timed out\n", conn->addr.c_str());
+            else
+                fprintf(stderr, "Incoming RDMA-CM connection from %s timed out\n", addr_to_string(conn->parsed_addr).c_str());
+            rdmacm_on_connect_peer_error(cmid, -EPIPE);
+        });
+    }
 }
 
 void osd_messenger_t::rdmacm_on_connect_peer_error(rdma_cm_id *cmid, int res)
@@ -332,15 +345,18 @@ void osd_messenger_t::rdmacm_on_connect_peer_error(rdma_cm_id *cmid, int res)
     }
     rdmacm_connecting.erase(cmid);
     delete conn;
-    if (!disable_tcp)
+    if (peer_osd)
     {
-        // Fall back to TCP instead of just reporting the error to on_connect_peer()
-        try_connect_peer_tcp(peer_osd, addr.c_str(), tcp_port);
-    }
-    else
-    {
-        // TCP is disabled
-        on_connect_peer(peer_osd, res == 0 ? -EINVAL : (res > 0 ? -res : res));
+        if (!disable_tcp)
+        {
+            // Fall back to TCP instead of just reporting the error to on_connect_peer()
+            try_connect_peer_tcp(peer_osd, addr.c_str(), tcp_port);
+        }
+        else
+        {
+            // TCP is disabled
+            on_connect_peer(peer_osd, res == 0 ? -EINVAL : (res > 0 ? -res : res));
+        }
     }
 }
 
@@ -374,6 +390,8 @@ void osd_messenger_t::rdmacm_try_connect_peer(uint64_t peer_osd, const std::stri
         on_connect_peer(peer_osd, res);
         return;
     }
+    if (log_level > 0)
+        fprintf(stderr, "Trying to connect to OSD %ju at %s:%d via RDMA-CM\n", peer_osd, addr.c_str(), rdmacm_port);
     auto conn = new rdmacm_connecting_t;
     rdmacm_connecting[cmid] = conn;
     conn->cmid = cmid;
@@ -383,19 +401,7 @@ void osd_messenger_t::rdmacm_try_connect_peer(uint64_t peer_osd, const std::stri
     conn->parsed_addr = sa;
     conn->rdmacm_port = rdmacm_port;
     conn->tcp_port = fallback_tcp_port;
-    conn->timeout_ms = peer_connect_timeout*1000;
-    conn->timeout_id = -1;
-    if (peer_connect_timeout > 0)
-    {
-        conn->timeout_id = tfd->set_timer(1000*peer_connect_timeout, false, [this, cmid](int timer_id)
-        {
-            auto conn = rdmacm_connecting.at(cmid);
-            conn->timeout_id = -1;
-            fprintf(stderr, "RDMA-CM connection to %s timed out\n", conn->addr.c_str());
-            rdmacm_on_connect_peer_error(cmid, -EPIPE);
-            return;
-        });
-    }
+    rdmacm_set_conn_timeout(conn);
     if (rdma_resolve_addr(cmid, NULL, (sockaddr*)&conn->parsed_addr, conn->timeout_ms) != 0)
     {
         auto res = -errno;
@@ -494,7 +500,7 @@ void osd_messenger_t::rdmacm_established(rdma_cm_event *ev)
     // Wrap into a new msgr_rdma_connection_t
     msgr_rdma_connection_t *rc = new msgr_rdma_connection_t;
     rc->ctx = conn->rdma_context;
-    rc->ctx->cm_refs++;
+    rc->ctx->cm_refs++; // FIXME now unused, count also connecting_t's when used
     rc->max_send = rdma_max_send;
     rc->max_recv = rdma_max_recv;
     rc->max_sge = rdma_max_sge > rc->ctx->attrx.orig_attr.max_sge
@@ -514,14 +520,20 @@ void osd_messenger_t::rdmacm_established(rdma_cm_event *ev)
     cl->rdma_conn = rc;
     clients[conn->peer_fd] = cl;
     if (conn->timeout_id >= 0)
+    {
         tfd->clear_timer(conn->timeout_id);
+    }
     delete conn;
     rdmacm_connecting.erase(cmid);
     rdmacm_connections[cmid] = cl;
-    if (log_level > 0)
+    if (log_level > 0 && peer_osd)
+    {
         fprintf(stderr, "Successfully connected with OSD %ju using RDMA-CM\n", peer_osd);
+    }
     // Add initial receive request(s)
     try_recv_rdma(cl);
-    osd_peer_fds[peer_osd] = cl->peer_fd;
-    on_connect_peer(peer_osd, cl->peer_fd);
+    if (peer_osd)
+    {
+        check_peer_config(cl);
+    }
 }

src/client/msgr_receive.cpp

@@ -8,11 +8,12 @@ void osd_messenger_t::read_requests()
     for (int i = 0; i < read_ready_clients.size(); i++)
     {
         int peer_fd = read_ready_clients[i];
-        osd_client_t *cl = clients[peer_fd];
-        if (cl->read_msg.msg_iovlen)
+        auto cl_it = clients.find(peer_fd);
+        if (cl_it == clients.end() || !cl_it->second || cl_it->second->read_msg.msg_iovlen)
         {
             continue;
         }
+        auto cl = cl_it->second;
         if (cl->read_remaining < receive_buffer_size)
         {
             cl->read_iov.iov_base = cl->in_buf;
@@ -33,8 +34,12 @@ void osd_messenger_t::read_requests()
             auto iothread = iothreads.size() ? iothreads[peer_fd % iothreads.size()] : NULL;
             io_uring_sqe sqe_local;
             ring_data_t data_local;
-            sqe_local.user_data = (uint64_t)&data_local;
             io_uring_sqe* sqe = (iothread ? &sqe_local : ringloop->get_sqe());
+            if (iothread)
+            {
+                sqe_local = { .user_data = (uint64_t)&data_local };
+                data_local = {};
+            }
             if (!sqe)
             {
                 cl->read_msg.msg_iovlen = 0;
@@ -56,7 +61,8 @@ void osd_messenger_t::read_requests()
             {
                 result = -errno;
             }
-            handle_read(result, cl);
+            // like set_immediate
+            tfd->set_timer_us(0, false, [this, result, cl](int){ handle_read(result, cl); });
         }
     }
     read_ready_clients.clear();
@@ -214,6 +220,7 @@ bool osd_messenger_t::handle_read_buffer(osd_client_t *cl, void *curbuf, int rem
 
 bool osd_messenger_t::handle_finished_read(osd_client_t *cl)
 {
+    // Reset OSD ping state
     cl->ping_time_remaining = 0;
     cl->idle_time_remaining = osd_idle_timeout;
     cl->recv_list.reset();
@@ -222,7 +229,19 @@ bool osd_messenger_t::handle_finished_read(osd_client_t *cl)
         if (cl->read_op->req.hdr.magic == SECONDARY_OSD_REPLY_MAGIC)
             return handle_reply_hdr(cl);
         else if (cl->read_op->req.hdr.magic == SECONDARY_OSD_OP_MAGIC)
+        {
+            if (cl->check_sequencing)
+            {
+                if (cl->read_op->req.hdr.id != cl->read_op_id)
+                {
+                    fprintf(stderr, "Warning: operation sequencing is broken on client %d: expected num %ju, got %ju, stopping client\n", cl->peer_fd, cl->read_op_id, cl->read_op->req.hdr.id);
+                    stop_client(cl->peer_fd);
+                    return false;
+                }
+                cl->read_op_id++;
+            }
             handle_op_hdr(cl);
+        }
         else
         {
             fprintf(stderr, "Received garbage: magic=%jx id=%ju opcode=%jx from %d\n", cl->read_op->req.hdr.magic, cl->read_op->req.hdr.id, cl->read_op->req.hdr.opcode, cl->peer_fd);

src/client/msgr_send.cpp

@@ -14,6 +14,7 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
     if (cur_op->op_type == OSD_OP_OUT)
     {
         clock_gettime(CLOCK_REALTIME, &cur_op->tv_begin);
+        cur_op->req.hdr.id = ++cl->send_op_id;
     }
     else
     {
@@ -193,18 +194,36 @@ bool osd_messenger_t::try_send(osd_client_t *cl)
         auto iothread = iothreads.size() ? iothreads[peer_fd % iothreads.size()] : NULL;
         io_uring_sqe sqe_local;
         ring_data_t data_local;
-        sqe_local.user_data = (uint64_t)&data_local;
         io_uring_sqe* sqe = (iothread ? &sqe_local : ringloop->get_sqe());
-        if (!sqe)
+        if (iothread)
         {
-            return false;
+            sqe_local = { .user_data = (uint64_t)&data_local };
+            data_local = {};
         }
+        if (!sqe)
+            return false;
         cl->write_msg.msg_iov = cl->send_list.data();
         cl->write_msg.msg_iovlen = cl->send_list.size() < IOV_MAX ? cl->send_list.size() : IOV_MAX;
         cl->refs++;
         ring_data_t* data = ((ring_data_t*)sqe->user_data);
-        data->callback = [this, cl](ring_data_t *data) { handle_send(data->res, cl); };
-        my_uring_prep_sendmsg(sqe, peer_fd, &cl->write_msg, 0);
+        data->callback = [this, cl](ring_data_t *data) { handle_send(data->res, data->prev, data->more, cl); };
+        bool use_zc = has_sendmsg_zc && min_zerocopy_send_size >= 0;
+        if (use_zc && min_zerocopy_send_size > 0)
+        {
+            size_t avg_size = 0;
+            for (size_t i = 0; i < cl->write_msg.msg_iovlen; i++)
+                avg_size += cl->write_msg.msg_iov[i].iov_len;
+            if (avg_size/cl->write_msg.msg_iovlen < min_zerocopy_send_size)
+                use_zc = false;
+        }
+        if (use_zc)
+        {
+            my_uring_prep_sendmsg_zc(sqe, peer_fd, &cl->write_msg, MSG_WAITALL);
+        }
+        else
+        {
+            my_uring_prep_sendmsg(sqe, peer_fd, &cl->write_msg, MSG_WAITALL);
+        }
         if (iothread)
         {
             iothread->add_sqe(sqe_local);
@@ -220,7 +239,8 @@ bool osd_messenger_t::try_send(osd_client_t *cl)
         {
             result = -errno;
         }
-        handle_send(result, cl);
+        // like set_immediate
+        tfd->set_timer_us(0, false, [this, result, cl](int){ handle_send(result, false, false, cl); });
     }
     return true;
 }
@@ -240,10 +260,16 @@ void osd_messenger_t::send_replies()
     write_ready_clients.clear();
 }
 
-void osd_messenger_t::handle_send(int result, osd_client_t *cl)
+void osd_messenger_t::handle_send(int result, bool prev, bool more, osd_client_t *cl)
 {
-    cl->write_msg.msg_iovlen = 0;
-    cl->refs--;
+    if (!prev)
+    {
+        cl->write_msg.msg_iovlen = 0;
+    }
+    if (!more)
+    {
+        cl->refs--;
+    }
     if (cl->peer_state == PEER_STOPPED)
     {
         if (cl->refs <= 0)
@@ -261,6 +287,16 @@ void osd_messenger_t::handle_send(int result, osd_client_t *cl)
     }
     if (result >= 0)
     {
+        if (prev)
+        {
+            // Second notification - only free a batch of postponed ops
+            int i = 0;
+            for (; i < cl->zc_free_list.size() && cl->zc_free_list[i]; i++)
+                delete cl->zc_free_list[i];
+            if (i > 0)
+                cl->zc_free_list.erase(cl->zc_free_list.begin(), cl->zc_free_list.begin()+i+1);
+            return;
+        }
         int done = 0;
         while (result > 0 && done < cl->send_list.size())
         {
@@ -270,7 +306,10 @@ void osd_messenger_t::handle_send(int result, osd_client_t *cl)
                 if (cl->outbox[done].flags & MSGR_SENDP_FREE)
                 {
                     // Reply fully sent
-                    delete cl->outbox[done].op;
+                    if (more)
+                        cl->zc_free_list.push_back(cl->outbox[done].op);
+                    else
+                        delete cl->outbox[done].op;
                 }
                 result -= iov.iov_len;
                 done++;
@@ -282,6 +321,12 @@ void osd_messenger_t::handle_send(int result, osd_client_t *cl)
                 break;
             }
         }
+        if (more)
+        {
+            auto expected = cl->send_list.size() < IOV_MAX ? cl->send_list.size() : IOV_MAX;
+            assert(done == expected);
+            cl->zc_free_list.push_back(NULL); // end marker
+        }
         if (done > 0)
         {
             cl->send_list.erase(cl->send_list.begin(), cl->send_list.begin()+done);

src/client/msgr_stop.cpp

@@ -9,38 +9,37 @@
 #include "msgr_rdma.h"
 #endif
 
-void osd_messenger_t::cancel_osd_ops(osd_client_t *cl)
+void osd_client_t::cancel_ops()
 {
     std::vector<osd_op_t*> cancel_ops;
-    cancel_ops.resize(cl->sent_ops.size());
+    cancel_ops.resize(sent_ops.size());
     int i = 0;
-    for (auto p: cl->sent_ops)
+    for (auto p: sent_ops)
     {
         cancel_ops[i++] = p.second;
     }
-    cl->sent_ops.clear();
-    cl->outbox.clear();
+    sent_ops.clear();
     for (auto op: cancel_ops)
     {
-        cancel_op(op);
+        op->cancel();
     }
 }
 
-void osd_messenger_t::cancel_op(osd_op_t *op)
+void osd_op_t::cancel()
 {
-    if (op->op_type == OSD_OP_OUT)
+    if (op_type == OSD_OP_OUT && callback)
     {
-        op->reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
-        op->reply.hdr.id = op->req.hdr.id;
-        op->reply.hdr.opcode = op->req.hdr.opcode;
-        op->reply.hdr.retval = -EPIPE;
-        // Copy lambda to be unaffected by `delete op`
-        std::function<void(osd_op_t*)>(op->callback)(op);
+        reply.hdr.magic = SECONDARY_OSD_REPLY_MAGIC;
+        reply.hdr.id = req.hdr.id;
+        reply.hdr.opcode = req.hdr.opcode;
+        reply.hdr.retval = -EPIPE;
+        // Copy lambda to be unaffected by `delete this`
+        (std::function<void(osd_op_t*)>(callback))(this);
     }
     else
     {
         // This function is only called in stop_client(), so it's fine to destroy the operation
-        delete op;
+        delete this;
     }
 }
 
@@ -63,6 +62,10 @@ void osd_messenger_t::stop_client(int peer_fd, bool force, bool force_delete)
         {
             fprintf(stderr, "[OSD %ju] Stopping client %d (OSD peer %ju)\n", osd_num, peer_fd, cl->osd_num);
         }
+        else if (cl->in_osd_num)
+        {
+            fprintf(stderr, "[OSD %ju] Stopping client %d (incoming OSD peer %ju)\n", osd_num, peer_fd, cl->in_osd_num);
+        }
         else
         {
             fprintf(stderr, "[OSD %ju] Stopping client %d (regular client)\n", osd_num, peer_fd);
@@ -73,8 +76,12 @@ void osd_messenger_t::stop_client(int peer_fd, bool force, bool force_delete)
     cl->peer_state = PEER_STOPPED;
     if (cl->osd_num)
     {
-        // ...and forget OSD peer
-        osd_peer_fds.erase(cl->osd_num);
+        auto osd_it = osd_peer_fds.find(cl->osd_num);
+        if (osd_it != osd_peer_fds.end() && osd_it->second == cl->peer_fd)
+        {
+            // ...and forget OSD peer
+            osd_peer_fds.erase(osd_it);
+        }
     }
 #ifndef __MOCK__
     // Then remove FD from the eventloop so we don't accidentally read something
@@ -101,30 +108,17 @@ void osd_messenger_t::stop_client(int peer_fd, bool force, bool force_delete)
         }
     }
 #endif
+    if (cl->in_osd_num && break_pg_locks)
+    {
+        // Break PG locks
+        break_pg_locks(cl->in_osd_num);
+    }
     if (cl->osd_num)
     {
         // Then repeer PGs because cancel_op() callbacks can try to perform
         // some actions and we need correct PG states to not do something silly
         repeer_pgs(cl->osd_num);
     }
-    // Then cancel all operations
-    if (cl->read_op)
-    {
-        if (!cl->read_op->callback)
-        {
-            delete cl->read_op;
-        }
-        else
-        {
-            cancel_op(cl->read_op);
-        }
-        cl->read_op = NULL;
-    }
-    if (cl->osd_num)
-    {
-        // Cancel outbound operations
-        cancel_osd_ops(cl);
-    }
     // Find the item again because it can be invalidated at this point
     it = clients.find(peer_fd);
     if (it != clients.end())
@@ -149,6 +143,17 @@ osd_client_t::~osd_client_t()
         close(peer_fd);
         peer_fd = -1;
     }
+    // Then cancel all operations
+    // Operations have to be canceled only after clearing all references to osd_client_t
+    // because otherwise their buffers may be still present in io_uring asynchronous requests
+    if (read_op)
+    {
+        // read_op may be an incoming op or a continued response for an outbound op
+        read_op->cancel();
+        read_op = NULL;
+    }
+    // Cancel outbound ops
+    cancel_ops();
 #ifndef __MOCK__
 #ifdef WITH_RDMA
     if (rdma_conn)

src/client/osd_ops.cpp

@@ -23,4 +23,5 @@ const char* osd_op_names[] = {
     "sec_read_bmp",
     "scrub",
     "describe",
+    "sec_lock",
 };

src/client/osd_ops.h

@@ -31,10 +31,13 @@
 #define OSD_OP_SEC_READ_BMP         16
 #define OSD_OP_SCRUB                17
 #define OSD_OP_DESCRIBE             18
-#define OSD_OP_MAX                  18
+#define OSD_OP_SEC_LOCK             19
+#define OSD_OP_MAX                  19
 #define OSD_RW_MAX                  64*1024*1024
 #define OSD_PROTOCOL_VERSION        1
+
 #define OSD_OP_RECOVERY_RELATED     (uint32_t)1
+#define OSD_OP_IGNORE_PG_LOCK       (uint32_t)2
 
 // Memory alignment for direct I/O (usually 512 bytes)
 #ifndef DIRECT_IO_ALIGNMENT
@@ -56,6 +59,9 @@
 #define OSD_DEL_SUPPORT_LEFT_ON_DEAD 1
 #define OSD_DEL_LEFT_ON_DEAD         2
 
+#define OSD_SEC_LOCK_PG 1
+#define OSD_SEC_UNLOCK_PG 2
+
 // common request and reply headers
 struct __attribute__((__packed__)) osd_op_header_t
 {
@@ -94,7 +100,7 @@ struct __attribute__((__packed__)) osd_op_sec_rw_t
     uint32_t len;
     // bitmap/attribute length - bitmap comes after header, but before data
     uint32_t attr_len;
-    // the only possible flag is OSD_OP_RECOVERY_RELATED
+    // OSD_OP_RECOVERY_RELATED, OSD_OP_IGNORE_PG_LOCK
     uint32_t flags;
 };
 
@@ -116,7 +122,7 @@ struct __attribute__((__packed__)) osd_op_sec_del_t
     object_id oid;
     // delete version (automatic or specific)
     uint64_t version;
-    // the only possible flag is OSD_OP_RECOVERY_RELATED
+    // OSD_OP_RECOVERY_RELATED, OSD_OP_IGNORE_PG_LOCK
     uint32_t flags;
     uint32_t pad0;
 };
@@ -131,7 +137,7 @@ struct __attribute__((__packed__)) osd_reply_sec_del_t
 struct __attribute__((__packed__)) osd_op_sec_sync_t
 {
     osd_op_header_t header;
-    // the only possible flag is OSD_OP_RECOVERY_RELATED
+    // OSD_OP_RECOVERY_RELATED, OSD_OP_IGNORE_PG_LOCK
     uint32_t flags;
     uint32_t pad0;
 };
@@ -147,7 +153,7 @@ struct __attribute__((__packed__)) osd_op_sec_stab_t
     osd_op_header_t header;
     // obj_ver_id array length in bytes
     uint64_t len;
-    // the only possible flag is OSD_OP_RECOVERY_RELATED
+    // OSD_OP_RECOVERY_RELATED, OSD_OP_IGNORE_PG_LOCK
     uint32_t flags;
     uint32_t pad0;
 };
@@ -165,6 +171,8 @@ struct __attribute__((__packed__)) osd_op_sec_read_bmp_t
     osd_op_header_t header;
     // obj_ver_id array length in bytes
     uint64_t len;
+    // OSD_OP_RECOVERY_RELATED, OSD_OP_IGNORE_PG_LOCK
+    uint32_t flags;
 };
 
 struct __attribute__((__packed__)) osd_reply_sec_read_bmp_t
@@ -173,7 +181,7 @@ struct __attribute__((__packed__)) osd_reply_sec_read_bmp_t
     osd_reply_header_t header;
 };
 
-// show configuration
+// show configuration and remember peer information
 struct __attribute__((__packed__)) osd_op_show_config_t
 {
     osd_op_header_t header;
@@ -303,6 +311,25 @@ struct __attribute__((__packed__)) osd_reply_describe_item_t
     osd_num_t osd_num;  // OSD number
 };
 
+// lock/unlock PG for use by a primary OSD
+struct __attribute__((__packed__)) osd_op_sec_lock_t
+{
+    osd_op_header_t header;
+    // OSD_SEC_LOCK_PG or OSD_SEC_UNLOCK_PG
+    uint64_t flags;
+    // Pool ID and PG number
+    uint64_t pool_id;
+    uint64_t pg_num;
+    // PG state as calculated by the primary OSD
+    uint64_t pg_state;
+};
+
+struct __attribute__((__packed__)) osd_reply_sec_lock_t
+{
+    osd_reply_header_t header;
+    uint64_t cur_primary;
+};
+
 // FIXME it would be interesting to try to unify blockstore_op and osd_op formats
 union osd_any_op_t
 {
@@ -313,6 +340,7 @@ union osd_any_op_t
     osd_op_sec_stab_t sec_stab;
     osd_op_sec_read_bmp_t sec_read_bmp;
     osd_op_sec_list_t sec_list;
+    osd_op_sec_lock_t sec_lock;
     osd_op_show_config_t show_conf;
     osd_op_rw_t rw;
     osd_op_sync_t sync;
@@ -329,6 +357,7 @@ union osd_any_reply_t
     osd_reply_sec_stab_t sec_stab;
     osd_reply_sec_read_bmp_t sec_read_bmp;
     osd_reply_sec_list_t sec_list;
+    osd_reply_sec_lock_t sec_lock;
     osd_reply_show_config_t show_conf;
     osd_reply_rw_t rw;
     osd_reply_del_t del;

src/client/qemu_driver.c

@@ -58,6 +58,7 @@ typedef struct VitastorClient
 {
     void *proxy;
     int uring_eventfd;
+    int auto_loop;
 
     void *watch;
     char *config_path;
@@ -155,16 +156,19 @@ static void qemu_vitastor_unescape(char *src)
 // vitastor[:key=value]*
 // vitastor[:etcd_host=127.0.0.1]:inode=1:pool=1[:rdma_gid_index=3]
 // vitastor:config_path=/etc/vitastor/vitastor.conf:image=testimg
+// vitastor://?config_path=/etc/vitastor/vitastor.conf&image=testimg
 static void vitastor_parse_filename(const char *filename, QDict *options, Error **errp)
 {
     const char *start;
     char *p, *buf;
 
-    if (!strstart(filename, "vitastor:", &start))
+    int url_style = strstart(filename, "vitastor://?", &start);
+    if (!url_style && !strstart(filename, "vitastor:", &start))
     {
         error_setg(errp, "File name must start with 'vitastor:'");
         return;
     }
+    char delim = url_style ? '&' : ':';
 
     buf = g_strdup(start);
     p = buf;
@@ -184,7 +188,7 @@ static void vitastor_parse_filename(const char *filename, QDict *options, Error
             if (name[i] == '_')
                 name[i] = '-';
         qemu_vitastor_unescape(name);
-        value = qemu_vitastor_next_tok(p, ':', &p);
+        value = qemu_vitastor_next_tok(p, delim, &p);
         qemu_vitastor_unescape(value);
         if (!strcmp(name, "inode") ||
             !strcmp(name, "pool") ||
@@ -294,9 +298,8 @@ static void coroutine_fn vitastor_co_get_metadata(VitastorRPC *task)
 
     qemu_mutex_lock(&client->mutex);
     vitastor_c_watch_inode(client->proxy, client->image, vitastor_co_generic_cb, task);
-#if !defined VITASTOR_C_API_VERSION || VITASTOR_C_API_VERSION < 5
-    vitastor_schedule_uring_handler(client);
-#endif
+    if (!client->auto_loop)
+        vitastor_schedule_uring_handler(client);
     qemu_mutex_unlock(&client->mutex);
 
     while (!task->complete)
@@ -449,6 +452,9 @@ static int vitastor_file_open(BlockDriverState *bs, QDict *options, int flags, E
     client->ctx = bdrv_get_aio_context(bs);
 #if defined VITASTOR_C_API_VERSION && VITASTOR_C_API_VERSION >= 2
     str_array opt = {};
+    char version_buffer[32];
+    memset(version_buffer, ' ', sizeof(version_buffer));
+    version_buffer[sizeof(version_buffer)-1] = '\0';
     strarray_push_kv(&opt, "config_path", qdict_get_try_str(options, "config-path"));
     strarray_push_kv(&opt, "etcd_address", qdict_get_try_str(options, "etcd-host"));
     strarray_push_kv(&opt, "etcd_prefix", qdict_get_try_str(options, "etcd-prefix"));
@@ -458,7 +464,9 @@ static int vitastor_file_open(BlockDriverState *bs, QDict *options, int flags, E
     strarray_push_kv(&opt, "rdma_gid_index", qdict_get_try_str(options, "rdma-gid-index"));
     strarray_push_kv(&opt, "rdma_mtu", qdict_get_try_str(options, "rdma-mtu"));
     strarray_push_kv(&opt, "client_writeback_allowed", (flags & BDRV_O_NOCACHE) ? "0" : "1");
+    strarray_push_kv(&opt, "__version_check_buffer", version_buffer);
     client->proxy = vitastor_c_create_uring_json(opt.items, opt.len);
+    client->auto_loop = 0;
     strarray_free(&opt);
     if (client->proxy)
     {
@@ -471,6 +479,12 @@ static int vitastor_file_open(BlockDriverState *bs, QDict *options, int flags, E
             return -1;
         }
         universal_aio_set_fd_handler(client->ctx, client->uring_eventfd, vitastor_uring_handler, NULL, client);
+        int vitastor_version[3] = { 0 };
+        if (sscanf(version_buffer, "%d.%d.%d", &vitastor_version[0], &vitastor_version[1], &vitastor_version[2]) == 3 &&
+            vitastor_version[0] >= 2)
+        {
+            client->auto_loop = 1;
+        }
     }
     else
     {
@@ -604,6 +618,29 @@ static void vitastor_close(BlockDriverState *bs)
     client->last_bitmap = NULL;
 }
 
+#if QEMU_VERSION_MAJOR >= 3 || QEMU_VERSION_MAJOR == 2 && QEMU_VERSION_MINOR >= 2
+static void vitastor_refresh_filename(BlockDriverState *bs)
+{
+    VitastorClient *client = bs->opaque;
+    size_t len = 0;
+    int n = 0;
+    len = snprintf(bs->exact_filename, sizeof(bs->exact_filename), "vitastor://");
+    if (len < sizeof(bs->exact_filename))
+    {
+        if (client->image)
+            len += snprintf(bs->exact_filename+len, sizeof(bs->exact_filename)-len, "%cimage=%s", (n++ ? '&' : '?'), client->image);
+        else
+            len += snprintf(bs->exact_filename+len, sizeof(bs->exact_filename)-len, "%cpool=%ju&inode=%ju&size=%ju", (n++ ? '&' : '?'), client->pool, client->inode, client->size);
+    }
+    if (client->config_path && len < sizeof(bs->exact_filename))
+        len += snprintf(bs->exact_filename+len, sizeof(bs->exact_filename)-len, "%cconfig_path=%s", (n++ ? '&' : '?'), client->config_path);
+    if (client->etcd_host && len < sizeof(bs->exact_filename))
+        len += snprintf(bs->exact_filename+len, sizeof(bs->exact_filename)-len, "%cetcd_host=%s", (n++ ? '&' : '?'), client->etcd_host);
+    if (client->etcd_prefix && len < sizeof(bs->exact_filename))
+        len += snprintf(bs->exact_filename+len, sizeof(bs->exact_filename)-len, "%cetcd_prefix=%s", (n++ ? '&' : '?'), client->etcd_prefix);
+}
+#endif
+
 #if QEMU_VERSION_MAJOR >= 3 || QEMU_VERSION_MAJOR == 2 && QEMU_VERSION_MINOR > 2
 static int vitastor_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 {
@@ -767,9 +804,8 @@ static int coroutine_fn vitastor_co_preadv(BlockDriverState *bs,
     uint64_t inode = client->watch ? vitastor_c_inode_get_num(client->watch) : client->inode;
     qemu_mutex_lock(&client->mutex);
     vitastor_c_read(client->proxy, inode, offset, bytes, iov->iov, iov->niov, vitastor_co_read_cb, &task);
-#if !defined VITASTOR_C_API_VERSION || VITASTOR_C_API_VERSION < 5
-    vitastor_schedule_uring_handler(client);
-#endif
+    if (!client->auto_loop)
+        vitastor_schedule_uring_handler(client);
     qemu_mutex_unlock(&client->mutex);
 
     while (!task.complete)
@@ -803,9 +839,8 @@ static int coroutine_fn vitastor_co_pwritev(BlockDriverState *bs,
     uint64_t inode = client->watch ? vitastor_c_inode_get_num(client->watch) : client->inode;
     qemu_mutex_lock(&client->mutex);
     vitastor_c_write(client->proxy, inode, offset, bytes, 0, iov->iov, iov->niov, vitastor_co_generic_cb, &task);
-#if !defined VITASTOR_C_API_VERSION || VITASTOR_C_API_VERSION < 5
-    vitastor_schedule_uring_handler(client);
-#endif
+    if (!client->auto_loop)
+        vitastor_schedule_uring_handler(client);
     qemu_mutex_unlock(&client->mutex);
 
     while (!task.complete)
@@ -885,9 +920,8 @@ static int coroutine_fn vitastor_co_block_status(
         task.bitmap = client->last_bitmap = NULL;
         qemu_mutex_lock(&client->mutex);
         vitastor_c_read_bitmap(client->proxy, task.inode, task.offset, task.len, !client->skip_parents, vitastor_co_read_bitmap_cb, &task);
-#if !defined VITASTOR_C_API_VERSION || VITASTOR_C_API_VERSION < 5
-        vitastor_schedule_uring_handler(client);
-#endif
+        if (!client->auto_loop)
+            vitastor_schedule_uring_handler(client);
         qemu_mutex_unlock(&client->mutex);
         while (!task.complete)
         {
@@ -974,9 +1008,8 @@ static int coroutine_fn vitastor_co_flush(BlockDriverState *bs)
 
     qemu_mutex_lock(&client->mutex);
     vitastor_c_sync(client->proxy, vitastor_co_generic_cb, &task);
-#if !defined VITASTOR_C_API_VERSION || VITASTOR_C_API_VERSION < 5
-    vitastor_schedule_uring_handler(client);
-#endif
+    if (!client->auto_loop)
+        vitastor_schedule_uring_handler(client);
     qemu_mutex_unlock(&client->mutex);
 
     while (!task.complete)
@@ -1038,6 +1071,9 @@ static BlockDriver bdrv_vitastor = {
     .bdrv_get_info                  = vitastor_get_info,
     .bdrv_getlength                 = vitastor_getlength,
 #endif
+#if QEMU_VERSION_MAJOR >= 3 || QEMU_VERSION_MAJOR == 2 && QEMU_VERSION_MINOR >= 2
+    .bdrv_refresh_filename          = vitastor_refresh_filename,
+#endif
 #if QEMU_VERSION_MAJOR >= 3 || QEMU_VERSION_MAJOR == 2 && QEMU_VERSION_MINOR > 2
     .bdrv_probe_blocksizes          = vitastor_probe_blocksizes,
 #endif

src/client/vitastor.pc.in

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

src/client/vitastor_c.cpp

@@ -178,7 +178,14 @@ vitastor_c *vitastor_c_create_uring_json(const char **options, int options_len)
     json11::Json::object cfg;
     for (int i = 0; i < options_len-1; i += 2)
     {
-        cfg[options[i]] = std::string(options[i+1]);
+        if (!strcmp(options[i], "__version_check_buffer"))
+        {
+            int buf_size = strlen(options[i+1])+1;
+            if (buf_size > strlen(VITASTOR_VERSION))
+                strncpy((char*)options[i+1], VITASTOR_VERSION, buf_size);
+        }
+        else
+            cfg[options[i]] = std::string(options[i+1]);
     }
     json11::Json cfg_json(cfg);
     vitastor_c *self = new vitastor_c;

src/client/vitastor_c.h

@@ -7,7 +7,7 @@
 #define VITASTOR_QEMU_PROXY_H
 
 // C API wrapper version
-#define VITASTOR_C_API_VERSION 5
+#define VITASTOR_C_API_VERSION 4
 
 #ifndef POOL_ID_BITS
 #define POOL_ID_BITS 16

src/cmd/cli.cpp

@@ -185,6 +185,7 @@ static const char* help_text =
     "    --immediate_commit all        Put pool only on OSDs with this or larger immediate_commit (none < small < all)\n"
     "    --level_placement <rules>     Use additional failure domain rules (example: \"dc=112233\")\n"
     "    --raw_placement <rules>       Specify raw PG generation rules (see documentation for details)\n"
+    "    --local_reads primary         Local read policy for replicated pools: primary, nearest or random\n"
     "    --primary_affinity_tags tags  Prefer to put primary copies on OSDs with all specified tags\n"
     "    --scrub_interval <time>       Enable regular scrubbing for this pool. Format: number + unit s/m/h/d/M/y\n"
     "    --used_for_app fs:<name>      Mark pool as used for VitastorFS with metadata in image <name>\n"
@@ -282,6 +283,7 @@ static json11::Json::object parse_args(int narg, const char *args[])
                 !strcmp(opt, "readonly") || !strcmp(opt, "readwrite") ||
                 !strcmp(opt, "force") || !strcmp(opt, "reverse") ||
                 !strcmp(opt, "allow-data-loss") || !strcmp(opt, "allow_data_loss") ||
+                !strcmp(opt, "allow-up") || !strcmp(opt, "allow_up") ||
                 !strcmp(opt, "down-ok") || !strcmp(opt, "down_ok") ||
                 !strcmp(opt, "dry-run") || !strcmp(opt, "dry_run") ||
                 !strcmp(opt, "help") || !strcmp(opt, "all") ||