WIP vitastor-cli create-user

Seems slightly overcomplicated...

.gitea/workflows/test.yml

@@ -63,7 +63,7 @@ jobs:
     container: ${{env.TEST_IMAGE}}:${{github.sha}}
     steps:
     # leak sanitizer sometimes crashes
-    - run: cd /root/vitastor/build && ASAN_OPTIONS=detect_leaks=0 make -j16 build_tests test
+    - run: cd /root/vitastor/build && ASAN_OPTIONS=detect_leaks=0 make -j16 test
 
   npm_lint:
     runs-on: ubuntu-latest
@@ -720,24 +720,6 @@ jobs:
           echo ""
         done
 
-  test_snapshot_chain_enc_gcm:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 3
-      run: TEST_NAME=enc_gcm ENCRYPTED=1 VITASTOR_CFG=',"proto_checksums":"gcm"' /root/vitastor/tests/test_snapshot_chain.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_old_snapshot_chain:
     runs-on: ubuntu-latest
     needs: build
@@ -1296,24 +1278,6 @@ jobs:
           echo ""
         done
 
-  test_heal_ec_rdma:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 10
-      run: TEST_NAME=ec_rdma RDMA=1 SCHEME=ec /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_checksum:
     runs-on: ubuntu-latest
     needs: build

CMakeLists.txt

@@ -1,20 +1,20 @@
-cmake_minimum_required(VERSION 2.8...3.30)
+cmake_minimum_required(VERSION 2.8.12)
 
 project(vitastor)
 
-set(VITASTOR_VERSION "3.0.12")
+set(VITASTOR_VERSION "3.0.5")
 
 include(CTest)
 
 add_custom_target(build_tests)
-set_property(TEST PROPERTY ENVIRONMENT LSAN_OPTIONS=suppressions=${CMAKE_CURRENT_BINARY_DIR}/lsan-suppress.txt)
-add_test(gen_lsan_suppress
-    ${CMAKE_COMMAND} -E echo leak:tcmalloc > "${CMAKE_CURRENT_BINARY_DIR}/lsan-suppress.txt"
+add_custom_target(test
+	COMMAND
+	echo leak:tcmalloc > ${CMAKE_CURRENT_BINARY_DIR}/lsan-suppress.txt &&
+	env LSAN_OPTIONS=suppressions=${CMAKE_CURRENT_BINARY_DIR}/lsan-suppress.txt ${CMAKE_CTEST_COMMAND}
 )
-set_tests_properties(gen_lsan_suppress PROPERTIES FIXTURES_SETUP f_lsan_suppress)
-set_property(TEST PROPERTY FIXTURES_REQUIRED f_lsan_suppress)
 # make -j16 -C ../../build test_heap && ../../build/src/test/test_heap
 # make -j16 -C ../../build test_heap && rm -f $(find ../../build -name '*.gcda') && ctest -V -T test -T coverage -R heap --test-dir ../../build && (cd ../../build; gcovr -f ../src --html --html-nested -o coverage/index.html; cd ../src/test)
 # make -j16 -C ../../build test_blockstore && rm -f $(find ../../build -name '*.gcda') && ctest -V -T test -T coverage -R blockstore --test-dir ../../build && (cd ../../build; gcovr -f ../src --html --html-nested -o coverage/index.html; cd ../src/test)
 # kcov --include-path=../../../src ../../kcov ./test_blockstore
+add_dependencies(test build_tests)
 add_subdirectory(src)

csi/Makefile

@@ -1,4 +1,4 @@
-VITASTOR_VERSION ?= v3.0.12
+VITASTOR_VERSION ?= v3.0.5
 
 all: build push
 

csi/deploy/004-csi-nodeplugin.yaml

@@ -49,7 +49,7 @@ spec:
             capabilities:
               add: ["SYS_ADMIN"]
             allowPrivilegeEscalation: true
-          image: vitalif/vitastor-csi:v3.0.12
+          image: vitalif/vitastor-csi:v3.0.5
           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:v3.0.12
+          image: vitalif/vitastor-csi:v3.0.5
           args:
             - "--node=$(NODE_ID)"
             - "--endpoint=$(CSI_ENDPOINT)"

csi/src/config.go

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

debian/changelog

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

debian/vitastor-build.sh

@@ -44,7 +44,7 @@ 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
-if [[ ( "$REL" = "trixie" || "$REL" = "resolute" ) && -e ../vitastor-bookworm/vitastor_$VER.orig.tar.xz ]]; then
+if [[ "$REL" = "trixie" && -e ../vitastor-bookworm/vitastor_$VER.orig.tar.xz ]]; then
     # Fucking shit, archives differ between bookworm (xz 5.4.1) and trixie (xz 5.8.1)
     cp ../vitastor-bookworm/vitastor_$VER.orig.tar.xz .
 else

debian/vitastor-buildenv.Dockerfile

@@ -12,18 +12,20 @@ ARG REL=
 WORKDIR /root
 
 RUN set -e -x; \
-    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; \
+    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 libgoogle-perftools-dev devscripts libjerasure-dev cmake libc-ares-dev libisal-crypto-dev \
+    apt-get -y install fio libgoogle-perftools-dev devscripts libjerasure-dev cmake libc-ares-dev \
         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

docker/Makefile

@@ -1,4 +1,4 @@
-VITASTOR_VERSION ?= v3.0.12
+VITASTOR_VERSION ?= v3.0.5
 
 all: build push
 

docker/etc/systemd/system/vitastor-etcd.service

@@ -12,7 +12,12 @@ EnvironmentFile=/etc/vitastor/etcd.conf
 SyslogIdentifier=etcd
 ExecStart=bash -c 'docker run --rm -i -v /var/lib/vitastor/etcd:/data \
     --log-driver none --network host $CONTAINER_OPTIONS --name vitastor-etcd \
-    $ETCD_IMAGE /usr/local/bin/etcd --data-dir /data
+    $ETCD_IMAGE /usr/local/bin/etcd --name "$ETCD_NAME" --data-dir /data \
+    --snapshot-count 10000 --advertise-client-urls http://$ETCD_IP:2379 --listen-client-urls http://$ETCD_IP:2379 \
+    --initial-advertise-peer-urls http://$ETCD_IP:2380 --listen-peer-urls http://$ETCD_IP:2380 \
+    --initial-cluster-token vitastor-etcd-1 --initial-cluster "$ETCD_INITIAL_CLUSTER" \
+    --initial-cluster-state new --max-txn-ops=100000 --max-request-bytes=104857600 \
+    --auto-compaction-retention=10 --auto-compaction-mode=revision'
 ExecStop=docker stop vitastor-etcd
 Restart=always
 StartLimitInterval=0

docker/etc/vitastor/docker.conf

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

docker/etc/vitastor/etcd.conf

@@ -1 +1,4 @@
 ETCD_IMAGE=quay.io/coreos/etcd:v3.5.18
+ETCD_NAME=""
+ETCD_IP=""
+ETCD_INITIAL_CLUSTER=""

docs/config/osd.en.md

@@ -70,7 +70,6 @@ with an OSD restart or, for some of them, even without restarting by updating co
 - [use_atomic_flag](#use_atomic_flag)
 - [pg_reshard_chunk_size](#pg_reshard_chunk_size)
 - [pg_reshard_chunk_pause_ms](#pg_reshard_chunk_pause_ms)
-- [gc_on_start](#gc_on_start)
 
 ## bind_address
 
@@ -754,9 +753,3 @@ This option sets the maximum number of object is a chunk. Moving 100k objects us
 - Default: 100
 
 This option sets the interval between handling two PG count change chunks.
-
-## gc_on_start
-
-- Type: boolean
-
-Forcibly clean all garbage entries in the new store on every OSD restart.

docs/config/osd.ru.md

@@ -71,7 +71,6 @@
 - [use_atomic_flag](#use_atomic_flag)
 - [pg_reshard_chunk_size](#pg_reshard_chunk_size)
 - [pg_reshard_chunk_pause_ms](#pg_reshard_chunk_pause_ms)
-- [gc_on_start](#gc_on_start)
 
 ## bind_address
 
@@ -794,9 +793,3 @@ pg_minsize OSD во время переключений, что может по
 - Значение по умолчанию: 100
 
 Данная опция задаёт интервал между обработкой двух порций изменения числа PG пулов.
-
-## gc_on_start
-
-- Тип: булево (да/нет)
-
-Принудительно очищать все мусорные записи в новом хранилище при каждом запуске OSD.

docs/config/security.en.md

@@ -25,7 +25,7 @@ Most of them can be set in /etc/vitastor/vitastor.conf and in etcd, but don't su
 - [vault_timeout_ms](#vault_timeout_ms)
 - [vault_error_timeout_sec](#vault_error_timeout_sec)
 - [vault_refresh_leeway_sec](#vault_refresh_leeway_sec)
-- [max_cipher_pool_size](#max_cipher_pool_size)
+- [max_aes_xts_pool_size](#max_aes_xts_pool_size)
 
 ## etcd_client_cert
 
@@ -141,10 +141,10 @@ Time (in seconds) to wait before retrying after receiving an error from Vault.
 Extra time (in seconds) before real Vault token lease_timeout to refresh it, just
 in case of system clock drift.
 
-## max_cipher_pool_size
+## max_aes_xts_pool_size
 
 - Type: integer
 - Default: 256
 
-Maximum number of OpenSSL cipher contexts cached in OSD memory, counted separately
-for each cipher and for encryption/decryption. Probably doesn't require modification.
+Maximum number of OpenSSL encryption contexts cached in OSD memory. Probably
+doesn't require modification.

docs/config/security.ru.md

@@ -27,7 +27,7 @@ OSD, мониторами и клиентами.
 - [vault_timeout_ms](#vault_timeout_ms)
 - [vault_error_timeout_sec](#vault_error_timeout_sec)
 - [vault_refresh_leeway_sec](#vault_refresh_leeway_sec)
-- [max_cipher_pool_size](#max_cipher_pool_size)
+- [max_aes_xts_pool_size](#max_aes_xts_pool_size)
 
 ## etcd_client_cert
 
@@ -145,10 +145,10 @@ OSD, клиенты и мониторы должны иметь разные п
 Зазор времени (в секундах), чтобы обновлять токены Vault чуть раньше их реального
 lease_timeout, на случай "ухода" системных часов.
 
-## max_cipher_pool_size
+## max_aes_xts_pool_size
 
 - Тип: целое число
 - Значение по умолчанию: 256
 
-Максимальное количество кэшируемых в памяти OSD контекстов шифра OpenSSL, учитываемое
-отдельно для каждого шифра и для шифрования и расшифровки. Вряд ли требует изменения.
+Максимальное количество кэшируемых в памяти OSD контекстов шифрования OpenSSL.
+Вряд ли требует изменения.

docs/config/src/osd.yml

@@ -938,7 +938,3 @@
     This option sets the interval between handling two PG count change chunks.
   info_ru: |
     Данная опция задаёт интервал между обработкой двух порций изменения числа PG пулов.
-- name: gc_on_start
-  type: bool
-  info: Forcibly clean all garbage entries in the new store on every OSD restart.
-  info_ru: Принудительно очищать все мусорные записи в новом хранилище при каждом запуске OSD.

docs/config/src/security.yml

@@ -120,12 +120,12 @@
   info_ru: |
     Зазор времени (в секундах), чтобы обновлять токены Vault чуть раньше их реального
     lease_timeout, на случай "ухода" системных часов.
-- name: max_cipher_pool_size
+- name: max_aes_xts_pool_size
   type: int
   default: 256
   info: |
-    Maximum number of OpenSSL cipher contexts cached in OSD memory, counted separately
-    for each cipher and for encryption/decryption. Probably doesn't require modification.
+    Maximum number of OpenSSL encryption contexts cached in OSD memory. Probably
+    doesn't require modification.
   info_ru: |
-    Максимальное количество кэшируемых в памяти OSD контекстов шифра OpenSSL, учитываемое
-    отдельно для каждого шифра и для шифрования и расшифровки. Вряд ли требует изменения.
+    Максимальное количество кэшируемых в памяти OSD контекстов шифрования OpenSSL.
+    Вряд ли требует изменения.

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 vitalif/vitastor:v3.0.12`
+   `docker pull vitalif/vitastor:v3.0.5`
 2. Install scripts to the host system: \
-   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v3.0.12 install.sh`
+   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v3.0.5 install.sh`
 3. Reload udev rules: \
    `udevadm control --reload-rules`
 4. Enable the vitastor-host service: \

docs/installation/docker.ru.md

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

docs/installation/packages.en.md

@@ -17,7 +17,6 @@
   - 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`
-  - Ubuntu 26.04 (Resolute): `deb https://vitastor.io/debian resolute 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
 - To always prefer vitastor-patched QEMU and Libvirt versions, add the following to `/etc/apt/preferences`:

docs/installation/packages.ru.md

@@ -17,7 +17,6 @@
   - 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`
-  - Ubuntu 26.04 (Resolute): `deb https://vitastor.io/debian resolute main`
   - Добавьте `-oldstable` к слову bookworm/bullseye/buster в этой строке, чтобы
     установить последнюю стабильную версию из ветки 0.9.x вместо 1.x
 - Чтобы всегда предпочитались версии пакетов QEMU и Libvirt с патчами Vitastor, добавьте в `/etc/apt/preferences`:

docs/installation/source.en.md

@@ -17,6 +17,7 @@
 - CMake
 - jerasure, c-ares headers and libraries
 - ISA-L, libibverbs, librdmacm, libnl3 headers and libraries (optional)
+- tcmalloc (google-perftools-dev)
 
 ## Basic instructions
 

docs/installation/source.ru.md

@@ -17,6 +17,7 @@
 - CMake
 - Заголовки и библиотеки jerasure, c-ares
 - Опционально - заголовки и библиотеки ISA-L, libibverbs, librdmacm, libnl3
+- tcmalloc (google-perftools-dev)
 
 ## Базовая инструкция
 

docs/intro/security.ru.md

@@ -1,439 +0,0 @@
-[Документация](../../README-ru.md#документация) → Безопасность
-
------
-
-[Read in English](security.en.md)
-
-# Оглавление
-
-⚠️ Предупреждение: детальное описание настроек безопасности достаточно длинное.
-
-Если не боитесь - читайте [Подробное описание](#подробное-описание).
-
-Если хотите просто быстро настроить Vitastor с шифрованием - читайте начало статьи.
-
-- [Быстрая настройка](#быстрая-настройка)
-- 
-
-# Быстрая настройка
-
-
-
-# Пользовательские сценарии
-
-Зачем всё это нужно вам?
-
-
-
-# Подробное описание
-
-Начиная с версии 3.1.0, в Vitastor есть следующие функции:
-1. Шифрование соединений с etcd (TLS)
-2. Шифрование соединений с OSD (AES-GCM) - по выбору либо только заголовков, либо и заголовков, и данных
-3. Сквозное шифрование данных образов (AES-XTS)
-4. Хранения ключей шифрования AES-XTS во внешнем Vault
-5. Контрольных сумм данных на транспортном уровне с секретной "солью"
-6. Аутентификация с помощью TLS (X.509) сертификатов и закрытых ключей
-7. Разграничение прав доступа клиентов к данным etcd
-8. Разграничение прав доступа клиентов к данным самих образов (на стороне OSD)
-
-По умолчанию шифрование, аутентификация и авторизация отключены, но, начиная с 3.1.0,
-используются контрольные суммы данных на транспортном уровне (`proto_checksums=payload`).
-
-## Шифрование соединений с etcd (TLS)
-
-Варианты настройки:
-- Без шифрования (http)
-- С шифрованием (https)
-- С клиентским сертификатом, но при выключенной авторизации (`use_auth=false`) - используется
-  отдельный сертификат и ключ: `etcd_client_cert`, `etcd_client_key`
-- С клиентским сертификатом, при включённой аутентификации на уровне OSD - используется общий
-  сертификат и ключ: для OSD - `osd_cert` и `osd_pkey`, для клиентов - `cert` и `pkey`
-
-## Шифрование соединений с OSD (AES-GCM)
-
-Варианты настройки:
-- Без шифрования и без контрольных сумм: `proto_checksums=none`.
-- Без шифрования, с контрольными суммами данных: `proto_checksums=payload` (можно не указывать,
-  т.к. это значение по умолчанию). При этом контрольные суммы можно отключить на стороне
-  клиента либо использовать более старые версии клиента, не поддерживающие контрольные суммы.
-  Если нужно запретить подключение клиентов без контрольных сумм, можно использовать опцию
-  `force_proto_checksums=payload`.
-- С шифрованием заголовков и контрольными суммами данных: активируется при установленных опциях
-  `cert`, `pkey`, `osd_ca` на стороне клиента и `osd_cert`, `osd_pkey`, `osd_ca`, `client_ca`
-  на стороне OSD, при `proto_checksums=payload`. При этом по умолчанию запрещается
-  отключение контрольных сумм на уровне клиента, то есть используется `force_proto_checksums=payload`.
-- С полным шифрованием всего трафика: аналогично прошлому варианту, но с `proto_checksums=gcm`.
-  Клиенту при этом по умолчанию разрешается понизить уровень защиты до контрольных сумм, но
-  это тоже можно запретить через `force_proto_checksums=gcm`. Данный вариант не является рекомендуемым,
-  так как добавлен в первую очередь для возможной поддержки небезопасных (публичных) сетей и
-  больше всего снижает производительность. В частности, если одновременно использовать полное
-  шифрование трафика и сквозное шифрование образов AES-XTS, то данные будут шифроваться дважды.
-
-Для шифрования используется алгоритм AES-256-GCM и собственный упрощённый протокол согласования
-ключей, полностью аналогичный TLS 1.3 ECDHE.
-
-## Сквозное шифрование данных образов (AES-XTS)
-
-Клиент Vitastor поддерживает шифрование данных каждого образа своим ключом. В этом случае на OSD
-уходят уже зашифрованные данные и сами OSD не видят настоящее содержимое образов. Разные ключи
-в том числе могут иметь разные снимки или клоны одного и того же образа. Например, можно сделать
-базовый образ ВМ (условный Debian Linux) нешифрованным, но наследовать от него шифрованные образы
-клиентских ВМ.
-
-Ключи шифрования образов могут храниться либо в etcd, либо во внешнем Vault. Во втором случае
-в etcd хранятся только ID ключей, а Vitastor вообще не имеет доступа к данным образов. Для
-использования Vault нужно создать образ с опцией `--enc_key vault:ID`, а в конфигурации указать
-опции:
-- vault_url
-- vault_ca
-- vault_client_cert
-- vault_client_key
-
-Ещё раз повторимся, что если AES-XTS используется с полным шифрованием трафика (`proto_checksums=gcm`),
-то данные образов шифруются дважды - сначала AES-XTS, а потом AES-GCM. Можете использовать,
-только если вы совсем параноик :-).
-
-## Производительность шифрования
-
-У вас может возникнуть вопрос - а как быстро всё это прекрасное шифрование работает?
-
-Ответ - скорость сильно зависит от процессора. Складывается она из нескольких вещей:
-
-- 
-
-TODO: vitastor-cli bench.
-
-## Аутентификация по сертификатам
-
-При включённом шифровании клиенты, OSD и мониторы Vitastor аутентифицируются по сертификатам
-как при соединениях с etcd (Antietcd), так и с OSD.
-
-Для OSD и мониторов должны использоваться отдельные сертификаты - либо самоподписанные, либо
-подписанные отдельными CA (`osd_ca` и `mon_ca`). При этом все OSD могут использовать один и
-тот же сертификат и все мониторы тоже могут использовать один и тот же сертификат, так как
-привилегии разных OSD или разных мониторов ничем не отличаются (теоретически можно было бы
-сделать разграничение сертификатов OSD по пулам, но пока что такой необходимости не было).
-
-Также сертификат монитора может быть вообще не нужен, если Antietcd встраивается в сам монитор.
-В этом случае монитор и так имеет доступ ко всем данным etcd прямо в памяти.
-
-Каждый клиент должен иметь свой сертификат, подписанный общим корневым сертификатом
-для клиентов (`client_ca`). Common Name сертификата должно равняться имени пользователя.
-
-## Модель прав доступа
-
-Привилегии пользователей хранятся в данных etcd в ключах `/vitastor/config/user/<имя>`.
-
-У пользователя есть 2 свойства:
-- Тип:
-  - Клиент (`type=client` или не указано) - может читать и модифицировать только явным образом
-    разрешённые образы.
-  - Администратор (`type=admin`) - может читать и модифицировать все образы, а также администрировать
-    кластер: смотреть общую статистику и состояние, создавать и удалять OSD и так далее.
-- Список имён групп, членом которых пользователь является.
-
-У образов есть 3 свойства:
-- Владелец (owner) - имя пользователя, которому разрешено и читать, и менять образ
-- Группа владельцев (owner_group) - имя группы владельцев
-- Группа читатетей (reader_group) - имя группы пользователей, которым разрешено читать образ
-
-У пулов есть 1 свойство:
-- Группа создателей (creator_group) - имя группы пользователей, которым разрешено создавать образы в пуле
-
-## Права доступа к данным etcd
-
-Привилегии реализуются через Antietcd во всех режимах работы. Если используется etcd, то
-Antietcd выступает в роли фильтрующего прокси, при этом он может быть встроен в монитор
-Vitastor или запущен отдельно. В этом случае etcd должен разрешать входящие подключения
-только от Antietcd, а все остальные компоненты должны соединяться с Antietcd.
-
-Если же используется Antietcd, то привилегии реализуются в нём самом.
-
-Если используется встроенный в монитор Antietcd, то привилегии включаются либо параметром
-`use_auth: true`, либо, если этот параметр не указан - включается автоматически, если задан
-любой из параметров `client_ca`, `osd_ca`, `mon_ca`. При этом монитор требует указания
-параметров `client_ca` и `osd_ca`, а если не используется режим проксирования в etcd -
-также `antietcd_server_ca`, чтобы Antietcd мог отличать кластерные соединения от клиентских.
-
-Если используется отдельно стоящий Antietcd, привилегии нужно включать явным образом.
-
-Встроенные привилегии etcd не поддерживаются по причине их многочисленных недоработок:
-- Аутентификация по сертификатам не работает в REST интерфейсе etcd,
-- Привилегии хранятся отдельно от k/v и не могут участвовать в транзакциях,
-- Менять привилегии может только администратор (root)
-- Нет поддержки фильтрации ответов чтения по привилегиям.
-
-Подробный список привилегий на ключи в etcd [смотрите ниже](#привилегии-etcd).
-
-## Права доступа к данным OSD
-
-Регулируется опцией `use_auth`, либо, если она не указана, включается автоматически,
-если используется шифрование, то есть, если заданы опции `osd_ca` и `client_ca`.
-
-OSD аутентифицирует клиентов по сертификатам и разрешает каждому клиенту только
-то, что ему разрешено согласно модели прав доступа.
-
-Подробный список разрешаемых OSD операций [смотрите ниже](#привилегии-osd).
-
-## Права доступа к API
-
-[vitastor-cli serve](../usage/cli.ru.md#serve) также поддерживает клиентскую
-аутентификацию по сертификатам. Принимаются только сертификаты, подписанные
-`client_ca`. В качестве серверного сертификата используется отдельный сертификат
-`server_cert` с ключом `server_key`.
-
-При этом для корректной работы `vitastor-cli serve` он сам должен использовать
-для доступа в Vitastor сертификат (`cert`+`pkey`) пользователя с правами
-администратора (`type=admin`).
-
-Обычным клиентам при доступе к API разрешаются только API-операции с образами,
-доступными им либо на чтение (для чтения), либо на запись (для модификации).
-Все остальные API-вызовы разрешаются только для администраторов.
-
-Подробный список разрешаемых API операций [смотрите ниже](#привилегии-api).
-
-## Привилегии etcd
-
-Ниже все названия ключей приведены без общего префикса `/vitastor`.
-
-Разрешённые операции с ключами в Antietcd для клиентов (`type=client`):
-- Только чтение:
-  - Разрешено всегда:
-    - `/config/global`
-    - `/config/node_placement`
-    - `/config/pools`
-    - `/pg/config`
-    - `/osd/state/*`
-    - `/pg/state/*`
-    - `/index/maxid/*`
-  - Для образов, которые [может читать пользователь](#модель-прав-доступа):
-    - `/config/inode/*`
-    - `/index/image/*`
-    - `/inode/stats/*`
-- Чтение и запись:
-  - Для пулов, в которых может создавать образы пользователь:
-    - `/index/maxid/*`
-  - Для образов, которыми владеет пользователь:
-    - `/config/inode/*`
-    - `/index/image/*`
-
-Разрешённые операции с ключами в Antietcd для администраторов (`type=admin`):
-- Чтение:
-  - `/stats`
-  - `/mon/*`
-  - `/pg/*`
-  - `/pgstats/*`
-  - `/inode/stats/*`
-  - `/pool/stats/*`
-- Чтение и запись:
-  - `/config/*`
-  - `/osd/*`
-  - `/index/*`
-  - `/pg/history/*`
-
-Разрешённые операции с ключами в etcd для OSD:
-- Чтение:
-  - `/pg/config`
-  - `/config/*`
-- Чтение и запись:
-  - `/osd/*`
-  - `/pg/state/*`
-  - `/pg/history/*`
-  - `/pgstats/*`
-
-Разрешённые операции с ключами в etcd для мониторов:
-- Чтение:
-  - `/config/*`
-  - `/osd/*`
-  - `/pgstats/*`
-- Чтение и запись:
-  - `/pg/config`
-  - `/stats`
-  - `/history/last_clean_pgs`
-  - `/mon/*`
-  - `/pg/history/*`
-  - `/inode/stats/*`
-  - `/pool/stats/*`
-
-## Привилегии OSD
-
-Клиентские операции:
-- READ - разрешено для образов, доступных пользователю на чтение.
-- WRITE, DELETE, SCRUB - разрешены для образов, доступных пользователю на запись.
-- SYNC - операция не связана с образом и разрешена всегда.
-- DESCRIBE - операция разрешена только для администраторов (используются командами
-  `vitastor-cli describe` и `fix`).
-- PING - операция разрешена всегда.
-- SHOW_CONFIG - операция разрешена всегда, однако если в ней клиент представляется
-  как OSD, то проверяется, что он использует сертификат, подписанный `osd_ca`.
-- SEC_LIST (листинг) - разрешена другим OSD и администраторам с любыми параметрами,
-  а обычным клиентам разрешена только для запросов, ограниченных образом, доступным
-  пользователю на чтение.
-
-Кластерные операции - разрешаются только другим OSD:
-- SEC_READ
-- SEC_WRITE
-- SEC_WRITE_STABLE
-- SEC_SYNC
-- SEC_STABILIZE
-- SEC_ROLLBACK
-- SEC_DELETE
-- SEC_READ_BMP
-- SEC_LOCK
-
-## Привилегии API
-
-Клиентам (пользователям с `type=client`) разрешаются операции:
-- image/list - для образов, которые пользователь может читать.
-- image/create - для пулов, в которых пользователю разрешено создавать образы, либо
-  для создания снимков образов, которыми пользователь владеет.
-- image/delete, image/flatten, image/modify - для образов, которыми пользователь владеет.
-
-Все остальные операции разрешаются только администраторам (`type=admin`).
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Таким образом, доступны следующие варианты настройки:
-
-### Mon в роли Etcd proxy
-
-Mon
-- use_antietcd: true
-- etcd_proxy = {
-    urls: [],
-    cert = <antietcd.pem>,
-    key,
-    ca = <etcd.pem>,
-}
-- antietcd_cert = antietcd.pem
-- antietcd_key
-
-etcd
---client-cert-auth --cert-file=etcd.pem --key-file=etcd.key --trusted-ca-file=antietcd.pem \
---peer-client-cert-auth --peer-cert-file=etcd.pem --peer-key-file=etcd.key --peer-trusted-ca-file=etcd.pem
-
-### Mon с отдельным Antietcd Proxy
-
-Mon
-- use_antietcd: false
-- etcd_ca = antietcd.pem
-
-Antietcd
---client_cert_auth 1 --auth_filter vitastor_auth_filter.js --etcd_proxy url1,url2,... \
---cert antietcd.pem --key antietcd.key --ca client_ca.pem --osd_ca osd_ca.pem \
---etcd_cert antietcd.pem --etcd_key antietcd.key --etcd_ca etcd.pem
-
-etcd
---client-cert-auth --cert-file=etcd.pem --key-file=etcd.key --trusted-ca-file=antietcd.pem \
---peer-client-cert-auth --peer-cert-file=etcd.pem --peer-key-file=etcd.key --peer-trusted-ca-file=etcd.pem
-
-### Mon со встроенным Antietcd
-
-Mon
-- use_antietcd: true
-- use_auth: true
-- antietcd_cert = antietcd.pem
-- antietcd_key
-
-### Отдельный Antietcd
-
-Mon
-- use_antietcd: false
-- etcd_ca = antietcd.pem
-
-Antietcd
---client_cert_auth 1 --auth_filter vitastor_auth_filter.js
-
-## Варианты настройки
-
-### Настройка по умолчанию
-
-Используются только контрольные суммы данных на транспортном уровне. Соединения с etcd не шифруются.
-Аутентификация и авторизация не используется, любой клиент имеет доступ ко всем данным кластера.
-
-Аналог настройки:
-- proto_checksums: payload
-
-### Полная защита
-
-Везде
-- osd_ca
-- client_ca
-- etcd_ca = antietcd.pem
-
-OSD
-- osd_cert
-- osd_pkey
-
-Клиент
-- cert
-- pkey
-
-### Только защита etcd
-
-- etcd_ca
-- etcd_cert
-- etcd_key
-
-### antietcd и только защита antietcd
-
-- etcd_ca
-- etcd_cert
-- etcd_key
-- use_antietcd: true
-- antietcd_cert = etcd_ca
-- antietcd_key
-- antietcd_ca = etcd_cert
-
-### Полное шифрование протокола, включая данные
-
-Внимание: если включить этот вариант защиты и при этом 
-
-### Только контрольные суммы на транспортном уровне, без шифрования
-
-## Настройка Vault/OpenBao
-
-openssl req -days 3650 -x509 -addext basicConstraints=critical,CA:TRUE,pathlen:1 --addext subjectAltName=DNS:vault \
-    -new -newkey rsa:4096 -nodes -keyout vault.key -out vault.crt
-
-bao status -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200
-
-bao operator init -n 1 -t 1 -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200
-
-bao operator unseal -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200
-
-bao auth enable -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200 cert
-
-bao secrets enable -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200 -path=secret kv-v1
-
-bao kv put -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200 secret/vitastor/testimg3 key=$(openssl rand -hex 64)
-
-cat >testimg3.policy <<EOF
-path "/secret/vitastor/testimg3" {
-  capabilities = ["read"]
-}
-EOF
-
-bao policy write -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200 testimg3 testimg3.policy
-
-bao write -ca-cert /etc/openbao/tls/vault.crt -address=https://vault:8200 auth/cert/certs/testimg3 certificate=@testimg3.crt display_name=testimg3 token_ttl=24h token_policies=testimg3
-
-curl --cacert /etc/vitastor/vault.crt --cert testimg3.crt --key testimg3.key --json '{}' https://vault:8200/v1/auth/cert/login
-
-curl --cacert /etc/vitastor/vault.crt --cert testimg3.crt --key testimg3.key -H 'X-Vault-Token: s.Qkrm78BeK7Rqdz5MA3eJZNbu' https://vault:8200/v1/secret/vitastor/testimg3

docs/usage/nfs.en.md

@@ -262,4 +262,3 @@ Options:
 | `--logfile <FILE>` | log to the specified file                                |
 | `--enforce 1`      | enforce permissions at the server side (no by default)   |
 | `--foreground 1`   | stay in foreground, do not daemonize                     |
-| `--trace`          | trace all NFS requests                                   |

docs/usage/nfs.ru.md

@@ -274,4 +274,3 @@ VitastorFS из GPUDirect.
 | `--logfile <FILE>` | записывать логи в заданный файл                         |
 | `--enforce 1`      | проверять права доступа на стороне сервера (по умолчанию нет) |
 | `--foreground 1`   | не уходить в фон после запуска                          |
-| `--trace`          | логгировать все запросы NFS                             |

mon/antietcd_adapter.js

@@ -3,7 +3,6 @@
 
 const AntiEtcd = require('antietcd');
 
-const vitastor_auth_filter = require('./vitastor_auth_filter.js');
 const vitastor_persist_filter = require('./vitastor_persist_filter.js');
 const { b64, local_ips } = require('./utils.js');
 
@@ -28,68 +27,28 @@ class AntiEtcdAdapter
             is_local['::'] = true;
             is_local[''] = true;
             // split :, 3 -> <schema>:<//ip>:<port>
-            const cluster_local = cluster.map(s =>
-            {
-                const m = /^https?:\/\/(?:\[(.*)\]|([^\[\:]+))(?::(\d+))?$/.exec(s);
-                return [ m[2] || m[1], m[3] || 2379 ];
-            });
-            const selected = cluster_local.filter(ip => is_local[ip[0]] && (!cfg_port || ip[1] == cfg_port));
+            const selected = cluster.map(s => s.split(':', 3)).filter(ip => is_local[ip[1].substr(2)] && (!cfg_port || ip[2] == cfg_port));
             if (selected.length > 1)
             {
-                console.error('More than 1 etcd_address matches local IPs: '+(selected.join(', '))+', please specify port');
+                console.error('More than 1 etcd_address matches local IPs, please specify port');
                 process.exit(1);
             }
             else if (selected.length == 1)
             {
                 const antietcd_config = {
-                    ip: selected[0][0],
-                    port: selected[0][1],
+                    ip: selected[0][1].substr(2),
+                    port: selected[0][2],
                     cert: config.antietcd_cert,
                     key: config.antietcd_key,
-                    ca: config.antietcd_ca,
-                    data: config.antietcd_data_file || ((config.antietcd_data_dir || '/var/lib/vitastor') + '/mon_'+selected[0][1]+'.json.gz'),
+                    ca: config.etcd_ca,
+                    data: config.antietcd_data_file || ((config.antietcd_data_dir || '/var/lib/vitastor') + '/mon_'+selected[0][2]+'.json.gz'),
                     persist_filter: vitastor_persist_filter({ vitastor_prefix: config.etcd_prefix || '/vitastor' }),
-                    node_id: selected[0][0]+':'+selected[0][1], // node_id = ip:port
+                    node_id: selected[0][1].substr(2)+':'+selected[0][2], // node_id = ip:port
                     cluster: (cluster.length == 1 ? null : cluster.reduce((a, c) => { a[c.replace(/^(https?:\/\/)/, '')] = c; return a; }, {})),
                     cluster_key: (config.etcd_prefix || '/vitastor'),
                     stale_read: 1,
                     log_level: 1,
                 };
-                if (config.etcd_proxy)
-                {
-                    // Monitor may use the builtin etcd_proxy mode
-                    if (!config.etcd_proxy.urls)
-                    {
-                        console.error('etcd_proxy.urls are empty');
-                        process.exit(1);
-                    }
-                    antietcd_config.etcd_proxy = config.etcd_proxy.urls;
-                    antietcd_config.etcd_cert = config.etcd_proxy.cert;
-                    antietcd_config.etcd_key = config.etcd_proxy.key;
-                    antietcd_config.etcd_ca = config.etcd_proxy.ca;
-                    delete antietcd_config.data;
-                    delete antietcd_config.persist_filter;
-                    delete antietcd_config.cluster;
-                    delete antietcd_config.cluster_key;
-                }
-                const use_auth = config.use_auth || config.use_auth == null && config.client_ca;
-                if (use_auth)
-                {
-                    antietcd_config.client_cert_auth = true;
-                    antietcd_config.auth_filter = vitastor_auth_filter;
-                    antietcd_config.ca = config.client_ca;
-                    antietcd_config.osd_ca = config.osd_ca;
-                    antietcd_config.mon_ca = config.mon_ca;
-                    if (!config.etcd_proxy)
-                    {
-                        antietcd_config.peer_ca = config.antietcd_server_ca;
-                        if (!config.antietcd_server_ca || config.antietcd_server_ca == config.client_ca)
-                        {
-                            console.error('Secure setup requires separate antietcd_server_ca (for signing antietcd server certificates) and client_ca (for signing client certificates)');
-                            process.exit(1);
-                        }
-                    }
-                }
                 for (const key in config)
                 {
                     if (key.substr(0, 9) === 'antietcd_')
@@ -214,7 +173,7 @@ class AntiEtcdAdapter
                     await new Promise(ok => setTimeout(ok, timeout-(Date.now()-prev)));
                 }
                 prev = Date.now();
-                const res = await this.antietcd.api(path.replace(/^\/+/, '').replace(/\/+$/, '').replace(/\/+/g, '_'), body, { user_type: 'mon' });
+                const res = await this.antietcd.api(path.replace(/^\/+/, '').replace(/\/+$/, '').replace(/\/+/g, '_'), body);
                 if (res.error)
                 {
                     console.error('Failed to query antietcd '+path+' (retry '+retry+'/'+retries+'): '+res.error);

mon/etcd_schema.js

@@ -16,7 +16,6 @@ const etcd_allow = new RegExp('^'+[
     'config/pools',
     'config/osd/[1-9]\\d*',
     'config/pgs', // old name
-    'config/user/.*',
     'pg/config',
     'config/inode/[1-9]\\d*/[1-9]\\d*',
     'osd/state/[1-9]\\d*',
@@ -209,8 +208,6 @@ const etcd_tree = {
                 primary_affinity_tags?: 'nvme' | [ 'nvme', ... ],
                 // scrub interval
                 scrub_interval?: '30d',
-                // users allowed to create images in this pool
-                creator_group?: '',
             },
             ...
         }, */
@@ -228,20 +225,11 @@ const etcd_tree = {
                     readonly?: boolean,
                     deleted?: boolean,
                     enc_key?: string,
-                    owner?: string,
-                    owner_group?: string,
-                    reader_group?: string,
+                    meta?: any,
                 }
             }
         }, */
         inode: {},
-        /* user: {
-            <username>: {
-                type: 'osd'|'mon'|'admin'|'client',
-                groups: string[],
-            },
-        }, */
-        user: {},
     },
     osd: {
         state: {
@@ -404,6 +392,7 @@ const etcd_tree = {
             /* <name>: {
                 id: uint64_t,
                 pool_id: uint64_t,
+                // ...plus a copy of everything from config/inode/x/y
             }, */
         },
         maxid: {

mon/mon.js

@@ -627,7 +627,7 @@ class Mon
                 if (this.state.pg.history[pool_id] &&
                     this.state.pg.history[pool_id][pg])
                 {
-                    pg_history[pg-1] = JSON.parse(JSON.stringify(this.state.pg.history[pool_id][pg]));
+                    pg_history[pg-1] = this.state.pg.history[pool_id][pg];
                 }
             }
             const real_prev_pgs = [];
@@ -719,7 +719,7 @@ class Mon
                 this.next_recheck_timer = null;
                 this.next_recheck_at = 0;
                 this.schedule_recheck();
-            }, (this.next_recheck_at-now)*1000);
+            }, now-this.next_recheck_at);
         }
     }
 

mon/package.json

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

mon/pg_utils.js

@@ -84,7 +84,7 @@ function scale_pg_history(prev_pg_history, prev_pgs, new_pgs)
         finish_pg_history(merged_history[1]);
         for (let i = 0; i < new_pg_count; i++)
         {
-            new_pg_history[i] = JSON.parse(JSON.stringify(merged_history[1]));
+            new_pg_history[i] = { ...merged_history[1] };
         }
     }
     // Mark history keys for removed PGs as removed
@@ -102,7 +102,7 @@ function scale_pg_count(prev_pgs, new_pg_count)
     {
         for (let i = prev_pgs.length; i < new_pg_count; i++)
         {
-            prev_pgs[i] = [ ...prev_pgs[i % prev_pgs.length] ];
+            prev_pgs[i] = prev_pgs[i % prev_pgs.length];
         }
     }
     else if (prev_pgs.length > new_pg_count)

mon/scripts/make-etcd

@@ -1,278 +1,38 @@
 #!/usr/bin/node
-// Simple Vitastor etcd / antietcd / TLS configurator
+// Simple systemd unit generator for etcd
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: MIT
 
+// USAGE:
+// 1) Put the same etcd_address into /etc/vitastor/vitastor.conf on all monitor nodes
+// 2) Run ./make-etcd.js. It will create the etcd service on one of specified IPs
+
 const child_process = require('child_process');
 const fs = require('fs');
 const os = require('os');
-const readline = require('readline');
 
 run().catch(e => { console.error(e); process.exit(1); });
 
-const help_text = `Initialize a Vitastor cluster (etcd, vitastor.conf and TLS certificates)
-(c) Vitaliy Filippov, 2019+ (MIT)
-
-USAGE:
-1) Create a minimal vitastor.conf with etcd_address, osd_network and (optionally) use_auth.
-   Example: {"etcd_address":["http://10.0.0.10:2379","http://10.0.0.11:2379","http://10.0.0.12:2379"],"use_auth":false,"osd_network":"10.0.0.0/24"}
-   Or: {"etcd_address":["https://10.0.0.10:2379","https://10.0.0.11:2379","https://10.0.0.12:2379"],"use_auth":true,"osd_network":"10.0.0.0/24"}
-2) Run: ${process.argv[1]} [./vitastor.conf]
-   You can run it on etcd/monitor nodes or on an external node.
-   It configures etcd, generates TLS certificates (on the first or external node), copies them
-   to other etcd/monitor nodes, and updates vitastor.conf with TLS options.
-3) If you have OSD-only nodes, run:
-   ${process.argv[1]} --copy-to-osd-node NODE_NAME ./vitastor.conf
-   It copies vitastor.conf and required TLS certificates to that node.
-
-OPTIONS:
---gen-certs
-    force certificate generation even if it's not the first node
---no-certs
-    disable certificate generation
---no-copy
-    do not copy initial certificates to other nodes
---copy-to-osd-node NODE[,NODE2,...]
-    copy vitastor.conf and TLS certificates required for OSDs to NODES using scp
---copy-to-mon-node NODE[,NODE2,...]
-    copy vitastor.conf and TLS certificates required for monitor and etcd to NODES using scp
---copy-to-client-node NODE[,NODE2,...]
-    copy vitastor.conf and TLS certificates required for clients to NODES using scp
-`;
-
 async function run()
 {
-    let config_path = '/etc/vitastor/vitastor.conf';
-    let config_dir = '/etc/vitastor/';
-    let gen_certs = 'auto';
-    let copy_initial = true;
-    let copy_to_osd = 
-    for (let i = 2; i < process.argv.length; i++)
+    const config_path = process.argv[2] || '/etc/vitastor/vitastor.conf';
+    if (config_path == '-h' || config_path == '--help')
     {
-        if (arg == '-h' || arg == '--help')
-        {
-            console.log(help_text);
-            process.exit(0);
-        }
-        else if (arg == '--only-certs')
-        {
-            i++;
-            gen_certs = 
-        }
-        else if (arg == '--copy')
-        {
-            i++;
-            copy = process.argv[i];
-            if (copy !== 'ask' && copy !== 'yes' && copy !== 'no')
-            {
-                console.error('--copy should be "ask", "yes" or "no"');
-                process.exit(1);
-            }
-        }
-        else if (arg[0] == '-')
-        {
-            console.error('Unknown option: '+arg[0]);
-            process.exit(1);
-        }
-        else
-        {
-            config_path = arg;
-        }
+        console.log(
+            'Initialize systemd etcd service for Vitastor\n'+
+            '(c) Vitaliy Filippov, 2019+ (MIT)\n'+
+            '\n'+
+            'USAGE:\n'+
+            '1) Put the same etcd_address into /etc/vitastor/vitastor.conf on all monitor nodes\n'+
+            '2) Run '+process.argv[1]+' [config_path]\n'
+        );
+        process.exit(0);
     }
     if (!fs.existsSync(config_path))
     {
         console.log(config_path+' is missing');
         process.exit(1);
     }
-    const config = JSON.parse(fs.readFileSync(config_path, { encoding: 'utf-8' }));
-    if (!config.etcd_address)
-    {
-        console.log("etcd_address is missing in "+config_path);
-        process.exit(1);
-    }
-    const etcds = (config.etcd_address instanceof Array ? config.etcd_address : (''+config.etcd_address).split(/,/))
-        .map(s => /^(https?):\/\/(\[[^\]]+\]|[^\[\]\:\/]+)(?::(\d+))?/.exec(s.toLowerCase()))
-        .filter(s => s)
-        .map(s => ({
-            scheme: s[1],
-            addr: s[2].indexOf(':') && s[2][0] != '[' ? '['+s[2]+']' : s[2],
-            ip: s[2][0] == '[' ? s[2].substr(1, s[2].length-2) : s[2],
-            port: s[3],
-        }));
-    const tls = etcds.filter(e => e.scheme === 'https').length > 0;
-    const use_auth = tls && config.use_auth;
-    const num = select_local_etcd(etcds);
-    if (tls)
-    {
-        if (gen_certs === 'yes')
-        {
-            gen_certs = true;
-            console.log('Certificate generation is requested explicitly, generating');
-        }
-        else if (gen_certs === 'no')
-        {
-            gen_certs = false;
-            console.log('Certificate generation is disabled explicitly, skipping');
-        }
-        else if (num < 0)
-        {
-            gen_certs = true;
-            console.log('No matching IPs in etcd_address from '+config_path+', only generating certificates');
-        }
-        else if (fs.existsSync("/etc/vitastor/etcd.crt"))
-        {
-            gen_certs = false;
-            console.log('/etc/vitastor/etcd.crt already exists, assuming certificates are already generated');
-        }
-        else if (num === 0)
-        {
-            gen_certs = true;
-            console.log('This is monitor node 1, generating certificates');
-        }
-        else
-        {
-            console.log('This is monitor node '+(num+1)+', /etc/vitastor/etcd.crt does not exist, please copy certificates to this node');
-            process.exit(1);
-        }
-        if (gen_certs)
-        {
-            if (copy === 'ask')
-                copy = await ask_copy('Copy certificates and vitastor.conf to other nodes after generation?');
-            copy = (copy === 'y' || copy === 'yes');
-            await make_certs(dir, copy);
-        }
-        await write_auth_config(config, config_path);
-    }
-    if (num < 0)
-    {
-        console.log('No matching IPs in etcd_address from '+config_path);
-        process.exit(tls && gen_certs ? 0 : 1);
-    }
-    await configure_etcd();
-    process.exit(0);
-}
-
-async function ask_copy(question)
-{
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: '> ',
-    });
-    let copy;
-    while (true)
-    {
-        copy = await new Promise(ok => rl.question(question, ok));
-        if (copy != 'y' && copy != 'n' && copy != 'yes' && copy != 'no')
-            console.log('Please type "yes" or "no"');
-        else
-            break;
-    }
-    return copy;
-}
-
-async function make_certs(dir, copy)
-{
-    console.log(`-----
-Generating certificates in ${dir}
------
-`);
-    await make_ca("/O=Vitastor etcd CA", dir+"etcd_ca");
-    await make_signed("/CN=Vitastor etcd", dir+"etcd", dir+"etcd_ca", etcds.map(e => "IP:"+e.ip).join(','));
-    if (use_auth)
-    {
-        await make_ca("/O=Vitastor Antietcd CA", dir+"antietcd_ca");
-        await make_signed("/CN=Vitastor Antietcd", dir+"antietcd", dir+"antietcd_ca", etcds.map(e => "IP:"+e.ip).join(','));
-        await make_ca("/CN=Vitastor OSD", dir+"osd");
-        await make_ca("/O=Vitastor Client CA", dir+"client_ca");
-        await make_signed("/CN=admin", dir+"admin", dir+"client_ca");
-    }
-    if (use_auth)
-    {
-        console.log(`-----
-Certificates generated, commands to copy them:
-- Monitor+OSD node:
-  cd ${dir} && scp antietcd_ca.crt antietcd.crt antietcd.key osd.crt osd.key client_ca.crt etcd_ca.crt etcd.crt etcd.key root@NODE:/etc/vitastor/
-- Monitor node:
-  cd ${dir} && scp antietcd_ca.crt antietcd.crt antietcd.key osd.crt client_ca.crt etcd_ca.crt etcd.crt etcd.key root@NODE:/etc/vitastor/
-- OSD node:
-  cd ${dir} && scp antietcd_ca.crt osd.crt osd.key client_ca.crt root@NODE:/etc/vitastor/
------
-`);
-    }
-    else
-    {
-        console.log(`-----
-Certificates generated, commands to copy them:
-- Monitor node:
-  cd ${dir} && scp etcd_ca.crt etcd.crt etcd.key root@NODE:/etc/vitastor/
------
-`);
-    }
-    if (copy)
-    {
-        const to_copy = use_auth
-            ? [ "antietcd_ca.crt", "antietcd.crt", "antietcd.key", "osd.crt", "osd.key", "client_ca.crt", "etcd_ca.crt", "etcd.crt", "etcd.key" ]
-            : [ "etcd_ca.crt", "etcd.crt", "etcd.key" ];
-        for (const node of etcds)
-        {
-            await system("scp "+dir+to_copy.join(" "+dir)+" root@"+node.ip+"/etc/vitastor/");
-        }
-    }
-    else
-    {
-        console.warn('Certificates generated in /etc/vitastor, please copy them to other nodes');
-    }
-}
-
-async function write_auth_config(config, config_path)
-{
-    const auth = {};
-    if (use_auth)
-    {
-        auth["use_antietcd"] = true;
-        auth["etcd_proxy"] = {
-            urls: etcds.map(e => e.ip+':2381'),
-            cert: "/etc/vitastor/antietcd.crt",
-            key: "/etc/vitastor/antietcd.key",
-            ca: "/etc/vitastor/etcd_ca.crt",
-        };
-        auth["antietcd_cert"] = "/etc/vitastor/antietcd.crt";
-        auth["antietcd_key"] = "/etc/vitastor/antietcd.key";
-        auth["etcd_ca"] = "/etc/vitastor/antietcd_ca.crt";
-        auth["osd_cert"] = "/etc/vitastor/osd.crt";
-        auth["osd_pkey"] = "/etc/vitastor/osd.key";
-        auth["osd_ca"] = "/etc/vitastor/osd.crt";
-        auth["client_ca"] = "/etc/vitastor/client_ca.crt";
-        auth["cert"] = "/etc/vitastor/admin.crt";
-        auth["pkey"] = "/etc/vitastor/admin.key";
-    }
-    else
-    {
-        auth["etcd_ca"] = "/etc/vitastor/etcd.crt";
-    }
-    for (const k in auth)
-    {
-        if ((k in config) && JSON.stringify(auth[k]) != JSON.stringify(config[k]))
-        {
-            // Auth options already overridden with non-default
-            console.log(k+" is already overridden in "+config_path+", skipping config update");
-            return;
-        }
-    }
-    for (const k in auth)
-    {
-        config[k] = auth[k];
-    }
-    console.log(`-----
-Updating ${config_path}
------
-`);
-    fs.writeFileSync(config_path, JSON.stringify(config, 0, 4));
-}
-
-async configure_etcd()
-{
     const in_docker = fs.existsSync("/etc/vitastor/etcd.conf") &&
         fs.existsSync("/etc/vitastor/docker.conf");
     if (!in_docker && fs.existsSync("/etc/systemd/system/vitastor-etcd.service"))
@@ -285,49 +45,30 @@ async configure_etcd()
         console.log("/etc/systemd/system/etcd.service already exists");
         process.exit(1);
     }
-    const etcd_url = etcds[num].scheme + '://' + etcds[num].addr;
-    const options = {
-        name: 'etcd'+etcds[num].ip.replace(/[^0-9a-z_]/ig, '_'),
-        advertise_client_urls: etcd_url+':'+(use_auth ? 2381 : 2379),
-        listen_client_urls: etcd_url+':'+(use_auth ? 2381 : 2379),
-        initial_advertise_peer_urls: etcd_url+':2380',
-        listen_peer_urls: etcd_url+':2380',
-        initial_cluster_token: 'vitastor-etcd-1',
-        initial_cluster_state: 'new',
-        initial_cluster: etcds.map(e => `etcd${e.ip.replace(/[^0-9a-z_]/ig, '_')}=${e.scheme}://${e.addr}:2380`).join(','),
-        snapshot_count: 10000,
-        max_txn_ops: 100000,
-        max_request_bytes: 104857600,
-        auto_compaction_retention: 10,
-        auto_compaction_mode: 'revision',
-    };
-    if (tls)
+    const config = JSON.parse(fs.readFileSync(config_path, { encoding: 'utf-8' }));
+    if (!config.etcd_address)
     {
-        options['cert_file'] = '/etc/vitastor/etcd.crt';
-        options['key_file'] = '/etc/vitastor/etcd.key';
-        if (use_auth)
-        {
-            options['client_cert_auth'] = '1';
-            options['trusted_ca_file'] = '/etc/vitastor/antietcd.crt';
-        }
-        options['peer_cert_file'] = '/etc/vitastor/etcd.crt';
-        options['peer_key_file'] = '/etc/vitastor/etcd.key';
-        if (use_auth)
-        {
-            options['peer_client_cert_auth'] = '1';
-            options['peer_trusted_ca_file'] = '/etc/vitastor/etcd.crt';
-        }
+        console.log("etcd_address is missing in "+config_path);
+        process.exit(1);
     }
-    let etcd_conf = fs.existsSync("/etc/vitastor/etcd.conf")
-        ? fs.readFileSync("/etc/vitastor/etcd.conf", { encoding: 'utf-8' })
-        : "";
-    for (const k in options)
+    const etcds = (config.etcd_address instanceof Array ? config.etcd_address : (''+config.etcd_address).split(/,/))
+        .map(s => (''+s).replace(/^https?:\/\/|(:\d+)?(\/.*)?$/g, '').replace(/^\[(.*)\]$/, '$1').toLowerCase());
+    const num = select_local_etcd(etcds);
+    if (num < 0)
     {
-        etcd_conf = replace_env(etcd_conf, 'ETCD_'+k.toUpperCase().replace(/-/, '_'), options[k]);
+        console.log('No matching IPs in etcd_address from '+config_path);
+        process.exit(0);
     }
-    fs.writeFileSync("/etc/vitastor/etcd.conf", etcd_conf);
+    const etcd_url = 'http://' + (etcds[num].indexOf(':') >= 0 ? '['+etcds[num]+']' : etcds[num]);
+    const etcd_name = 'etcd'+etcds[num].replace(/[^0-9a-z_]/ig, '_');
+    const etcd_cluster = etcds.map(e => `etcd${e.replace(/[^0-9a-z_]/ig, '_')}=http://${e.indexOf(':') >= 0 ? '['+e+']' : e}:2380`).join(',');
     if (in_docker)
     {
+        let etcd_conf = fs.readFileSync("/etc/vitastor/etcd.conf", { encoding: 'utf-8' });
+        etcd_conf = replace_env(etcd_conf, 'ETCD_NAME', etcd_name);
+        etcd_conf = replace_env(etcd_conf, 'ETCD_IP', etcds[num]);
+        etcd_conf = replace_env(etcd_conf, 'ETCD_INITIAL_CLUSTER', etcd_cluster);
+        fs.writeFileSync("/etc/vitastor/etcd.conf", etcd_conf);
         console.log('etcd for Vitastor configured. Run `systemctl enable --now vitastor-etcd` to start etcd');
         process.exit(0);
     }
@@ -342,8 +83,12 @@ Wants=network-online.target local-fs.target time-sync.target
 [Service]
 Restart=always
 Environment=GOGC=50
-EnvironmentFile=/etc/vitastor/etcd.conf
-ExecStart=etcd --data-dir /var/lib/etcd/vitastor
+ExecStart=etcd --name ${etcd_name} --data-dir /var/lib/etcd/vitastor \\
+    --snapshot-count 10000 --advertise-client-urls ${etcd_url}:2379 --listen-client-urls ${etcd_url}:2379 \\
+    --initial-advertise-peer-urls ${etcd_url}:2380 --listen-peer-urls ${etcd_url}: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/vitastor
 ExecStartPre=+chown -R etcd /var/lib/etcd/vitastor
 User=etcd
@@ -361,6 +106,7 @@ WantedBy=multi-user.target
     // Disable distribution etcd unit and enable our one
     await system(`systemctl disable --now etcd`);
     await system(`systemctl enable --now vitastor-etcd`);
+    process.exit(0);
 }
 
 function replace_env(text, key, value)
@@ -373,29 +119,16 @@ function replace_env(text, key, value)
 function select_local_etcd(etcds)
 {
     const ifaces = os.networkInterfaces();
-    const local = {};
     for (const ifname in ifaces)
-    {
         for (const iface of ifaces[ifname])
-        {
-            const addr = iface.address;
-            if (iface.family == 'IPv6')
-                local[addr.toLowerCase()] = local['['+addr.toLowerCase()+']'] = true;
-            else
-                local[addr] = true;
-        }
-    }
-    for (let i = 0; i < etcds.length; i++)
-    {
-        if (local[etcds[i].addr])
-            return i;
-    }
+            for (let i = 0; i < etcds.length; i++)
+                if (etcds[i] == iface.address.toLowerCase())
+                    return i;
     return -1;
 }
 
 async function system(cmd)
 {
-    console.log('Running '+cmd);
     const cp = child_process.spawn(cmd, { shell: true, stdio: [ 0, 1, 2 ] });
     let finish_cb;
     cp.on('exit', () => finish_cb && finish_cb());
@@ -403,19 +136,3 @@ async function system(cmd)
         await new Promise(ok => finish_cb = ok);
     return cp.exitCode;
 }
-
-async function make_ca(subj, filename)
-{
-    if (await system("openssl req -days 3650 -x509 -subj '"+subj+"' -addext basicConstraints=critical,CA:TRUE,pathlen:1"+
-        " -new -newkey rsa:4096 -nodes -keyout "+filename+".key -out "+filename+".crt"))
-        process.exit(1);
-}
-
-async function make_signed(subj, f, ca, san)
-{
-    if (await system(`openssl req -subj '${subj}' ${san ? "-addext 'subjectAltName="+san+"'" : ""} -nodes -new -keyout ${f}.key -out ${f}.csr`))
-        process.exit(1);
-    if (await system(`openssl x509 -req -days 3650 -CA ${ca}.crt -CAkey ${ca}.key -CAcreateserial -in ${f}.csr -out ${f}.crt`))
-        process.exit(1);
-    fs.unlinkSync(f+".csr");
-}

mon/stats.js

@@ -37,7 +37,6 @@ function derive_osd_stats(st, prev, prev_diff)
         const n = c.count - BigInt(pr && pr.count||0);
         diff.recovery_stats[op] = { ...c, bps: n > 0 ? b*1000n/timediff : 0n, iops: n > 0 ? n*1000n/timediff : 0n };
     }
-    diff.inode_stats = {};
     for (const pool_id in st.inode_stats||{})
     {
         diff.inode_stats[pool_id] = {};

mon/vitastor_auth_filter.js

@@ -1,539 +0,0 @@
-// AntiEtcd authentication filter for Vitastor
-// (c) Vitaliy Filippov, 2026
-// License: Mozilla Public License 2.0 or Vitastor Network Public License 1.1
-
-// Permissions are based on:
-// 1. Users.
-//    Stored in /vitastor/config/user/<username>.
-//    Has 2 properties:
-//    - type, one of: admin, client.
-//      admin has full access to all images and also to cluster config.
-//      client has r/w access to owned images and r/o access to images with reader_group.
-//    - groups, a list of group names the user is included in.
-// 2. Images.
-//    Stored in /vitastor/config/inode/<pool>/<inode>. Has the following properties:
-//    - owner (user name)
-//    - owner_group (group name)
-//    - reader_group
-// 3. Certificates.
-//    - osd, mon use their own trusted certificates.
-
-const { X509Certificate } = require('node:crypto');
-
-const static_perms = {
-    invalid: {
-        keys: {},
-        prefixes: {},
-    },
-    osd: {
-        keys: { '/pg/config': false },
-        prefixes: { '/config/': false, '/osd/': true, '/pg/state/': true, '/pg/history/': true, '/pgstats/': true },
-    },
-    mon: {
-        keys: { '/pg/config': true, '/stats': true, '/history/last_clean_pgs': true },
-        prefixes: {
-            '/config/': false, '/osd/': false, '/mon/': true, '/pg/history/': true,
-            '/pgstats/': false, '/inode/stats/': true, '/pool/stats/': true,
-        },
-    },
-    admin: {
-        keys: { '/stats': false },
-        prefixes: {
-            '/config/': true, '/osd/': true, '/index/': true, '/pg/history/': true,
-            '/mon/': false, '/pg/': false, '/pgstats/': false, '/inode/stats/': false, '/pool/stats/': false,
-        },
-    },
-    client: {
-        keys: { '/config/global': false, '/config/node_placement': false, '/config/pools': false, '/pg/config': false },
-        prefixes: { '/osd/state/': false, '/pg/state/': false, '/index/maxid/': false },
-    },
-};
-
-const api_perms = {
-    osd: { lease_grant: true, lease_revoke: true, lease_keepalive: true, maintenance_status: true },
-    mon: { lease_grant: true, lease_revoke: true, lease_keepalive: true, maintenance_status: true },
-    admin: { maintenance_status: true },
-    client: { maintenance_status: true },
-};
-
-class VitastorAuthFilter
-{
-    constructor(antietcd)
-    {
-        this.cfg = antietcd.cfg;
-        this.antietcd = antietcd;
-        this.prefix = this.cfg.vitastor_prefix || '/vitastor';
-        this.prefix_parts = this.prefix.split('/');
-    }
-
-    async init()
-    {
-        if (!this.cfg.cert || !this.cfg.key || !this.cfg.osd_ca || !this.cfg.etcd_proxy && !this.cfg.peer_ca || !this.cfg.client_cert_auth)
-        {
-            throw new Error('Authenticated Vitastor setups require enabled client_cert_auth, cert, key'+
-                ' and separate ca (client CA), osd_ca'+(this.cfg.etcd_proxy ? '' : ', peer_ca')+' and optionally mon_ca');
-        }
-        this.osd_ca = await this.antietcd.readPEM(this.cfg.osd_ca);
-        this.osd_ca_obj = new X509Certificate(this.osd_ca);
-        this.antietcd.tls.ca.push(this.osd_ca);
-        if (this.cfg.mon_ca)
-        {
-            this.mon_ca = await this.antietcd.readPEM(this.cfg.mon_ca);
-            this.mon_ca_obj = new X509Certificate(this.mon_ca_obj);
-            this.antietcd.tls.ca.push(this.mon_ca);
-        }
-    }
-
-    init_context(context, clientCert)
-    {
-        let cert = clientCert;
-        while (cert)
-        {
-            if (cert.fingerprint256 == this.osd_ca_obj.fingerprint256)
-            {
-                context.user_type = 'osd';
-                break;
-            }
-            if (this.mon_ca_obj && cert.fingerprint256 == this.mon_ca_obj.fingerprint256)
-            {
-                context.user_type = 'mon';
-                break;
-            }
-            cert = cert.issuerCertificate;
-        }
-    }
-
-    _get(path, decode)
-    {
-        let cur = this.antietcd.etctree.state;
-        path = path instanceof Array ? path : path.split('/');
-        for (const p of path)
-        {
-            if (!cur.children)
-            {
-                return null;
-            }
-            cur = cur.children[p];
-            if (!cur)
-            {
-                return null;
-            }
-        }
-        if (decode)
-        {
-            return this._decode(path, cur.value);
-        }
-        return cur;
-    }
-
-    _decode(path, cur)
-    {
-        if (!cur)
-        {
-            return null;
-        }
-        if (cur)
-        {
-            try
-            {
-                cur = JSON.parse(cur);
-            }
-            catch (e)
-            {
-                console.warn('Invalid JSON in '+(path instanceof Array ? path.join('/') : path)+': '+e);
-            }
-        }
-        return cur;
-    }
-
-    // userInfo: { name: string, type: string, perms: static_perms[type], groups: { [string]: true } }
-    _check_compare(check, userInfo, checked)
-    {
-        let key = String(check.key);
-        if (key.substr(0, this.prefix.length) !== this.prefix)
-        {
-            return false;
-        }
-        key = key.substr(this.prefix.length);
-        if (key in userInfo.perms.keys)
-        {
-            return true;
-        }
-        for (const pfx in userInfo.perms.prefixes)
-        {
-            if (key.substr(0, pfx.length) == pfx)
-            {
-                return true;
-            }
-        }
-        if (userInfo.type == 'client')
-        {
-            // Image permissions
-            if (key.substr(0, 14) == '/config/inode/')
-            {
-                // Allowed to check that a key does not exist
-                if (check.target == 'VERSION' && check.version == 0)
-                {
-                    checked['M'+key] = true;
-                    return true;
-                }
-                else if (check.target == 'MOD')
-                {
-                    const data = this._get(check.key);
-                    if (!data || data.mod_revision != check.mod_revision)
-                    {
-                        // Break check to trigger CAS failure
-                        check.mod_revision = '18446744073709551615'; // UINT64_MAX
-                        return true;
-                    }
-                    const inode = this._decode(check.key, data.value);
-                    if (inode && (inode.owner_group && userInfo.groups[inode.owner_group] ||
-                        inode.owner === userInfo.name))
-                    {
-                        checked['M'+key] = true;
-                        return true;
-                    }
-                }
-                return false;
-            }
-            if (key.substr(0, 13) == '/index/image/')
-            {
-                // Allowed to check that a key does not exist
-                if (check.target == 'VERSION' && check.version == 0)
-                {
-                    checked['M'+key] = true;
-                    return true;
-                }
-                else if (check.target == 'MOD')
-                {
-                    let data = this._get(check.key);
-                    if (!data || data.mod_revision != check.mod_revision)
-                    {
-                        // Break check to trigger CAS failure
-                        check.mod_revision = '18446744073709551615'; // UINT64_MAX
-                        return true;
-                    }
-                    data = this._decode(check.key, data.value);
-                    if (data)
-                    {
-                        const inode = this._get([ ...this.prefix_parts, 'config', 'inode', data.pool_id, data.id ], true);
-                        if (inode && (inode.owner_group && userInfo.groups[inode.owner_group] ||
-                            inode.owner === userInfo.name))
-                        {
-                            checked['M'+key] = true;
-                            return true;
-                        }
-                    }
-                }
-                return false;
-            }
-            if (key.substr(0, 13) == '/index/maxid/')
-            {
-                const pool_id = key.substr(13);
-                const pool_cfg = this._get([ ...this.prefix_parts, 'config', 'pools' ], true);
-                if (!pool_cfg || !pool_cfg[pool_id] || !pool_cfg[pool_id].creator_group || !userInfo.groups[pool_cfg[pool_id].creator_group])
-                {
-                    return false;
-                }
-                if (check.target == 'VERSION' && check.version == 0)
-                {
-                    checked['I'+parseInt(key.substr(13))+'_0'] = true;
-                    return true;
-                }
-                else if (check.target == 'MOD')
-                {
-                    const data = this._get(check.key);
-                    if (!data || data.mod_revision != check.mod_revision)
-                    {
-                        // Break check to trigger CAS failure
-                        check.mod_revision = '18446744073709551615'; // UINT64_MAX
-                        return true;
-                    }
-                    checked['I'+parseInt(key.substr(13))+'_'+data.value] = true;
-                    return true;
-                }
-                return false;
-            }
-        }
-        return false;
-    }
-
-    _check_read(kv, userInfo)
-    {
-        let key = String(kv.key);
-        if (key.substr(0, this.prefix.length) !== this.prefix)
-        {
-            return false;
-        }
-        key = key.substr(this.prefix.length);
-        if (key in userInfo.perms.keys)
-        {
-            return true;
-        }
-        for (const pfx in userInfo.perms.prefixes)
-        {
-            if (key.substr(0, pfx.length) == pfx)
-            {
-                return true;
-            }
-        }
-        if (userInfo.type == 'client')
-        {
-            // Image permissions
-            if (key.substr(0, 14) == '/config/inode/')
-            {
-                const inode = this._decode(kv.key, kv.value);
-                if (inode && (inode.reader_group && userInfo.groups[inode.reader_group] ||
-                    inode.owner_group && userInfo.groups[inode.owner_group] ||
-                    inode.owner === userInfo.name))
-                {
-                    return true;
-                }
-                return false;
-            }
-            if (key.substr(0, 13) == '/index/image/')
-            {
-                const data = this._decode(kv.key, kv.value);
-                const inode = this._get([ ...this.prefix_parts, 'config', 'inode', data.pool_id, data.id ], true);
-                if (inode && (inode.reader_group && userInfo.groups[inode.reader_group] ||
-                    inode.owner_group && userInfo.groups[inode.owner_group] ||
-                    inode.owner === userInfo.name))
-                {
-                    return true;
-                }
-                return false;
-            }
-            if (key.substr(0, 13) == '/inode/stats/')
-            {
-                const [ pool_id, id ] = key.substr(13).split('/');
-                const inode = this._get([ ...this.prefix_parts, 'config', 'inode', pool_id, id ], true);
-                if (inode && (inode.reader_group && userInfo.groups[inode.reader_group] ||
-                    inode.owner_group && userInfo.groups[inode.owner_group] ||
-                    inode.owner === userInfo.name))
-                {
-                    return true;
-                }
-                return false;
-            }
-        }
-        return false;
-    }
-
-    _check_write(put, userInfo, checked)
-    {
-        let key = String(put.key);
-        if (key.substr(0, this.prefix.length) !== this.prefix)
-        {
-            return false;
-        }
-        key = key.substr(this.prefix.length);
-        if (userInfo.perms.keys[key])
-        {
-            return true;
-        }
-        for (const pfx in userInfo.perms.prefixes)
-        {
-            if (userInfo.perms.prefixes[pfx] && key.substr(0, pfx.length) == pfx)
-            {
-                return true;
-            }
-        }
-        if (checked && userInfo.type == 'client')
-        {
-            if (key.substr(0, 13) == '/index/maxid/' &&
-                checked['I'+parseInt(key.substr(13))+'_'+(put.value-1)])
-            {
-                // Allowed to increment maxid
-                return true;
-            }
-            if (checked['M'+key])
-            {
-                // Allowed to modify known images with CAS checks
-                return true;
-            }
-        }
-        return false;
-    }
-
-    _check_req(req, userInfo, checked)
-    {
-        let r;
-        if ((r = (req.request_range || req.requestRange)))
-        {
-            // All range queries are allowed, but responses are filtered - it's simpler
-        }
-        else if ((r = (req.request_put || req.requestPut)))
-        {
-            if (!this._check_write(r, userInfo, checked))
-                return false;
-        }
-        else if ((r = (req.request_delete_range || req.requestDeleteRange)))
-        {
-            if (!r.range_end || r.range_end === r.key)
-            {
-                if (!this._check_write({ key: r.key }, userInfo))
-                    return false;
-            }
-            else
-            {
-                // All keys in range must satisfy prefix
-                r.range_end = String(r.range_end);
-                if (r.key.length != r.range_end.length ||
-                    r.key[r.key.length-1] != '/' ||
-                    r.range_end[r.range_end.length-1] != '0')
-                {
-                    return false;
-                }
-                let key = r.key.substr(this.prefix.length);
-                let found = false;
-                for (const pfx in userInfo.perms.prefixes)
-                {
-                    if (userInfo.perms.prefixes[pfx] && key.substr(0, pfx.length) == pfx)
-                    {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found)
-                    return false;
-            }
-        }
-        return true;
-    }
-
-    _get_user(context)
-    {
-        if (context.user_type === 'osd' || context.user_type === 'mon')
-        {
-            return {
-                name: context.user_type,
-                type: context.user_type,
-                perms: static_perms[context.user_type],
-            };
-        }
-        if (!context.username)
-        {
-            return {};
-        }
-        let userInfo = this._get([ ...this.prefix_parts, 'config', 'user', context.username ], true);
-        if (!userInfo)
-        {
-            userInfo = { type: 'client' };
-        }
-        else if (userInfo.type !== 'client' && userInfo.type !== 'admin')
-        {
-            userInfo.type = 'client';
-        }
-        userInfo.perms = static_perms[userInfo.type] || static_perms['invalid'];
-        userInfo.name = context.username;
-        if (userInfo.groups instanceof Array)
-        {
-            userInfo.groups = userInfo.groups.reduce((a, c) => { a[c] = true; return a; }, {});
-        }
-        else
-        {
-            userInfo.groups = {};
-        }
-        return userInfo;
-    }
-
-    filter_api(context, api/*, data*/)
-    {
-        let type = 'client';
-        if (context.user_type === 'osd' || context.user_type === 'mon')
-        {
-            type = context.user_type;
-        }
-        else if (context.username)
-        {
-            const userInfo = this._get([ ...this.prefix_parts, 'config', 'user', context.username ], true);
-            if (userInfo && userInfo.type === 'admin')
-            {
-                type = 'admin';
-            }
-        }
-        return api_perms[type] && api_perms[type][api];
-    }
-
-    filter_txn(context, txn)
-    {
-        const userInfo = this._get_user(context);
-        if (!userInfo)
-        {
-            return null;
-        }
-        const checked = {};
-        if (txn.compare)
-        {
-            for (const check of txn.compare)
-            {
-                if (!this._check_compare(check, userInfo, checked))
-                    return null;
-            }
-        }
-        // Special transactions:
-        // 1. create image: create config/inode and index/image, increment index/maxid/<pool> (with CAS)
-        // 2. create snapshot: same as create image but also rename previous to @snap
-        if (txn.success)
-        {
-            for (const req of txn.success)
-            {
-                if (!this._check_req(req, userInfo, checked))
-                    return null;
-            }
-        }
-        if (txn.failure)
-        {
-            for (const req of txn.failure)
-            {
-                if (!this._check_req(req, userInfo, null))
-                    return null;
-            }
-        }
-        return txn;
-    }
-
-    filter_txn_response(context, txn, res)
-    {
-        if (!res.responses)
-        {
-            return;
-        }
-        const userInfo = this._get_user(context);
-        if (!userInfo)
-        {
-            for (const resp of res.responses)
-            {
-                if (resp.response_range && resp.response_range.kvs)
-                {
-                    resp.response_range.kvs = [];
-                }
-            }
-            return;
-        }
-        for (const resp of res.responses)
-        {
-            if (resp.response_range && resp.response_range.kvs)
-            {
-                resp.response_range.kvs = resp.response_range.kvs.filter(kv => this._check_read(kv, userInfo));
-            }
-        }
-    }
-
-    filter_watch_message(context, msg)
-    {
-        if (!msg.result || !msg.result.events)
-        {
-            return;
-        }
-        const userInfo = this._get_user(context);
-        if (!userInfo)
-        {
-            msg.result.events = [];
-            return;
-        }
-        msg.result.events = msg.result.events.filter(ev => this._check_read(ev.kv, userInfo));
-    }
-}
-
-module.exports = VitastorAuthFilter;

node-binding/package.json

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

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 = '3.0.12'
+VITASTOR_VERSION = '3.0.5'
 
 LOG = logging.getLogger(__name__)
 

patches/libvirt-12.0-vitastor.diff

@@ -1,637 +0,0 @@
-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 9ca5c2450c..cc52f00c0c 100644
---- a/src/conf/domain_conf.c
-+++ b/src/conf/domain_conf.c
-@@ -7453,7 +7453,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)
-@@ -32187,6 +32188,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 7346a61731..83e94d762e 100644
---- a/src/conf/domain_validate.c
-+++ b/src/conf/domain_validate.c
-@@ -520,6 +520,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:
-@@ -592,7 +593,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) {
-@@ -600,10 +601,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 114dd3f96f..c71f9a3277 100644
---- a/src/conf/schemas/domaincommon.rng
-+++ b/src/conf/schemas/domaincommon.rng
-@@ -2093,6 +2093,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">
-@@ -2443,6 +2472,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 d7b9bdfecb..38aefd0dd4 100644
---- a/src/conf/storage_source_conf.c
-+++ b/src/conf/storage_source_conf.c
-@@ -90,6 +90,7 @@ VIR_ENUM_IMPL(virStorageNetProtocol,
-               "ssh",
-               "vxhs",
-               "nfs",
-+              "vitastor",
- );
- 
- 
-@@ -1317,6 +1318,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 22c35d420d..f1e32ea83d 100644
---- a/src/conf/storage_source_conf.h
-+++ b/src/conf/storage_source_conf.h
-@@ -131,6 +131,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 2b988157fa..9d0eb47b25 100644
---- a/src/libxl/libxl_conf.c
-+++ b/src/libxl/libxl_conf.c
-@@ -1069,6 +1069,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 e72e7d7f44..8482c21805 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 9b43279797..459d8e8a65 100644
---- a/src/qemu/qemu_block.c
-+++ b/src/qemu/qemu_block.c
-@@ -743,6 +743,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)
- {
-@@ -1094,6 +1126,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)))
-@@ -1997,6 +2035,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:
-@@ -2377,6 +2416,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 ac56fc7cb4..9e407b4aab 100644
---- a/src/qemu/qemu_domain.c
-+++ b/src/qemu/qemu_domain.c
-@@ -4677,7 +4677,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;
-@@ -9103,6 +9104,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 e738afffc3..37d64f469b 100644
---- a/src/qemu/qemu_snapshot.c
-+++ b/src/qemu/qemu_snapshot.c
-@@ -665,6 +665,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:
-@@ -893,6 +894,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 821378883c..2211f6891b 100644
---- a/src/storage_file/storage_source_backingstore.c
-+++ b/src/storage_file/storage_source_backingstore.c
-@@ -264,6 +264,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)
-@@ -379,6 +448,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:
-@@ -953,6 +1027,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,
-@@ -1130,6 +1252,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 1165689de7..bba846351c 100644
---- a/src/test/test_driver.c
-+++ b/src/test/test_driver.c
-@@ -7345,6 +7345,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;
-             }

patches/qemu-10.1-vitastor.patch

@@ -1,172 +1,29 @@
-diff --git a/block/meson.build b/block/meson.build
-index 34b1b2a306..24ca0f1e52 100644
---- a/block/meson.build
-+++ b/block/meson.build
-@@ -114,6 +114,7 @@ foreach m : [
-   [libnfs, 'nfs', files('nfs.c')],
-   [libssh, 'ssh', files('ssh.c')],
-   [rbd, 'rbd', files('rbd.c')],
-+  [vitastor, 'vitastor', files('vitastor.c')],
- ]
-   if m[0].found()
-     module_ss = ss.source_set()
-diff --git a/meson.build b/meson.build
-index 50c774a195..e5c7a3a4b1 100644
---- a/meson.build
-+++ b/meson.build
-@@ -1652,6 +1652,26 @@ if not get_option('rbd').auto() or have_block
-   endif
- endif
+diff --git a/src/client/qemu_driver.c b/src/client/qemu_driver.c
+index d8356dab..5f4cd50d 100644
+--- a/src/client/qemu_driver.c
++++ b/src/client/qemu_driver.c
+@@ -974,14 +974,21 @@ static void vitastor_co_read_bitmap_cb(void *opaque, long retval, uint8_t *bitma
+ #endif
+ }
  
-+vitastor = not_found
-+if not get_option('vitastor').auto() or have_block
-+  libvitastor_client = cc.find_library('vitastor_client', has_headers: ['vitastor_c.h'],
-+    required: get_option('vitastor'))
-+  if libvitastor_client.found()
-+    if cc.links('''
-+      #include <vitastor_c.h>
-+      int main(void) {
-+        vitastor_c_create_qemu(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-+        return 0;
-+      }''', dependencies: libvitastor_client)
-+      vitastor = declare_dependency(dependencies: libvitastor_client)
-+    elif get_option('vitastor').enabled()
-+      error('could not link libvitastor_client')
-+    else
-+      warning('could not link libvitastor_client, disabling')
-+    endif
-+  endif
-+endif
-+
- glusterfs = not_found
- glusterfs_ftruncate_has_stat = false
- glusterfs_iocb_has_stat = false
-@@ -2547,6 +2567,7 @@ endif
- config_host_data.set('CONFIG_OPENGL', opengl.found())
- config_host_data.set('CONFIG_PLUGIN', get_option('plugins'))
- config_host_data.set('CONFIG_RBD', rbd.found())
-+config_host_data.set('CONFIG_VITASTOR', vitastor.found())
- config_host_data.set('CONFIG_RDMA', rdma.found())
- config_host_data.set('CONFIG_RELOCATABLE', get_option('relocatable'))
- config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack'))
-@@ -4972,6 +4993,7 @@ summary_info += {'fdt support':       fdt_opt == 'internal' ? 'internal' : fdt}
- summary_info += {'libcap-ng support': libcap_ng}
- summary_info += {'bpf support':       libbpf}
- summary_info += {'rbd support':       rbd}
-+summary_info += {'vitastor support':  vitastor}
- summary_info += {'smartcard support': cacard}
- summary_info += {'U2F support':       u2f}
- summary_info += {'libusb':            libusb}
-diff --git a/meson_options.txt b/meson_options.txt
-index fff1521e58..f0844c0e00 100644
---- a/meson_options.txt
-+++ b/meson_options.txt
-@@ -202,6 +202,8 @@ option('pvg', type: 'feature', value: 'auto',
-        description: 'macOS paravirtualized graphics support')
- option('rbd', type : 'feature', value : 'auto',
-        description: 'Ceph block device driver')
-+option('vitastor', type : 'feature', value : 'auto',
-+       description: 'Vitastor block device driver')
- option('opengl', type : 'feature', value : 'auto',
-        description: 'OpenGL support')
- option('rdma', type : 'feature', value : 'auto',
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index dc6eb4ae23..d043f4340e 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -3280,7 +3280,7 @@
-             'parallels', 'preallocate', 'qcow', 'qcow2', 'qed', 'quorum',
-             'raw', 'rbd',
-             { 'name': 'replication', 'if': 'CONFIG_REPLICATION' },
--            'ssh', 'throttle', 'vdi', 'vhdx',
-+            'ssh', 'throttle', 'vdi', 'vhdx', 'vitastor',
-             { 'name': 'virtio-blk-vfio-pci', 'if': 'CONFIG_BLKIO' },
-             { 'name': 'virtio-blk-vhost-user', 'if': 'CONFIG_BLKIO' },
-             { 'name': 'virtio-blk-vhost-vdpa', 'if': 'CONFIG_BLKIO' },
-@@ -4363,6 +4363,28 @@
-             '*key-secret': 'str',
-             '*server': ['InetSocketAddressBase'] } }
- 
-+##
-+# @BlockdevOptionsVitastor:
-+#
-+# Driver specific block device options for vitastor
-+#
-+# @image:       Image name
-+# @inode:       Inode number
-+# @pool:        Pool ID
-+# @size:        Desired image size in bytes
-+# @config-path: Path to Vitastor configuration
-+# @etcd-host:   etcd connection address(es)
-+# @etcd-prefix: etcd key/value prefix
-+##
-+{ 'struct': 'BlockdevOptionsVitastor',
-+  'data': { '*inode': 'uint64',
-+            '*pool': 'uint64',
-+            '*size': 'uint64',
-+            '*image': 'str',
-+            '*config-path': 'str',
-+            '*etcd-host': 'str',
-+            '*etcd-prefix': 'str' } }
-+
- ##
- # @ReplicationMode:
- #
-@@ -4831,6 +4853,7 @@
-       'throttle':   'BlockdevOptionsThrottle',
-       'vdi':        'BlockdevOptionsGenericFormat',
-       'vhdx':       'BlockdevOptionsGenericFormat',
-+      'vitastor':   'BlockdevOptionsVitastor',
-       'virtio-blk-vfio-pci':
-                     { 'type': 'BlockdevOptionsVirtioBlkVfioPci',
-                       'if': 'CONFIG_BLKIO' },
-@@ -5304,6 +5327,20 @@
-             '*cluster-size' :   'size',
-             '*encrypt' :        'RbdEncryptionCreateOptions' } }
- 
-+##
-+# @BlockdevCreateOptionsVitastor:
-+#
-+# Driver specific image creation options for Vitastor.
-+#
-+# @location: Where to store the new image file.  This location cannot
-+#     point to a snapshot.
-+#
-+# @size: Size of the virtual disk in bytes
-+##
-+{ 'struct': 'BlockdevCreateOptionsVitastor',
-+  'data': { 'location':         'BlockdevOptionsVitastor',
-+            'size':             'size' } }
-+
- ##
- # @BlockdevVmdkSubformat:
- #
-@@ -5526,6 +5563,7 @@
-       'ssh':            'BlockdevCreateOptionsSsh',
-       'vdi':            'BlockdevCreateOptionsVdi',
-       'vhdx':           'BlockdevCreateOptionsVhdx',
-+      'vitastor':       'BlockdevCreateOptionsVitastor',
-       'vmdk':           'BlockdevCreateOptionsVmdk',
-       'vpc':            'BlockdevCreateOptionsVpc'
-   } }
-diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
-index 0ebe6bc52a..2c37ad3892 100644
---- a/scripts/meson-buildoptions.sh
-+++ b/scripts/meson-buildoptions.sh
-@@ -175,6 +175,7 @@ meson_options_help() {
-   printf "%s\n" '  qga-vss         build QGA VSS support (broken with MinGW)'
-   printf "%s\n" '  qpl             Query Processing Library support'
-   printf "%s\n" '  rbd             Ceph block device driver'
-+  printf "%s\n" '  vitastor        Vitastor block device driver'
-   printf "%s\n" '  rdma            Enable RDMA-based migration'
-   printf "%s\n" '  replication     replication support'
-   printf "%s\n" '  rust            Rust support'
-@@ -459,6 +460,8 @@ _meson_option_parse() {
-     --disable-qpl) printf "%s" -Dqpl=disabled ;;
-     --enable-rbd) printf "%s" -Drbd=enabled ;;
-     --disable-rbd) printf "%s" -Drbd=disabled ;;
-+    --enable-vitastor) printf "%s" -Dvitastor=enabled ;;
-+    --disable-vitastor) printf "%s" -Dvitastor=disabled ;;
-     --enable-rdma) printf "%s" -Drdma=enabled ;;
-     --disable-rdma) printf "%s" -Drdma=disabled ;;
-     --enable-relocatable) printf "%s" -Drelocatable=true ;;
+-static int coroutine_fn vitastor_co_block_status(
+-    BlockDriverState *bs, bool want_zero, int64_t offset, int64_t bytes,
+-    int64_t *pnum, int64_t *map, BlockDriverState **file)
++static int coroutine_fn vitastor_co_block_status(BlockDriverState *bs,
++#if QEMU_VERSION_MAJOR > 10 || QEMU_VERSION_MAJOR == 10 && QEMU_VERSION_MINOR >= 1
++    unsigned int mode,
++#else
++    bool want_zero,
++#endif
++    int64_t offset, int64_t bytes, int64_t *pnum, int64_t *map, BlockDriverState **file)
+ {
+     // Allocated => return BDRV_BLOCK_DATA|BDRV_BLOCK_OFFSET_VALID
+     // Not allocated => return 0
+     // Error => return -errno
+     // Set pnum to length of the extent, `*map` = `offset`, `*file` = `bs`
++#if QEMU_VERSION_MAJOR > 10 || QEMU_VERSION_MAJOR == 10 && QEMU_VERSION_MINOR >= 1
++    int want_zero = (mode == BDRV_WANT_PRECISE);
++#endif
+     VitastorRPC task;
+     VitastorClient *client = bs->opaque;
+     uint64_t inode = client->watch ? vitastor_c_inode_get_num(client->watch) : client->inode;

patches/qemu-10.2-vitastor.patch

@@ -1,172 +0,0 @@
-diff --git a/block/meson.build b/block/meson.build
-index 34b1b2a306..24ca0f1e52 100644
---- a/block/meson.build
-+++ b/block/meson.build
-@@ -114,6 +114,7 @@ foreach m : [
-   [libnfs, 'nfs', files('nfs.c')],
-   [libssh, 'ssh', files('ssh.c')],
-   [rbd, 'rbd', files('rbd.c')],
-+  [vitastor, 'vitastor', files('vitastor.c')],
- ]
-   if m[0].found()
-     module_ss = ss.source_set()
-diff --git a/meson.build b/meson.build
-index d9293294d8..776a5becc6 100644
---- a/meson.build
-+++ b/meson.build
-@@ -1665,6 +1665,26 @@ if not get_option('rbd').auto() or have_block
-   endif
- endif
- 
-+vitastor = not_found
-+if not get_option('vitastor').auto() or have_block
-+  libvitastor_client = cc.find_library('vitastor_client', has_headers: ['vitastor_c.h'],
-+    required: get_option('vitastor'))
-+  if libvitastor_client.found()
-+    if cc.links('''
-+      #include <vitastor_c.h>
-+      int main(void) {
-+        vitastor_c_create_qemu(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-+        return 0;
-+      }''', dependencies: libvitastor_client)
-+      vitastor = declare_dependency(dependencies: libvitastor_client)
-+    elif get_option('vitastor').enabled()
-+      error('could not link libvitastor_client')
-+    else
-+      warning('could not link libvitastor_client, disabling')
-+    endif
-+  endif
-+endif
-+
- glusterfs = not_found
- glusterfs_ftruncate_has_stat = false
- glusterfs_iocb_has_stat = false
-@@ -2509,6 +2529,7 @@ endif
- config_host_data.set('CONFIG_OPENGL', opengl.found())
- config_host_data.set('CONFIG_PLUGIN', get_option('plugins'))
- config_host_data.set('CONFIG_RBD', rbd.found())
-+config_host_data.set('CONFIG_VITASTOR', vitastor.found())
- config_host_data.set('CONFIG_RDMA', rdma.found())
- config_host_data.set('CONFIG_RELOCATABLE', get_option('relocatable'))
- config_host_data.set('CONFIG_SAFESTACK', get_option('safe_stack'))
-@@ -4948,6 +4969,7 @@ summary_info += {'fdt support':       fdt_opt == 'internal' ? 'internal' : fdt}
- summary_info += {'libcap-ng support': libcap_ng}
- summary_info += {'bpf support':       libbpf}
- summary_info += {'rbd support':       rbd}
-+summary_info += {'vitastor support':  vitastor}
- summary_info += {'smartcard support': cacard}
- summary_info += {'U2F support':       u2f}
- summary_info += {'libusb':            libusb}
-diff --git a/meson_options.txt b/meson_options.txt
-index 2836156257..148086cc6f 100644
---- a/meson_options.txt
-+++ b/meson_options.txt
-@@ -206,6 +206,8 @@ option('pvg', type: 'feature', value: 'auto',
-        description: 'macOS paravirtualized graphics support')
- option('rbd', type : 'feature', value : 'auto',
-        description: 'Ceph block device driver')
-+option('vitastor', type : 'feature', value : 'auto',
-+       description: 'Vitastor block device driver')
- option('opengl', type : 'feature', value : 'auto',
-        description: 'OpenGL support')
- option('rdma', type : 'feature', value : 'auto',
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index b82af74256..f25a6f5ce8 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -3351,7 +3351,7 @@
-             'parallels', 'preallocate', 'qcow', 'qcow2', 'qed', 'quorum',
-             'raw', 'rbd',
-             { 'name': 'replication', 'if': 'CONFIG_REPLICATION' },
--            'ssh', 'throttle', 'vdi', 'vhdx',
-+            'ssh', 'throttle', 'vdi', 'vhdx', 'vitastor',
-             { 'name': 'virtio-blk-vfio-pci', 'if': 'CONFIG_BLKIO' },
-             { 'name': 'virtio-blk-vhost-user', 'if': 'CONFIG_BLKIO' },
-             { 'name': 'virtio-blk-vhost-vdpa', 'if': 'CONFIG_BLKIO' },
-@@ -4434,6 +4434,28 @@
-             '*key-secret': 'str',
-             '*server': ['InetSocketAddressBase'] } }
- 
-+##
-+# @BlockdevOptionsVitastor:
-+#
-+# Driver specific block device options for vitastor
-+#
-+# @image:       Image name
-+# @inode:       Inode number
-+# @pool:        Pool ID
-+# @size:        Desired image size in bytes
-+# @config-path: Path to Vitastor configuration
-+# @etcd-host:   etcd connection address(es)
-+# @etcd-prefix: etcd key/value prefix
-+##
-+{ 'struct': 'BlockdevOptionsVitastor',
-+  'data': { '*inode': 'uint64',
-+            '*pool': 'uint64',
-+            '*size': 'uint64',
-+            '*image': 'str',
-+            '*config-path': 'str',
-+            '*etcd-host': 'str',
-+            '*etcd-prefix': 'str' } }
-+
- ##
- # @ReplicationMode:
- #
-@@ -4902,6 +4924,7 @@
-       'throttle':   'BlockdevOptionsThrottle',
-       'vdi':        'BlockdevOptionsGenericFormat',
-       'vhdx':       'BlockdevOptionsGenericFormat',
-+      'vitastor':   'BlockdevOptionsVitastor',
-       'virtio-blk-vfio-pci':
-                     { 'type': 'BlockdevOptionsVirtioBlkVfioPci',
-                       'if': 'CONFIG_BLKIO' },
-@@ -5376,6 +5399,20 @@
-             '*cluster-size' :   'size',
-             '*encrypt' :        'RbdEncryptionCreateOptions' } }
- 
-+##
-+# @BlockdevCreateOptionsVitastor:
-+#
-+# Driver specific image creation options for Vitastor.
-+#
-+# @location: Where to store the new image file.  This location cannot
-+#     point to a snapshot.
-+#
-+# @size: Size of the virtual disk in bytes
-+##
-+{ 'struct': 'BlockdevCreateOptionsVitastor',
-+  'data': { 'location':         'BlockdevOptionsVitastor',
-+            'size':             'size' } }
-+
- ##
- # @BlockdevVmdkSubformat:
- #
-@@ -5598,6 +5635,7 @@
-       'ssh':            'BlockdevCreateOptionsSsh',
-       'vdi':            'BlockdevCreateOptionsVdi',
-       'vhdx':           'BlockdevCreateOptionsVhdx',
-+      'vitastor':       'BlockdevCreateOptionsVitastor',
-       'vmdk':           'BlockdevCreateOptionsVmdk',
-       'vpc':            'BlockdevCreateOptionsVpc'
-   } }
-diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
-index 3d0d132344..65ee8c855e 100644
---- a/scripts/meson-buildoptions.sh
-+++ b/scripts/meson-buildoptions.sh
-@@ -177,6 +177,7 @@ meson_options_help() {
-   printf "%s\n" '  qga-vss         build QGA VSS support (broken with MinGW)'
-   printf "%s\n" '  qpl             Query Processing Library support'
-   printf "%s\n" '  rbd             Ceph block device driver'
-+  printf "%s\n" '  vitastor        Vitastor block device driver'
-   printf "%s\n" '  rdma            Enable RDMA-based migration'
-   printf "%s\n" '  replication     replication support'
-   printf "%s\n" '  rust            Rust support'
-@@ -464,6 +465,8 @@ _meson_option_parse() {
-     --disable-qpl) printf "%s" -Dqpl=disabled ;;
-     --enable-rbd) printf "%s" -Drbd=enabled ;;
-     --disable-rbd) printf "%s" -Drbd=disabled ;;
-+    --enable-vitastor) printf "%s" -Dvitastor=enabled ;;
-+    --disable-vitastor) printf "%s" -Dvitastor=disabled ;;
-     --enable-rdma) printf "%s" -Drdma=enabled ;;
-     --disable-rdma) printf "%s" -Drdma=disabled ;;
-     --enable-relocatable) printf "%s" -Drelocatable=true ;;

rpm/vitastor-el10.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.12
+Version:        3.0.5
 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-3.0.12.el10.tar.gz
+Source0:        vitastor-3.0.5.el10.tar.gz
 
 BuildRequires:  gperftools-devel
 BuildRequires:  gcc-c++

rpm/vitastor-el7.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.12
+Version:        3.0.5
 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-3.0.12.el7.tar.gz
+Source0:        vitastor-3.0.5.el7.tar.gz
 
 BuildRequires:  gperftools-devel
 BuildRequires:  devtoolset-9-gcc-c++

rpm/vitastor-el8.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.12
+Version:        3.0.5
 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-3.0.12.el8.tar.gz
+Source0:        vitastor-3.0.5.el8.tar.gz
 
 BuildRequires:  gperftools-devel
 BuildRequires:  gcc-toolset-9-gcc-c++

rpm/vitastor-el9.spec

@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.12
+Version:        3.0.5
 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-3.0.12.el9.tar.gz
+Source0:        vitastor-3.0.5.el9.tar.gz
 
 BuildRequires:  gperftools-devel
 BuildRequires:  gcc-c++

src/CMakeLists.txt

@@ -1,8 +1,9 @@
-cmake_minimum_required(VERSION 2.8...3.30)
+cmake_minimum_required(VERSION 2.8.12)
 
 project(vitastor)
 
 include(GNUInstallDirs)
+include(CTest)
 include(CheckIncludeFile)
 
 find_package(PkgConfig)
@@ -20,7 +21,7 @@ if("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/local/?$")
 endif()
 set(ENABLE_COVERAGE false CACHE BOOL "Enable code coverage")
 
-add_definitions(-DVITASTOR_VERSION="3.0.12")
+add_definitions(-DVITASTOR_VERSION="3.0.5")
 add_definitions(-D_GNU_SOURCE -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 -fvisibility=hidden -I ${CMAKE_SOURCE_DIR}/src)
 add_link_options(-fno-omit-frame-pointer)
 if (${WITH_ASAN})
@@ -69,17 +70,15 @@ pkg_check_modules(ISAL libisal)
 if (ISAL_LIBRARIES)
 	add_definitions(-DWITH_ISAL)
 endif (ISAL_LIBRARIES)
-pkg_check_modules(ISAL_CRYPTO libisal_crypto)
-if (ISAL_CRYPTO_LIBRARIES)
-	add_definitions(-DWITH_ISAL_CRYPTO)
-endif (ISAL_CRYPTO_LIBRARIES)
 pkg_check_modules(RDMACM librdmacm)
 if (RDMACM_LIBRARIES)
 	add_definitions(-DWITH_RDMACM)
 endif (RDMACM_LIBRARIES)
 
 find_package(OpenSSL REQUIRED)
-add_definitions(-DWITH_OPENSSL)
+if (OPENSSL_FOUND)
+	add_definitions(-DWITH_OPENSSL)
+endif (OPENSSL_FOUND)
 
 pkg_check_modules(CARES REQUIRED libcares)
 include_directories(${CARES_INCLUDE_DIRS})

src/blockstore/CMakeLists.txt

@@ -1,10 +1,10 @@
-cmake_minimum_required(VERSION 2.8...3.30)
+cmake_minimum_required(VERSION 2.8.12)
 
 project(vitastor)
 
 # libvitastor_blk.a
 add_library(vitastor_blk STATIC
-	../util/allocator.cpp ../util/crc32c.c ../util/ringloop.cpp
+	../util/allocator.cpp ../util/crc32c.c ../util/xxhash.c ../util/ringloop.cpp
 	multilist.cpp blockstore_heap.cpp blockstore_disk.cpp
 	blockstore.cpp blockstore_impl.cpp blockstore_init.cpp blockstore_open.cpp
 	blockstore_flush.cpp blockstore_read.cpp blockstore_stable.cpp blockstore_sync.cpp blockstore_write.cpp

src/blockstore/blockstore.h

@@ -228,9 +228,4 @@ public:
     virtual uint64_t get_journal_size() = 0;
 
     virtual uint32_t get_bitmap_granularity() = 0;
-
-    virtual uint64_t get_live_entries() = 0;
-    virtual uint64_t get_live_memory() = 0;
-    virtual uint64_t get_garbage_entries() = 0;
-    virtual uint64_t get_garbage_memory() = 0;
 };

src/blockstore/blockstore_disk.cpp

@@ -98,9 +98,6 @@ void blockstore_disk_t::parse_config(std::map<std::string, std::string> & config
     csum_block_size = parse_size(config["csum_block_size"]);
     discard_on_start = config.find("discard_on_start") != config.end() &&
         (config["discard_on_start"] == "true" || config["discard_on_start"] == "1" || config["discard_on_start"] == "yes");
-    gc_on_start = config.find("gc_on_start") == config.end() ||
-        (config["gc_on_start"] == "true" || config["gc_on_start"] == "1" || config["gc_on_start"] == "yes");
-    skip_double_claim = (config["skip_double_claim"] == "true" || config["skip_double_claim"] == "1" || config["skip_double_claim"] == "yes");
     min_discard_size = parse_size(config["min_discard_size"]);
     if (!min_discard_size)
         min_discard_size = 1024*1024;

src/blockstore/blockstore_disk.h

@@ -58,10 +58,6 @@ struct blockstore_disk_t
     bool inmemory_journal = true;
     // Data discard granularity and minimum size (for the sake of performance)
     bool discard_on_start = false;
-    // GC on start (new store)
-    bool gc_on_start = true;
-    // Skip double claim conflicts on start (new store, temporary until the bug is found)
-    bool skip_double_claim = false;
     uint64_t min_discard_size = 1024*1024;
     uint64_t discard_granularity = 0;
 

src/blockstore/blockstore_flush.cpp

@@ -174,18 +174,14 @@ bool journal_flusher_co::loop()
     else if (wait_state == 19) goto resume_19;
     else if (wait_state == 20) goto resume_20;
     else if (wait_state == 21) goto resume_21;
-    else if (wait_state == 22) goto resume_22;
-    else if (wait_state == 23) goto resume_23;
-    else if (wait_state == 24) goto resume_24;
-    else if (wait_state == 25) goto resume_25;
 resume_0:
     wait_state = 0;
     wait_count = 0;
     cur_oid = {};
     res = bs->heap->get_next_compact(cur_oid);
+    // Advance fsynced_lsn every <journal_trim_interval> intent writes
     if ((bs->intent_write_counter >= bs->journal_trim_interval) && co_id == 0)
     {
-        // Advance fsynced_lsn every <journal_trim_interval> intent writes
         bs->intent_write_counter = 0;
 resume_17:
 resume_18:
@@ -200,7 +196,6 @@ resume_21:
     if (res == ENOENT && flusher->force_start > 0 && co_id == 0 &&
         (!bs->dsk.disable_journal_fsync || !bs->dsk.disable_meta_fsync || !bs->dsk.disable_data_fsync))
     {
-        // When under pressure, do an additional fsync to force entries to be marked compactable
         flusher->active_flushers++;
 resume_14:
 resume_15:
@@ -264,9 +259,11 @@ resume_1:
         if (wr->type() == BS_HEAP_SMALL_WRITE ||
             wr->type() == BS_HEAP_INTENT_WRITE && bs->dsk.csum_block_size > bs->dsk.bitmap_granularity)
         {
-            bs->prepare_read(read_vec, cur_obj, wr, 0, bs->dsk.data_block_size,
+            auto res = bs->prepare_read(read_vec, cur_obj, wr, 0, bs->dsk.data_block_size,
                 wr->type() == BS_HEAP_INTENT_WRITE && bs->dsk.csum_block_size > bs->dsk.bitmap_granularity && !bs->perfect_csum_update
                 ? COPY_BUF_SKIP_CSUM : 0);
+            if (res > 0)
+                copy_count++;
         }
     });
     if (!compact_info.compact_lsn)
@@ -276,25 +273,6 @@ resume_1:
         bs->heap->unlock_entry(cur_oid);
         goto resume_0;
     }
-    flusher->active_flushers++;
-    for (i = 0; i < read_vec.size(); i++)
-    {
-        if ((read_vec[i].copy_flags & COPY_BUF_JOURNAL) &&
-            !(read_vec[i].copy_flags & COPY_BUF_COALESCED))
-        {
-            copy_count++;
-        }
-    }
-    if (copy_count > 0 && !bs->dsk.disable_data_fsync)
-    {
-        init_fsync_data();
-    }
-    if (bs->log_level > 10)
-    {
-        printf("Compacting %jx:%jx v%ju..v%ju / l%ju..l%ju (%d writes)\n", cur_oid.inode, cur_oid.stripe,
-            compact_info.clean_wr->version, compact_info.compact_version,
-            compact_info.clean_wr->lsn, compact_info.compact_lsn, copy_count);
-    }
     mem_or(new_bmp, compact_info.clean_wr->get_int_bitmap(bs->heap), bs->dsk.clean_entry_bitmap_size);
     if (!bitmap_copied)
     {
@@ -313,6 +291,13 @@ resume_1:
         csum_copy.clear();
     }
     clean_loc = compact_info.clean_wr->big_location(bs->heap);
+    flusher->active_flushers++;
+    if (bs->log_level > 10)
+    {
+        printf("Compacting %jx:%jx v%ju..v%ju / l%ju..l%ju (%d writes)\n", cur_oid.inode, cur_oid.stripe,
+            compact_info.clean_wr->version, compact_info.compact_version,
+            compact_info.clean_wr->lsn, compact_info.compact_lsn, copy_count);
+    }
     overwrite_start = overwrite_end = 0;
     if (read_vec.size() > 0)
     {
@@ -351,13 +336,6 @@ resume_3:
     if (res == ENOENT || res == EDOM)
     {
         // Abort compaction
-abort_compact:
-        if (copy_count > 0 && !bs->dsk.disable_data_fsync)
-        {
-            cur_sync->member_count--;
-            if (cur_sync->member_count > 0)
-                bs->ringloop->wakeup();
-        }
         flusher->flushing.erase(cur_oid);
         bs->heap->unlock_entry(cur_oid);
         flusher->active_flushers--;
@@ -371,7 +349,10 @@ resume_4:
         if (res == ENOENT)
         {
             // Abort compaction
-            goto abort_compact;
+            flusher->flushing.erase(cur_oid);
+            bs->heap->unlock_entry(cur_oid);
+            flusher->active_flushers--;
+            goto resume_0;
         }
         if (res == EAGAIN)
         {
@@ -400,14 +381,14 @@ resume_9:
     for (i = 0; i < read_vec.size(); i++)
     {
         if ((read_vec[i].copy_flags & COPY_BUF_JOURNAL) &&
-            !(read_vec[i].copy_flags & COPY_BUF_COALESCED))
+            !(read_vec[i].copy_flags & COPY_BUF_COALESCED) ||
+            (read_vec[i].copy_flags & COPY_BUF_PADDED)) // FIXME Shit, simplify these flags
         {
             assert(read_vec[i].buf);
             await_sqe(10);
             data->iov = (struct iovec){ read_vec[i].buf + (read_vec[i].copy_flags & COPY_BUF_PADDED
                 ? read_vec[i].offset - read_vec[i].disk_offset : 0), (size_t)read_vec[i].len };
             data->callback = simple_callback_w;
-            assert(clean_loc + read_vec[i].offset + data->iov.iov_len <= bs->dsk.block_count*bs->dsk.data_block_size);
             io_uring_prep_writev(sqe, bs->dsk.data_fd, &data->iov, 1, bs->dsk.data_offset + clean_loc + read_vec[i].offset);
             wait_count++;
         }
@@ -418,17 +399,6 @@ resume_11:
         wait_state = 11;
         return false;
     }
-    if (copy_count > 0 && !bs->dsk.disable_data_fsync)
-    {
-resume_22:
-resume_23:
-resume_24:
-resume_25:
-        if (!fsync_data(22))
-        {
-            return false;
-        }
-    }
     // Lock is only needed to prevent freeing the big_write because we overwrite it...
     bs->heap->unlock_entry(cur_oid);
     // Mark the object compacted, but don't free and remove small_writes
@@ -438,14 +408,12 @@ resume_25:
     if (!cur_obj)
     {
         // Abort compaction
-        flusher->active_flushers--;
         flusher->flushing.erase(cur_oid);
         goto resume_0;
     }
     if (!calc_block_checksums())
     {
         // Abort compaction
-        flusher->active_flushers--;
         flusher->flushing.erase(cur_oid);
         goto resume_0;
     }
@@ -454,7 +422,6 @@ resume_25:
     if (res == EBUSY)
     {
         // Abort compaction, object is already overwritten by something else
-        flusher->active_flushers--;
         flusher->flushing.erase(cur_oid);
         goto resume_0;
     }
@@ -619,7 +586,7 @@ int journal_flusher_co::check_and_punch_checksums()
             bs->heap->calc_block_checksums((uint32_t*)(new_csums+csum_off), vec.buf, punch_bmp, vec.offset, vec.offset+vec.len, true, NULL);
         }
     }
-    // Modified, we should punch_holes and then write the block to disk
+    // Modified, we should add_punch_holes and then write the block to disk
     return EBUSY;
 }
 
@@ -732,67 +699,6 @@ resume_1:
     return true;
 }
 
-void journal_flusher_co::init_fsync_data()
-{
-    cur_sync = flusher->data_syncs.begin();
-    if (cur_sync == flusher->data_syncs.end() || cur_sync->ready_count > 0)
-    {
-        cur_sync = flusher->data_syncs.emplace(cur_sync);
-    }
-    cur_sync->member_count++;
-}
-
-bool journal_flusher_co::fsync_data(int wait_base)
-{
-    if (wait_state == wait_base)
-        goto resume_0;
-    else if (wait_state == wait_base+1)
-        goto resume_1;
-    else if (wait_state == wait_base+2)
-        goto resume_2;
-    else if (wait_state == wait_base+3)
-        goto resume_3;
-    cur_sync->ready_count++;
-resume_0:
-    if (cur_sync->ready_count < cur_sync->member_count)
-    {
-        wait_state = wait_base;
-        return false;
-    }
-    if (!cur_sync->sent)
-    {
-        // Sync batch is ready. Do it.
-        await_sqe(1);
-        data->iov = { 0 };
-        data->callback = simple_callback_w;
-        io_uring_prep_fsync(sqe, bs->dsk.data_fd, IORING_FSYNC_DATASYNC);
-        cur_sync->sent = true;
-        wait_count++;
-resume_2:
-        if (wait_count > 0)
-        {
-            wait_state = wait_base+2;
-            return false;
-        }
-        cur_sync->done = true;
-        // Wake up other flushers
-        bs->ringloop->wakeup();
-    }
-resume_3:
-    if (!cur_sync->done)
-    {
-        wait_state = wait_base+3;
-        return false;
-    }
-    cur_sync->done_count++;
-    if (cur_sync->done_count >= cur_sync->member_count)
-    {
-        flusher->data_syncs.erase(cur_sync);
-        cur_sync = flusher->data_syncs.end();
-    }
-    return true;
-}
-
 bool journal_flusher_co::fsync_meta(int wait_base)
 {
     if (wait_state == wait_base)        goto resume_0;

src/blockstore/blockstore_flush.h

@@ -25,15 +25,6 @@ struct flusher_meta_write_t
     std::map<uint64_t, meta_sector_t>::iterator it;
 };
 
-struct flusher_data_sync_t
-{
-    int member_count = 0;
-    int ready_count = 0;
-    int done_count = 0;
-    bool sent = false;
-    bool done = false;
-};
-
 class journal_flusher_t;
 
 // Journal flusher coroutine
@@ -67,7 +58,6 @@ class journal_flusher_co
     int i, res;
     bool read_to_fill_incomplete;
     int copy_count;
-    std::list<flusher_data_sync_t>::iterator cur_sync;
 
     friend class journal_flusher_t;
 
@@ -78,8 +68,6 @@ class journal_flusher_co
     bool calc_block_checksums();
     bool write_meta_block(int wait_base);
     bool read_buffered(int wait_base);
-    void init_fsync_data();
-    bool fsync_data(int wait_base);
     bool fsync_meta(int wait_base);
     bool fsync_buffer(int wait_base);
     bool trim_lsn(int wait_base);
@@ -100,7 +88,6 @@ class journal_flusher_t
 
     robin_hood::unordered_flat_set<object_id> flushing;
     int active_flushers = 0;
-    std::list<flusher_data_sync_t> data_syncs;
     int wanting_meta_fsync = 0;
     bool fsyncing_meta = false;
     int syncing_buffer = 0;

src/blockstore/blockstore_heap.h

@@ -57,11 +57,11 @@ struct __attribute__((__packed__)) heap_entry_t
     inline heap_small_write_t& small() { return *(heap_small_write_t*)this; }
     inline heap_big_write_t& big() { return *(heap_big_write_t*)this; }
     inline heap_big_intent_t& big_intent() { return *(heap_big_intent_t*)this; }
-    bool is_garbage() const;
+    bool is_garbage();
     void set_garbage();
-    bool is_overwrite() const;
-    bool is_compactable() const;
-    bool is_before(const heap_entry_t *other) const;
+    bool is_overwrite();
+    bool is_compactable();
+    bool is_before(heap_entry_t *other);
     uint32_t get_size(blockstore_heap_t *heap);
     uint8_t *get_ext_bitmap(blockstore_heap_t *heap);
     uint8_t *get_int_bitmap(blockstore_heap_t *heap);
@@ -118,13 +118,10 @@ struct heap_object_mvcc_t
 
 struct heap_block_info_t
 {
-    struct __attribute__((__packed__))
-    {
-        uint32_t used_space = 0;
-        uint32_t garbage_space = 0;
-    };
+    uint32_t used_space = 0;
     uint64_t mod_lsn = 0, mod_lsn_to = 0; // only 1 block write of LSN sequence is allowed at a moment
-    bool is_writing = false;
+    bool is_writing: 1;
+    bool has_garbage: 1;
     std::vector<heap_list_item_t*> entries;
 };
 
@@ -159,16 +156,6 @@ struct heap_li_equal
     }
 };
 
-struct heap_recheck_state_t
-{
-    heap_entry_t *obj = NULL;
-    heap_entry_t *next_wr = NULL;
-    size_t total_reads = 0;
-    size_t sent_reads = 0;
-    size_t checked_reads = 0;
-    heap_entry_t *bad_wr = NULL;
-};
-
 using i64hash_t = robin_hood::hash<uint64_t>;
 using heap_inode_map_t = robin_hood::unordered_flat_set<heap_list_item_t*, heap_li_hash, heap_li_equal, 88>;
 using heap_block_index_t = robin_hood::unordered_flat_map<uint64_t,
@@ -198,11 +185,6 @@ class blockstore_heap_t
     uint64_t buffer_area_used_space = 0;
     uint64_t data_used_space = 0;
 
-    uint64_t live_entries = 0;
-    uint64_t live_memory = 0;
-    uint64_t garbage_entries = 0;
-    uint64_t garbage_memory = 0;
-
     uint64_t next_lsn = 0;
     uint32_t last_allocated_block = UINT32_MAX;
     heap_mvcc_map_t object_mvcc;
@@ -219,11 +201,9 @@ class blockstore_heap_t
 
     bool marked_used_blocks = false;
     bool recheck_queue_filled = false;
-    std::vector<heap_list_item_t*> postponed_items;
+    std::vector<heap_list_item_t*> loaded_list_items;
     std::set<uint32_t> recheck_modified_blocks;
     std::deque<heap_entry_t*> recheck_queue;
-    std::map<heap_entry_t*, heap_recheck_state_t> recheck_states;
-    size_t recheck_pending_reads = 0;
     int recheck_in_progress = 0;
     bool in_recheck = false;
     std::function<void(bool is_data, uint64_t offset, uint64_t len, uint8_t* buf, std::function<void()>)> recheck_cb;
@@ -232,22 +212,14 @@ class blockstore_heap_t
     uint64_t get_pg_id(inode_t inode, uint64_t stripe);
     bool validate_object(heap_entry_t *obj);
     void fill_recheck_queue();
-    void recheck_drop_entries(heap_entry_t *obj, heap_entry_t *bad_wr);
-    void recheck_start_reads(heap_recheck_state_t *st);
     int mark_used_blocks();
-    void init_free_bad_entry(heap_entry_t *wr);
-    void init_erase_bad_entry(heap_list_item_t *li);
-    bool init_erase_double_claim(heap_list_item_t *prev_li, heap_list_item_t *cur_li);
-    void recheck_full_gc();
     void recheck_buffer(heap_entry_t *cwr, uint8_t *buf);
     void defragment_block(uint32_t block_num);
     void reshard_add(heap_reshard_state_t *st, heap_list_item_t *li);
 
     void gc_block(heap_block_info_t & inf);
     int allocate_entry(uint32_t entry_size, uint32_t *block_num, bool allow_last_free);
-    void insert_list_items(heap_list_item_t** v, size_t count, bool postpone);
-    void remove_list_item(heap_list_item_t *li);
-    void unlink_list_item(heap_list_item_t *li);
+    void insert_list_item(heap_list_item_t *li);
     int add_entry(uint32_t wr_size, uint32_t *modified_block, bool allow_last_free,
         bool explicit_complete, std::function<void(heap_entry_t *wr)> fill_entry);
     int add_simple(heap_entry_t *obj, uint64_t version, uint32_t *modified_block, uint32_t entry_type);
@@ -374,10 +346,6 @@ public:
     uint32_t get_compact_queue_size();
     uint32_t get_to_compact_count();
     uint64_t get_compacted_count();
-    uint64_t get_live_entries();
-    uint64_t get_live_memory();
-    uint64_t get_garbage_entries();
-    uint64_t get_garbage_memory();
 
     uint64_t entry_pos(uint32_t block_num, uint32_t offset);
     heap_entry_t *entry_from_pos(uint64_t entry_pos, bool allow_unallocated = false);

src/blockstore/blockstore_impl.cpp

@@ -101,7 +101,6 @@ void blockstore_impl_t::loop()
         unsigned initial_ring_space = ringloop->space_left();
         int op_idx = 0, new_idx = 0;
         bool has_unfinished_writes = false;
-        bool has_unfinished_sync = false;
         for (; op_idx < submit_queue.size(); op_idx++, new_idx++)
         {
             auto op = submit_queue[op_idx];
@@ -139,13 +138,7 @@ void blockstore_impl_t::loop()
             else if (op->opcode == BS_OP_SYNC)
             {
                 // syncs only completed writes, so doesn't have to be blocked by anything
-                if (!has_unfinished_sync)
-                {
-                    wr_st = continue_sync(op);
-                    has_unfinished_sync = (wr_st != 2);
-                }
-                else
-                    wr_st = 0;
+                wr_st = continue_sync(op);
             }
             else if (op->opcode == BS_OP_STABLE || op->opcode == BS_OP_ROLLBACK)
             {
@@ -161,7 +154,9 @@ void blockstore_impl_t::loop()
                     wr_st = 2;
                 }
                 else
+                {
                     wr_st = 0;
+                }
             }
             if (wr_st == 2)
             {

src/blockstore/blockstore_impl.h

@@ -229,9 +229,4 @@ public:
     uint64_t get_free_block_count();
     inline uint32_t get_bitmap_granularity() { return dsk.bitmap_granularity; }
     inline uint64_t get_journal_size() { return dsk.journal_len; }
-
-    inline uint64_t get_live_entries() { return heap->get_live_entries(); }
-    inline uint64_t get_live_memory() { return heap->get_live_memory(); }
-    inline uint64_t get_garbage_entries() { return heap->get_garbage_entries(); }
-    inline uint64_t get_garbage_memory() { return heap->get_garbage_memory(); }
 };

src/blockstore/blockstore_init.cpp

@@ -153,14 +153,6 @@ resume_1:
             );
             exit(1);
         }
-        uint32_t csum = hdr->header_csum;
-        hdr->header_csum = 0;
-        if (crc32c(0, hdr, sizeof(*hdr)) != csum)
-        {
-            printf("Metadata header is corrupt (checksum mismatch).\n");
-            exit(1);
-        }
-        hdr->header_csum = csum;
     }
     bs->heap->start_load(((blockstore_meta_header_v3_t *)bs->meta_superblock)->completed_lsn);
     if (bs->dsk.inmemory_journal)
@@ -248,7 +240,23 @@ resume_4:
     }
     // metadata read finished
     bs->heap->finish_load();
-    printf("Metadata entries loaded: %ju, rechecking unfinished writes and garbage entries\n", entries_loaded);
+    printf("Metadata entries loaded: %ju, used blocks: %ju / %ju\n", entries_loaded, bs->heap->get_data_used_space() / bs->dsk.data_block_size, bs->dsk.block_count);
+    if (zero_on_init && !bs->dsk.disable_meta_fsync)
+    {
+        GET_SQE();
+        io_uring_prep_fsync(sqe, bs->dsk.meta_fd, IORING_FSYNC_DATASYNC);
+        last_read_offset = 0;
+        data->iov = { 0 };
+        data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
+        submitted++;
+        bs->ringloop->submit();
+    resume_5:
+        if (submitted > 0)
+        {
+            wait_state = 5;
+            return 1;
+        }
+    }
     // asynchronous recheck
 resume_6:
     wait_state = 6;
@@ -285,11 +293,6 @@ resume_7:
     if (bs->readonly)
     {
         recheck_mod.clear();
-        printf("Actual metadata entries: %ju\n", bs->heap->get_live_entries());
-    }
-    else
-    {
-        printf("Actual metadata entries: %ju, clearing garbage in %zu metadata blocks\n", bs->heap->get_live_entries(), recheck_mod.size());
     }
     for (i = 0; i < recheck_mod.size(); i++)
     {
@@ -303,7 +306,7 @@ resume_8:
         uint32_t block_num = recheck_mod[i];
         uint64_t block_offset = bs->dsk.meta_offset + (uint64_t)(block_num+1) * bs->dsk.meta_block_size;
         data = ((ring_data_t*)sqe->user_data);
-        uint8_t *buf = (uint8_t*)memalign_or_die(MEM_ALIGNMENT, bs->dsk.meta_block_size);
+        uint8_t *buf = (uint8_t*)malloc_or_die(bs->dsk.meta_block_size);
         bs->heap->get_meta_block(block_num, buf);
         data->iov = { buf, bs->dsk.meta_block_size };
         data->callback = [this, buf, block_offset](ring_data_t *data)
@@ -329,25 +332,5 @@ resume_9:
     }
     free(metadata_buffer);
     metadata_buffer = NULL;
-    if (!bs->dsk.disable_meta_fsync && !bs->readonly)
-    {
-        GET_SQE();
-        io_uring_prep_fsync(sqe, bs->dsk.meta_fd, IORING_FSYNC_DATASYNC);
-        last_read_offset = 0;
-        data->iov = { 0 };
-        data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
-        submitted++;
-        bs->ringloop->submit();
-    resume_5:
-        if (submitted > 0)
-        {
-            wait_state = 5;
-            return 1;
-        }
-    }
-    printf("Loading finished. Data used: %ju / %ju bytes (%s / %s)\n",
-        bs->heap->get_data_used_space(), bs->dsk.block_count * bs->dsk.data_block_size,
-        format_size(bs->heap->get_data_used_space()).c_str(),
-        format_size(bs->dsk.block_count * bs->dsk.data_block_size).c_str());
     return 0;
 }

src/blockstore/blockstore_read.cpp

@@ -462,10 +462,6 @@ int blockstore_impl_t::read_bitmap(object_id oid, uint64_t target_version, void
         {
             if (target_version >= wr->version)
             {
-                if (wr->type() == BS_HEAP_DELETE)
-                {
-                    return false;
-                }
                 found = true;
                 if (result_version)
                 {

src/blockstore/blockstore_stable.cpp

@@ -16,7 +16,6 @@ int blockstore_impl_t::dequeue_stable(blockstore_op_t *op)
     else if (priv->op_state == 5) goto resume_5;
     assert(!priv->op_state);
     op->retval = 0;
-    PRIV(op)->lsn = 0;
     priv->modified_block = priv->modified_block2 = UINT32_MAX;
     for (priv->stab_pos = 0; priv->stab_pos < op->len; priv->stab_pos++)
     {
@@ -37,12 +36,6 @@ int blockstore_impl_t::dequeue_stable(blockstore_op_t *op)
                 FINISH_OP(op);
                 return 2;
             }
-            if (res == ENOENT)
-            {
-                op->retval = -ENOENT;
-                FINISH_OP(op);
-                return 2;
-            }
             if (res == ENOSPC)
             {
                 if (!heap->get_to_compact_count())

src/blockstore/blockstore_sync.cpp

@@ -9,7 +9,6 @@ int blockstore_impl_t::continue_sync(blockstore_op_t *op)
     if (!PRIV(op)->op_state)
     {
         op->retval = 0;
-        PRIV(op)->lsn = 0;
     }
     int res = do_sync(op, 0);
     if (res == 2)
@@ -105,8 +104,7 @@ int blockstore_impl_t::do_sync(blockstore_op_t *op, int base_state)
         unsynced_data_write_count = unsynced_buffer_write_count = unsynced_meta_write_count = 0;
         return 2;
     }
-    assert(!PRIV(op)->lsn);
-    PRIV(op)->lsn = heap->get_completed_lsn();
+    PRIV(op)->modified_block = heap->get_completed_lsn();
     if (!submit_fsyncs(PRIV(op)->pending_ops))
     {
         PRIV(op)->wait_detail = 1;
@@ -120,6 +118,6 @@ resume_1:
         return 1;
     }
 resume_2:
-    heap->mark_lsn_fsynced(PRIV(op)->lsn);
+    heap->mark_lsn_fsynced(PRIV(op)->modified_block);
     return 2;
 }

src/blockstore/blockstore_write.cpp

@@ -37,7 +37,6 @@ void blockstore_impl_t::prepare_meta_block_write(uint32_t modified_block)
         heap->complete_block_write(modified_block);
         ringloop->wakeup();
     };
-    assert(((uint64_t)modified_block+2)*dsk.meta_block_size <= dsk.meta_area_size);
     io_uring_prep_writev(
         sqe, dsk.meta_fd, &data->iov, 1, dsk.meta_offset + ((uint64_t)modified_block+1)*dsk.meta_block_size
     );
@@ -178,7 +177,6 @@ enospc:
         ring_data_t *data = ((ring_data_t*)sqe->user_data);
         data->iov = (struct iovec){ op->buf, op->len };
         data->callback = [this, op](ring_data_t *data) { handle_write_event(data, op); };
-        assert(loc+op->offset+op->len <= dsk.block_count*dsk.data_block_size);
         io_uring_prep_writev(sqe, dsk.data_fd, &data->iov, 1, dsk.data_offset + loc + op->offset);
         PRIV(op)->pending_ops++;
         write_iodepth++;
@@ -266,7 +264,6 @@ enospc:
             BS_SUBMIT_GET_SQE(sqe2, data2);
             data2->iov = (struct iovec){ op->buf, op->len };
             data2->callback = [this, op](ring_data_t *data) { handle_write_event(data, op); };
-            assert(loc+op->len <= dsk.journal_len);
             io_uring_prep_writev(sqe2, dsk.journal_fd, &data2->iov, 1, dsk.journal_offset + loc);
             PRIV(op)->pending_ops++;
         }
@@ -456,7 +453,6 @@ resume_10:
     BS_SUBMIT_GET_SQE(sqe, data);
     data->iov = (struct iovec){ op->buf, op->len };
     data->callback = [this, op](ring_data_t *data) { handle_write_event(data, op); };
-    assert(PRIV(op)->location + op->offset <= dsk.block_count*dsk.data_block_size);
     io_uring_prep_writev(sqe, dsk.data_fd, &data->iov, 1, dsk.data_offset + PRIV(op)->location + op->offset);
     if (dsk.use_atomic_flag)
         sqe->rw_flags = RWF_ATOMIC;

src/blockstore/ondisk_formats.h

@@ -141,7 +141,7 @@ struct __attribute__((__packed__)) journal_entry
 inline uint32_t je_crc32(journal_entry *je)
 {
     // 0x48674bc7 = crc32(4 zero bytes)
-    return je->size < 4 ? 0 : crc32c(0x48674bc7, ((uint8_t*)je)+4, je->size-4);
+    return crc32c(0x48674bc7, ((uint8_t*)je)+4, je->size-4);
 }
 
 // "VITAstor"

src/blockstore/v1/flush.cpp

@@ -520,7 +520,6 @@ resume_2:
                 await_sqe(15);
                 data->iov = (struct iovec){ it->buf, (size_t)it->len };
                 data->callback = simple_callback_w;
-                assert(clean_loc+it->offset+it->len <= bs->dsk.block_count*bs->dsk.data_block_size);
                 io_uring_prep_writev(
                     sqe, bs->dsk.data_fd, &data->iov, 1, bs->dsk.data_offset + clean_loc + it->offset
                 );
@@ -750,7 +749,6 @@ bool journal_flusher_co::write_meta_block(flusher_meta_write_t & meta_block, int
     await_sqe(0);
     data->iov = (struct iovec){ meta_block.buf, (size_t)bs->dsk.meta_block_size };
     data->callback = simple_callback_w;
-    assert(bs->dsk.meta_block_size + meta_block.sector + bs->dsk.meta_block_size <= bs->dsk.meta_area_size);
     io_uring_prep_writev(
         sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset + bs->dsk.meta_block_size + meta_block.sector
     );

src/blockstore/v1/impl.cpp

@@ -855,29 +855,4 @@ std::string blockstore_impl_t::get_op_diag(blockstore_op_t *op)
     return std::string(buf);
 }
 
-uint64_t blockstore_impl_t::get_live_entries()
-{
-    return used_blocks;
-}
-
-uint64_t blockstore_impl_t::get_live_memory()
-{
-    uint64_t used = 0;
-    for (auto & kv: clean_db_shards)
-    {
-        used += kv.second.size() * sizeof(blockstore_clean_db_t::value_type);
-    }
-    return used;
-}
-
-uint64_t blockstore_impl_t::get_garbage_entries()
-{
-    return dirty_db.size();
-}
-
-uint64_t blockstore_impl_t::get_garbage_memory()
-{
-    return (sizeof(obj_ver_id) + sizeof(dirty_entry) + 32) * dirty_db.size();
-}
-
 } // namespace v1

src/blockstore/v1/impl.h

@@ -332,10 +332,6 @@ public:
     inline uint64_t get_free_block_count() { return dsk.block_count - used_blocks; }
     inline uint32_t get_bitmap_granularity() { return dsk.disk_alignment; }
     inline uint64_t get_journal_size() { return dsk.journal_len; }
-    uint64_t get_live_entries();
-    uint64_t get_live_memory();
-    uint64_t get_garbage_entries();
-    uint64_t get_garbage_memory();
 };
 
 } // namespace v1

src/blockstore/v1/journal.cpp

@@ -193,7 +193,6 @@ void blockstore_impl_t::prepare_journal_sector_write(int cur_sector, blockstore_
             (size_t)journal.block_size
         };
         data->callback = [this, flush_id = journal.submit_id](ring_data_t *data) { handle_journal_write(data, flush_id); };
-        assert(journal.sector_info[cur_sector].offset+journal.block_size <= dsk.journal_len);
         io_uring_prep_writev(
             sqe, dsk.journal_fd, &data->iov, 1, journal.offset + journal.sector_info[cur_sector].offset
         );

src/blockstore/v1/write.cpp

@@ -368,9 +368,9 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op)
         }
         data->iov.iov_len = op->len + stripe_offset + stripe_end; // to check it in the callback
         data->callback = [this, op](ring_data_t *data) { handle_write_event(data, op); };
-        const uint64_t write_offset = (loc * dsk.data_block_size) + op->offset - stripe_offset;
-        assert(write_offset+op->len+stripe_offset+stripe_end <= dsk.block_count*dsk.data_block_size);
-        io_uring_prep_writev(sqe, dsk.data_fd, PRIV(op)->iov_zerofill, vcnt, dsk.data_offset + write_offset);
+        io_uring_prep_writev(
+            sqe, dsk.data_fd, PRIV(op)->iov_zerofill, vcnt, dsk.data_offset + (loc * dsk.data_block_size) + op->offset - stripe_offset
+        );
         PRIV(op)->pending_ops = 1;
         if (!(dirty_it->second.state & BS_ST_INSTANT))
         {
@@ -495,8 +495,9 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op)
                 .op = op,
             });
             data2->callback = [this, flush_id = journal.submit_id](ring_data_t *data) { handle_journal_write(data, flush_id); };
-            assert(journal.next_free+op->len <= dsk.journal_len);
-            io_uring_prep_writev(sqe2, dsk.journal_fd, &data2->iov, 1, journal.offset + journal.next_free);
+            io_uring_prep_writev(
+                sqe2, dsk.journal_fd, &data2->iov, 1, journal.offset + journal.next_free
+            );
             PRIV(op)->pending_ops++;
         }
         else

src/client/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8...3.30)
+cmake_minimum_required(VERSION 2.8.12)
 
 project(vitastor)
 
@@ -12,11 +12,11 @@ if (RDMACM_LIBRARIES)
 	set(MSGR_RDMACM "msgr_rdmacm.cpp")
 endif (RDMACM_LIBRARIES)
 add_library(vitastor_common STATIC
-	../util/epoll_manager.cpp etcd_state_client.cpp messenger.cpp msgr_iothread.cpp ../util/addr_util.cpp ../util/xxh_x86dispatch.c ../util/openssl_util.cpp
-	msgr_encrypt.cpp msgr_handshake.cpp msgr_stop.cpp msgr_op.cpp msgr_send.cpp msgr_receive.cpp ../util/ringloop.cpp ../../json11/json11.cpp
+	../util/epoll_manager.cpp etcd_state_client.cpp messenger.cpp ../util/addr_util.cpp
+	msgr_encrypt.cpp msgr_stop.cpp msgr_op.cpp msgr_send.cpp msgr_receive.cpp ../util/ringloop.cpp ../../json11/json11.cpp
 	http_client.cpp osd_ops.cpp pg_states.cpp ../util/timerfd_manager.cpp ../util/str_util.cpp ../util/json_util.cpp ${MSGR_RDMA} ${MSGR_RDMACM}
 )
-target_link_libraries(vitastor_common pthread ${OPENSSL_LIBRARIES} ${CARES_LIBRARIES} ${ISAL_CRYPTO_LIBRARIES})
+target_link_libraries(vitastor_common pthread ${OPENSSL_LIBRARIES} ${CARES_LIBRARIES})
 target_compile_options(vitastor_common PUBLIC -fPIC)
 
 # libvitastor_client.so
@@ -35,7 +35,6 @@ target_link_libraries(vitastor_client
 	${IBVERBS_LIBRARIES}
 	${RDMACM_LIBRARIES}
 	${OPENSSL_LIBRARIES}
-	${ISAL_CRYPTO_LIBRARIES}
 )
 set_target_properties(vitastor_client PROPERTIES VERSION ${VITASTOR_VERSION} SOVERSION 0)
 configure_file(vitastor.pc.in vitastor.pc @ONLY)
@@ -55,6 +54,9 @@ if (${WITH_FIO})
 		../util/rw_blocking.cpp
 		../util/addr_util.cpp
 	)
+	target_link_libraries(fio_vitastor_sec
+		tcmalloc_minimal
+	)
 endif (${WITH_FIO})
 
 # vitastor-nbd
@@ -99,9 +101,9 @@ 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 cluster_client_icache.cpp msgr_op.cpp ../test/mock/messenger.cpp msgr_stop.cpp msgr_encrypt.cpp
-	etcd_state_client.cpp ../util/timerfd_manager.cpp ../util/addr_util.cpp ../util/str_util.cpp ../util/json_util.cpp ../util/xxh_x86dispatch.c ../util/openssl_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_link_libraries(test_cluster_client ${LIBURING_LIBRARIES} ${OPENSSL_LIBRARIES} ${ISAL_CRYPTO_LIBRARIES})
+target_link_libraries(test_cluster_client ${OPENSSL_LIBRARIES})
 target_compile_definitions(test_cluster_client PUBLIC -D__MOCK__)
 target_include_directories(test_cluster_client BEFORE PUBLIC ${CMAKE_SOURCE_DIR}/src/test/mock)
 add_dependencies(build_tests test_cluster_client)

src/client/cluster_client.cpp

@@ -27,7 +27,7 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
     msgr.ringloop = ringloop;
     msgr.repeer_pgs = [this](osd_num_t peer_osd)
     {
-        if (msgr.osd_peers.find(peer_osd) != msgr.osd_peers.end())
+        if (msgr.osd_peer_fds.find(peer_osd) != msgr.osd_peer_fds.end())
         {
             // peer_osd just connected
             continue_ops();
@@ -47,11 +47,11 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
     msgr.exec_op = [this](osd_op_t *op)
     {
         // Garbage in
-        fprintf(stderr, "Can't handle incoming operation from client %lu\n", op->client_id);
-        msgr.stop_client(op->client_id);
+        fprintf(stderr, "Incoming garbage from peer %d\n", op->peer_fd);
+        msgr.stop_client(op->peer_fd);
         delete op;
     };
-    msgr.parse_config(config, true);
+    msgr.parse_config(config);
 
     st_cli.tfd = tfd;
     st_cli.on_load_config_hook = [this](json11::Json::object & cfg) { on_load_config_hook(cfg); };
@@ -71,6 +71,9 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
         st_cli.infinite_start = config["client_infinite_start"].bool_value();
     }
     st_cli.load_global_config();
+
+    scrap_buffer_size = SCRAP_BUFFER_SIZE;
+    scrap_buffer = malloc_or_die(scrap_buffer_size);
 }
 
 cluster_client_t::~cluster_client_t()
@@ -93,6 +96,7 @@ cluster_client_t::~cluster_client_t()
     {
         ringloop->unregister_consumer(&consumer);
     }
+    free(scrap_buffer);
     delete wb;
     wb = NULL;
 }
@@ -154,7 +158,7 @@ void cluster_client_t::continue_raw_ops(osd_num_t peer_osd)
     {
         auto op = it->second;
         op->op_type = OSD_OP_OUT;
-        op->client_id = msgr.osd_peers.at(peer_osd)->client_id;
+        op->peer_fd = msgr.osd_peer_fds.at(peer_osd);
         msgr.outbox_push(op);
         raw_ops.erase(it++);
     }
@@ -481,7 +485,7 @@ void cluster_client_t::on_load_config_hook(json11::Json::object & etcd_global_co
     }
     // vault
     vault_parse_config();
-    msgr.parse_config(config, false);
+    msgr.parse_config(config);
     st_cli.parse_config(config);
     st_cli.load_pgs();
 }
@@ -590,7 +594,7 @@ void cluster_client_t::on_change_pool_config_hook()
         {
             if (log_level > 2 && pg_counts[pool_item.first])
             {
-                fprintf(stderr, "Pool %u (%s) PG count changed from %lu to %lu\n", pool_item.first, pool_item.second.name.c_str(),
+                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
@@ -878,13 +882,13 @@ void cluster_client_t::execute_cas(cluster_op_t *op)
         if (op->retval != expected && op->retval >= 0)
             op->retval = -EIO;
         op->retval = op->retval == -EPIPE ? -EINTR : op->retval;
-        auto peer_it = msgr.osd_peers.find(op->parts[0].osd_num);
+        auto peer_it = msgr.osd_peer_fds.find(op->parts[0].osd_num);
         if (op->retval != 0 || (op->flags & OP_IMMEDIATE_COMMIT))
         {
             auto cb = std::move(op->callback);
             cb(op);
         }
-        else if (peer_it == msgr.osd_peers.end())
+        else if (peer_it == msgr.osd_peer_fds.end())
         {
             // Care must be taken to make sure that the client doesn't reconnect to the OSD
             // before executing the previously completed operation callback (!)
@@ -895,10 +899,10 @@ void cluster_client_t::execute_cas(cluster_op_t *op)
         else
         {
             // CAS writes have a built-in sync
-            osd_client_t *cl = peer_it->second;
+            auto peer_fd = peer_it->second;
             *part = (osd_op_t){
                 .op_type = OSD_OP_OUT,
-                .client_id = cl->client_id,
+                .peer_fd = peer_fd,
                 .req = {
                     .hdr = {
                         .magic = SECONDARY_OSD_OP_MAGIC,
@@ -1047,11 +1051,11 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
 
 void cluster_client_t::execute_raw(osd_num_t osd_num, osd_op_t *op)
 {
-    auto peer_it = msgr.osd_peers.find(osd_num);
-    if (peer_it != msgr.osd_peers.end())
+    auto fd_it = msgr.osd_peer_fds.find(osd_num);
+    if (fd_it != msgr.osd_peer_fds.end())
     {
         op->op_type = OSD_OP_OUT;
-        op->client_id = peer_it->second->client_id;
+        op->peer_fd = fd_it->second;
         msgr.outbox_push(op);
     }
     else
@@ -1162,13 +1166,6 @@ resume_2:
         // Finished successfully
         // Even if the PG count has changed in meanwhile we treat it as success
         // because if some operations were invalid for the new PG count we'd get errors
-        if (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP)
-        {
-            // Copy part bitmaps only after finishing all part reads
-            for (auto & part: op->parts)
-                if ((part.flags & (PART_SENT|PART_DONE|PART_VALID)) == (PART_SENT|PART_DONE|PART_VALID))
-                    copy_part_bitmap(op, &part);
-        }
         if (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_CHAIN_BITMAP)
         {
             uint64_t next_inode = 0;
@@ -1216,7 +1213,7 @@ resume_2:
         erase_op(op);
         return 1;
     }
-    else if (op->retval != 0 && op->opcode != OSD_OP_SYNC && !(op->flags & OP_FLUSH_BUFFER) &&
+    else if (op->retval != 0 && !(op->flags & OP_FLUSH_BUFFER) &&
         op->retval != -EPIPE && (op->retval != -EIO || !client_eio_retry_interval) && (op->retval != -ENOSPC || !client_retry_enospc))
     {
         // Fatal error (neither -EPIPE, -EIO nor -ENOSPC)
@@ -1248,7 +1245,7 @@ resume_2:
     return 0;
 }
 
-static void add_iov(int size, int skip, cluster_op_t *op, int &iov_idx, size_t &iov_pos, osd_op_buf_list_t &iov)
+static void add_iov(int size, bool skip, cluster_op_t *op, int &iov_idx, size_t &iov_pos, osd_op_buf_list_t &iov, void *scrap, int scrap_len)
 {
     int left = size;
     while (left > 0 && iov_idx < op->iov.count)
@@ -1256,7 +1253,7 @@ static void add_iov(int size, int skip, cluster_op_t *op, int &iov_idx, size_t &
         int cur_left = op->iov.buf[iov_idx].iov_len - iov_pos;
         if (cur_left < left)
         {
-            if (skip == 0)
+            if (!skip)
             {
                 iov.push_back((uint8_t*)op->iov.buf[iov_idx].iov_base + iov_pos, cur_left);
             }
@@ -1266,7 +1263,7 @@ static void add_iov(int size, int skip, cluster_op_t *op, int &iov_idx, size_t &
         }
         else
         {
-            if (skip == 0)
+            if (!skip)
             {
                 iov.push_back((uint8_t*)op->iov.buf[iov_idx].iov_base + iov_pos, left);
             }
@@ -1275,10 +1272,16 @@ static void add_iov(int size, int skip, cluster_op_t *op, int &iov_idx, size_t &
         }
     }
     assert(left == 0);
-    if (skip == 1)
+    if (skip && scrap_len > 0)
     {
-        // data read into a NULL buffer will be discarded by messenger
-        iov.push_back(NULL, size);
+        // All skipped ranges are read into the same useless buffer
+        left = size;
+        while (left > 0)
+        {
+            int cur_left = scrap_len < left ? scrap_len : left;
+            iov.push_back(scrap, cur_left);
+            left -= cur_left;
+        }
     }
 }
 
@@ -1301,8 +1304,8 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
         unsigned bitmap_mem = object_bitmap_size +
             op->parts.size() * pg_data_size *
             (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8
-            // read chain_info - max 4 bytes per block
-            + (op->enc ? osd_op_rw_t::chain_info_bytes(op->enc->chain_size)*op->len/pool_cfg.bitmap_granularity : 0));
+            // read chain info - 1 byte per block
+            + (op->enc ? op->len/pool_cfg.bitmap_granularity : 0));
         if (!op->bitmap_buf || op->bitmap_buf_size < bitmap_mem)
         {
             op->bitmap_buf = realloc_or_die(op->bitmap_buf, bitmap_mem);
@@ -1344,10 +1347,10 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
                         {
                             begin = cur;
                             // Just advance iov_idx & iov_pos
-                            add_iov(cur-prev, 2, op, iov_idx, iov_pos, op->parts[i].iov);
+                            add_iov(cur-prev, true, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
                         }
                         else
-                            add_iov(cur-prev, skip_prev ? 1 : 0, op, iov_idx, iov_pos, op->parts[i].iov);
+                            add_iov(cur-prev, skip_prev, op, iov_idx, iov_pos, op->parts[i].iov, scrap_buffer, scrap_buffer_size);
                     }
                     skip_prev = skip;
                     prev = cur;
@@ -1358,11 +1361,11 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
             if (skip_prev)
             {
                 // Just advance iov_idx & iov_pos
-                add_iov(end-prev, 2, op, iov_idx, iov_pos, op->parts[i].iov);
+                add_iov(end-prev, true, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
                 end = prev;
             }
             else
-                add_iov(cur-prev, skip_prev ? 1 : 0, op, iov_idx, iov_pos, op->parts[i].iov);
+                add_iov(cur-prev, skip_prev, op, iov_idx, iov_pos, op->parts[i].iov, scrap_buffer, scrap_buffer_size);
             if (end == begin)
             {
                 op->done_count++;
@@ -1371,7 +1374,7 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
         }
         else if (op->opcode != OSD_OP_READ_BITMAP && op->opcode != OSD_OP_READ_CHAIN_BITMAP && op->opcode != OSD_OP_DELETE)
         {
-            add_iov(end-begin, 0, op, iov_idx, iov_pos, op->parts[i].iov);
+            add_iov(end-begin, false, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
         }
         op->parts[i].parent = op;
         op->parts[i].offset = begin;
@@ -1451,18 +1454,15 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
                 primary_osd = nearest_osd;
         }
         part->osd_num = primary_osd;
-        auto peer_it = msgr.osd_peers.find(primary_osd);
-        if (peer_it != msgr.osd_peers.end())
+        auto peer_it = msgr.osd_peer_fds.find(primary_osd);
+        if (peer_it != msgr.osd_peer_fds.end())
         {
-            osd_client_t *cl = peer_it->second;
+            int peer_fd = peer_it->second;
             part->flags |= PART_SENT|PART_VALID;
             op->inflight_count++;
             uint32_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
             uint64_t pg_bitmap_size = pg_data_size * (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8
-                // read chain_info - max 4 bytes per block
-                + (op->opcode == OSD_OP_READ && op->enc
-                    ? osd_op_rw_t::chain_info_bytes(op->enc->chain_size)*pool_cfg.data_block_size/pool_cfg.bitmap_granularity
-                    : 0));
+                + (op->opcode == OSD_OP_READ && op->enc ? pool_cfg.data_block_size/pool_cfg.bitmap_granularity : 0));
             uint64_t meta_rev = 0;
             if (op->opcode != OSD_OP_READ_BITMAP && op->opcode != OSD_OP_DELETE && !op->deoptimise_snapshot)
             {
@@ -1472,7 +1472,7 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
             }
             part->op = (osd_op_t){
                 .op_type = OSD_OP_OUT,
-                .client_id = cl->client_id,
+                .peer_fd = peer_fd,
                 .req = { .rw = {
                     .header = {
                         .magic = SECONDARY_OSD_OP_MAGIC,
@@ -1523,8 +1523,8 @@ int cluster_client_t::continue_sync(cluster_op_t *op)
     for (auto do_it = dirty_osds.begin(); do_it != dirty_osds.end(); )
     {
         osd_num_t sync_osd = *do_it;
-        auto peer_it = msgr.osd_peers.find(sync_osd);
-        if (peer_it == msgr.osd_peers.end())
+        auto peer_it = msgr.osd_peer_fds.find(sync_osd);
+        if (peer_it == msgr.osd_peer_fds.end())
             dirty_osds.erase(do_it++);
         else
             do_it++;
@@ -1577,12 +1577,12 @@ resume_1:
 
 void cluster_client_t::send_sync(cluster_op_t *op, cluster_op_part_t *part)
 {
-    osd_client_t *cl = msgr.osd_peers.at(part->osd_num);
+    auto peer_fd = msgr.osd_peer_fds.at(part->osd_num);
     part->flags |= PART_SENT;
     op->inflight_count++;
     part->op = (osd_op_t){
         .op_type = OSD_OP_OUT,
-        .client_id = cl->client_id,
+        .peer_fd = peer_fd,
         .req = {
             .hdr = {
                 .magic = SECONDARY_OSD_OP_MAGIC,
@@ -1607,9 +1607,6 @@ static inline void mem_or(void *res, const void *r2, unsigned int len)
     }
 }
 
-// Error priority: others > EPERM > EIO > ENOSPC > ETIMEDOUT > EPIPE
-#define ERR_PRIO(e) (((e) == -EPERM ? 5 : ((e) == -EIO ? 4 : ((e) == -ENOSPC ? 3 : ((e) == -ETIMEDOUT ? 2 : ((e) == -EPIPE ? 1 : (!(e) ? 0 : 10)))))))
-
 void cluster_client_t::handle_op_part(cluster_op_part_t *part)
 {
     cluster_op_t *op = part->parent;
@@ -1618,12 +1615,17 @@ void cluster_client_t::handle_op_part(cluster_op_part_t *part)
     {
         // Operation failed, retry
         part->flags |= PART_ERROR;
-        if (ERR_PRIO(part->op.reply.hdr.retval) > ERR_PRIO(op->retval))
-            op->retval = part->op.reply.hdr.retval;
-        uint64_t stop_client_id = 0;
-        if (op->retval != -EINTR && op->retval != -EIO && op->retval != -ENOSPC && op->retval != -EPERM)
+        if (!op->retval || op->retval == -EPIPE ||
+            part->op.reply.hdr.retval == -ENOSPC && op->retval == -ETIMEDOUT ||
+            part->op.reply.hdr.retval == -EIO)
         {
-            stop_client_id = part->op.client_id;
+            // Error priority: EIO > ENOSPC > ETIMEDOUT > EPIPE
+            op->retval = part->op.reply.hdr.retval;
+        }
+        int stop_fd = -1;
+        if (op->retval != -EINTR && op->retval != -EIO && op->retval != -ENOSPC)
+        {
+            stop_fd = part->op.peer_fd;
             if (op->retval != -EPIPE || log_level > 0)
             {
                 fprintf(
@@ -1650,9 +1652,9 @@ void cluster_client_t::handle_op_part(cluster_op_part_t *part)
             op->retry_after = op->retval != -EPIPE ? client_eio_retry_interval : client_retry_interval;
         }
         reset_retry_timer(op->retry_after);
-        if (stop_client_id)
+        if (stop_fd >= 0)
         {
-            msgr.stop_client(stop_client_id);
+            msgr.stop_client(stop_fd);
         }
         op->inflight_count--;
         if (op->inflight_count == 0 && !op->retry_after)
@@ -1683,6 +1685,13 @@ void cluster_client_t::handle_op_part(cluster_op_part_t *part)
         }
         if (op->inflight_count == 0 && !op->retry_after)
         {
+            // Copy part bitmaps only after finishing all part reads
+            if (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP)
+            {
+                for (auto & part: op->parts)
+                    if (part.flags == (PART_SENT|PART_VALID|PART_DONE))
+                        copy_part_bitmap(op, &part);
+            }
             if (op->opcode == OSD_OP_SYNC)
                 continue_sync(op);
             else

src/client/cluster_client.h

@@ -84,7 +84,7 @@ class writeback_cache_t;
 
 struct inode_cache_t
 {
-    std::vector<inode_t> chain; // only parents from the same pool
+    std::vector<inode_t> chain;
     uint8_t *key_data = NULL;
     osd_op_enc_t *op_enc = NULL;
     bool readonly = false;
@@ -104,6 +104,9 @@ struct vault_load_key_t
 // FIXME: Split into public and private interfaces
 class __attribute__((visibility("default"))) cluster_client_t
 {
+#ifdef __MOCK__
+public:
+#endif
     timerfd_manager_t *tfd = NULL;
     ring_loop_t *ringloop = NULL;
 
@@ -150,6 +153,9 @@ class __attribute__((visibility("default"))) cluster_client_t
     std::set<osd_num_t> dirty_osds;
     uint64_t dirty_bytes = 0, dirty_ops = 0;
 
+    void *scrap_buffer = NULL;
+    unsigned scrap_buffer_size = 0;
+
     // inodes require some extra state for read/write, it's stored here.
     // moreover, robin_hood access is slightly faster than std::map :)
     robin_hood::unordered_flat_map<inode_t, std::shared_ptr<inode_cache_t>> inode_cache;
@@ -197,7 +203,12 @@ public:
     void list_inode(inode_t inode, uint64_t min_offset, uint64_t max_offset, int max_parallel_pgs, std::function<void(
         int status, int pgs_left, pg_num_t pg_num, std::set<object_id>&& objects)> pg_callback);
 
+    //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; }
+
+#ifndef __MOCK__
 protected:
+#endif
     void continue_ops(int time_passed = 0);
 
     std::shared_ptr<inode_cache_t> inode_cache_get(inode_t ino);
@@ -207,6 +218,7 @@ protected:
     void vault_destroy();
     void vault_parse_secret(const std::string & key_id, const std::string & err, json11::Json data);
 
+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);
 
@@ -249,5 +261,4 @@ protected:
     osd_num_t select_nearest_osd(const std::vector<osd_num_t> & osds);
 
     friend class writeback_cache_t;
-    friend class cluster_client_test_t;
 };

src/client/cluster_client_impl.h

@@ -5,6 +5,7 @@
 
 #include "cluster_client.h"
 
+#define SCRAP_BUFFER_SIZE 4*1024*1024
 #define PART_SENT 1
 #define PART_DONE 2
 #define PART_ERROR 4

src/client/cluster_client_list.cpp

@@ -295,7 +295,7 @@ int cluster_client_t::start_pg_listing(inode_list_pg_t *pg)
     bool conn = true;
     for (osd_num_t peer_osd: all_peers)
     {
-        if (msgr.osd_peers.find(peer_osd) == msgr.osd_peers.end())
+        if (msgr.osd_peer_fds.find(peer_osd) == msgr.osd_peer_fds.end())
         {
             // Initiate connection
             if (st_cli.peer_states[peer_osd].is_null())
@@ -340,7 +340,7 @@ void cluster_client_t::send_list(inode_list_osd_t *cur_list)
     osd_op_t *op = new osd_op_t();
     op->op_type = OSD_OP_OUT;
     // Already checked that it exists above, but anyway
-    op->client_id = msgr.osd_peers.at(cur_list->osd_num)->client_id;
+    op->peer_fd = msgr.osd_peer_fds.at(cur_list->osd_num);
     op->req = (osd_any_op_t){
         .sec_list = {
             .header = {

src/client/cluster_client_wb.cpp

@@ -88,11 +88,6 @@ void writeback_cache_t::copy_write(cluster_op_t *op, int state, uint64_t new_flu
     // ...or just save it for writeback if write buffering is enabled
     if (op->len == 0)
     {
-        // FIXME: OSD_OP_DELETEs are currently only sent by vitastor-cli rm/rm-data and
-        // actually have len=0, because delete is actually a delete of the full object
-        // containing the requested offset, not a "punch hole" operation. But here, writeback
-        // cache assumes it IS a "punch hole" operation. I should select one of these
-        // approaches and fix everything accordingly when I decide to implement TRIM.
         return;
     }
     auto dirty_it = find_dirty(op->inode, op->offset);
@@ -249,13 +244,12 @@ void writeback_cache_t::copy_write(cluster_op_t *op, int state, uint64_t new_flu
             writeback_queue_size--;
         }
     }
-    if (!is_del && op->len > 0)
+    if (!is_del)
     {
         uint64_t pos = 0, len = op->len, iov_idx = 0;
-        while (iov_idx < op->iov.count)
+        while (len > 0 && iov_idx < op->iov.count)
         {
             auto & iov = op->iov.buf[iov_idx];
-            assert(pos + iov.iov_len <= len);
             memcpy(buf + pos, iov.iov_base, iov.iov_len);
             pos += iov.iov_len;
             iov_idx++;
@@ -449,7 +443,7 @@ void writeback_cache_t::start_writebacks(cluster_client_t *cli, int count)
         started++;
         assert(writeback_queue_size > 0);
         writeback_queue_size--;
-        writeback_bytes -= (is_del ? 0 : off - from_it->first.stripe);
+        writeback_bytes -= off - from_it->first.stripe;
         assert(writeback_queue_size > 0 || !writeback_bytes);
         flush_buffers(cli, from_it, to_it);
     }

src/client/etcd_state_client.cpp

@@ -12,7 +12,6 @@
 #include "http_client.h"
 #endif
 #include "str_util.h"
-#include "json_util.h"
 
 etcd_state_client_t::~etcd_state_client_t()
 {
@@ -81,46 +80,6 @@ std::vector<std::string> etcd_state_client_t::get_addresses()
     return addrs;
 }
 
-std::shared_ptr<user_info_t> etcd_state_client_t::get_user(const std::string & username)
-{
-    auto user_it = user_info.find(username);
-    if (user_it != user_info.end())
-    {
-        return user_it->second;
-    }
-    auto inf = std::make_shared<user_info_t>();
-    inf->name = username;
-    return inf;
-}
-
-bool etcd_state_client_t::check_image_perm(const std::shared_ptr<user_info_t> & user_info, inode_t inode_num, bool write)
-{
-    if (user_info->type == user_type_t::ADMIN)
-    {
-        return true;
-    }
-    auto cache_it = user_info->perm_cache.find(inode_num);
-    if (cache_it != user_info->perm_cache.end() &&
-        cache_it->second.mod_revision == user_perm_cache_revision)
-    {
-        return write ? (cache_it->second.perm == user_perm_t::OWNER) : (cache_it->second.perm != user_perm_t::DENY);
-    }
-    auto inode_it = inode_config.find(inode_num);
-    if (inode_it == inode_config.end())
-    {
-        return false;
-    }
-    // FIXME Implement cache reset after reworking etcd interaction to not keep everything in memory
-    auto & perm_item = user_info->perm_cache[inode_num];
-    perm_item.mod_revision = user_perm_cache_revision;
-    perm_item.perm = (user_info->name == inode_it->second.owner || inode_it->second.owner_group != "" &&
-        user_info->groups.find(inode_it->second.owner_group) != user_info->groups.end()
-        ? user_perm_t::OWNER : (inode_it->second.reader_group != "" &&
-            user_info->groups.find(inode_it->second.reader_group) != user_info->groups.end()
-            ? user_perm_t::READER : user_perm_t::DENY));
-    return write ? (perm_item.perm == user_perm_t::OWNER) : (perm_item.perm != user_perm_t::DENY);
-}
-
 http_context_t *etcd_state_client_t::get_http_ctx()
 {
     if (!http_ctx)
@@ -291,20 +250,15 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
             add_etcd_url(ea.string_value());
         }
     }
-    if (this->etcd_client_cert != "")
+    if (this->osd_num)
     {
-        this->etcd_client_cert = config["etcd_client_cert"].string_value();
-        this->etcd_client_key = config["etcd_client_key"].string_value();
-    }
-    else if (this->osd_num)
-    {
-        this->etcd_client_cert = config["osd_cert"].string_value();
-        this->etcd_client_key = config["osd_pkey"].string_value();
+        this->etcd_client_cert = config["osd_etcd_client_cert"].string_value();
+        this->etcd_client_key = config["osd_etcd_client_key"].string_value();
     }
     else
     {
-        this->etcd_client_cert = config["cert"].string_value();
-        this->etcd_client_key = config["pkey"].string_value();
+        this->etcd_client_cert = config["etcd_client_cert"].string_value();
+        this->etcd_client_key = config["etcd_client_key"].string_value();
     }
     this->etcd_ca = config["etcd_ca"].string_value();
     this->etcd_prefix = config["etcd_prefix"].string_value();
@@ -350,6 +304,7 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
     {
         this->etcd_min_reload_interval = 50;
     }
+    this->use_image_index_for_auth = config["use_image_index_for_auth"].bool_value();
     if (this->etcd_ws_keepalive_interval != old_etcd_ws_keepalive_interval && ws_keepalive_timer >= 0)
     {
 #ifndef __MOCK__
@@ -481,6 +436,7 @@ void etcd_state_client_t::start_etcd_watcher_selected()
         etcd_watch_ws = http_init(get_http_ctx());
     else
         http_close(etcd_watch_ws);
+    etcd_total_watches = (use_image_index_for_auth ? 4 : 3);
     open_websocket(etcd_watch_ws, url.addr, url.hostname, url.path+"/watch", { .timeout = etcd_slow_timeout, .ssl = url.ssl },
         [this, cur_addr = url.addr](http_message_t *msg)
     {
@@ -500,11 +456,12 @@ void etcd_state_client_t::start_etcd_watcher_selected()
                 {
                     if (watch_id == ETCD_CONFIG_WATCH_ID ||
                         watch_id == ETCD_PG_STATE_WATCH_ID ||
-                        watch_id == ETCD_OSD_STATE_WATCH_ID)
+                        watch_id == ETCD_OSD_STATE_WATCH_ID ||
+                        watch_id == ETCD_INDEX_WATCH_ID)
                     {
                         etcd_watches_initialised++;
                     }
-                    if (etcd_watches_initialised == ETCD_TOTAL_WATCHES && this->log_level > 0)
+                    if (etcd_watches_initialised == etcd_total_watches && this->log_level > 0)
                     {
                         fprintf(stderr, "Successfully subscribed to etcd at %s, revision %ju/%ju/%ju\n", cur_addr.c_str(),
                             etcd_watch_revision_config, etcd_watch_revision_osd, etcd_watch_revision_pg);
@@ -525,7 +482,7 @@ void etcd_state_client_t::start_etcd_watcher_selected()
                                 fprintf(stderr, "Revisions before %ju were compacted by etcd, reloading state\n",
                                     data["result"]["compact_revision"].uint64_value());
                                 http_close(etcd_watch_ws);
-                                etcd_watch_revision_config = etcd_watch_revision_osd = etcd_watch_revision_pg = 0;
+                                etcd_watch_revision_config = etcd_watch_revision_osd = etcd_watch_revision_pg = etcd_watch_revision_index = 0;
                                 on_reload_hook();
                             }
                             return;
@@ -546,7 +503,7 @@ void etcd_state_client_t::start_etcd_watcher_selected()
                 // Save revision only if it's present in the message - because sometimes etcd sends something without a header, like:
                 // {"error": {"grpc_code": 14, "http_code": 503, "http_status": "Service Unavailable", "message": "error reading from server: EOF"}}
                 // Also don't save revision from the initial created: true messages because they always contain the latest revision
-                if (etcd_watches_initialised == ETCD_TOTAL_WATCHES &&
+                if (etcd_watches_initialised == etcd_total_watches &&
                     !data["result"]["header"]["revision"].is_null() &&
                     !data["result"]["created"].bool_value())
                 {
@@ -569,6 +526,8 @@ void etcd_state_client_t::start_etcd_watcher_selected()
                         etcd_watch_revision_pg = watch_rev;
                     else if (watch_id == ETCD_OSD_STATE_WATCH_ID)
                         etcd_watch_revision_osd = watch_rev;
+                    else if (watch_id == ETCD_INDEX_WATCH_ID)
+                        etcd_watch_revision_index = watch_rev;
                     etcd_urls_to_try.clear();
                 }
                 // First gather all changes into a hash to remove multiple overwrites
@@ -644,6 +603,18 @@ void etcd_state_client_t::start_etcd_watcher_selected()
             { "progress_notify", true },
         } }
     }).dump());
+    if (use_image_index_for_auth)
+    {
+        http_post_message(etcd_watch_ws, WS_TEXT, json11::Json(json11::Json::object {
+            { "create_request", json11::Json::object {
+                { "key", base64_encode(etcd_prefix+"/index/image/") },
+                { "range_end", base64_encode(etcd_prefix+"/index/image0") },
+                { "start_revision", etcd_watch_revision_index },
+                { "watch_id", ETCD_INDEX_WATCH_ID },
+                { "progress_notify", true },
+            } }
+        }).dump());
+    }
     // FIXME: Do not watch /pg/history/ at all in client code (not in OSD)
     if (on_start_watcher_hook)
     {
@@ -667,7 +638,7 @@ void etcd_state_client_t::start_ws_keepalive()
     {
         ws_keepalive_timer = tfd->set_timer(etcd_ws_keepalive_interval*1000, true, [this](int)
         {
-            if (!etcd_watch_ws || etcd_watches_initialised < ETCD_TOTAL_WATCHES)
+            if (!etcd_watch_ws || etcd_watches_initialised < etcd_total_watches)
             {
                 // Do nothing
             }
@@ -775,8 +746,12 @@ void etcd_state_client_t::load_pgs()
     json11::Json::array txn = {
         json11::Json::object {
             { "request_range", json11::Json::object {
-                { "key", base64_encode(etcd_prefix+"/config/") },
-                { "range_end", base64_encode(etcd_prefix+"/config0") },
+                { "key", base64_encode(etcd_prefix+"/config/pools") },
+            } }
+        },
+        json11::Json::object {
+            { "request_range", json11::Json::object {
+                { "key", base64_encode(etcd_prefix+"/config/pgs") },
             } }
         },
         json11::Json::object {
@@ -784,6 +759,12 @@ void etcd_state_client_t::load_pgs()
                 { "key", base64_encode(etcd_prefix+"/pg/config") },
             } }
         },
+        json11::Json::object {
+            { "request_range", json11::Json::object {
+                { "key", base64_encode(etcd_prefix+"/config/inode/") },
+                { "range_end", base64_encode(etcd_prefix+"/config/inode0") },
+            } }
+        },
         json11::Json::object {
             { "request_range", json11::Json::object {
                 { "key", base64_encode(etcd_prefix+"/pg/history/") },
@@ -803,6 +784,15 @@ void etcd_state_client_t::load_pgs()
             } }
         },
     };
+    if (use_image_index_for_auth)
+    {
+        txn.push_back(json11::Json::object {
+            { "request_range", json11::Json::object {
+                { "key", base64_encode(etcd_prefix+"/index/image/") },
+                { "range_end", base64_encode(etcd_prefix+"/index/image0") },
+            } }
+        });
+    }
     json11::Json::object req = { { "success", txn } };
     json11::Json checks = load_pgs_checks_hook != NULL ? load_pgs_checks_hook() : json11::Json();
     if (checks.array_items().size() > 0)
@@ -1053,8 +1043,6 @@ 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();
-            // Create group permission
-            pc.creator_group = pool_item.second["creator_group"].string_value();
             // Local Read Configuration
             std::string local_reads = pool_item.second["local_reads"].string_value();
             if (local_reads == "nearest")
@@ -1298,6 +1286,7 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
                 if (i >= pg_state_bit_count)
                 {
                     fprintf(stderr, "Unexpected pool %u PG %u state keyword in etcd: %s\n", pool_id, pg_num, e.dump().c_str());
+                    return;
                 }
             }
             if (!cur_primary || !value["state"].is_array() || !state ||
@@ -1306,6 +1295,7 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
                 (state & PG_INCOMPLETE) && state != PG_INCOMPLETE && state != (PG_INCOMPLETE|PG_HAS_INVALID))
             {
                 fprintf(stderr, "Unexpected pool %u PG %u state in etcd: primary=%ju, state=%s\n", pool_id, pg_num, cur_primary, value["state"].dump().c_str());
+                return;
             }
             pg_cfg.cur_primary = cur_primary;
             pg_cfg.cur_state = state;
@@ -1372,10 +1362,6 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
                 {
                     on_inode_change_hook(inode_num, true);
                 }
-                if (this->inode_config.find(inode_num) != this->inode_config.end())
-                {
-                    user_perm_cache_revision = kv.mod_revision;
-                }
                 this->inode_config.erase(inode_num);
             }
             else
@@ -1384,6 +1370,39 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
             }
         }
     }
+    else if (key.substr(0, etcd_prefix.length()+13) == etcd_prefix+"/index/image/")
+    {
+        // <etcd_prefix>/index/image/%s
+        // Used for environments based on etcd authentication to grant client image access
+        // by names - granting by ID is inconvenient because of snapshots
+        std::string inode_name = key.substr(etcd_prefix.length()+13);
+        if (!value.is_object())
+        {
+            auto n_it = this->inode_by_name.find(inode_name);
+            if (n_it != this->inode_by_name.end())
+            {
+                uint64_t inode_num = n_it->second;
+                if (on_inode_change_hook != NULL)
+                {
+                    on_inode_change_hook(inode_num, true);
+                }
+                this->inode_config.erase(inode_num);
+                this->inode_by_name.erase(n_it);
+            }
+        }
+        else if (value["name"] == inode_name)
+        {
+            uint64_t inode_num = INODE_WITH_POOL(value["pool_id"].uint64_value(), value["id"].uint64_value());
+            if (!INODE_POOL(inode_num) || !INODE_NO_POOL(inode_num))
+            {
+                fprintf(stderr, "Invalid inode ID in key %s: %ju\n", key.c_str(), inode_num);
+            }
+            else
+            {
+                insert_inode_config(deserialize_inode_cfg(inode_num, value, kv.mod_revision));
+            }
+        }
+    }
     else if (key == etcd_prefix+"/config/node_placement")
     {
         // <etcd_prefix>/config/node_placement
@@ -1391,38 +1410,6 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
         if (on_change_node_placement_hook)
             on_change_node_placement_hook();
     }
-    else if (key.substr(0, etcd_prefix.length()+13) == etcd_prefix+"/config/user/")
-    {
-        // <etcd_prefix>/config/user/<username>
-        auto name = key.substr(etcd_prefix.length()+13);
-        auto & inf = user_info[name];
-        if (!value.is_object())
-        {
-            if (inf)
-            {
-                inf->type = user_type_t::CLIENT;
-                inf->groups.clear();
-                inf->perm_cache.clear();
-            }
-            user_info.erase(name);
-        }
-        else
-        {
-            if (!inf)
-            {
-                inf = std::make_shared<user_info_t>();
-                inf->name = name;
-            }
-            inf->type = value["type"] == "admin" ? user_type_t::ADMIN : user_type_t::CLIENT;
-            inf->groups.clear();
-            for (auto & group: value["groups"].array_items())
-            {
-                if (group.string_value() != "")
-                    inf->groups.insert(group.string_value());
-            }
-            inf->perm_cache.clear();
-        }
-    }
 }
 
 uint32_t etcd_state_client_t::parse_immediate_commit(const std::string & immediate_commit_str, uint32_t default_value)
@@ -1445,12 +1432,7 @@ uint32_t etcd_state_client_t::parse_scheme(const std::string & scheme)
 
 void etcd_state_client_t::insert_inode_config(const inode_config_t & cfg)
 {
-    auto & cfg_ref = this->inode_config[cfg.num];
-    if (cfg_ref.mod_revision != cfg.mod_revision)
-    {
-        user_perm_cache_revision = cfg.mod_revision;
-    }
-    cfg_ref = cfg;
+    this->inode_config[cfg.num] = cfg;
     if (cfg.name != "")
     {
         this->inode_by_name[cfg.name] = cfg.num;
@@ -1518,18 +1500,6 @@ json11::Json::object etcd_state_client_t::serialize_inode_cfg(inode_config_t *cf
     {
         new_cfg["deleted"] = true;
     }
-    if (!cfg->owner.empty())
-    {
-        new_cfg["owner"] = cfg->owner;
-    }
-    if (!cfg->owner_group.empty())
-    {
-        new_cfg["owner_group"] = cfg->owner_group;
-    }
-    if (!cfg->reader_group.empty())
-    {
-        new_cfg["reader_group"] = cfg->reader_group;
-    }
     if (cfg->meta.is_object())
     {
         new_cfg["meta"] = cfg->meta;
@@ -1576,9 +1546,6 @@ inode_config_t etcd_state_client_t::deserialize_inode_cfg(uint64_t inode_num, js
         .readonly = value["readonly"].bool_value(),
         .deleted = value["deleted"].bool_value(),
         .enc_key = std::move(enc_key),
-        .owner = value["owner"].string_value(),
-        .owner_group = value["owner_group"].string_value(),
-        .reader_group = value["reader_group"].string_value(),
         .meta = value["meta"],
         .mod_revision = mod_revision,
     };

src/client/etcd_state_client.h

@@ -9,12 +9,11 @@
 #include "json11/json11.hpp"
 #include "object_id.h"
 #include "timerfd_manager.h"
-#include "../util/robin_hood.h"
 
 #define ETCD_CONFIG_WATCH_ID 1
 #define ETCD_OSD_STATE_WATCH_ID 2
 #define ETCD_PG_STATE_WATCH_ID 3
-#define ETCD_TOTAL_WATCHES 3
+#define ETCD_INDEX_WATCH_ID 4
 
 #define DEFAULT_BLOCK_SIZE 128*1024
 #define MIN_DATA_BLOCK_SIZE 4*1024
@@ -70,7 +69,6 @@ struct pool_config_t
     std::map<pg_num_t, pg_config_t> pg_config;
     uint64_t scrub_interval = 0;
     std::string used_for_app;
-    std::string creator_group;
     int backfillfull = 0;
     int local_reads = 0;
 
@@ -89,8 +87,6 @@ struct inode_config_t
     bool readonly = false;
     bool deleted = false;
     std::string enc_key;
-    // Permissions
-    std::string owner, owner_group, reader_group;
     // Arbitrary metadata
     json11::Json meta;
     // Change revision of the metadata in etcd
@@ -111,30 +107,6 @@ struct http_url_t
     std::string path;
 };
 
-enum class user_type_t
-{
-    CLIENT = 0,
-    ADMIN = 1,
-};
-
-struct user_perm_t
-{
-    enum class perm_type_t: uint8_t;
-    constexpr static perm_type_t DENY = (perm_type_t)0;
-    constexpr static perm_type_t READER = (perm_type_t)1;
-    constexpr static perm_type_t OWNER = (perm_type_t)2;
-    uint64_t mod_revision = 0;
-    perm_type_t perm = DENY;
-};
-
-struct user_info_t
-{
-    std::string name;
-    user_type_t type;
-    robin_hood::unordered_flat_set<std::string> groups;
-    robin_hood::unordered_flat_map<inode_t, user_perm_t> perm_cache;
-};
-
 struct http_co_t;
 struct http_context_t;
 
@@ -154,6 +126,7 @@ protected:
     std::vector<inode_watch_t*> watches;
     std::vector<std::function<void()>> on_resolve_queue;
     bool new_pg_config = false;
+    bool use_image_index_for_auth = false;
     int ws_keepalive_timer = -1;
     int ws_alive = 0;
     bool rand_initialized = false;
@@ -185,9 +158,11 @@ public:
     http_context_t *http_ctx = NULL;
     http_co_t *etcd_watch_ws = NULL, *keepalive_client = NULL;
     int etcd_watches_initialised = 0;
+    int etcd_total_watches = 0;
     uint64_t etcd_watch_revision_config = 0;
     uint64_t etcd_watch_revision_osd = 0;
     uint64_t etcd_watch_revision_pg = 0;
+    uint64_t etcd_watch_revision_index = 0;
     timespec etcd_last_reload = {};
     int load_pgs_timer_id = -1;
     std::map<pool_id_t, pool_config_t> pool_config;
@@ -195,8 +170,6 @@ 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;
-    robin_hood::unordered_flat_map<std::string, std::shared_ptr<user_info_t>> user_info;
-    uint64_t user_perm_cache_revision = 0;
     json11::Json node_placement;
 
     std::function<void(std::map<std::string, etcd_kv_t> &)> on_change_hook;
@@ -218,8 +191,6 @@ public:
     inode_config_t deserialize_inode_cfg(uint64_t inode_num, json11::Json value, uint64_t mod_revision);
     etcd_kv_t parse_etcd_kv(const json11::Json & kv_json);
     std::vector<std::string> get_addresses();
-    std::shared_ptr<user_info_t> get_user(const std::string & username);
-    bool check_image_perm(const std::shared_ptr<user_info_t> & user_info, inode_t inode_num, bool write);
     http_context_t *get_http_ctx();
     void etcd_call_oneshot(const std::string & etcd_address, const std::string & api, json11::Json payload, int timeout, std::function<void(std::string, json11::Json)> callback);
     void etcd_call(const std::string & api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);

src/client/http_client.cpp

@@ -19,7 +19,6 @@
 #include <openssl/err.h>
 #include <openssl/pem.h>
 #include <openssl/ssl.h>
-#include "openssl_util.h"
 #endif
 
 // libc-ares
@@ -49,7 +48,6 @@ struct http_context_t
 
 #ifdef WITH_OPENSSL
     SSL_CTX *ssl_ctx = NULL;
-    std::string ssl_cn;
 #endif
 
     ~http_context_t()
@@ -164,6 +162,71 @@ void http_ares_cb(void *data, ares_socket_t socket_fd, int readable, int writabl
     });
 }
 
+#ifdef WITH_OPENSSL
+bool openssl_ctx_use_ca(SSL_CTX *ssl_ctx, const std::string & file_or_pem)
+{
+    if (file_or_pem.substr(0, 5) == "-----")
+    {
+        BIO *bio = BIO_new_mem_buf(file_or_pem.data(), file_or_pem.size());
+        if (!bio)
+            return false;
+        X509 *x509 = PEM_read_bio_X509(bio, NULL, 0, NULL);
+        bool ok = !!x509;
+        if (x509)
+        {
+            X509_STORE *store = SSL_CTX_get_cert_store(ssl_ctx);
+            X509_STORE_add_cert(store, x509);
+            X509_free(x509);
+        }
+        BIO_free(bio);
+        return ok;
+    }
+    return file_or_pem.empty()
+        ? !!SSL_CTX_set_default_verify_paths(ssl_ctx)
+        : !!SSL_CTX_load_verify_locations(ssl_ctx, file_or_pem.c_str(), NULL);
+}
+
+bool openssl_ctx_use_cert(SSL_CTX *ssl_ctx, const std::string & file_or_pem)
+{
+    if (file_or_pem.substr(0, 5) == "-----")
+    {
+        BIO *bio = BIO_new_mem_buf(file_or_pem.data(), file_or_pem.size());
+        if (!bio)
+            return false;
+        X509 *x509 = PEM_read_bio_X509(bio, NULL, 0, NULL);
+        bool ok = !!x509;
+        if (x509)
+        {
+            ok = SSL_CTX_use_certificate(ssl_ctx, x509);
+            X509_free(x509);
+        }
+        BIO_free(bio);
+        return ok;
+    }
+    return !!SSL_CTX_use_certificate_file(ssl_ctx, file_or_pem.c_str(), SSL_FILETYPE_PEM);
+}
+
+bool openssl_ctx_use_key(SSL_CTX *ssl_ctx, const std::string & file_or_pem)
+{
+    if (file_or_pem.substr(0, 5) == "-----")
+    {
+        BIO *bio = BIO_new_mem_buf(file_or_pem.data(), file_or_pem.size());
+        if (!bio)
+            return false;
+        EVP_PKEY *pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL);
+        bool ok = !!pkey;
+        if (pkey)
+        {
+            ok = SSL_CTX_use_PrivateKey(ssl_ctx, pkey);
+            EVP_PKEY_free(pkey);
+        }
+        BIO_free(bio);
+        return ok;
+    }
+    return !!SSL_CTX_use_PrivateKey_file(ssl_ctx, file_or_pem.c_str(), SSL_FILETYPE_PEM);
+}
+#endif
+
 http_context_t* http_context_init(timerfd_manager_t *tfd, const std::string & ssl_cert, const std::string & ssl_key,
     const std::string & ssl_ca, bool verify_peer, std::string & error)
 {
@@ -180,7 +243,6 @@ http_context_t* http_context_init(timerfd_manager_t *tfd, const std::string & ss
     ctx->ssl_key = ssl_key;
     ctx->ssl_ca = ssl_ca;
     ctx->ssl_ctx = ssl_ctx;
-    ctx->ssl_cn = "";
     if (!ssl_ctx)
         goto init_err;
     SSL_CTX_set_verify(ssl_ctx, verify_peer ? SSL_VERIFY_PEER : SSL_VERIFY_NONE, NULL);
@@ -189,7 +251,7 @@ http_context_t* http_context_init(timerfd_manager_t *tfd, const std::string & ss
     if (!openssl_ctx_use_ca(ssl_ctx, ssl_ca))
         goto init_err;
     if (ssl_cert != "" && ssl_key != "" &&
-        (!openssl_ctx_use_cert(ssl_ctx, ssl_cert, ctx->ssl_cn) ||
+        (!openssl_ctx_use_cert(ssl_ctx, ssl_cert) ||
         !openssl_ctx_use_key(ssl_ctx, ssl_key)))
         goto init_err;
 #endif
@@ -200,11 +262,6 @@ init_err:
     return NULL;
 }
 
-std::string http_context_get_ssl_cn(http_context_t *ctx)
-{
-    return ctx->ssl_cn;
-}
-
 struct http_ctx_resolve_t
 {
     std::function<void(const std::string & error, const std::vector<std::string> & addrs)> cb;
@@ -1055,11 +1112,6 @@ bool http_co_t::handle_read()
             }
             state = HTTP_CO_REQ_HDR_RECEIVED;
             parse_http_headers(response, &parsed, true);
-            if (ssl)
-            {
-                auto x509 = SSL_get0_peer_certificate(ssl_cli);
-                parsed.headers["_tls_common_name"] = openssl_get_cn(x509);
-            }
             auto conn_it = parsed.headers.find("connection");
             keepalive = (conn_it != parsed.headers.end() && conn_it->second == "keep-alive");
             auto enc_it = parsed.headers.find("transfer-encoding");

src/client/http_client.h

@@ -48,7 +48,6 @@ struct http_co_t;
 
 http_context_t* http_context_init(timerfd_manager_t *tfd, const std::string & ssl_cert, const std::string & ssl_key,
     const std::string & ssl_ca, bool verify_peer, std::string & error);
-std::string http_context_get_ssl_cn(http_context_t *ctx);
 void http_resolve(http_context_t *ctx, bool ssl, std::string host,
     std::function<void(const std::string & error, const std::vector<std::string> & addrs)> cb);
 void http_context_destroy(http_context_t *ctx);

src/client/messenger.cpp

@@ -10,15 +10,113 @@
 #include <stdexcept>
 
 #include "addr_util.h"
-#include "str_util.h"
 #include "messenger.h"
 #ifdef WITH_RDMA
 #include "msgr_rdma.h"
 #endif
 
+#include <sys/poll.h>
+
+msgr_iothread_t::msgr_iothread_t():
+    ring(RINGLOOP_DEFAULT_SIZE, true),
+    thread(&msgr_iothread_t::run, this)
+{
+    eventfd = ring.register_eventfd();
+    if (eventfd < 0)
+    {
+        throw std::runtime_error(std::string("failed to register eventfd: ") + strerror(-eventfd));
+    }
+}
+
+msgr_iothread_t::~msgr_iothread_t()
+{
+    stop();
+}
+
+void msgr_iothread_t::add_sqe(io_uring_sqe & sqe)
+{
+    mu.lock();
+    queue.push_back((iothread_sqe_t){ .sqe = sqe, .data = std::move(*(ring_data_t*)sqe.user_data) });
+    if (queue.size() == 1)
+    {
+        cond.notify_all();
+    }
+    mu.unlock();
+}
+
+void msgr_iothread_t::stop()
+{
+    mu.lock();
+    if (stopped)
+    {
+        mu.unlock();
+        return;
+    }
+    stopped = true;
+    if (outer_loop_data)
+    {
+        outer_loop_data->callback = [](ring_data_t*){};
+    }
+    cond.notify_all();
+    close(eventfd);
+    mu.unlock();
+    thread.join();
+}
+
+void msgr_iothread_t::add_to_ringloop(ring_loop_t *outer_loop)
+{
+    assert(!this->outer_loop || this->outer_loop == outer_loop);
+    io_uring_sqe *sqe = outer_loop->get_sqe();
+    assert(sqe != NULL);
+    this->outer_loop = outer_loop;
+    this->outer_loop_data = ((ring_data_t*)sqe->user_data);
+    io_uring_prep_poll_add(sqe, eventfd, POLLIN);
+    outer_loop_data->callback = [this](ring_data_t *data)
+    {
+        if (data->res < 0)
+        {
+            throw std::runtime_error(std::string("eventfd poll failed: ") + strerror(-data->res));
+        }
+        outer_loop_data = NULL;
+        if (stopped)
+        {
+            return;
+        }
+        add_to_ringloop(this->outer_loop);
+        ring.loop();
+    };
+}
+
+void msgr_iothread_t::run()
+{
+    while (true)
+    {
+        {
+            std::unique_lock<std::mutex> lk(mu);
+            while (!stopped && !queue.size())
+                cond.wait(lk);
+            if (stopped)
+                return;
+            int i = 0;
+            for (; i < queue.size(); i++)
+            {
+                io_uring_sqe *sqe = ring.get_sqe();
+                if (!sqe)
+                    break;
+                ring_data_t *data = ((ring_data_t*)sqe->user_data);
+                *data = std::move(queue[i].data);
+                *sqe = queue[i].sqe;
+                sqe->user_data = (uint64_t)data;
+            }
+            queue.erase(queue.begin(), queue.begin()+i);
+        }
+        // We only want to offload sendmsg/recvmsg. Callbacks will be called in main thread
+        ring.submit();
+    }
+}
+
 void osd_messenger_t::init()
 {
-    init_tls();
 #ifdef WITH_RDMACM
     if (use_rdmacm)
     {
@@ -75,17 +173,21 @@ void osd_messenger_t::init()
     }
     if (ringloop && iothread_count > 0)
     {
-        init_iothreads();
+        for (int i = 0; i < iothread_count; i++)
+        {
+            auto iot = new msgr_iothread_t();
+            iothreads.push_back(iot);
+            iot->add_to_ringloop(ringloop);
+        }
     }
     keepalive_timer_id = tfd->set_timer(1000, true, [this](int)
     {
-        std::vector<uint64_t> clients_to_stop;
-        std::vector<osd_op_t*> ops_to_send;
         auto cl_it = clients.begin();
         while (cl_it != clients.end())
         {
             auto cl = cl_it->second;
             cl_it++;
+            auto peer_fd = cl->peer_fd;
             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
@@ -97,9 +199,10 @@ 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 %ju), disconnecting peer\n",
-                        cl->in_osd_num ? cl->in_osd_num : cl->osd_num, cl->client_id);
-                    clients_to_stop.push_back(cl->client_id);
+                    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);
                 }
             }
             else if (cl->idle_time_remaining > 0)
@@ -110,36 +213,37 @@ void osd_messenger_t::init()
                     // Connection is idle for <osd_idle_time>, send ping
                     osd_op_t *op = new osd_op_t();
                     op->op_type = OSD_OP_OUT;
-                    op->client_id = cl->client_id;
+                    op->peer_fd = cl->peer_fd;
                     op->req = (osd_any_op_t){
                         .hdr = {
                             .magic = SECONDARY_OSD_OP_MAGIC,
                             .opcode = OSD_OP_PING,
                         },
                     };
-                    op->callback = [this](osd_op_t *op)
+                    op->callback = [this, cl](osd_op_t *op)
                     {
-                        auto cl_it = clients.find(op->client_id);
-                        if (cl_it == clients.end())
+                        auto cl_it = clients.find(op->peer_fd);
+                        if (cl_it == clients.end() || cl_it->second != cl)
                         {
                             // client is already dropped
                             delete op;
                             return;
                         }
-                        auto cl = cl_it->second;
-                        uint64_t fail_client_id = (op->reply.hdr.retval != 0 ? op->client_id : 0);
+                        int fail_fd = (op->reply.hdr.retval != 0 ? op->peer_fd : -1);
                         auto fail_osd_num = cl->in_osd_num ? cl->in_osd_num : cl->osd_num;
                         cl->ping_time_remaining = 0;
                         delete op;
-                        if (fail_client_id)
+                        if (fail_fd >= 0)
                         {
-                            fprintf(stderr, "Ping failed for OSD %ju (client %ju), disconnecting peer\n", fail_osd_num, fail_client_id);
-                            stop_client(fail_client_id);
+                            fprintf(stderr, "Ping failed for OSD %ju (client %d), disconnecting peer\n", fail_osd_num, fail_fd);
+                            stop_client(fail_fd, true);
                         }
                     };
                     cl->ping_time_remaining = osd_ping_timeout;
                     cl->idle_time_remaining = osd_idle_timeout;
-                    ops_to_send.push_back(op);
+                    outbox_push(op);
+                    // Restart iterator because it may be invalidated
+                    cl_it = clients.upper_bound(peer_fd);
                 }
             }
             else
@@ -147,14 +251,6 @@ void osd_messenger_t::init()
                 cl->idle_time_remaining = osd_idle_timeout;
             }
         }
-        for (uint64_t client_id: clients_to_stop)
-        {
-            stop_client(client_id);
-        }
-        for (osd_op_t *op: ops_to_send)
-        {
-            outbox_push(op);
-        }
     });
 }
 
@@ -167,9 +263,16 @@ osd_messenger_t::~osd_messenger_t()
     }
     while (clients.size() > 0)
     {
-        stop_client(clients.begin()->first, true);
+        stop_client(clients.begin()->first, true, true);
+    }
+    if (iothreads.size())
+    {
+        for (auto iot: iothreads)
+        {
+            delete iot;
+        }
+        iothreads.clear();
     }
-    destroy_iothreads();
 #ifdef WITH_RDMA
     for (auto rdma_context: rdma_contexts)
     {
@@ -186,67 +289,18 @@ osd_messenger_t::~osd_messenger_t()
         rdmacm_evch = NULL;
     }
 #endif
-    for (auto encrypt_ctx: encrypt_xts_pool)
+    for (auto encrypt_ctx: encrypt_ctx_pool)
     {
         destroy_aes_xts_encrypt(encrypt_ctx);
     }
-    for (auto decrypt_ctx: decrypt_xts_pool)
+    for (auto decrypt_ctx: decrypt_ctx_pool)
     {
         destroy_aes_xts_decrypt(decrypt_ctx);
     }
-    destroy_tls();
 }
 
-static int parse_proto_checksums(const json11::Json & val, int default_value)
+void osd_messenger_t::parse_config(const json11::Json & config)
 {
-    if (val.is_string())
-    {
-        const auto & str = val.string_value();
-        if (str == "full")
-            return MSGR_CSUM_FULL;
-        else if (str == "payload")
-            return MSGR_CSUM_PAYLOAD;
-        else if (str == "gcm")
-            return MSGR_CSUM_GCM;
-        else if (str == "none")
-            return 0;
-        else if (str == "")
-            return default_value;
-    }
-    else if (val.is_null())
-        return default_value;
-    fprintf(stderr, "proto_checksums should be \"full\", \"payload\", \"gcm\", \"none\""
-        ", \"\" or null (default), but it is: %s\n", val.dump().c_str());
-    exit(1);
-}
-
-void osd_messenger_t::parse_config(const json11::Json & config, bool init)
-{
-    this->max_cipher_pool_size = config["max_cipher_pool_size"].uint64_value();
-    if (!this->max_cipher_pool_size)
-        this->max_cipher_pool_size = 256;
-    this->receive_buffer_size = (uint32_t)config["tcp_header_buffer_size"].uint64_value();
-    if (!this->receive_buffer_size || this->receive_buffer_size > 1024*1024*1024)
-        this->receive_buffer_size = 65536;
-    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;
-    this->peer_connect_timeout = config["peer_connect_timeout"].uint64_value();
-    if (!this->peer_connect_timeout)
-        this->peer_connect_timeout = 5;
-    this->osd_idle_timeout = config["osd_idle_timeout"].uint64_value();
-    if (!this->osd_idle_timeout)
-        this->osd_idle_timeout = 5;
-    this->osd_ping_timeout = config["osd_ping_timeout"].uint64_value();
-    if (!this->osd_ping_timeout)
-        this->osd_ping_timeout = 5;
-    this->log_level = config["log_level"].uint64_value();
-    // All other parameters are only set on init
-    if (!init)
-        return;
 #ifdef WITH_RDMA
     if (!config["use_rdma"].is_null())
     {
@@ -277,27 +331,34 @@ void osd_messenger_t::parse_config(const json11::Json & config, bool init)
     if (!this->rdma_max_msg || this->rdma_max_msg > 128*1024*1024)
         this->rdma_max_msg = 129*1024;
 #endif
-    if (!osd_num)
-    {
-        tls_cert = config["cert"].string_value();
-        tls_key = config["pkey"].string_value();
-        osd_tls_ca = config["osd_ca"].string_value();
-    }
-    else
-    {
-        tls_cert = config["osd_cert"].string_value();
-        tls_key = config["osd_pkey"].string_value();
-        osd_tls_ca = config["osd_ca"].string_value();
-        client_tls_ca = config["client_ca"].string_value();
-    }
-    this->use_proto_checksums = parse_proto_checksums(config["proto_checksums"], MSGR_CSUM_PAYLOAD);
-    this->force_proto_checksums = parse_proto_checksums(config["force_proto_checksums"], tls_cert != "" ? MSGR_CSUM_PAYLOAD : 0);
+    this->max_aes_xts_pool_size = config["max_aes_xts_pool_size"].uint64_value();
+    if (!this->max_aes_xts_pool_size)
+        this->max_aes_xts_pool_size = 256;
     if (!osd_num)
         this->iothread_count = (uint32_t)config["client_iothread_count"].uint64_value();
     else
         this->iothread_count = (uint32_t)config["osd_iothread_count"].uint64_value();
+    this->receive_buffer_size = (uint32_t)config["tcp_header_buffer_size"].uint64_value();
+    if (!this->receive_buffer_size || this->receive_buffer_size > 1024*1024*1024)
+        this->receive_buffer_size = 65536;
     this->use_sync_send_recv = config["use_sync_send_recv"].bool_value() ||
-        config["use_sync_send_recv"].uint64_value() || !ringloop;
+        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;
+    this->peer_connect_timeout = config["peer_connect_timeout"].uint64_value();
+    if (!this->peer_connect_timeout)
+        this->peer_connect_timeout = 5;
+    this->osd_idle_timeout = config["osd_idle_timeout"].uint64_value();
+    if (!this->osd_idle_timeout)
+        this->osd_idle_timeout = 5;
+    this->osd_ping_timeout = config["osd_ping_timeout"].uint64_value();
+    if (!this->osd_ping_timeout)
+        this->osd_ping_timeout = 5;
+    this->log_level = config["log_level"].uint64_value();
     // OSD public & cluster networks
     this->osd_networks.clear();
     if (config["osd_network"].is_string())
@@ -390,7 +451,7 @@ void osd_messenger_t::try_connect_peer(uint64_t peer_osd)
     {
         return;
     }
-    if (osd_peers.find(peer_osd) != osd_peers.end())
+    if (osd_peer_fds.find(peer_osd) != osd_peer_fds.end())
     {
         wanted_peers.erase(peer_osd);
         return;
@@ -417,20 +478,20 @@ void osd_messenger_t::try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_
 #ifdef WITH_RDMACM
     if (disable_tcp)
     {
-        on_connect_peer(peer_osd, -EINVAL, 0);
+        on_connect_peer(peer_osd, -EINVAL);
         return;
     }
 #endif
     struct sockaddr_storage addr;
     if (!string_to_addr(peer_host, 0, peer_port, &addr))
     {
-        on_connect_peer(peer_osd, -EINVAL, 0);
+        on_connect_peer(peer_osd, -EINVAL);
         return;
     }
     int peer_fd = socket(addr.ss_family, SOCK_STREAM, 0);
     if (peer_fd < 0)
     {
-        on_connect_peer(peer_osd, -errno, 0);
+        on_connect_peer(peer_osd, -errno);
         return;
     }
     fcntl(peer_fd, F_SETFL, fcntl(peer_fd, F_GETFL, 0) | O_NONBLOCK);
@@ -438,25 +499,21 @@ void osd_messenger_t::try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_
     if (r < 0 && errno != EINPROGRESS)
     {
         close(peer_fd);
-        on_connect_peer(peer_osd, -errno, 0);
+        on_connect_peer(peer_osd, -errno);
         return;
     }
-    const uint64_t client_id = next_client_id++;
-    osd_client_t *cl = new osd_client_t();
+    clients[peer_fd] = new osd_client_t();
     if (log_level > 0)
     {
-        fprintf(stderr, "Connecting to OSD %ju at %s:%d (client %ju, FD %d)\n", peer_osd, peer_host, peer_port, client_id, peer_fd);
+        fprintf(stderr, "Connecting to OSD %ju at %s:%d (client %d)\n", peer_osd, peer_host, peer_port, peer_fd);
     }
-    cl->client_id = client_id;
-    cl->peer_addr = addr;
-    cl->peer_port = peer_port;
-    cl->peer_fd = peer_fd;
-    cl->peer_state = PEER_CONNECTING;
-    cl->connect_timeout_id = -1;
-    cl->osd_num = peer_osd;
-    cl->in_buf = (uint8_t*)malloc_or_die(receive_buffer_size);
-    clients[client_id] = cl;
-    clients_by_fd[peer_fd] = cl;
+    clients[peer_fd]->peer_addr = addr;
+    clients[peer_fd]->peer_port = peer_port;
+    clients[peer_fd]->peer_fd = peer_fd;
+    clients[peer_fd]->peer_state = PEER_CONNECTING;
+    clients[peer_fd]->connect_timeout_id = -1;
+    clients[peer_fd]->osd_num = peer_osd;
+    clients[peer_fd]->in_buf = (uint8_t*)malloc_or_die(receive_buffer_size);
     tfd->set_fd_handler(peer_fd, true, [this](int peer_fd, int epoll_events)
     {
         // Either OUT (connected) or HUP
@@ -464,11 +521,11 @@ void osd_messenger_t::try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_
     });
     if (peer_connect_timeout > 0)
     {
-        cl->connect_timeout_id = tfd->set_timer(1000*peer_connect_timeout, false, [this, client_id](int timer_id)
+        clients[peer_fd]->connect_timeout_id = tfd->set_timer(1000*peer_connect_timeout, false, [this, peer_fd](int timer_id)
         {
-            osd_num_t peer_osd = clients.at(client_id)->osd_num;
-            stop_client(client_id);
-            on_connect_peer(peer_osd, -EPIPE, 0);
+            osd_num_t peer_osd = clients.at(peer_fd)->osd_num;
+            stop_client(peer_fd, true);
+            on_connect_peer(peer_osd, -EPIPE);
             return;
         });
     }
@@ -476,7 +533,7 @@ void osd_messenger_t::try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_
 
 void osd_messenger_t::handle_connect_epoll(int peer_fd)
 {
-    auto cl = clients_by_fd.at(peer_fd);
+    auto cl = clients[peer_fd];
     if (cl->connect_timeout_id >= 0)
     {
         tfd->clear_timer(cl->connect_timeout_id);
@@ -491,8 +548,8 @@ void osd_messenger_t::handle_connect_epoll(int peer_fd)
     }
     if (result != 0)
     {
-        stop_client(cl->client_id);
-        on_connect_peer(peer_osd, -result, 0);
+        stop_client(peer_fd, true);
+        on_connect_peer(peer_osd, -result);
         return;
     }
     int one = 1;
@@ -503,30 +560,29 @@ void osd_messenger_t::handle_connect_epoll(int peer_fd)
         handle_peer_epoll(peer_fd, epoll_events);
     });
     // Check OSD number
-    init_tls_client(cl);
     check_peer_config(cl);
 }
 
 void osd_messenger_t::handle_peer_epoll(int peer_fd, int epoll_events)
 {
     // Mark client as ready (i.e. some data is available)
-    auto cl = clients_by_fd.at(peer_fd);
     if (epoll_events & EPOLLRDHUP)
     {
         // Stop client
         if (log_level > 0)
         {
-            fprintf(stderr, "[OSD %ju] client %ju disconnected\n", this->osd_num, cl->client_id);
+            fprintf(stderr, "[OSD %ju] client %d disconnected\n", this->osd_num, peer_fd);
         }
-        stop_client(cl->client_id);
+        stop_client(peer_fd, true);
     }
     else if (epoll_events & EPOLLIN)
     {
         // Mark client as ready (i.e. some data is available)
+        auto cl = clients[peer_fd];
         cl->read_ready++;
         if (cl->read_ready == 1)
         {
-            read_ready_clients.push_back(cl->client_id);
+            read_ready_clients.push_back(cl->peer_fd);
             if (ringloop)
                 ringloop->wakeup();
             else
@@ -535,13 +591,13 @@ void osd_messenger_t::handle_peer_epoll(int peer_fd, int epoll_events)
     }
 }
 
-void osd_messenger_t::on_connect_peer(osd_num_t peer_osd, int errcode, uint64_t client_id)
+void osd_messenger_t::on_connect_peer(osd_num_t peer_osd, int peer_fd)
 {
     auto & wp = wanted_peers.at(peer_osd);
     wp.connecting = false;
-    if (errcode < 0)
+    if (peer_fd < 0)
     {
-        fprintf(stderr, "Failed to connect to peer OSD %ju address %s port %d: %s\n", peer_osd, wp.cur_addr.c_str(), wp.cur_port, strerror(-errcode));
+        fprintf(stderr, "Failed to connect to peer OSD %ju address %s port %d: %s\n", peer_osd, wp.cur_addr.c_str(), wp.cur_port, strerror(-peer_fd));
         if (wp.address_changed)
         {
             wp.address_changed = false;
@@ -568,7 +624,7 @@ void osd_messenger_t::on_connect_peer(osd_num_t peer_osd, int errcode, uint64_t
     }
     if (log_level > 0)
     {
-        fprintf(stderr, "[OSD %ju] Connected with peer OSD %ju (client %ju)\n", osd_num, peer_osd, client_id);
+        fprintf(stderr, "[OSD %ju] Connected with peer OSD %ju (client %d)\n", osd_num, peer_osd, peer_fd);
     }
     wanted_peers.erase(peer_osd);
     repeer_pgs(peer_osd);
@@ -578,7 +634,7 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
 {
     osd_op_t *op = new osd_op_t();
     op->op_type = OSD_OP_OUT;
-    op->client_id = cl->client_id;
+    op->peer_fd = cl->peer_fd;
     op->req = (osd_any_op_t){
         .show_conf = {
             .header = {
@@ -593,12 +649,7 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
         // Inform that we're OSD <osd_num>
         payload["osd_num"] = osd_num;
     }
-    auto features = json11::Json::object{ { "check_sequencing", true } };
-    if (use_proto_checksums)
-    {
-        features["proto_checksums"] = use_proto_checksums;
-    }
-    payload["features"] = features;
+    payload["features"] = json11::Json::object{ { "check_sequencing", true } };
 #ifdef WITH_RDMA
     if (!use_rdmacm && rdma_contexts.size())
     {
@@ -607,7 +658,7 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
         if (!selected_ctx)
         {
             if (log_level > 0)
-                fprintf(stderr, "No RDMA context for OSD %ju connection (client %ju), using only TCP\n", cl->osd_num, cl->client_id);
+                fprintf(stderr, "No RDMA context for OSD %ju connection (peer %d), using only TCP\n", cl->osd_num, cl->peer_fd);
         }
         else
         {
@@ -638,11 +689,6 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
             err = true;
             fprintf(stderr, "Failed to get config from OSD %ju (retval=%jd), disconnecting peer\n", cl->osd_num, op->reply.hdr.retval);
         }
-        else if (cl->gcm_enabled && !cl->hs_result.peer_is_osd)
-        {
-            err = true;
-            fprintf(stderr, "Client %ju is not authenticated as an OSD, disconnecting peer\n", cl->client_id);
-        }
         else
         {
             config = json11::Json::parse(std::string((char*)op->buf), json_err);
@@ -670,26 +716,11 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
                 err = !check_config_hook(cl, config);
             }
         }
-        if (!err && use_proto_checksums)
-        {
-            auto peer_csums = config["features"]["proto_checksums"].uint64_value();
-            if (peer_csums == MSGR_CSUM_GCM && use_proto_checksums == MSGR_CSUM_GCM && cl->gcm_enabled)
-                cl->proto_csum_status = MSGR_CSUM_GCM;
-            else if (peer_csums == MSGR_CSUM_FULL && use_proto_checksums == MSGR_CSUM_FULL)
-                cl->proto_csum_status = MSGR_CSUM_FULL;
-            else if (peer_csums && use_proto_checksums)
-                cl->proto_csum_status = MSGR_CSUM_PAYLOAD;
-            if (cl->proto_csum_status < force_proto_checksums)
-            {
-                fprintf(stderr, "Error: OSD %ju use_proto_checksums security level is lower than force_proto_checksums\n", cl->osd_num);
-                err = true;
-            }
-        }
         if (err)
         {
             osd_num_t peer_osd = cl->osd_num;
-            stop_client(op->client_id);
-            on_connect_peer(peer_osd, -EINVAL, 0);
+            stop_client(op->peer_fd);
+            on_connect_peer(peer_osd, -EINVAL);
             delete op;
             return;
         }
@@ -724,8 +755,8 @@ void osd_messenger_t::check_peer_config(osd_client_t *cl)
             }
         }
 #endif
-        osd_peers[cl->osd_num] = cl;
-        on_connect_peer(cl->osd_num, 0, cl->client_id);
+        osd_peer_fds[cl->osd_num] = cl->peer_fd;
+        on_connect_peer(cl->osd_num, cl->peer_fd);
         delete op;
     };
     outbox_push(op);
@@ -740,16 +771,13 @@ void osd_messenger_t::accept_connections(int listen_fd)
     while ((peer_fd = accept(listen_fd, (sockaddr*)&addr, &peer_addr_size)) >= 0)
     {
         assert(peer_fd != 0);
-        const uint64_t client_id = next_client_id++;
-        fprintf(stderr, "[OSD %ju] new client %ju (FD %d): connection from %s\n", this->osd_num, client_id, peer_fd,
+        fprintf(stderr, "[OSD %ju] new client %d: connection from %s\n", this->osd_num, peer_fd,
             addr_to_string(addr).c_str());
         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));
         auto cl = new osd_client_t();
-        cl->client_id = client_id;
-        clients[cl->client_id] = cl;
-        clients_by_fd[peer_fd] = cl;
+        clients[peer_fd] = cl;
         cl->is_incoming = true;
         cl->peer_addr = addr;
         cl->peer_addr = addr;
@@ -757,7 +785,6 @@ void osd_messenger_t::accept_connections(int listen_fd)
         cl->peer_fd = peer_fd;
         cl->peer_state = PEER_CONNECTED;
         cl->in_buf = (uint8_t*)malloc_or_die(receive_buffer_size);
-        init_tls_client(cl);
         // Add FD to epoll
         tfd->set_fd_handler(peer_fd, false, [this](int peer_fd, int epoll_events)
         {
@@ -800,11 +827,6 @@ bool osd_messenger_t::is_use_rdmacm()
 }
 #endif
 
-bool osd_messenger_t::is_encryption_enabled()
-{
-    return tls_cert != "" || tls_key != "" || osd_tls_ca != "";
-}
-
 json11::Json::object osd_messenger_t::read_config(const json11::Json & config)
 {
     json11::Json::object file_config;

src/client/messenger.h

@@ -12,20 +12,11 @@
 #include <deque>
 #include <vector>
 
-#include <openssl/types.h>
-
-#ifdef WITH_ISAL_CRYPTO
-#include <isa-l_crypto/aes_gcm.h>
-#endif
-
-#include "../util/xxh_x86dispatch.h"
-#include "../util/robin_hood.h"
 #include "malloc_or_die.h"
 #include "json11/json11.hpp"
 #include "msgr_op.h"
 #include "timerfd_manager.h"
 #include "addr_util.h"
-#include "msgr_handshake.h"
 #include <ringloop.h>
 
 #define CL_READ_HDR 1
@@ -39,20 +30,10 @@
 #define PEER_RDMA 4
 #define PEER_STOPPED 5
 
-#define MSGR_CSUM_PAYLOAD 1
-#define MSGR_CSUM_FULL 2
-#define MSGR_CSUM_GCM 4
-#define MSGR_CSUM_NEG 8
-
 #define VITASTOR_CONFIG_PATH "/etc/vitastor/vitastor.conf"
 
 #define DEFAULT_MIN_ZEROCOPY_SEND_SIZE 32*1024
 
-#define AES_256_GCM_KEY_SIZE 32
-#define AES_256_GCM_IV_SIZE 12
-
-#define MAX_SIMPLE_PAYLOAD_SIZE 1048576
-
 struct msgr_sendp_t
 {
     osd_op_t *op;
@@ -69,11 +50,8 @@ struct op_aes_xts_decrypt_t;
 void destroy_aes_xts_encrypt(op_aes_xts_encrypt_t *encrypt_ctx);
 void destroy_aes_xts_decrypt(op_aes_xts_decrypt_t *decrypt_ctx);
 
-struct user_info_t;
-
 struct osd_client_t
 {
-    uint64_t client_id = 0;
     int refs = 0;
 
     sockaddr_storage peer_addr = {};
@@ -93,27 +71,7 @@ struct osd_client_t
     msgr_rdma_connection_t *rdma_conn = NULL;
 #endif
 
-    bool gcm_enabled = false;
-    msgr_handshake_i *hs = NULL;
-    msgr_handshake_result_t hs_result;
-    std::shared_ptr<user_info_t> user_info;
-    std::vector<uint8_t> my_key, peer_key;
-    uint64_t my_iv_ctr = 0, peer_iv_ctr = 0;
-#ifdef WITH_ISAL_CRYPTO
-    isal_gcm_key_data my_key_isal, peer_key_isal;
-    isal_gcm_context_data *enc_ctx = NULL;
-    isal_gcm_context_data *dec_ctx = NULL;
-#else
-    EVP_CIPHER_CTX *enc_ctx = NULL;
-    EVP_CIPHER_CTX *dec_ctx = NULL;
-#endif
-    uint8_t enc_tag[16];
-    size_t enc_tag_size = 0;
-    uint8_t dec_tag[16];
-    size_t dec_tag_size = 0;
-
     // Read state
-    bool io_error = false;
     int read_ready = 0;
     osd_op_t *read_op = NULL;
     size_t read_op_size = 0;
@@ -121,21 +79,19 @@ struct osd_client_t
     iovec read_iov = { 0 };
     msghdr read_msg = { 0 };
     std::vector<iovec> recv_list;
-    std::vector<int> recv_flags;
+    size_t recv_list_size = 0;
     uint64_t read_op_id = 1;
     bool check_sequencing = false;
     bool enable_pg_locks = false;
-    op_aes_xts_decrypt_t *xts_dec_ctx = NULL;
+    op_aes_xts_decrypt_t *decrypt_ctx = NULL;
     size_t read_op_inline_decrypt_pos = 0;
     size_t read_op_inline_decrypt_in = 0;
-    int proto_csum_status = 0;
-    XXH3_state_t* read_csum_state = NULL;
 
     // Incoming operations
     std::vector<osd_op_t*> received_ops;
 
     // Outbound operations
-    robin_hood::unordered_flat_map<uint64_t, osd_op_t*> sent_ops;
+    std::map<uint64_t, osd_op_t*> sent_ops;
     uint64_t send_op_id = 0;
 
     // PGs dirtied by this client's primary-writes
@@ -151,8 +107,7 @@ struct osd_client_t
     size_t send_list_size = 0;
     std::deque<osd_op_t*> send_free_ops;
     std::vector<osd_op_t*> zc_free_list;
-    op_aes_xts_encrypt_t *xts_enc_ctx = NULL;
-    XXH3_state_t* write_csum_state = NULL;
+    op_aes_xts_encrypt_t *encrypt_ctx = NULL;
 
     ~osd_client_t();
     void cancel_ops();
@@ -183,7 +138,43 @@ struct osd_op_stats_t
     uint64_t subop_stat_count[OSD_OP_MAX+1] = { 0 };
 };
 
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+
+#ifdef __MOCK__
 class msgr_iothread_t;
+#else
+struct iothread_sqe_t
+{
+    io_uring_sqe sqe;
+    ring_data_t data;
+};
+
+class msgr_iothread_t
+{
+protected:
+    ring_loop_t ring;
+    ring_loop_t *outer_loop = NULL;
+    ring_data_t *outer_loop_data = NULL;
+    int eventfd = -1;
+    bool stopped = false;
+    std::mutex mu;
+    std::condition_variable cond;
+    std::vector<iothread_sqe_t> queue;
+    std::thread thread;
+
+    void run();
+public:
+
+    msgr_iothread_t();
+    ~msgr_iothread_t();
+
+    void add_sqe(io_uring_sqe & sqe);
+    void stop();
+    void add_to_ringloop(ring_loop_t *outer_loop);
+};
+#endif
 
 #ifdef WITH_RDMA
 struct rdma_event_channel;
@@ -194,19 +185,9 @@ struct osd_messenger_t;
 struct rdmacm_connecting_t;
 #endif
 
-class msgr_op_reader_t;
-class msgr_op_writer_t;
-
 struct __attribute__((visibility("default"))) osd_messenger_t
 {
 protected:
-    friend class copy_op_reader_t;
-    friend class gcm_op_reader_t;
-    friend class get_op_reader_t;
-    friend class copy_op_writer_t;
-    friend class gcm_op_writer_t;
-    friend class get_op_writer_t;
-
     int keepalive_timer_id = -1;
 
     uint32_t receive_buffer_size = 0;
@@ -218,12 +199,7 @@ protected:
     bool use_sync_send_recv = false;
     int min_zerocopy_send_size = DEFAULT_MIN_ZEROCOPY_SEND_SIZE;
     int iothread_count = 0;
-    int max_cipher_pool_size = 256;
-
-    std::string tls_cert;
-    std::string tls_key;
-    std::string osd_tls_ca;
-    std::string client_tls_ca;
+    int max_aes_xts_pool_size = 256;
 
 #ifdef WITH_RDMA
     bool use_rdma = true;
@@ -237,77 +213,49 @@ protected:
     uint64_t rdma_max_sge = 0, rdma_max_send = 0, rdma_max_recv = 0;
     uint64_t rdma_max_msg = 0;
     rdma_event_channel *rdmacm_evch = NULL;
-    robin_hood::unordered_flat_map<rdma_cm_id*, osd_client_t*> rdmacm_connections;
-    robin_hood::unordered_flat_map<rdma_cm_id*, rdmacm_connecting_t*> rdmacm_connecting;
+    std::map<rdma_cm_id*, osd_client_t*> rdmacm_connections;
+    std::map<rdma_cm_id*, rdmacm_connecting_t*> rdmacm_connecting;
 #endif
 
-    bool gcm_enabled = false;
-    msgr_handshake_ctx_i *hs_ctx = NULL;
-
-    void init_tls();
-    void destroy_tls();
-    void init_tls_client(osd_client_t *cl);
-    bool do_tls_handshake(osd_client_t *cl, bool from_recv = false);
-    bool derive_aes_keys(osd_client_t *cl, bool update_my, bool update_peer);
-
     std::vector<msgr_iothread_t*> iothreads;
-    std::vector<uint64_t> read_ready_clients;
-    std::vector<uint64_t> write_ready_clients;
+    std::vector<int> read_ready_clients;
+    std::vector<int> write_ready_clients;
     // We don't use ringloop->set_immediate here because we may have no ringloop in client :)
     std::deque<osd_op_t*> set_immediate_ops;
 
-    std::vector<op_aes_xts_encrypt_t*> encrypt_xts_pool;
-    std::vector<op_aes_xts_decrypt_t*> decrypt_xts_pool;
-
-#ifdef WITH_ISAL_CRYPTO
-    std::vector<isal_gcm_context_data*> encrypt_gcm_pool;
-    std::vector<isal_gcm_context_data*> decrypt_gcm_pool;
-#else
-    std::vector<EVP_CIPHER_CTX*> encrypt_gcm_pool;
-    std::vector<EVP_CIPHER_CTX*> decrypt_gcm_pool;
-#endif
+    std::vector<op_aes_xts_encrypt_t*> encrypt_ctx_pool;
+    std::vector<op_aes_xts_decrypt_t*> decrypt_ctx_pool;
 
 public:
     timerfd_manager_t *tfd = NULL;
-    ring_loop_i *ringloop = NULL;
+    ring_loop_t *ringloop = NULL;
     bool has_sendmsg_zc = false;
-    uint64_t next_client_id = 1;
-    // osd_num = 0 for client messenger, osd_num > 0 for OSD messenger
-    osd_num_t osd_num = 0;
-    uint32_t clean_entry_bitmap_size = 0;
-    uint32_t bs_block_size = 0;
-    uint32_t max_write_request_size = 0;
-    robin_hood::unordered_flat_map<uint64_t, osd_client_t*> clients;
-    robin_hood::unordered_flat_map<uint64_t, osd_client_t*> osd_peers;
-    robin_hood::unordered_flat_map<int, osd_client_t*> clients_by_fd;
-    robin_hood::unordered_flat_map<osd_num_t, osd_wanted_peer_t> wanted_peers;
+    // osd_num_t is only for logging and asserts
+    osd_num_t osd_num;
+    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;
     std::vector<std::string> osd_networks;
     std::vector<addr_mask_t> osd_network_masks;
     std::vector<std::string> osd_cluster_networks;
     std::vector<addr_mask_t> osd_cluster_network_masks;
     std::vector<std::string> all_osd_networks;
     std::vector<addr_mask_t> all_osd_network_masks;
-    int use_proto_checksums = 0;
-    int force_proto_checksums = 0;
     // op statistics
     osd_op_stats_t stats, recovery_stats;
 
     void init();
-    void init_iothreads();
-    void parse_config(const json11::Json & config, bool init);
+    void parse_config(const json11::Json & config);
     void connect_peer(uint64_t osd_num, json11::Json peer_state);
-    void stop_client(uint64_t client_id, bool force_delete = false);
-    void destroy_client(osd_client_t *cl);
+    void stop_client(int peer_fd, bool force = false, bool force_delete = false);
     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;
-    std::function<void(osd_client_t*)> handshake_hook;
     void read_requests();
     void send_replies();
     void accept_connections(int listen_fd);
-    void destroy_iothreads();
     ~osd_messenger_t();
 
     static json11::Json::object read_config(const json11::Json & config);
@@ -318,14 +266,13 @@ public:
 
 #ifdef WITH_RDMA
     bool is_rdma_enabled();
-    bool connect_rdma(uint64_t client_id, std::string rdma_address, uint64_t client_max_msg);
+    bool connect_rdma(int peer_fd, std::string rdma_address, uint64_t client_max_msg);
 #endif
 #ifdef WITH_RDMACM
     bool is_use_rdmacm();
     rdma_cm_id *rdmacm_listen(const std::string & bind_address, int rdmacm_port, int *bound_port, int log_level);
     void rdmacm_destroy_listener(rdma_cm_id *listener);
 #endif
-    bool is_encryption_enabled();
 
     void inc_op_stats(osd_op_stats_t & stats, uint64_t opcode, timespec & tv_begin, timespec & tv_end, uint64_t len);
     void measure_exec(osd_op_t *cur_op);
@@ -335,43 +282,44 @@ protected:
     void try_connect_peer_tcp(osd_num_t peer_osd, const char *peer_host, int peer_port);
     void handle_peer_epoll(int peer_fd, int epoll_events);
     void handle_connect_epoll(int peer_fd);
-    void on_connect_peer(osd_num_t peer_osd, int errcode, uint64_t client_id);
+    void on_connect_peer(osd_num_t peer_osd, int peer_fd);
     void check_peer_config(osd_client_t *cl);
     void cancel_osd_ops(osd_client_t *cl);
     void cancel_op(osd_op_t *op);
 
     bool try_send(osd_client_t *cl);
     void handle_send(int result, bool prev, bool more, osd_client_t *cl);
-    bool op_write_to(osd_client_t *cl, msgr_op_writer_t & wr);
-    void next_write_op(osd_client_t *cl);
-    bool op_write_buf(osd_client_t *cl, uint8_t *src, size_t src_len, uint8_t *dst, size_t dst_len, bool skip_csum, size_t & from, size_t & done);
-    bool op_copy_data_to(osd_client_t *cl, uint8_t *dst, size_t dst_len, size_t & from, size_t & done);
-    size_t copy_ops_to(osd_client_t *cl, uint8_t *dst, size_t dst_len);
-    template<typename T> size_t copy_ops_to_with(osd_client_t *cl, uint8_t *dst, size_t dst_len);
+    size_t op_copy_to(osd_client_t *cl, uint8_t *dst, size_t dst_len);
+    void op_get_write_buffers(osd_client_t *cl, std::vector<iovec> & lst);
 
     void handle_read(int result, osd_client_t *cl);
     bool handle_read_buffer(osd_client_t *cl, uint8_t *curbuf, size_t bufsize);
-    template<typename T> bool handle_buffer_with(osd_client_t *cl, uint8_t *curbuf, size_t bufsize);
     bool handle_hdr(osd_client_t *cl);
     bool allocate_op_buffers(osd_client_t *cl);
     bool allocate_reply_buffers(osd_client_t *cl, osd_op_t *op);
-    bool op_read_from(osd_client_t *cl, msgr_op_reader_t & rdr);
-    bool handle_finished_op(osd_client_t *cl);
-    void handle_immediate_ops();
+    size_t op_copy_from(osd_client_t *cl, uint8_t *src, size_t src_len, size_t & done);
+    size_t op_get_read_buffers(osd_client_t *cl, std::vector<iovec> & lst);
+    void handle_finished_op(osd_client_t *cl);
 
-    void op_encrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc);
-    void op_encrypt_free(osd_client_t* cl);
-    void op_decrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc);
+    bool op_encrypted_copy_data_to(osd_client_t* cl, uint8_t *buf, size_t len, size_t from, size_t & done);
+    bool op_decrypted_copy_data_from(osd_client_t* cl, uint8_t *buf, size_t len, size_t from, size_t & done);
     void op_decrypt_start(osd_client_t* cl);
     void op_decrypt_inline(osd_client_t* cl);
     void op_decrypt_free(osd_client_t* cl);
 
+    bool handle_finished_read(osd_client_t *cl);
+    void handle_op_hdr(osd_client_t *cl);
+    bool handle_reply_hdr(osd_client_t *cl);
+    void handle_reply_ready(osd_op_t *op);
+    void handle_immediate_ops();
+    void clear_immediate_ops(int peer_fd);
+
 #ifdef WITH_RDMA
     void try_send_rdma(osd_client_t *cl);
+    int try_send_rdma_copy(osd_client_t *cl, uint8_t *dst, int dst_len);
     bool init_recv_rdma(osd_client_t *cl);
     void handle_rdma_events(msgr_rdma_context_t *rdma_context);
     msgr_rdma_context_t* choose_rdma_context(osd_client_t *cl);
-    void destroy_rdma_conn(msgr_rdma_connection_t *rdma_conn);
 #endif
 #ifdef WITH_RDMACM
     void handle_rdmacm_events();

src/client/msgr_encrypt.cpp

@@ -3,23 +3,13 @@
 
 #include <assert.h>
 
-#ifdef WITH_ISAL_CRYPTO
-#include <isa-l_crypto/isal_crypto_api.h>
-#endif
-
-#include "str_util.h"
 #include "etcd_state_client.h"
 #include "messenger.h"
 #include "msgr_encrypt.h"
-#include "http_client.h"
-#include "openssl_util.h"
-
-#include <openssl/ssl.h>
-#include <openssl/err.h>
 
 op_aes_xts_encrypt_t::op_aes_xts_encrypt_t()
 {
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     if (!(ctx = EVP_CIPHER_CTX_new()))
     {
         ERR_print_errors_fp(stderr);
@@ -31,23 +21,25 @@ op_aes_xts_encrypt_t::op_aes_xts_encrypt_t()
         ERR_print_errors_fp(stderr);
         abort();
     }
+#else
+    fprintf(stderr, "Error: Vitastor is built without encryption support\n");
+    abort();
 #endif
 }
 
 op_aes_xts_encrypt_t::~op_aes_xts_encrypt_t()
 {
     assert(!encrypted);
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     EVP_CIPHER_CTX_free(ctx);
 #endif
     if (tmp)
         free(tmp);
 }
 
-void op_aes_xts_encrypt_t::start(osd_client_t *cl, uint8_t *key, uint64_t start_offset, size_t block_size)
+void op_aes_xts_encrypt_t::start(uint8_t *key, uint64_t start_offset, size_t block_size)
 {
     assert(!encrypted);
-    this->cl = cl;
     this->start_offset = start_offset;
     this->key = key;
     this->block_size = block_size;
@@ -60,7 +52,7 @@ void op_aes_xts_encrypt_t::start(osd_client_t *cl, uint8_t *key, uint64_t start_
         tmp = NULL;
         tmp_size = 0;
     }
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     if (EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL) != 1)
     {
         ERR_print_errors_fp(stderr);
@@ -71,12 +63,9 @@ void op_aes_xts_encrypt_t::start(osd_client_t *cl, uint8_t *key, uint64_t start_
 
 void op_aes_xts_encrypt_t::encrypt_block(uint8_t *in, uint8_t *out)
 {
+#ifdef WITH_OPENSSL
     uint8_t iv[16] = { 0 };
     *((uint64_t*)iv) = start_offset + offset - offset%block_size;
-#ifdef WITH_ISAL_CRYPTO
-    int r = isal_aes_xts_enc_256(key+32, key, iv, block_size, in, out);
-    assert(r == 0 || r == ISAL_CRYPTO_ERR_XTS_SAME_KEYS);
-#else
     if (EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv) != 1)
     {
         ERR_print_errors_fp(stderr);
@@ -92,28 +81,7 @@ void op_aes_xts_encrypt_t::encrypt_block(uint8_t *in, uint8_t *out)
 #endif
 }
 
-static inline void copy_or_gcm(osd_client_t *cl, uint8_t *out, uint8_t *in, size_t n)
-{
-    if (cl->proto_csum_status != MSGR_CSUM_GCM)
-        memcpy(out, in, n);
-    else
-    {
-#ifdef WITH_ISAL_CRYPTO
-        int r = isal_aes_gcm_enc_256_update(&cl->my_key_isal, cl->enc_ctx, out, in, n);
-        assert(!r);
-#else
-        int actual_out;
-        if (EVP_EncryptUpdate(cl->enc_ctx, out, &actual_out, in, n) != 1)
-        {
-            fprintf(stderr, "EncryptUpdate error: ");
-            ERR_print_errors_fp(stderr);
-            abort();
-        }
-        assert(actual_out == n);
-#endif
-    }
-}
-
+// FIXME: Copy-paste
 void op_aes_xts_encrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out)
 {
     // Fucking AES-XTS implementations (all of them) don't have streaming support,
@@ -127,14 +95,11 @@ void op_aes_xts_encrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
         assert(tmp);
         if (max_out > block_size - tmp_pos)
             max_out = block_size - tmp_pos;
-        copy_or_gcm(cl, out, tmp + tmp_pos, max_out);
+        memcpy(out, tmp + tmp_pos, max_out);
         done_out += max_out;
         tmp_pos += max_out;
         if (tmp_pos >= block_size)
-        {
             encrypted = false;
-            done_in += 1;
-        }
     }
     else if (max_in < block_size - offset%block_size)
     {
@@ -160,9 +125,9 @@ void op_aes_xts_encrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
         memcpy(tmp + offset%block_size, in, max_in);
         encrypt_block(tmp, tmp);
         encrypted = true;
-        copy_or_gcm(cl, out, tmp, max_out);
+        memcpy(out, tmp, max_out);
         tmp_pos = max_out;
-        done_in += max_in-1;
+        done_in += max_in;
         offset += max_in;
         done_out += max_out;
     }
@@ -170,8 +135,6 @@ void op_aes_xts_encrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
     {
         // Full block - simplest case
         encrypt_block(in, out);
-        if (cl->proto_csum_status == MSGR_CSUM_GCM)
-            copy_or_gcm(cl, out, out, block_size);
         done_in += block_size;
         offset += block_size;
         done_out += block_size;
@@ -183,8 +146,6 @@ void op_aes_xts_encrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
         max_in = block_size - offset%block_size;
         memcpy(tmp + offset%block_size, in, max_in);
         encrypt_block(tmp, out);
-        if (cl->proto_csum_status == MSGR_CSUM_GCM)
-            copy_or_gcm(cl, out, out, block_size);
         done_in += max_in;
         offset += max_in;
         done_out += block_size;
@@ -198,7 +159,7 @@ void destroy_aes_xts_encrypt(op_aes_xts_encrypt_t *encrypt_ctx)
 
 op_aes_xts_decrypt_t::op_aes_xts_decrypt_t()
 {
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     if (!(ctx = EVP_CIPHER_CTX_new()))
     {
         ERR_print_errors_fp(stderr);
@@ -210,28 +171,29 @@ op_aes_xts_decrypt_t::op_aes_xts_decrypt_t()
         ERR_print_errors_fp(stderr);
         abort();
     }
+#else
+    fprintf(stderr, "Error: Vitastor is built without encryption support\n");
+    abort();
 #endif
 }
 
 op_aes_xts_decrypt_t::~op_aes_xts_decrypt_t()
 {
     assert(!decrypted);
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     EVP_CIPHER_CTX_free(ctx);
 #endif
     if (tmp)
         free(tmp);
 }
 
-void op_aes_xts_decrypt_t::start(osd_client_t *cl, uint8_t **key_chain, size_t chain_size, void *key_indexes, uint64_t start_offset, size_t block_size)
+void op_aes_xts_decrypt_t::start(uint8_t **key_chain, size_t chain_size, uint8_t *key_indexes, uint64_t start_offset, size_t block_size)
 {
     assert(!decrypted);
-    this->cl = cl;
     this->start_offset = start_offset;
-    this->key_chain = key_chain;
-    this->chain_size = chain_size;
-    this->key_indexes = key_indexes;
-    this->key_index_bytes = osd_op_rw_t::chain_info_bytes(chain_size);
+    this->key_chain = chain_size > 1 ? key_chain : 0;
+    this->chain_size = chain_size > 1 ? chain_size : 0;
+    this->key_indexes = chain_size > 1 ? key_indexes : NULL;
     assert(chain_size <= 1 || key_indexes != NULL);
     this->block_size = block_size;
     this->offset = 0;
@@ -242,7 +204,7 @@ void op_aes_xts_decrypt_t::start(osd_client_t *cl, uint8_t **key_chain, size_t c
         tmp = NULL;
         tmp_size = 0;
     }
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     if (chain_size == 1 && key_chain[0] && EVP_DecryptInit_ex(ctx, NULL, NULL, key_chain[0], NULL) != 1)
     {
         ERR_print_errors_fp(stderr);
@@ -254,35 +216,21 @@ void op_aes_xts_decrypt_t::start(osd_client_t *cl, uint8_t **key_chain, size_t c
 void op_aes_xts_decrypt_t::decrypt_block(uint8_t *in, uint8_t *out)
 {
     uint8_t *key = NULL;
-    if (chain_size > 1)
+    if (chain_size)
     {
-        uint32_t key_index = key_index_bytes == 1
-            ? ((uint8_t*)key_indexes)[offset/block_size]
-            : (key_index_bytes == 2
-                ? ((uint16_t*)key_indexes)[offset/block_size]
-                : (key_index_bytes == 4
-                    ? ((uint32_t*)key_indexes)[offset/block_size]
-                    : UINT32_MAX));
-        assert(key_index < chain_size);
-        key = key_chain[key_index];
-    }
-    else
-    {
-        key = key_chain[0];
-    }
-    if (!key)
-    {
-        if (in != out)
-            memcpy(out, in, block_size);
-        return;
+        assert(key_indexes[offset/block_size] < chain_size);
+        key = key_chain[key_indexes[offset/block_size]];
+        if (!key)
+        {
+            if (in != out)
+                memcpy(out, in, block_size);
+            return;
+        }
     }
+#ifdef WITH_OPENSSL
     uint8_t iv[16] = { 0 };
     *((uint64_t*)iv) = start_offset + offset - offset%block_size;
-#ifdef WITH_ISAL_CRYPTO
-    int r = isal_aes_xts_dec_256(key+32, key, iv, block_size, in, out);
-    assert(r == 0 || r == ISAL_CRYPTO_ERR_XTS_SAME_KEYS);
-#else
-    if (EVP_DecryptInit_ex(ctx, NULL, NULL, chain_size == 1 ? NULL : key, iv) != 1)
+    if (EVP_DecryptInit_ex(ctx, NULL, NULL, key, iv) != 1)
     {
         ERR_print_errors_fp(stderr);
         abort();
@@ -297,25 +245,6 @@ void op_aes_xts_decrypt_t::decrypt_block(uint8_t *in, uint8_t *out)
 #endif
 }
 
-static inline void gcm_dec(osd_client_t *cl, uint8_t *out, uint8_t *in, size_t n)
-{
-#ifdef WITH_ISAL_CRYPTO
-    int r = isal_aes_gcm_dec_256_update(&cl->peer_key_isal, cl->dec_ctx, out, in, n);
-    assert(!r);
-#else
-    int actual_out;
-    if (EVP_DecryptUpdate(cl->dec_ctx, out, &actual_out, in, n) != 1)
-    {
-        fprintf(stderr, "DecryptUpdate error: ");
-        ERR_print_errors_fp(stderr);
-        abort();
-    }
-    assert(actual_out == n);
-#endif
-}
-
-// out may be NULL, in this case all input is still decrypted to calculate checksums,
-// but part of it is skipped and not copied to out
 void op_aes_xts_decrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out)
 {
     // Fucking AES-XTS implementations (all of them) don't have streaming support,
@@ -329,15 +258,11 @@ void op_aes_xts_decrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
         assert(tmp);
         if (max_out > block_size - tmp_pos)
             max_out = block_size - tmp_pos;
-        if (out)
-            memcpy(out, tmp + tmp_pos, max_out);
+        memcpy(out, tmp + tmp_pos, max_out);
         done_out += max_out;
         tmp_pos += max_out;
         if (tmp_pos >= block_size)
-        {
             decrypted = false;
-            done_in += 1;
-        }
     }
     else if (max_in < block_size - offset%block_size)
     {
@@ -351,7 +276,7 @@ void op_aes_xts_decrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
         done_in += max_in;
         offset += max_in;
     }
-    else if (max_out < block_size || !out)
+    else if (max_out < block_size)
     {
         // Accumulate and decrypt input in <tmp>, then copy part of it to <out>
         if (!tmp)
@@ -361,33 +286,18 @@ void op_aes_xts_decrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
         }
         max_in = block_size - offset%block_size;
         memcpy(tmp + offset%block_size, in, max_in);
-        if (cl->proto_csum_status == MSGR_CSUM_GCM)
-            gcm_dec(cl, tmp, tmp, block_size);
         decrypt_block(tmp, tmp);
         decrypted = true;
-        if (out)
-            memcpy(out, tmp, max_out);
+        memcpy(out, tmp, max_out);
         tmp_pos = max_out;
-        done_in += max_in-1;
+        done_in += max_in;
         offset += max_in;
         done_out += max_out;
     }
     else if (!(offset%block_size))
     {
         // Full block - simplest case
-        if (cl->proto_csum_status == MSGR_CSUM_GCM)
-        {
-            if (!tmp)
-            {
-                tmp = (uint8_t*)malloc_or_die(block_size);
-                tmp_size = block_size;
-            }
-            gcm_dec(cl, tmp, in, block_size);
-            if (out)
-                decrypt_block(tmp, out);
-        }
-        else
-            decrypt_block(in, out);
+        decrypt_block(in, out);
         done_in += block_size;
         offset += block_size;
         done_out += block_size;
@@ -398,9 +308,6 @@ void op_aes_xts_decrypt_t::update(uint8_t *in, size_t max_in, uint8_t *out, size
         assert(tmp);
         max_in = block_size - offset%block_size;
         memcpy(tmp + offset%block_size, in, max_in);
-        assert(out);
-        if (cl->proto_csum_status == MSGR_CSUM_GCM)
-            gcm_dec(cl, tmp, tmp, block_size);
         decrypt_block(tmp, out);
         done_in += max_in;
         offset += max_in;
@@ -413,65 +320,96 @@ void destroy_aes_xts_decrypt(op_aes_xts_decrypt_t *decrypt_ctx)
     delete decrypt_ctx;
 }
 
-void osd_messenger_t::op_encrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc)
+bool osd_messenger_t::op_encrypted_copy_data_to(osd_client_t* cl, uint8_t *enc_buf, size_t enc_len, size_t from, size_t & done)
 {
-    if (!cl->xts_enc_ctx)
+    auto op = cl->write_op;
+    auto & op_pos = cl->write_op_pos;
+    assert(op->req.hdr.opcode == OSD_OP_WRITE);
+    if (!from)
     {
-        if (encrypt_xts_pool.size())
+        if (!cl->encrypt_ctx)
         {
-            cl->xts_enc_ctx = encrypt_xts_pool.back();
-            encrypt_xts_pool.pop_back();
+            if (encrypt_ctx_pool.size())
+            {
+                cl->encrypt_ctx = encrypt_ctx_pool.back();
+                encrypt_ctx_pool.pop_back();
+            }
+            else
+                cl->encrypt_ctx = new op_aes_xts_encrypt_t();
         }
-        else
-            cl->xts_enc_ctx = new op_aes_xts_encrypt_t();
-        assert(cl->write_op->enc->key_chain[0]);
-        cl->xts_enc_ctx->start(cl, cl->write_op->enc->key_chain[0], cl->write_op->req.rw.offset, cl->write_op->enc->bitmap_granularity);
+        assert(op->enc->key_chain[0]);
+        cl->encrypt_ctx->start(op->enc->key_chain[0], op->req.rw.offset, op->enc->bitmap_granularity);
     }
-    while (done_plain < plain_len && done_enc < enc_len)
+    for (int i = 0; i < op->iov.count; i++)
     {
-        size_t done_in = 0;
-        size_t done_out = 0;
-        cl->xts_enc_ctx->update(plain+done_plain, plain_len-done_plain, enc_buf+done_enc, enc_len-done_enc, done_in, done_out);
-        if (cl->write_csum_state && done_out > 0)
-            XXH3_64bits_update(cl->write_csum_state, enc_buf+done_enc, done_out);
-        done_enc += done_out;
-        cl->write_op_pos += done_in;
-        done_plain += done_in;
+        uint8_t *plain = (uint8_t*)op->iov.buf[i].iov_base;
+        size_t plain_len = op->iov.buf[i].iov_len;
+        while (from < plain_len || cl->encrypt_ctx->has_buffered())
+        {
+            if (done >= enc_len)
+                return false;
+            size_t done_in = 0;
+            size_t done_out = 0;
+            cl->encrypt_ctx->update(plain+from, plain_len-from, enc_buf+done, enc_len-done, done_in, done_out);
+            done += done_out;
+            op_pos += done_in;
+            from += done_in;
+        }
+        from -= plain_len;
     }
+    if (cl->encrypt_ctx)
+    {
+        if (encrypt_ctx_pool.size() > max_aes_xts_pool_size)
+            delete cl->encrypt_ctx;
+        else
+            encrypt_ctx_pool.push_back(cl->encrypt_ctx);
+        cl->encrypt_ctx = NULL;
+    }
+    return true;
 }
 
-void osd_messenger_t::op_decrypted_copy_buf(osd_client_t *cl, uint8_t *enc_buf, size_t enc_len, uint8_t *plain, size_t plain_len, size_t & done_plain, size_t & done_enc)
+bool osd_messenger_t::op_decrypted_copy_data_from(osd_client_t* cl, uint8_t *enc_buf, size_t enc_len, size_t from, size_t & done)
 {
     op_decrypt_start(cl);
-    while (done_plain < plain_len && done_enc < enc_len)
+    auto op = cl->read_op;
+    assert(op->req.hdr.opcode == OSD_OP_READ);
+    for (int i = 0; i < op->iov.count; i++)
     {
-        size_t done_in = 0;
-        size_t done_out = 0;
-        // plain == NULL means skip output
-        cl->xts_dec_ctx->update(enc_buf+done_enc, enc_len-done_enc, plain ? plain+done_plain : NULL, plain_len-done_plain, done_in, done_out);
-        if (cl->read_csum_state && done_in > 0)
-            XXH3_64bits_update(cl->read_csum_state, enc_buf+done_enc, done_in);
-        done_enc += done_in;
-        cl->read_op_pos += done_out;
-        cl->read_op_inline_decrypt_in += done_in;
-        done_plain += done_out;
+        uint8_t *plain = (uint8_t*)op->iov.buf[i].iov_base;
+        size_t plain_len = op->iov.buf[i].iov_len;
+        while (from < plain_len)
+        {
+            if (done >= enc_len)
+                return false;
+            size_t done_in = 0;
+            size_t done_out = 0;
+            cl->decrypt_ctx->update(enc_buf+done, enc_len-done, plain+from, plain_len-from, done_in, done_out);
+            done += done_in;
+            cl->read_op_pos += done_out;
+            cl->read_op_inline_decrypt_in += done_in;
+            from += done_out;
+            if (!done_out)
+                return false;
+        }
+        from -= plain_len;
     }
+    op_decrypt_free(cl);
+    return true;
 }
 
 void osd_messenger_t::op_decrypt_start(osd_client_t* cl)
 {
-    if (!cl->xts_dec_ctx)
+    if (!cl->decrypt_ctx)
     {
-        if (decrypt_xts_pool.size())
+        if (decrypt_ctx_pool.size())
         {
-            cl->xts_dec_ctx = decrypt_xts_pool.back();
-            decrypt_xts_pool.pop_back();
+            cl->decrypt_ctx = decrypt_ctx_pool.back();
+            decrypt_ctx_pool.pop_back();
         }
         else
-            cl->xts_dec_ctx = new op_aes_xts_decrypt_t();
+            cl->decrypt_ctx = new op_aes_xts_decrypt_t();
         auto & enc = cl->read_op->enc;
-        assert(cl->read_op->req.hdr.opcode == OSD_OP_READ);
-        cl->xts_dec_ctx->start(cl, enc->key_chain, enc->chain_size,
+        cl->decrypt_ctx->start(enc->key_chain, enc->chain_size,
             (cl->read_op->req.rw.flags & OSD_OP_RETURN_CHAIN) ? (uint8_t*)cl->read_op->bitmap + enc->read_chain_bitmap_pos : 0,
             cl->read_op->req.rw.offset, enc->bitmap_granularity);
     }
@@ -503,7 +441,7 @@ void osd_messenger_t::op_decrypt_inline(osd_client_t* cl)
         size_t out_len = op->iov.buf[j].iov_len - from_out;
         size_t done_in = 0;
         size_t done_out = 0;
-        cl->xts_dec_ctx->update(in, in_len, out, out_len, done_in, done_out);
+        cl->decrypt_ctx->update(in, in_len, out, out_len, done_in, done_out);
         if (done_in >= in_len)
         {
             i++;
@@ -520,142 +458,17 @@ void osd_messenger_t::op_decrypt_inline(osd_client_t* cl)
             from_out += done_out;
     }
     assert(j >= op->iov.count);
+    op_decrypt_free(cl);
 }
 
 void osd_messenger_t::op_decrypt_free(osd_client_t* cl)
 {
-    if (cl->xts_dec_ctx)
+    if (cl->decrypt_ctx)
     {
-        if (decrypt_xts_pool.size() > max_cipher_pool_size)
-            delete cl->xts_dec_ctx;
+        if (decrypt_ctx_pool.size() > max_aes_xts_pool_size)
+            delete cl->decrypt_ctx;
         else
-            decrypt_xts_pool.push_back(cl->xts_dec_ctx);
-        cl->xts_dec_ctx = NULL;
-    }
-}
-
-void osd_messenger_t::op_encrypt_free(osd_client_t* cl)
-{
-    if (cl->xts_enc_ctx)
-    {
-        if (encrypt_xts_pool.size() > max_cipher_pool_size)
-            delete cl->xts_enc_ctx;
-        else
-            encrypt_xts_pool.push_back(cl->xts_enc_ctx);
-        cl->xts_enc_ctx = NULL;
-    }
-}
-
-bool osd_messenger_t::derive_aes_keys(osd_client_t *cl, bool update_my, bool update_peer)
-{
-    if (!cl->hs_result.shared_secret.size())
-    {
-        cl->hs_result = cl->hs->get_result();
-        if (handshake_hook)
-        {
-            handshake_hook(cl);
-        }
-    }
-    std::vector<uint8_t> old_my = cl->my_key, old_peer = cl->peer_key;
-    // Both keys include AES key and iv + xxhash3 secret
-    const auto len = AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE + XXH_SECRET_DEFAULT_SIZE;
-    cl->my_key.resize(len);
-    cl->peer_key.resize(len);
-    bool ok = true;
-    if (update_my || !old_my.size())
-    {
-        ok = ok && hs_ctx->derive_kdf(cl->hs_result.shared_secret.data(), cl->hs_result.shared_secret.size(),
-            old_my.size() ? old_my.data() : NULL, old_my.size(),
-            cl->is_incoming ? "server key" : "client key", cl->my_key.data(), len);
-#ifdef WITH_ISAL_CRYPTO
-        if (ok)
-            isal_aes_gcm_pre_256(cl->my_key.data(), &cl->my_key_isal);
-#endif
-        cl->my_iv_ctr = 0;
-    }
-    if (update_peer || !old_peer.size())
-    {
-        ok = ok && hs_ctx->derive_kdf(cl->hs_result.shared_secret.data(), cl->hs_result.shared_secret.size(),
-            old_peer.size() ? old_peer.data() : NULL, old_peer.size(),
-            !cl->is_incoming ? "server key" : "client key", cl->peer_key.data(), len);
-#ifdef WITH_ISAL_CRYPTO
-        if (ok)
-            isal_aes_gcm_pre_256(cl->peer_key.data(), &cl->peer_key_isal);
-#endif
-        cl->peer_iv_ctr = 0;
-    }
-    return ok;
-}
-
-void osd_messenger_t::init_tls()
-{
-    if (!tls_cert.empty() || !tls_key.empty() || !osd_tls_ca.empty() || !client_tls_ca.empty())
-    {
-        if (tls_cert.empty() || tls_key.empty() || osd_tls_ca.empty() || osd_num && client_tls_ca.empty())
-        {
-            if (osd_num)
-                fprintf(stderr, "Vitastor transport encryption requires osd_cert, osd_pkey, osd_ca, client_ca options for OSDs\n");
-            else
-                fprintf(stderr, "Vitastor transport encryption requires cert, pkey and osd_ca options\n");
-            exit(1);
-        }
-        else
-        {
-#ifndef __MOCK__
-            gcm_enabled = true;
-            hs_ctx = msgr_handshake_ctx_i::create_ctx();
-            if (!hs_ctx->init(tls_cert, tls_key, osd_tls_ca, client_tls_ca))
-            {
-                fprintf(stderr, "Error: %s\n", hs_ctx->get_error().c_str());
-                exit(1);
-            }
-#endif
-        }
-    }
-}
-
-void osd_messenger_t::init_tls_client(osd_client_t *cl)
-{
-    if (gcm_enabled)
-    {
-        cl->gcm_enabled = true;
-        cl->hs = hs_ctx->create();
-        cl->hs->init(cl->is_incoming);
-        if (cl->hs->out_size())
-        {
-            if (cl->write_state == 0)
-            {
-                cl->write_state = CL_WRITE_READY;
-                write_ready_clients.push_back(cl->client_id);
-            }
-        }
-    }
-}
-
-void osd_messenger_t::destroy_tls()
-{
-#ifdef WITH_ISAL_CRYPTO
-    for (isal_gcm_context_data *ctx: encrypt_gcm_pool)
-    {
-        free(ctx);
-    }
-    for (isal_gcm_context_data *ctx: decrypt_gcm_pool)
-    {
-        free(ctx);
-    }
-#else
-    for (EVP_CIPHER_CTX *ctx: encrypt_gcm_pool)
-    {
-        EVP_CIPHER_CTX_free(ctx);
-    }
-    for (EVP_CIPHER_CTX *ctx: decrypt_gcm_pool)
-    {
-        EVP_CIPHER_CTX_free(ctx);
-    }
-#endif
-    if (hs_ctx)
-    {
-        delete hs_ctx;
-        hs_ctx = NULL;
+            decrypt_ctx_pool.push_back(cl->decrypt_ctx);
+        cl->decrypt_ctx = NULL;
     }
 }

src/client/msgr_encrypt.h

@@ -3,23 +3,18 @@
 
 #include <stdint.h>
 
-#ifdef WITH_ISAL_CRYPTO
-#include <isa-l_crypto/aes_xts.h>
-#endif
-
-#include "../util/xxh_x86dispatch.h"
+// WITH_OPENSSL is left to possibly support other crypto libraries
+#ifdef WITH_OPENSSL
 #include <openssl/conf.h>
 #include <openssl/evp.h>
 #include <openssl/err.h>
-
-struct osd_client_t;
+#endif
 
 class op_aes_xts_encrypt_t
 {
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     EVP_CIPHER_CTX *ctx = NULL;
 #endif
-    osd_client_t *cl = NULL;
     uint64_t start_offset = 0;
     uint8_t *key = NULL;
     size_t offset = 0;
@@ -35,7 +30,8 @@ public:
     op_aes_xts_encrypt_t();
     ~op_aes_xts_encrypt_t();
 
-    void start(osd_client_t *cl, uint8_t *key, uint64_t start_offset, size_t block_size);
+    inline bool has_buffered() { return encrypted; };
+    void start(uint8_t *key, uint64_t start_offset, size_t block_size);
     void update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out);
 };
 
@@ -43,15 +39,13 @@ void destroy_aes_xts_encrypt(op_aes_xts_encrypt_t *encrypt_ctx);
 
 class op_aes_xts_decrypt_t
 {
-#ifndef WITH_ISAL_CRYPTO
+#ifdef WITH_OPENSSL
     EVP_CIPHER_CTX *ctx = NULL;
 #endif
-    osd_client_t *cl = NULL;
     uint64_t start_offset = 0;
     uint8_t **key_chain = NULL;
     size_t chain_size = 0;
-    void *key_indexes = NULL;
-    int key_index_bytes = 0;
+    uint8_t *key_indexes = NULL;
     size_t offset = 0;
     size_t block_size = 0;
     uint8_t *tmp = NULL;
@@ -65,7 +59,8 @@ public:
     op_aes_xts_decrypt_t();
     ~op_aes_xts_decrypt_t();
 
-    void start(osd_client_t *cl, uint8_t **key_chain, size_t chain_size, void *key_indexes, uint64_t start_offset, size_t block_size);
+    inline bool has_buffered() { return decrypted; };
+    void start(uint8_t **key_chain, size_t chain_size, uint8_t *key_indexes, uint64_t start_offset, size_t block_size);
     void update(uint8_t *in, size_t max_in, uint8_t *out, size_t max_out, size_t & done_in, size_t & done_out);
 };
 

src/client/msgr_handshake.cpp

@@ -1,810 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2026+
-// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
-
-#include <stdint.h>
-#include <assert.h>
-
-#include <string>
-#include <vector>
-#include <memory>
-
-#include <openssl/conf.h>
-#include <openssl/evp.h>
-#include <openssl/obj_mac.h>
-#include <openssl/ec.h>
-#include <openssl/kdf.h>
-#include <openssl/bio.h>
-#include <openssl/pem.h>
-#include <openssl/err.h>
-
-#include "msgr_handshake.h"
-#include "malloc_or_die.h"
-#include "openssl_util.h"
-#include "str_util.h"
-
-#define AES_256_GCM_KEY_SIZE 32
-#define AES_256_GCM_IV_SIZE 12
-
-// TLS 1.3-like handshake
-
-// 1. Client->server: EC public key
-// 2. Server->client: EC public key, encrypted certificate and digital signature of the handshake
-// 3. Client->server: encrypted certificate and digital signature of the handshake
-
-// "vitaECDH" interleaved
-#define MSGR_HS_MAGIC 0x4861447443694576l
-#define MSGR_HS_MAX_LEN 131072
-
-#define MSGR_HS_SERVER_INIT 0
-#define MSGR_HS_CLIENT_INIT 1
-#define MSGR_HS_SERVER_REPLY 2
-#define MSGR_HS_CLIENT_REPLY 3
-#define MSGR_HS_DONE 100
-#define MSGR_HS_ERROR 101
-
-struct __attribute__((__packed__)) msgr_handshake_hdr_t
-{
-    uint32_t msg_len;
-    uint64_t magic;
-    uint32_t type;
-};
-
-class msgr_handshake_ctx_t: public msgr_handshake_ctx_i
-{
-    friend class msgr_handshake_t;
-
-    EVP_PKEY_CTX *pctx = NULL;
-    EVP_PKEY *params = NULL;
-    X509_STORE *ca = NULL;
-    X509 *osd_ca = NULL;
-    X509 *client_ca = NULL;
-    std::string my_cert_pem;
-    X509 *my_cert = NULL;
-    EVP_PKEY *my_pubkey = NULL;
-    const EVP_MD *md = NULL;
-    EVP_PKEY *my_privkey = NULL;
-    EVP_KDF_CTX* kdf_ctx = NULL;
-    std::string error;
-
-    bool on_error(const std::string & prefix);
-
-public:
-    ~msgr_handshake_ctx_t();
-    msgr_handshake_i* create() override;
-    bool init(const std::string & pem_cert, const std::string & pem_key,
-        const std::string & pem_osd_ca, const std::string & pem_client_ca) override;
-    std::string get_error() override;
-    bool derive_kdf(const uint8_t* insecret, size_t insecret_len,
-        const uint8_t* salt, size_t salt_len, const char *label, uint8_t *outsecret, size_t outsize) override;
-};
-
-class msgr_handshake_t: public msgr_handshake_i
-{
-    msgr_handshake_ctx_t *ctx = NULL;
-    bool is_server = false;
-
-    std::vector<uint8_t> full_handshake;
-    std::vector<uint8_t> in_buf;
-    uint8_t *out_buf = NULL;
-    size_t out_buf_size = 0;
-    std::string error;
-
-    int state = 0;
-
-    EVP_PKEY *ec_key = NULL;
-    X509 *peer_cert = NULL;
-    bool peer_is_osd = false;
-    std::vector<uint8_t> shared_secret;
-    std::vector<uint8_t> hs_key, peer_hs_key;
-
-    msgr_handshake_hdr_t *cur_hdr = NULL;
-    uint8_t *cur_buf = NULL;
-    size_t cur_left = 0;
-
-    bool on_error(const std::string & prefix);
-    bool derive_shared_secret(EVP_PKEY *peer_ec_key);
-    bool derive_hs_keys(const uint8_t *encoded_peer_key, size_t encoded_key_len);
-    bool sign(std::vector<uint8_t> & out);
-    bool verify(const uint8_t *signature, size_t signature_len);
-    bool encrypt(const uint8_t* src, size_t len, uint8_t* dest);
-    bool decrypt(const uint8_t* src, size_t & len, uint8_t* dest);
-    bool make_client_init();
-    bool make_server_reply();
-    bool make_client_reply();
-    bool verify_peer(const uint8_t *peer_cert_pem, size_t peer_cert_len);
-    ssize_t start_msg(uint8_t* src, size_t len, uint32_t expected_type);
-    bool read_with_len(const uint8_t* & dst, uint32_t & dst_len);
-    bool handle_client_init();
-    bool handle_server_reply();
-    bool handle_client_reply();
-    bool handle_peer_cert(const uint8_t *key, uint32_t key_len);
-    void complete();
-
-public:
-    // Workflow: create -> init -> handle -> get_result/get_error -> destruct
-    msgr_handshake_t(msgr_handshake_ctx_t *ctx): ctx(ctx) {}
-    ~msgr_handshake_t();
-    bool init(bool server_mode) override;
-    ssize_t handle(uint8_t* in_buf, size_t in_size) override;
-    bool done() override;
-    uint8_t *get_out() override;
-    size_t out_size() override;
-    void eat_out(size_t n) override;
-    void reset_out() override;
-    msgr_handshake_result_t get_result() override;
-    std::string get_error() override;
-};
-
-msgr_handshake_ctx_i* msgr_handshake_ctx_i::create_ctx()
-{
-    return new msgr_handshake_ctx_t();
-}
-
-msgr_handshake_i* msgr_handshake_ctx_t::create()
-{
-    return new msgr_handshake_t(this);
-}
-
-bool msgr_handshake_ctx_t::init(const std::string & pem_cert, const std::string & pem_key,
-    const std::string & pem_osd_ca, const std::string & pem_client_ca)
-{
-    if (pem_cert.substr(0, 5) == "-----")
-        my_cert_pem = pem_cert;
-    else
-    {
-        my_cert_pem = read_file(pem_cert);
-        if (my_cert_pem.empty())
-        {
-            error = "Failed to load certificate file";
-            return false;
-        }
-    }
-    {
-        BIO *bio = BIO_new_mem_buf(my_cert_pem.data(), my_cert_pem.size());
-        if (!bio)
-            return on_error("BIO_new_mem_buf: ");
-        my_cert = PEM_read_bio_X509(bio, NULL, 0, NULL);
-        BIO_free(bio);
-        if (!my_cert)
-            return on_error("Failed to load certificate: ");
-    }
-    if (!(my_pubkey = X509_get0_pubkey(my_cert)))
-        return on_error("X509_get0_pubkey: ");
-    if (!(md = EVP_get_digestbynid(NID_sha384)))
-        return on_error("EVP_get_digestbynid SHA384: ");
-    if (!(my_privkey = openssl_load_key(pem_key)))
-        return on_error("Failed to load private key: ");
-    if (!(ca = X509_STORE_new()))
-        return on_error("X509_STORE_CTX_new: ");
-    if (!(osd_ca = openssl_load_cert(pem_osd_ca)))
-        return on_error("Failed to load OSD CA certificate: ");
-    if (X509_STORE_add_cert(ca, osd_ca) <= 0)
-        return on_error("X509_STORE_add_cert OSD CA: ");
-    if (!pem_client_ca.empty() && !(client_ca = openssl_load_cert(pem_client_ca)))
-        return on_error("Failed to load client CA certificate: ");
-    if (client_ca && X509_STORE_add_cert(ca, client_ca) <= 0)
-        return on_error("X509_STORE_add_cert client CA: ");
-    if (!(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)))
-        return on_error("EVP_PKEY_CTX_new_id: ");
-    if (EVP_PKEY_paramgen_init(pctx) <= 0)
-        return on_error("EVP_PKEY_paramgen_init: ");
-    if (EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, /*NID_X9_62_prime256v1*/NID_secp384r1) <= 0)
-        return on_error("EVP_PKEY_CTX_set_ec_paramgen_curve_nid: ");
-    if (EVP_PKEY_paramgen(pctx, &params) <= 0)
-        return on_error("EVP_PKEY_paramgen: ");
-    EVP_KDF *kdf = EVP_KDF_fetch(NULL, "hkdf", NULL);
-    if (!kdf)
-        return on_error("EVP_KDF_fetch: ");
-    kdf_ctx = EVP_KDF_CTX_new(kdf);
-    EVP_KDF_free(kdf);
-    return true;
-}
-
-std::string msgr_handshake_ctx_t::get_error()
-{
-    return error;
-}
-
-msgr_handshake_ctx_t::~msgr_handshake_ctx_t()
-{
-    if (pctx)
-        EVP_PKEY_CTX_free(pctx);
-    if (params)
-        EVP_PKEY_free(params);
-    if (ca)
-        X509_STORE_free(ca);
-    if (osd_ca)
-        X509_free(osd_ca);
-    if (client_ca)
-        X509_free(client_ca);
-    my_pubkey = NULL;
-    if (my_cert)
-        X509_free(my_cert);
-    if (my_privkey)
-        EVP_PKEY_free(my_privkey);
-    if (kdf_ctx)
-        EVP_KDF_CTX_free(kdf_ctx);
-}
-
-bool msgr_handshake_ctx_t::on_error(const std::string & prefix)
-{
-    error = prefix+ERR_error_string(ERR_get_error(), NULL);
-    return false;
-}
-
-bool msgr_handshake_ctx_t::derive_kdf(const uint8_t* insecret, size_t insecret_len,
-    const uint8_t* salt, size_t salt_len, const char *label, uint8_t *outsecret, size_t outsize)
-{
-    OSSL_PARAM params[5];
-    int n = 0;
-    params[n++] = OSSL_PARAM_construct_utf8_string("digest", (char*)"sha384", (size_t)7);
-    params[n++] = OSSL_PARAM_construct_octet_string("key", (void*)insecret, insecret_len);
-    params[n++] = OSSL_PARAM_construct_octet_string("info", (void*)label, strlen(label)+1);
-    params[n++] = OSSL_PARAM_construct_octet_string("salt", (salt ? (void*)salt : (void*)""), salt_len);
-    params[n++] = OSSL_PARAM_construct_end();
-    assert(n <= sizeof(params)/sizeof(OSSL_PARAM));
-    if (EVP_KDF_CTX_set_params(kdf_ctx, params) <= 0)
-        return false;
-    if (EVP_KDF_derive(kdf_ctx, outsecret, outsize, NULL) <= 0)
-        return false;
-    return true;
-}
-
-msgr_handshake_t::~msgr_handshake_t()
-{
-    if (out_buf)
-        free(out_buf);
-    if (peer_cert)
-        X509_free(peer_cert);
-    if (ec_key)
-        EVP_PKEY_free(ec_key);
-}
-
-bool msgr_handshake_t::on_error(const std::string & prefix)
-{
-    error = prefix+ERR_error_string(ERR_get_error(), NULL);
-    state = MSGR_HS_ERROR;
-    return false;
-}
-
-bool msgr_handshake_t::init(bool server_mode)
-{
-    this->ctx = ctx;
-    std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)> kctx(EVP_PKEY_CTX_new(ctx->params, NULL), EVP_PKEY_CTX_free);
-    if (!kctx)
-        return on_error("EVP_PKEY_CTX_new with EC params: ");
-    if (EVP_PKEY_keygen_init(kctx.get()) <= 0)
-        return on_error("EVP_PKEY_keygen_init: ");
-    if (EVP_PKEY_keygen(kctx.get(), &ec_key) <= 0)
-        return on_error("EVP_PKEY_keygen: ");
-    if (!server_mode)
-    {
-        // Send initial message - only the EC public key
-        if (!make_client_init())
-            return false;
-    }
-    this->is_server = server_mode;
-    this->state = server_mode ? MSGR_HS_SERVER_INIT : MSGR_HS_CLIENT_INIT;
-    return true;
-}
-
-static void copy_to(std::vector<uint8_t> & buf, const void* src, uint32_t len)
-{
-    size_t old_size = buf.size();
-    buf.resize(buf.size() + len);
-    memcpy(buf.data() + old_size, src, len);
-}
-
-static void copy_to_raw(uint8_t* & buf, const void* src, size_t len)
-{
-    memcpy(buf, src, len);
-    buf += len;
-}
-
-static void copy_to_with_len(std::vector<uint8_t> & buf, const void* src, uint32_t len)
-{
-    copy_to(buf, &len, sizeof(len));
-    copy_to(buf, src, len);
-}
-
-bool msgr_handshake_t::derive_shared_secret(EVP_PKEY *peer_ec_key)
-{
-    EVP_PKEY_CTX *dh_ctx = NULL;
-    if (!(dh_ctx = EVP_PKEY_CTX_new(ec_key, NULL)))
-        return on_error("EVP_PKEY_CTX_new for ECDH: ");
-    if (!EVP_PKEY_derive_init(dh_ctx))
-    {
-        EVP_PKEY_CTX_free(dh_ctx);
-        return on_error("EVP_PKEY_derive_init: ");
-    }
-    if (!EVP_PKEY_derive_set_peer(dh_ctx, peer_ec_key))
-    {
-        EVP_PKEY_CTX_free(dh_ctx);
-        return on_error("EVP_PKEY_derive_set_peer: ");
-    }
-    size_t len = 0;
-    if (!EVP_PKEY_derive(dh_ctx, NULL, &len))
-    {
-        EVP_PKEY_CTX_free(dh_ctx);
-        return on_error("EVP_PKEY_derive get length: ");
-    }
-    shared_secret.resize(len);
-    assert(len == 48);
-    if (!EVP_PKEY_derive(dh_ctx, shared_secret.data(), &len))
-    {
-        EVP_PKEY_CTX_free(dh_ctx);
-        return on_error("EVP_PKEY_derive: ");
-    }
-    assert(len == shared_secret.size());
-    shared_secret.resize(len);
-    EVP_PKEY_CTX_free(dh_ctx);
-    return true;
-}
-
-bool msgr_handshake_t::derive_hs_keys(const uint8_t *encoded_peer_key, size_t encoded_key_len)
-{
-    std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)> peer_ec_key(EVP_PKEY_new(), EVP_PKEY_free);
-    if (!peer_ec_key)
-        return on_error("EVP_PKEY_new: ");
-    if (EVP_PKEY_copy_parameters(peer_ec_key.get(), ec_key) <= 0)
-        return on_error("EVP_PKEY_copy_parameters: ");
-    if (EVP_PKEY_set1_encoded_public_key(peer_ec_key.get(), encoded_peer_key, encoded_key_len) <= 0)
-        return on_error("Invalid handshake peer key: ");
-    if (!derive_shared_secret(peer_ec_key.get()))
-        return false;
-    hs_key.resize(AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE);
-    peer_hs_key.resize(AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE);
-    if (!ctx->derive_kdf(shared_secret.data(), shared_secret.size(),
-        NULL, 0, (state == MSGR_HS_SERVER_INIT ? "server hs key" : "client hs key"),
-        hs_key.data(), hs_key.size()))
-        return on_error("derive_kdf: ");
-    if (!ctx->derive_kdf(shared_secret.data(), shared_secret.size(),
-        NULL, 0, (state != MSGR_HS_SERVER_INIT ? "server hs key" : "client hs key"),
-        peer_hs_key.data(), peer_hs_key.size()))
-        return on_error("derive_kdf: ");
-    return true;
-}
-
-bool msgr_handshake_t::sign(std::vector<uint8_t> & out)
-{
-    std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)> md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
-    if (!md_ctx)
-        return on_error("EVP_MD_CTX_create: ");
-    if (EVP_DigestSignInit(md_ctx.get(), NULL, ctx->md, NULL, ctx->my_privkey) <= 0)
-        return on_error("EVP_DigestSignInit: ");
-    if (EVP_DigestSignUpdate(md_ctx.get(), full_handshake.data(), full_handshake.size()) <= 0)
-        return on_error("EVP_DigestSignUpdate: ");
-    size_t siglen = 0;
-    if (EVP_DigestSignFinal(md_ctx.get(), NULL, &siglen) <= 0)
-        return on_error("EVP_DigestSignFinal get length: ");
-    size_t oldsize = out.size();
-    out.resize(oldsize + siglen);
-    if (EVP_DigestSignFinal(md_ctx.get(), out.data() + oldsize, &siglen) <= 0)
-        return on_error("EVP_DigestSignFinal: ");
-    out.resize(oldsize + siglen);
-    return true;
-}
-
-bool msgr_handshake_t::verify(const uint8_t *signature, size_t signature_len)
-{
-    std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)> md_ctx(EVP_MD_CTX_new(), EVP_MD_CTX_free);
-    if (!md_ctx)
-        return on_error("EVP_MD_CTX_create: ");
-    if (EVP_DigestVerifyInit(md_ctx.get(), NULL, ctx->md, NULL, X509_get0_pubkey(peer_cert)) <= 0)
-        return on_error("EVP_DigestVerifyInit: ");
-    if (EVP_DigestVerifyUpdate(md_ctx.get(), full_handshake.data(), full_handshake.size()) <= 0)
-        return on_error("EVP_DigestVerifyUpdate: ");
-    if (EVP_DigestVerifyFinal(md_ctx.get(), signature, signature_len) <= 0)
-        return false;
-    return true;
-}
-
-bool msgr_handshake_t::encrypt(const uint8_t* src, size_t len, uint8_t* dest)
-{
-    std::unique_ptr<EVP_CIPHER_CTX, decltype(&EVP_CIPHER_CTX_free)> enc_ctx(EVP_CIPHER_CTX_new(), EVP_CIPHER_CTX_free);
-    if (!ctx)
-        return on_error("EVP_CIPHER_CTX_new: ");
-    if (EVP_EncryptInit_ex(enc_ctx.get(), EVP_aes_256_gcm(), NULL, hs_key.data(), hs_key.data() + AES_256_GCM_KEY_SIZE) <= 0)
-        return on_error("EVP_EncryptInit AES-256-GCM: ");
-    int actual_out;
-    if (EVP_EncryptUpdate(enc_ctx.get(), dest, &actual_out, src, len) <= 0)
-        return on_error("EVP_EncryptUpdate: ");
-    assert(actual_out == len);
-    if (EVP_EncryptFinal_ex(enc_ctx.get(), NULL, &actual_out) <= 0)
-        return on_error("EVP_EncryptFinal: ");
-    if (EVP_CIPHER_CTX_ctrl(enc_ctx.get(), EVP_CTRL_GCM_GET_TAG, 16, dest+len) <= 0)
-        return on_error("EVP_CTRL_GCM_GET_TAG: ");
-    (*(uint64_t*)(hs_key.data() + AES_256_GCM_KEY_SIZE))++; // change IV
-    return true;
-}
-
-bool msgr_handshake_t::decrypt(const uint8_t *src, size_t & len, uint8_t* dest)
-{
-    if (len <= 16) // only tag?!
-    {
-        len = 0;
-        error = "Handshake decryption failed";
-        state = MSGR_HS_ERROR;
-        return false;
-    }
-    std::unique_ptr<EVP_CIPHER_CTX, decltype(&EVP_CIPHER_CTX_free)> dec_ctx(EVP_CIPHER_CTX_new(), EVP_CIPHER_CTX_free);
-    if (!ctx)
-        return on_error("EVP_CIPHER_CTX_new: ");
-    if (EVP_DecryptInit_ex(dec_ctx.get(), EVP_aes_256_gcm(), NULL, peer_hs_key.data(), peer_hs_key.data() + AES_256_GCM_KEY_SIZE) <= 0)
-        return on_error("EVP_DecryptInit AES-256-GCM: ");
-    int actual_out;
-    len -= 16;
-    if (EVP_DecryptUpdate(dec_ctx.get(), dest, &actual_out, src, len) <= 0)
-        return on_error("EVP_DecryptUpdate: ");
-    assert(actual_out == len);
-    if (EVP_CIPHER_CTX_ctrl(dec_ctx.get(), EVP_CTRL_GCM_SET_TAG, 16, (void*)(src+len)) <= 0)
-        return on_error("EVP_CTRL_GCM_SET_TAG: ");
-    if (EVP_DecryptFinal_ex(dec_ctx.get(), NULL, &actual_out) <= 0)
-    {
-        error = "Handshake decryption failed";
-        state = MSGR_HS_ERROR;
-        return false;
-    }
-    (*(uint64_t*)(peer_hs_key.data() + AES_256_GCM_KEY_SIZE))++; // change IV
-    return true;
-}
-
-bool msgr_handshake_t::make_client_init()
-{
-    uint8_t *key = NULL;
-    size_t key_len = EVP_PKEY_get1_encoded_public_key(ec_key, &key);
-    if (!key_len)
-        return on_error("EVP_PKEY_get1_encoded_public_key: ");
-    const size_t old_out_size = out_buf_size;
-    out_buf_size += key_len + sizeof(msgr_handshake_hdr_t);
-    out_buf = (uint8_t*)realloc_or_die(out_buf, out_buf_size);
-    uint8_t *buf = out_buf + old_out_size;
-    msgr_handshake_hdr_t *hdr = (msgr_handshake_hdr_t *)buf;
-    hdr->msg_len = key_len + sizeof(msgr_handshake_hdr_t);
-    hdr->magic = MSGR_HS_MAGIC;
-    hdr->type = MSGR_HS_CLIENT_INIT;
-    memcpy(buf + sizeof(msgr_handshake_hdr_t), key, key_len);
-    copy_to(full_handshake, &hdr->type, sizeof(hdr->type));
-    copy_to_with_len(full_handshake, key, key_len);
-    OPENSSL_free(key);
-    return true;
-}
-
-bool msgr_handshake_t::make_server_reply()
-{
-    uint8_t *key = NULL;
-    size_t key_len = EVP_PKEY_get1_encoded_public_key(ec_key, &key);
-    if (!key_len)
-        return on_error("EVP_PKEY_get1_encoded_public_key: ");
-    // Append type, key and raw certificate to signed data and sign it
-    msgr_handshake_hdr_t hdr = { .magic = MSGR_HS_MAGIC, .type = MSGR_HS_SERVER_REPLY };
-    copy_to(full_handshake, &hdr.type, sizeof(hdr.type));
-    copy_to_with_len(full_handshake, key, key_len);
-    copy_to_with_len(full_handshake, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
-    std::vector<uint8_t> signature;
-    if (!sign(signature))
-    {
-        OPENSSL_free(key);
-        return false;
-    }
-    // Encrypt certificate and signature
-    std::vector<uint8_t> encrypt_data;
-    copy_to_with_len(encrypt_data, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
-    copy_to_with_len(encrypt_data, signature.data(), signature.size());
-    encrypt_data.resize(encrypt_data.size()+16);
-    if (!encrypt(encrypt_data.data(), encrypt_data.size()-16, encrypt_data.data()))
-    {
-        OPENSSL_free(key);
-        return false;
-    }
-    // Construct message
-    hdr.msg_len = sizeof(msgr_handshake_hdr_t) + 4 + key_len + encrypt_data.size();
-    out_buf = (uint8_t*)realloc_or_die(out_buf, (out_buf_size += hdr.msg_len));
-    uint8_t *cur = out_buf + out_buf_size - hdr.msg_len;
-    copy_to_raw(cur, &hdr, sizeof(hdr));
-    copy_to_raw(cur, &key_len, 4);
-    copy_to_raw(cur, key, key_len);
-    copy_to_raw(cur, encrypt_data.data(), encrypt_data.size());
-    OPENSSL_free(key);
-    return true;
-}
-
-bool msgr_handshake_t::make_client_reply()
-{
-    // Append type and raw certificate to signed data and sign it
-    msgr_handshake_hdr_t hdr = { .magic = MSGR_HS_MAGIC, .type = MSGR_HS_CLIENT_REPLY };
-    copy_to(full_handshake, &hdr.type, sizeof(hdr.type));
-    copy_to_with_len(full_handshake, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
-    std::vector<uint8_t> signature;
-    if (!sign(signature))
-        return false;
-    // Encrypt certificate and signature
-    std::vector<uint8_t> encrypt_data;
-    copy_to_with_len(encrypt_data, ctx->my_cert_pem.data(), ctx->my_cert_pem.size());
-    copy_to_with_len(encrypt_data, signature.data(), signature.size());
-    encrypt_data.resize(encrypt_data.size()+16);
-    if (!encrypt(encrypt_data.data(), encrypt_data.size()-16, encrypt_data.data()))
-        return false;
-    // Construct message
-    hdr.msg_len = sizeof(msgr_handshake_hdr_t) + encrypt_data.size();
-    out_buf = (uint8_t*)realloc_or_die(out_buf, (out_buf_size += hdr.msg_len));
-    uint8_t *cur = out_buf + out_buf_size - hdr.msg_len;
-    copy_to_raw(cur, &hdr, sizeof(hdr));
-    copy_to_raw(cur, encrypt_data.data(), encrypt_data.size());
-    return true;
-}
-
-bool msgr_handshake_t::verify_peer(const uint8_t *peer_cert_pem, size_t peer_cert_len)
-{
-    BIO *bio = BIO_new_mem_buf(peer_cert_pem, peer_cert_len);
-    if (!bio)
-        return on_error("BIO_new_mem_buf: ");
-    peer_cert = PEM_read_bio_X509(bio, NULL, 0, NULL);
-    BIO_free(bio);
-    if (!peer_cert)
-    {
-        error = "Invalid peer certificate";
-        state = MSGR_HS_ERROR;
-        return false;
-    }
-    std::unique_ptr<X509_STORE_CTX, decltype(&X509_STORE_CTX_free)> ca_ctx(X509_STORE_CTX_new(), X509_STORE_CTX_free);
-    if (!ca_ctx)
-        return on_error("X509_STORE_CTX_new: ");
-    if (X509_STORE_CTX_init(ca_ctx.get(), ctx->ca, peer_cert, NULL) <= 0)
-        return on_error("X509_STORE_CTX_init: ");
-    // Maybe use X509_VERIFY_PARAM_set_auth_level(X509_STORE_CTX_get0_param(ca_ctx.get()), 2) ?
-    X509_STORE_CTX_set_default(ca_ctx.get(), is_server ? "ssl_client" : "ssl_server");
-    if (X509_verify_cert(ca_ctx.get()) <= 0)
-    {
-        error = "Peer certificate verification failed: ";
-        error += X509_verify_cert_error_string(X509_STORE_CTX_get_error(ca_ctx.get()));
-        state = MSGR_HS_ERROR;
-        return false;
-    }
-    peer_is_osd = (X509_verify(peer_cert, X509_get0_pubkey(ctx->osd_ca)) > 0);
-    if (!is_server && !peer_is_osd)
-    {
-        error = "Peer is not an OSD";
-        state = MSGR_HS_ERROR;
-        return false;
-    }
-    return true;
-}
-
-ssize_t msgr_handshake_t::start_msg(uint8_t* src, size_t len, uint32_t expected_type)
-{
-    size_t orig_len = len;
-    size_t to_buffer = (len < sizeof(msgr_handshake_hdr_t)-in_buf.size()
-        ? len : sizeof(msgr_handshake_hdr_t)-in_buf.size());
-    in_buf.insert(in_buf.end(), src, src+to_buffer);
-    len -= to_buffer;
-    src += to_buffer;
-    if (in_buf.size() < sizeof(msgr_handshake_hdr_t))
-        return 0;
-    cur_hdr = (msgr_handshake_hdr_t *)in_buf.data();
-    if (cur_hdr->magic != MSGR_HS_MAGIC ||
-        cur_hdr->type != expected_type ||
-        cur_hdr->msg_len <= sizeof(msgr_handshake_hdr_t) ||
-        cur_hdr->msg_len >= MSGR_HS_MAX_LEN)
-    {
-        error = "Invalid handshake packet magic, type or size";
-        state = MSGR_HS_ERROR;
-        return -1;
-    }
-    to_buffer = (len < cur_hdr->msg_len-in_buf.size()
-        ? len : cur_hdr->msg_len-in_buf.size());
-    in_buf.insert(in_buf.end(), src, src+to_buffer);
-    cur_hdr = (msgr_handshake_hdr_t *)in_buf.data();
-    len -= to_buffer;
-    src += to_buffer;
-    if (in_buf.size() < cur_hdr->msg_len)
-        return 0;
-    cur_left = cur_hdr->msg_len - sizeof(msgr_handshake_hdr_t);
-    cur_buf = in_buf.data() + sizeof(msgr_handshake_hdr_t);
-    return orig_len - len;
-}
-
-bool msgr_handshake_t::read_with_len(const uint8_t* & dst, uint32_t & dst_len)
-{
-    if (cur_left < 4)
-    {
-        error = "Handshake packet too short";
-        state = MSGR_HS_ERROR;
-        return false;
-    }
-    dst_len = *(uint32_t*)cur_buf;
-    cur_buf += 4;
-    cur_left -= 4;
-    if (cur_left < dst_len)
-    {
-        error = "Handshake packet too short";
-        state = MSGR_HS_ERROR;
-        return false;
-    }
-    dst = cur_buf;
-    cur_buf += dst_len;
-    cur_left -= dst_len;
-    return true;
-}
-
-bool msgr_handshake_t::handle_client_init()
-{
-    // Derive shared secret and handshake keys
-    if (!derive_hs_keys(cur_buf, cur_left))
-        return false;
-    // Add type and key to full_handshake
-    copy_to(full_handshake, &cur_hdr->type, sizeof(cur_hdr->type));
-    copy_to_with_len(full_handshake, cur_buf, cur_left);
-    in_buf.clear();
-    return true;
-}
-
-// Decrypt and check peer certificate
-bool msgr_handshake_t::handle_peer_cert(const uint8_t *key, uint32_t key_len)
-{
-    if (!decrypt(cur_buf, cur_left, cur_buf))
-        return false;
-    const uint8_t *peer_cert_pem = NULL;
-    uint32_t peer_cert_len = 0;
-    if (!read_with_len(peer_cert_pem, peer_cert_len))
-        return false;
-    // Parse and verify certificate
-    if (!verify_peer(peer_cert_pem, peer_cert_len))
-        return false;
-    // Verify signature
-    copy_to(full_handshake, &cur_hdr->type, sizeof(cur_hdr->type));
-    if (key)
-        copy_to_with_len(full_handshake, key, key_len);
-    copy_to_with_len(full_handshake, peer_cert_pem, peer_cert_len);
-    const uint8_t *signature = NULL;
-    uint32_t signature_len = 0;
-    if (!read_with_len(signature, signature_len))
-        return false;
-    if (!verify(signature, signature_len))
-        return false;
-    return true;
-}
-
-bool msgr_handshake_t::handle_server_reply()
-{
-    // Derive shared secret and handshake keys
-    const uint8_t *key = NULL;
-    uint32_t key_len = 0;
-    if (!read_with_len(key, key_len))
-        return false;
-    if (!derive_hs_keys(key, key_len))
-        return false;
-    // Decrypt and check peer certificate
-    if (!handle_peer_cert(key, key_len))
-        return false;
-    in_buf.clear();
-    return true;
-}
-
-bool msgr_handshake_t::handle_client_reply()
-{
-    // Decrypt and check peer certificate
-    if (!handle_peer_cert(NULL, 0))
-        return false;
-    in_buf.clear();
-    return true;
-}
-
-void msgr_handshake_t::complete()
-{
-    state = MSGR_HS_DONE;
-    hs_key.clear();
-    peer_hs_key.clear();
-    full_handshake.clear();
-}
-
-ssize_t msgr_handshake_t::handle(uint8_t* in_buf, size_t in_size)
-{
-    if (state == MSGR_HS_SERVER_INIT)
-    {
-        ssize_t r = start_msg(in_buf, in_size, MSGR_HS_CLIENT_INIT);
-        if (r < 0)
-            return r;
-        if (r == 0)
-            return in_size;
-        if (!handle_client_init())
-            return -1;
-        // Send encrypted & signed response
-        if (!make_server_reply())
-            return -1;
-        state = MSGR_HS_SERVER_REPLY;
-        return r;
-    }
-    else if (state == MSGR_HS_CLIENT_INIT)
-    {
-        ssize_t r = start_msg(in_buf, in_size, MSGR_HS_SERVER_REPLY);
-        if (r < 0)
-            return r;
-        if (r == 0)
-            return in_size;
-        if (!handle_server_reply())
-            return -1;
-        // Verification passed, send certificate to the server
-        if (!make_client_reply())
-            return -1;
-        // Finished!
-        complete();
-        return r;
-    }
-    else if (state == MSGR_HS_SERVER_REPLY)
-    {
-        ssize_t r = start_msg(in_buf, in_size, MSGR_HS_CLIENT_REPLY);
-        if (r < 0)
-            return r;
-        if (r == 0)
-            return in_size;
-        if (!handle_client_reply())
-            return -1;
-        // Verification passed
-        // Finished!
-        complete();
-        return r;
-    }
-    else if (state == MSGR_HS_DONE)
-    {
-        return 0;
-    }
-    else if (state != MSGR_HS_ERROR)
-    {
-        error = "Unexpected handshake state: "+std::to_string(state);
-    }
-    return -1;
-}
-
-bool msgr_handshake_t::done()
-{
-    return (state == MSGR_HS_DONE);
-}
-
-uint8_t *msgr_handshake_t::get_out()
-{
-    return out_buf;
-}
-
-size_t msgr_handshake_t::out_size()
-{
-    return out_buf_size;
-}
-
-void msgr_handshake_t::eat_out(size_t n)
-{
-    if (n >= out_buf_size)
-    {
-        free(out_buf);
-        out_buf = NULL;
-        out_buf_size = 0;
-    }
-    else
-    {
-        memmove(out_buf, out_buf + n, out_buf_size - n);
-        out_buf_size -= n;
-    }
-}
-
-void msgr_handshake_t::reset_out()
-{
-    out_buf = NULL;
-    out_buf_size = 0;
-}
-
-msgr_handshake_result_t msgr_handshake_t::get_result()
-{
-    if (state != MSGR_HS_DONE)
-        return msgr_handshake_result_t{};
-    X509_up_ref(peer_cert);
-    return msgr_handshake_result_t{
-        .peer_cert = peer_cert,
-        .peer_is_osd = peer_is_osd,
-        .shared_secret = shared_secret,
-    };
-}
-
-std::string msgr_handshake_t::get_error()
-{
-    return error;
-}

src/client/msgr_handshake.h

@@ -1,57 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2026+
-// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
-
-#pragma once
-
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-#include <openssl/types.h>
-
-#define AES_256_GCM_KEY_SIZE 32
-#define AES_256_GCM_IV_SIZE 12
-#define AES_256_GCM_MAX_IV_CTR ((uint64_t)1 << 32)
-
-// TLS 1.3-like handshake
-
-// 1. Client->server: EC public key
-// 2. Server->client: EC public key, encrypted certificate and digital signature of the handshake
-// 3. Client->server: encrypted certificate and digital signature of the handshake
-
-struct msgr_handshake_result_t
-{
-    X509 *peer_cert = NULL;
-    bool peer_is_osd = false;
-    std::vector<uint8_t> shared_secret;
-};
-
-class msgr_handshake_i
-{
-public:
-    // Workflow: create -> init -> handle_msg -> get_result/get_error -> destruct
-    virtual ~msgr_handshake_i() = default;
-    virtual bool init(bool server_mode) = 0;
-    virtual ssize_t handle(uint8_t* in_buf, size_t in_size) = 0;
-    virtual bool done() = 0;
-    virtual uint8_t *get_out() = 0;
-    virtual size_t out_size() = 0;
-    virtual void eat_out(size_t n) = 0;
-    virtual void reset_out() = 0;
-    virtual msgr_handshake_result_t get_result() = 0;
-    virtual std::string get_error() = 0;
-};
-
-class msgr_handshake_ctx_i
-{
-public:
-    static msgr_handshake_ctx_i* create_ctx();
-    virtual ~msgr_handshake_ctx_i() = default;
-    virtual msgr_handshake_i* create() = 0;
-    virtual bool init(const std::string & pem_cert, const std::string & pem_key,
-        const std::string & pem_osd_ca, const std::string & pem_client_ca) = 0;
-    virtual std::string get_error() = 0;
-    virtual bool derive_kdf(const uint8_t* insecret, size_t insecret_len,
-        const uint8_t* salt, size_t salt_len, const char *label, uint8_t *outsecret, size_t outsize) = 0;
-};

src/client/msgr_iothread.cpp

@@ -1,129 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
-
-#include <stdexcept>
-#include <sys/poll.h>
-#include <unistd.h>
-
-#include "messenger.h"
-#include "msgr_iothread.h"
-
-msgr_iothread_t::msgr_iothread_t():
-    ring(RINGLOOP_DEFAULT_SIZE, true),
-    thread(&msgr_iothread_t::run, this)
-{
-    eventfd = ring.register_eventfd();
-    if (eventfd < 0)
-    {
-        throw std::runtime_error(std::string("failed to register eventfd: ") + strerror(-eventfd));
-    }
-}
-
-msgr_iothread_t::~msgr_iothread_t()
-{
-    stop();
-}
-
-void msgr_iothread_t::add_sqe(io_uring_sqe & sqe)
-{
-    mu.lock();
-    queue.push_back((iothread_sqe_t){ .sqe = sqe, .data = std::move(*(ring_data_t*)sqe.user_data) });
-    if (queue.size() == 1)
-    {
-        cond.notify_all();
-    }
-    mu.unlock();
-}
-
-void msgr_iothread_t::stop()
-{
-    mu.lock();
-    if (stopped)
-    {
-        mu.unlock();
-        return;
-    }
-    stopped = true;
-    if (outer_loop_data)
-    {
-        outer_loop_data->callback = [](ring_data_t*){};
-    }
-    cond.notify_all();
-    close(eventfd);
-    mu.unlock();
-    thread.join();
-}
-
-void msgr_iothread_t::add_to_ringloop(ring_loop_i *outer_loop)
-{
-    assert(!this->outer_loop || this->outer_loop == outer_loop);
-    io_uring_sqe *sqe = outer_loop->get_sqe();
-    assert(sqe != NULL);
-    this->outer_loop = outer_loop;
-    this->outer_loop_data = ((ring_data_t*)sqe->user_data);
-    io_uring_prep_poll_add(sqe, eventfd, POLLIN);
-    outer_loop_data->callback = [this](ring_data_t *data)
-    {
-        if (data->res < 0)
-        {
-            throw std::runtime_error(std::string("eventfd poll failed: ") + strerror(-data->res));
-        }
-        outer_loop_data = NULL;
-        if (stopped)
-        {
-            return;
-        }
-        add_to_ringloop(this->outer_loop);
-        ring.loop();
-    };
-}
-
-void msgr_iothread_t::run()
-{
-    while (true)
-    {
-        {
-            std::unique_lock<std::mutex> lk(mu);
-            while (!stopped && !queue.size())
-                cond.wait(lk);
-            if (stopped)
-                return;
-            int i = 0;
-            for (; i < queue.size(); i++)
-            {
-                io_uring_sqe *sqe = ring.get_sqe();
-                if (!sqe)
-                    break;
-                ring_data_t *data = ((ring_data_t*)sqe->user_data);
-                *data = std::move(queue[i].data);
-                *sqe = queue[i].sqe;
-                sqe->user_data = (uint64_t)data;
-            }
-            queue.erase(queue.begin(), queue.begin()+i);
-        }
-        // We only want to offload sendmsg/recvmsg. Callbacks will be called in main thread
-        ring.submit();
-    }
-}
-
-void osd_messenger_t::init_iothreads()
-{
-    for (int i = 0; i < iothread_count; i++)
-    {
-        auto iot = new msgr_iothread_t();
-        iothreads.push_back(iot);
-        iot->add_to_ringloop(ringloop);
-    }
-}
-
-void osd_messenger_t::destroy_iothreads()
-{
-    if (iothreads.size())
-    {
-        for (auto iot: iothreads)
-        {
-            delete iot;
-        }
-        iothreads.clear();
-    }
-}

src/client/msgr_iothread.h

@@ -1,38 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
-
-#include <mutex>
-#include <condition_variable>
-#include <thread>
-
-#include "ringloop.h"
-
-struct iothread_sqe_t
-{
-    io_uring_sqe sqe;
-    ring_data_t data;
-};
-
-class msgr_iothread_t
-{
-protected:
-    ring_loop_t ring;
-    ring_loop_i *outer_loop = NULL;
-    ring_data_t *outer_loop_data = NULL;
-    int eventfd = -1;
-    bool stopped = false;
-    std::mutex mu;
-    std::condition_variable cond;
-    std::vector<iothread_sqe_t> queue;
-    std::thread thread;
-
-    void run();
-public:
-
-    msgr_iothread_t();
-    ~msgr_iothread_t();
-
-    void add_sqe(io_uring_sqe & sqe);
-    void stop();
-    void add_to_ringloop(ring_loop_i *outer_loop);
-};

src/client/msgr_op.cpp

@@ -23,6 +23,10 @@ osd_op_t::~osd_op_t()
         // So we don't reuse it, but free it every time
         free(buf);
     }
+    if (enc_buf)
+    {
+        free(enc_buf);
+    }
 }
 
 bool osd_op_t::is_recovery_related()

src/client/msgr_op.h

@@ -173,8 +173,7 @@ struct __attribute__((visibility("default"))) osd_op_t
 {
     timespec tv_begin = { 0 }, tv_end = { 0 };
     uint64_t op_type = OSD_OP_IN;
-    uint64_t client_id = 0;
-    osd_num_t osd_num = 0;
+    int peer_fd;
     osd_any_op_t req;
     osd_any_reply_t reply;
     blockstore_op_t *bs_op = NULL;
@@ -182,11 +181,11 @@ struct __attribute__((visibility("default"))) osd_op_t
     // bitmap, bitmap_len, bmp_data are only meaningful for reads
     void *bitmap = NULL;
     unsigned bitmap_len = 0;
-    size_t bmp_data = 0;
-    uint8_t *bitmap_buf = NULL;
+    unsigned bmp_data = 0;
+    void *bitmap_buf = NULL;
     void *rmw_buf = NULL;
     std::shared_ptr<osd_op_enc_t> enc;
-    uint64_t csum = 0; // network layer checksum
+    uint8_t *enc_buf = NULL;
     osd_primary_op_data_t* op_data = NULL;
     std::function<void(osd_op_t*)> callback;
 
@@ -196,5 +195,4 @@ struct __attribute__((visibility("default"))) osd_op_t
     void cancel();
 
     bool is_recovery_related();
-    uint64_t calc_data_checksum();
 };

src/client/msgr_rdma.cpp

@@ -187,8 +187,6 @@ std::vector<msgr_rdma_context_t*> msgr_rdma_context_t::create_all(const std::vec
     ibv_device **raw_dev_list = NULL;
     ibv_device **dev_list = NULL;
     ibv_device *single_list[2] = {};
-    int up_ports = 0;
-    int single_port_num = 0;
 
     raw_dev_list = dev_list = ibv_get_device_list(NULL);
     if (!dev_list || !*dev_list)
@@ -223,7 +221,6 @@ std::vector<msgr_rdma_context_t*> msgr_rdma_context_t::create_all(const std::vec
         dev_list = single_list;
     }
 
-retry:
     for (int i = 0; dev_list[i]; ++i)
     {
         auto dev = dev_list[i];
@@ -261,9 +258,6 @@ retry:
                 fprintf(stderr, "RDMA device %s port %d GID %d does not exist\n", ibv_get_device_name(dev), port_num, sel_gid_index);
                 continue;
             }
-            up_ports++;
-            single_port_num = port_num;
-            single_list[0] = dev;
             uint32_t port_mtu = sel_mtu ? sel_mtu : ibv_mtu_to_bytes(portinfo.active_mtu);
 #ifdef IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT
             if (sel_gid_index < 0)
@@ -304,14 +298,6 @@ cleanup_dev:
         ibv_close_device(context);
     }
 
-    if (!ret.size() && up_ports == 1 && dev_list != single_list)
-    {
-        // Auto-select the only available device/port if there is only one
-        dev_list = single_list;
-        sel_port_num = single_port_num;
-        goto retry;
-    }
-
 cleanup:
     if (raw_dev_list)
         ibv_free_device_list(raw_dev_list);
@@ -507,7 +493,7 @@ int msgr_rdma_connection_t::connect(msgr_rdma_address_t *dest)
     return 0;
 }
 
-bool osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address, uint64_t client_max_msg)
+bool osd_messenger_t::connect_rdma(int peer_fd, std::string rdma_address, uint64_t client_max_msg)
 {
     // Try to connect to the peer using RDMA
     msgr_rdma_address_t addr;
@@ -517,12 +503,12 @@ bool osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address,
         {
             client_max_msg = rdma_max_msg;
         }
-        auto cl = clients.at(client_id);
+        auto cl = clients.at(peer_fd);
         msgr_rdma_context_t *selected_ctx = choose_rdma_context(cl);
         if (!selected_ctx)
         {
             if (log_level > 0)
-                fprintf(stderr, "No RDMA context for peer %ju, using only TCP\n", client_id);
+                fprintf(stderr, "No RDMA context for peer %d, using only TCP\n", cl->peer_fd);
             return false;
         }
         msgr_rdma_connection_t *rdma_conn = msgr_rdma_connection_t::create(selected_ctx, rdma_max_send, rdma_max_recv, rdma_max_sge, client_max_msg);
@@ -533,13 +519,14 @@ bool osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address,
             {
                 delete rdma_conn;
                 fprintf(
-                    stderr, "Failed to connect RDMA queue pair to %s (client %ju)\n",
-                    addr.to_string().c_str(), client_id
+                    stderr, "Failed to connect RDMA queue pair to %s (client %d)\n",
+                    addr.to_string().c_str(), peer_fd
                 );
             }
             else
             {
                 // Remember connection, but switch to RDMA only after sending the configuration response
+                auto cl = clients.at(peer_fd);
                 cl->rdma_conn = rdma_conn;
                 cl->peer_state = PEER_RDMA_CONNECTING;
                 return true;
@@ -553,7 +540,7 @@ static void try_send_rdma_wr(osd_client_t *cl, ibv_sge *sge, int op_sge)
 {
     ibv_send_wr *bad_wr = NULL;
     ibv_send_wr wr = {
-        .wr_id = cl->client_id,
+        .wr_id = (uint64_t)(cl->peer_fd*2+1),
         .sg_list = sge,
         .num_sge = op_sge,
         .opcode = IBV_WR_SEND,
@@ -568,6 +555,33 @@ static void try_send_rdma_wr(osd_client_t *cl, ibv_sge *sge, int op_sge)
     cl->rdma_conn->cur_send++;
 }
 
+int osd_messenger_t::try_send_rdma_copy(osd_client_t *cl, uint8_t *dst, int dst_len)
+{
+    int total_dst_len = dst_len;
+    while (dst_len > 0 && (cl->write_op || cl->write_ops.size()))
+    {
+        if (!cl->write_op)
+        {
+            cl->write_op = cl->write_ops.front();
+            cl->write_ops.pop_front();
+        }
+        osd_op_t *op = cl->write_op;
+        size_t copied = op_copy_to(cl, dst, dst_len);
+        if (!copied)
+        {
+            break;
+        }
+        dst += copied;
+        dst_len -= copied;
+        if (!cl->write_op && op->op_type == OSD_OP_IN)
+        {
+            // this is a reply, free the op after sending it
+            cl->send_free_ops.push_back(op);
+        }
+    }
+    return total_dst_len-dst_len;
+}
+
 void osd_messenger_t::try_send_rdma(osd_client_t *cl)
 {
     auto rc = cl->rdma_conn;
@@ -590,24 +604,17 @@ void osd_messenger_t::try_send_rdma(osd_client_t *cl)
     while (!rc->send_out_full && copied > 0 && rc->cur_send < rc->max_send)
     {
         dst = (uint8_t*)rc->send_out.buf + rc->send_out_pos;
-        dst_len = (rc->send_out_pos >= rc->send_done_pos
-            ? rc->send_out_size-rc->send_out_pos
-            : rc->send_done_pos-rc->send_out_pos);
+        dst_len = (rc->send_out_pos < rc->send_out_size ? rc->send_out_size-rc->send_out_pos : rc->send_done_pos-rc->send_out_pos);
         if (dst_len > rc->max_msg)
             dst_len = rc->max_msg;
-        copied = copy_ops_to(cl, dst, dst_len);
-        if (cl->io_error)
-        {
-            stop_client(cl->client_id);
-            return;
-        }
+        copied = try_send_rdma_copy(cl, dst, dst_len);
         if (copied > 0)
         {
             rc->send_out_pos += copied;
             if (rc->send_out_pos == rc->send_out_size)
                 rc->send_out_pos = 0;
             assert(rc->send_out_pos < rc->send_out_size);
-            if (rc->send_out_pos == rc->send_done_pos)
+            if (rc->send_out_pos >= rc->send_done_pos)
                 rc->send_out_full = true;
             ibv_sge sge = {
                 .addr = (uintptr_t)dst,
@@ -630,7 +637,7 @@ static void try_recv_rdma_wr(osd_client_t *cl, void *buf)
     };
     ibv_recv_wr *bad_wr = NULL;
     ibv_recv_wr wr = {
-        .wr_id = cl->client_id,
+        .wr_id = (uint64_t)(cl->peer_fd*2),
         .sg_list = &sge,
         .num_sge = 1,
     };
@@ -687,8 +694,8 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
         event_count = ibv_poll_cq(rdma_context->cq, RDMA_EVENTS_AT_ONCE, wc);
         for (int i = 0; i < event_count; i++)
         {
-            uint64_t client_id = wc[i].wr_id;
-            bool is_send = wc[i].opcode == IBV_WC_SEND;
+            int client_id = wc[i].wr_id >> 1;
+            bool is_send = wc[i].wr_id & 1;
             auto cl_it = clients.find(client_id);
             if (cl_it == clients.end())
             {
@@ -702,13 +709,14 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
             auto rc = cl->rdma_conn;
             if (wc[i].status != IBV_WC_SUCCESS)
             {
-                fprintf(stderr, "RDMA work request failed for client %ju", client_id);
+                fprintf(stderr, "RDMA work request failed for client %d", client_id);
                 if (cl->osd_num)
                 {
                     fprintf(stderr, " (OSD %ju)", cl->osd_num);
                 }
                 fprintf(stderr, " with status: %s, stopping client\n", ibv_wc_status_str(wc[i].status));
                 stop_client(client_id);
+                clear_immediate_ops(client_id);
                 continue;
             }
             if (!is_send)
@@ -716,6 +724,8 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
                 rc->cur_recv--;
                 if (!handle_read_buffer(cl, rc->recv_buffers[rc->next_recv_buf], wc[i].byte_len))
                 {
+                    // handle_read_buffer may stop the client
+                    clear_immediate_ops(client_id);
                     continue;
                 }
                 try_recv_rdma_wr(cl, rc->recv_buffers[rc->next_recv_buf]);
@@ -732,35 +742,14 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
                 if (rc->send_done_pos == rc->send_out_size)
                     rc->send_done_pos = 0;
                 assert(rc->send_done_pos < rc->send_out_size);
-                while (osd_op_t *op = cl->send_free_ops.front())
+                while (cl->send_free_ops.front())
                 {
-                    if (!((size_t)op & 7))
-                        delete op;
-                    else
-                        free((void*)((size_t)op & ~(size_t)7));
+                    delete cl->send_free_ops.front();
                     cl->send_free_ops.pop_front();
                 }
                 cl->send_free_ops.pop_front();
-                if ((cl->proto_csum_status & MSGR_CSUM_NEG) && !cl->write_op && !cl->write_ops.size())
-                {
-                    // Checksums negotiated, enable
-                    cl->proto_csum_status = cl->proto_csum_status & (~MSGR_CSUM_NEG);
-                }
                 try_send_rdma(cl);
             }
         }
     } while (event_count > 0);
 }
-
-void osd_messenger_t::destroy_rdma_conn(msgr_rdma_connection_t *rdma_conn)
-{
-    if (rdma_conn->cmid)
-    {
-        auto rdma_it = rdmacm_connections.find(rdma_conn->cmid);
-        if (rdma_it != rdmacm_connections.end() && rdma_it->second->rdma_conn == rdma_conn)
-        {
-            rdmacm_connections.erase(rdma_it);
-        }
-    }
-    delete rdma_conn;
-}

src/client/msgr_rdma.h

@@ -79,7 +79,7 @@ struct msgr_rdma_connection_t
     msgr_rdma_buf_t recv_buf;
     std::deque<uint64_t> send_sizes;
     msgr_rdma_buf_t send_out;
-    size_t send_out_pos = 0, send_done_pos = 0, send_out_size = 0;
+    int send_out_pos = 0, send_done_pos = 0, send_out_size = 0;
     bool send_out_full = false;
 
     ~msgr_rdma_connection_t();

src/client/msgr_rdmacm.cpp

@@ -11,7 +11,7 @@
 struct rdmacm_connecting_t
 {
     rdma_cm_id *cmid = NULL;
-    uint64_t client_id = 0;
+    int peer_fd = -1;
     osd_num_t peer_osd = 0;
     std::string addr;
     sockaddr_storage parsed_addr = {};
@@ -19,7 +19,6 @@ struct rdmacm_connecting_t
     int tcp_port = 0;
     int timeout_ms = 0;
     int timeout_id = -1;
-    bool is_incoming = false;
     msgr_rdma_context_t *rdma_context = NULL;
 };
 
@@ -118,9 +117,9 @@ void osd_messenger_t::handle_rdmacm_events()
             auto cli_it = rdmacm_connections.find(ev->id);
             if (cli_it != rdmacm_connections.end())
             {
-                fprintf(stderr, "Received %s event for client %ju, closing connection\n",
-                    event_type_name, cli_it->second->client_id);
-                stop_client(cli_it->second->client_id);
+                fprintf(stderr, "Received %s event for peer %d, closing connection\n",
+                    event_type_name, cli_it->second->peer_fd);
+                stop_client(cli_it->second->peer_fd);
             }
             else if (rdmacm_connecting.find(ev->id) != rdmacm_connecting.end())
             {
@@ -266,6 +265,14 @@ msgr_rdma_context_t* osd_messenger_t::rdmacm_create_qp(rdma_cm_id *cmid)
 
 void osd_messenger_t::rdmacm_accept(rdma_cm_event *ev)
 {
+    // Make a fake FD (FIXME: do not use FDs for identifying clients!)
+    int fake_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fake_fd < 0)
+    {
+        fprintf(stderr, "Failed to allocate a fake socket for RDMA-CM client: %s (code %d)\n", strerror(errno), errno);
+        rdma_destroy_id(ev->id);
+        return;
+    }
     auto rdma_context = rdmacm_create_qp(ev->id);
     if (!rdma_context)
     {
@@ -290,13 +297,12 @@ void osd_messenger_t::rdmacm_accept(rdma_cm_event *ev)
     // Wait for RDMA_CM_ESTABLISHED, and enable the connection only after it
     auto conn = new rdmacm_connecting_t;
     conn->cmid = ev->id;
-    conn->client_id = next_client_id++;
+    conn->peer_fd = fake_fd;
     conn->parsed_addr = *(sockaddr_storage*)rdma_get_peer_addr(ev->id);
     conn->rdma_context = rdma_context;
-    conn->is_incoming = true;
     rdmacm_set_conn_timeout(conn);
     rdmacm_connecting[ev->id] = conn;
-    fprintf(stderr, "[OSD %ju] new client %ju: connection from %s via RDMA-CM\n", this->osd_num, conn->client_id,
+    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());
 }
 
@@ -326,6 +332,8 @@ void osd_messenger_t::rdmacm_on_connect_peer_error(rdma_cm_id *cmid, int res)
     auto peer_osd = conn->peer_osd;
     if (conn->timeout_id >= 0)
         tfd->clear_timer(conn->timeout_id);
+    if (conn->peer_fd >= 0)
+        close(conn->peer_fd);
     if (conn->rdma_context)
         conn->rdma_context->reserve_cqe(-rdma_max_send-rdma_max_recv);
     if (conn->cmid)
@@ -346,7 +354,7 @@ void osd_messenger_t::rdmacm_on_connect_peer_error(rdma_cm_id *cmid, int res)
         else
         {
             // TCP is disabled
-            on_connect_peer(peer_osd, res == 0 ? -EINVAL : (res > 0 ? -res : res), 0);
+            on_connect_peer(peer_osd, res == 0 ? -EINVAL : (res > 0 ? -res : res));
         }
     }
 }
@@ -357,7 +365,7 @@ void osd_messenger_t::rdmacm_try_connect_peer(uint64_t peer_osd, const std::stri
     if (!string_to_addr(addr, false, rdmacm_port, &sa))
     {
         fprintf(stderr, "Address %s is invalid\n", addr.c_str());
-        on_connect_peer(peer_osd, -EINVAL, 0);
+        on_connect_peer(peer_osd, -EINVAL);
         return;
     }
     rdma_cm_id *cmid = NULL;
@@ -368,7 +376,17 @@ void osd_messenger_t::rdmacm_try_connect_peer(uint64_t peer_osd, const std::stri
         if (!disable_tcp)
             try_connect_peer_tcp(peer_osd, addr.c_str(), fallback_tcp_port);
         else
-            on_connect_peer(peer_osd, res, 0);
+            on_connect_peer(peer_osd, res);
+        return;
+    }
+    // Make a fake FD (FIXME: do not use FDs for identifying clients!)
+    int fake_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fake_fd < 0)
+    {
+        int res = -errno;
+        rdma_destroy_id(cmid);
+        // Can't create socket, pointless to try TCP
+        on_connect_peer(peer_osd, res);
         return;
     }
     if (log_level > 0)
@@ -376,7 +394,7 @@ void osd_messenger_t::rdmacm_try_connect_peer(uint64_t peer_osd, const std::stri
     auto conn = new rdmacm_connecting_t;
     rdmacm_connecting[cmid] = conn;
     conn->cmid = cmid;
-    conn->client_id = next_client_id++;
+    conn->peer_fd = fake_fd;
     conn->peer_osd = peer_osd;
     conn->addr = addr;
     conn->parsed_addr = sa;
@@ -493,15 +511,13 @@ void osd_messenger_t::rdmacm_established(rdma_cm_event *ev)
     auto cl = new osd_client_t();
     cl->peer_addr = conn->parsed_addr;
     cl->peer_port = conn->rdmacm_port;
-    cl->client_id = conn->client_id;
-    cl->is_incoming = conn->is_incoming;
+    cl->peer_fd = conn->peer_fd;
     cl->peer_state = PEER_RDMA;
     cl->connect_timeout_id = -1;
     cl->osd_num = peer_osd;
     cl->in_buf = (uint8_t*)malloc_or_die(receive_buffer_size);
     cl->rdma_conn = rc;
-    init_tls_client(cl);
-    clients[conn->client_id] = cl;
+    clients[conn->peer_fd] = cl;
     if (conn->timeout_id >= 0)
     {
         tfd->clear_timer(conn->timeout_id);

src/client/msgr_send.cpp

@@ -6,436 +6,11 @@
 #include <sys/epoll.h>
 
 #include "messenger.h"
-#include "msgr_iothread.h"
-
-#include <openssl/evp.h>
-#include <openssl/err.h>
-
-#define WR_GCM     1
-#define WR_XTS     2
-#define WR_NO_CSUM 4
-
-#define GCM_TMP_BUF_SIZE 4096
-
-class msgr_op_writer_t
-{
-public:
-    virtual bool write(uint8_t *src, size_t src_len, int flags = 0) = 0;
-    virtual bool finish() = 0;
-};
-
-class copy_op_writer_t: public msgr_op_writer_t
-{
-protected:
-    osd_messenger_t* msgr;
-    osd_client_t* cl;
-    size_t from;
-
-    uint8_t *curbuf;
-    size_t bufsize;
-    size_t done;
-
-public:
-    copy_op_writer_t(osd_messenger_t* msgr, osd_client_t* cl, uint8_t *curbuf, size_t bufsize):
-        msgr(msgr), cl(cl), from(cl->write_op_pos), curbuf(curbuf), bufsize(bufsize), done(0)
-    {}
-
-    void reset()
-    {
-        from = cl->write_op_pos;
-    }
-
-    bool write(uint8_t *src, size_t src_len, int flags = 0) override
-    {
-        if (from >= src_len)
-        {
-            from -= src_len;
-            return true;
-        }
-        if (flags & WR_XTS)
-        {
-            msgr->op_encrypted_copy_buf(cl, curbuf, bufsize, src, src_len, from, done);
-        }
-        else
-        {
-            size_t n = src_len-from;
-            if (n > bufsize-done)
-                n = bufsize-done;
-            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
-                XXH3_64bits_update(cl->write_csum_state, src+from, n);
-            memcpy(curbuf+done, src+from, n);
-            done += n;
-            cl->write_op_pos += n;
-            from += n;
-        }
-        if (from < src_len)
-            return false;
-        from = 0;
-        return true;
-    }
-
-    bool finish() override
-    {
-        return true;
-    }
-
-    size_t get_done()
-    {
-        return done;
-    }
-};
-
-class gcm_op_writer_t: public msgr_op_writer_t
-{
-    osd_messenger_t* msgr;
-    osd_client_t* cl;
-    size_t from;
-
-    uint8_t *curbuf;
-    size_t bufsize;
-    size_t done;
-
-public:
-    gcm_op_writer_t(osd_messenger_t* msgr, osd_client_t* cl, uint8_t *curbuf, size_t bufsize):
-        msgr(msgr), cl(cl), from(cl->write_op_pos), curbuf(curbuf), bufsize(bufsize), done(0)
-    {
-    }
-
-    void reset()
-    {
-        from = cl->write_op_pos;
-        init_ctx(msgr, cl);
-    }
-
-    static void init_ctx(osd_messenger_t* msgr, osd_client_t *cl)
-    {
-        if (!cl->enc_ctx)
-        {
-            if (msgr->encrypt_gcm_pool.size())
-            {
-                cl->enc_ctx = msgr->encrypt_gcm_pool.back();
-                msgr->encrypt_gcm_pool.pop_back();
-            }
-            else
-            {
-#ifdef WITH_ISAL_CRYPTO
-                cl->enc_ctx = (isal_gcm_context_data*)malloc_or_die(sizeof(isal_gcm_context_data));
-#else
-                cl->enc_ctx = EVP_CIPHER_CTX_new();
-                assert(cl->enc_ctx);
-                int r = EVP_EncryptInit_ex(cl->enc_ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
-                if (r != 1)
-                {
-                    fprintf(stderr, "EncryptInit error: ");
-                    ERR_print_errors_fp(stderr);
-                    abort();
-                }
-#endif
-            }
-        }
-        if (cl->my_iv_ctr >= AES_256_GCM_MAX_IV_CTR)
-        {
-            // Rotate key every 2^32 messages
-            bool ok = msgr->derive_aes_keys(cl, true, false);
-            assert(ok);
-        }
-#ifdef WITH_ISAL_CRYPTO
-        int r = isal_aes_gcm_init_256(&cl->my_key_isal, cl->enc_ctx, cl->my_key.data() + AES_256_GCM_KEY_SIZE, NULL, 0);
-        if (r != 0)
-        {
-            fprintf(stderr, "isal_aes_gcm_init_256 error %d\n", r);
-            abort();
-        }
-#else
-        int r = EVP_EncryptInit_ex(cl->enc_ctx, NULL, NULL, (uint8_t*)cl->my_key.data(), cl->my_key.data() + AES_256_GCM_KEY_SIZE);
-        if (r != 1)
-        {
-            fprintf(stderr, "EncryptInit error: ");
-            ERR_print_errors_fp(stderr);
-            abort();
-        }
-#endif
-        // Increase IV
-        cl->my_iv_ctr++;
-        (*(uint64_t*)(cl->my_key.data() + AES_256_GCM_KEY_SIZE))++;
-    }
-
-    static void free_ctx(osd_messenger_t* msgr, osd_client_t *cl)
-    {
-        if (msgr->encrypt_gcm_pool.size() < msgr->max_cipher_pool_size)
-            msgr->encrypt_gcm_pool.push_back(cl->enc_ctx);
-        else
-        {
-#ifdef WITH_ISAL_CRYPTO
-            free(cl->enc_ctx);
-#else
-            EVP_CIPHER_CTX_free(cl->enc_ctx);
-#endif
-        }
-        cl->enc_ctx = NULL;
-    }
-
-    bool write(uint8_t *src, size_t src_len, int flags) override
-    {
-        if (from >= src_len)
-        {
-            from -= src_len;
-            return true;
-        }
-        if (flags & WR_XTS)
-        {
-            msgr->op_encrypted_copy_buf(cl, curbuf, bufsize, src, src_len, from, done);
-        }
-        else if (flags & WR_GCM)
-        {
-            size_t n = src_len-from;
-            if (n > bufsize-done)
-                n = bufsize-done;
-            if (!n)
-                return false;
-#ifdef WITH_ISAL_CRYPTO
-            int r = isal_aes_gcm_enc_256_update(&cl->my_key_isal, cl->enc_ctx, curbuf+done, src+from, n);
-            assert(!r);
-#else
-            int actual_out;
-            if (EVP_EncryptUpdate(cl->enc_ctx, curbuf+done, &actual_out, src+from, n) != 1)
-            {
-                fprintf(stderr, "EncryptUpdate error: ");
-                ERR_print_errors_fp(stderr);
-                abort();
-            }
-            assert(actual_out == n);
-#endif
-            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
-                XXH3_64bits_update(cl->write_csum_state, src+from, n);
-            done += n;
-            cl->write_op_pos += n;
-            from += n;
-        }
-        else
-        {
-            size_t n = src_len-from;
-            if (n > bufsize-done)
-                n = bufsize-done;
-            if (!n)
-                return false;
-            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
-                XXH3_64bits_update(cl->write_csum_state, src+from, n);
-            memcpy(curbuf+done, src+from, n);
-            done += n;
-            cl->write_op_pos += n;
-            from += n;
-        }
-        if (from < src_len)
-            return false;
-        from = 0;
-        return true;
-    }
-
-    static void write_tag_to(osd_messenger_t *msgr, osd_client_t *cl, uint8_t *dst)
-    {
-#ifdef WITH_ISAL_CRYPTO
-        int r = isal_aes_gcm_enc_256_finalize(&cl->my_key_isal, cl->enc_ctx, dst, 16);
-        assert(!r);
-#else
-        int actual_out = 0;
-        int r = EVP_EncryptFinal_ex(cl->enc_ctx, NULL, &actual_out);
-        if (r != 1)
-        {
-            fprintf(stderr, "EncryptFinal error: ");
-            ERR_print_errors_fp(stderr);
-            abort();
-        }
-        assert(actual_out == 0);
-        r = EVP_CIPHER_CTX_ctrl(cl->enc_ctx, EVP_CTRL_GCM_GET_TAG, 16, dst);
-        assert(r == 1);
-#endif
-    }
-
-    bool finish() override
-    {
-        // Tag is 16 bytes
-        if (done >= bufsize)
-            return false;
-        if (bufsize-done < 16 || cl->enc_tag_size)
-        {
-            // No space for the full tag, but msgr_rdma expects us to always fill the whole buffer
-            if (!cl->enc_tag_size)
-            {
-                write_tag_to(msgr, cl, cl->enc_tag);
-                cl->enc_tag_size = 16;
-            }
-            size_t n = bufsize-done;
-            if (n > cl->enc_tag_size)
-                n = cl->enc_tag_size;
-            memcpy(curbuf+done, cl->enc_tag+16-cl->enc_tag_size, n);
-            done += n;
-            cl->enc_tag_size -= n;
-            if (cl->enc_tag_size > 0)
-                return false;
-        }
-        else
-        {
-            // The whole tag fits at once
-            write_tag_to(msgr, cl, curbuf+done);
-            done += 16;
-        }
-        free_ctx(msgr, cl);
-        return true;
-    }
-
-    size_t get_done()
-    {
-        return done;
-    }
-};
-
-class get_op_writer_t: public msgr_op_writer_t
-{
-    osd_messenger_t* msgr;
-    osd_client_t* cl;
-    size_t from;
-    size_t done;
-    size_t op_enc;
-    size_t enc_size;
-    size_t done_enc;
-    uint8_t *enc_buf;
-
-public:
-    get_op_writer_t(osd_messenger_t* msgr, osd_client_t* cl, uint8_t*, size_t):
-        msgr(msgr), cl(cl), from(cl->write_op_pos), done(0), enc_size(0), done_enc(0), enc_buf(NULL)
-    {
-    }
-
-    void reset()
-    {
-        op_enc = 0;
-        from = cl->write_op_pos;
-        if (cl->gcm_enabled)
-        {
-            gcm_op_writer_t::init_ctx(msgr, cl);
-        }
-    }
-
-    void extend_tmp(size_t n)
-    {
-        if (!enc_buf || done_enc + n > enc_size)
-        {
-            enc_size = n < GCM_TMP_BUF_SIZE ? GCM_TMP_BUF_SIZE : n;
-            enc_buf = (uint8_t*)malloc_or_die(enc_size);
-            done_enc = 0;
-            assert(!((size_t)enc_buf & 7));
-            cl->send_free_ops.push_back((osd_op_t*)((size_t)enc_buf | 1));
-        }
-    }
-
-    void send_tmp(size_t n)
-    {
-        if (cl->send_list.size() && cl->send_list.back().iov_base == (enc_buf + done_enc))
-            cl->send_list.back().iov_len += n;
-        else
-            cl->send_list.push_back((iovec){ .iov_base = enc_buf + done_enc, .iov_len = n });
-        done += n;
-        done_enc += n;
-    }
-
-    bool write(uint8_t *src, size_t src_len, int flags) override
-    {
-        if (from >= src_len)
-        {
-            // Skip
-            from -= src_len;
-            return true;
-        }
-        if (cl->send_list.size() >= IOV_MAX-1)
-        {
-            // Make sure tag always fits
-            return false;
-        }
-        if (flags & WR_XTS)
-        {
-            // Allocate a temporary buffer and encrypt data to it
-            if (!op_enc)
-            {
-                assert(cl->write_op->req.hdr.opcode == OSD_OP_WRITE);
-                op_enc = cl->write_op->req.rw.len - from + (from % 16);
-                assert(op_enc > 0);
-                extend_tmp(op_enc);
-            }
-            size_t new_done = done_enc;
-            msgr->op_encrypted_copy_buf(cl, enc_buf, enc_size, src, src_len, from, new_done);
-            send_tmp(new_done-done_enc);
-            assert(from == src_len);
-        }
-        else if ((flags & WR_GCM) && cl->gcm_enabled)
-        {
-            // Allocate a temporary buffer and encrypt data to it
-            size_t n = src_len-from;
-            extend_tmp(n);
-#ifdef WITH_ISAL_CRYPTO
-            int r = isal_aes_gcm_enc_256_update(&cl->my_key_isal, cl->enc_ctx, enc_buf+done_enc, src+from, n);
-            assert(!r);
-#else
-            int actual_out;
-            if (EVP_EncryptUpdate(cl->enc_ctx, enc_buf+done_enc, &actual_out, src+from, n) != 1)
-            {
-                fprintf(stderr, "EncryptUpdate error: ");
-                ERR_print_errors_fp(stderr);
-                abort();
-            }
-            assert(actual_out == n);
-#endif
-            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
-                XXH3_64bits_update(cl->write_csum_state, src+from, n);
-            send_tmp(n);
-            cl->write_op_pos += n;
-            from += n;
-            if (from < src_len)
-                return false;
-            from = 0;
-            return true;
-        }
-        else
-        {
-            if (cl->write_csum_state && !(flags & WR_NO_CSUM))
-                XXH3_64bits_update(cl->write_csum_state, src+from, src_len-from);
-            cl->send_list.push_back((iovec){ src+from, src_len-from });
-            done += src_len-from;
-            cl->write_op_pos += src_len-from;
-        }
-        from = 0;
-        return true;
-    }
-
-    bool finish() override
-    {
-        if (cl->enc_ctx)
-        {
-            // Tag is 16 bytes
-            extend_tmp(16);
-            gcm_op_writer_t::write_tag_to(msgr, cl, enc_buf + done_enc);
-            send_tmp(16);
-            gcm_op_writer_t::free_ctx(msgr, cl);
-        }
-        return true;
-    }
-
-    size_t get_done()
-    {
-        return done;
-    }
-};
 
 void osd_messenger_t::outbox_push(osd_op_t *cur_op)
 {
-    assert(cur_op->client_id);
-    auto cl_it = clients.find(cur_op->client_id);
-    if (cl_it == clients.end() || cl_it->second->peer_state == PEER_STOPPED)
-    {
-        delete cur_op;
-        return;
-    }
-    osd_client_t *cl = cl_it->second;
+    assert(cur_op->peer_fd);
+    osd_client_t *cl = clients.at(cur_op->peer_fd);
     if (cur_op->op_type == OSD_OP_OUT)
     {
         clock_gettime(CLOCK_REALTIME, &cur_op->tv_begin);
@@ -444,7 +19,8 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
     }
     else
     {
-        // Remove the operation from received op list
+        // Check that operation actually belongs to this client
+        // FIXME: Review if this is still needed
         bool found = false;
         for (auto it = cl->received_ops.begin(); it != cl->received_ops.end(); it++)
         {
@@ -455,8 +31,11 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
                 break;
             }
         }
-        // Can't be not found because client IDs are unique
-        assert(found);
+        if (!found)
+        {
+            delete cur_op;
+            return;
+        }
         measure_exec(cur_op);
     }
     cl->write_ops.push_back(cur_op);
@@ -477,10 +56,10 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
     }
     else
     {
-        if (!try_send(cl) && cl->write_state == 0)
+        if ((cl->write_msg.msg_iovlen > 0 || !try_send(cl)) && (cl->write_state == 0))
         {
             cl->write_state = CL_WRITE_READY;
-            write_ready_clients.push_back(cl->client_id);
+            write_ready_clients.push_back(cur_op->peer_fd);
         }
         ringloop->wakeup();
     }
@@ -537,51 +116,29 @@ void osd_messenger_t::measure_exec(osd_op_t *cur_op)
 
 bool osd_messenger_t::try_send(osd_client_t *cl)
 {
-    if (cl->peer_state == PEER_STOPPED || cl->peer_fd < 0)
+    int peer_fd = cl->peer_fd;
+    if (!cl->write_op && !cl->write_ops.size() || cl->write_msg.msg_iovlen > 0)
     {
         return true;
     }
-    if (cl->write_msg.msg_iovlen > 0 || !ringloop->space_left() && !use_sync_send_recv)
-    {
-        return false;
-    }
     assert(cl->peer_state != PEER_RDMA);
-    if (cl->hs)
+    while ((cl->write_op || cl->write_ops.size()) && cl->send_list.size() < IOV_MAX)
     {
-        // Send handshake message
-        if (cl->hs->out_size())
+        if (!cl->write_op)
         {
-            uint8_t *out = cl->hs->get_out();
-            cl->send_list.push_back((iovec){ .iov_base = out, .iov_len = cl->hs->out_size() });
-            assert(!((size_t)out & 7));
-            cl->send_free_ops.push_back((osd_op_t*)((size_t)out | 1));
-            cl->hs->reset_out();
+            cl->write_op = cl->write_ops.front();
+            cl->write_ops.pop_front();
         }
-        if (!cl->hs->out_size() && cl->hs->done())
+        osd_op_t *op = cl->write_op;
+        op_get_write_buffers(cl, cl->send_list);
+        if (!cl->write_op && op->op_type == OSD_OP_IN)
         {
-            delete cl->hs;
-            cl->hs = NULL;
-            goto copy_ops;
+            cl->send_free_ops.push_back(op);
         }
     }
-    else
+    if (ringloop && !use_sync_send_recv)
     {
-copy_ops:
-        copy_ops_to_with<get_op_writer_t>(cl, NULL, 0);
-    }
-    if (cl->io_error)
-    {
-        stop_client(cl->client_id);
-        return true;
-    }
-    if (!cl->send_list.size())
-    {
-        cl->write_state = 0;
-        return true;
-    }
-    if (!use_sync_send_recv)
-    {
-        auto iothread = iothreads.size() ? iothreads[cl->peer_fd % iothreads.size()] : NULL;
+        auto iothread = iothreads.size() ? iothreads[peer_fd % iothreads.size()] : NULL;
         io_uring_sqe sqe_local;
         ring_data_t data_local;
         io_uring_sqe* sqe = (iothread ? &sqe_local : ringloop->get_sqe());
@@ -590,7 +147,10 @@ copy_ops:
             sqe_local = { .user_data = (uint64_t)&data_local };
             data_local = {};
         }
-        assert(sqe);
+        if (!sqe)
+        {
+            return false;
+        }
         cl->send_list_size = 0;
         for (auto & iov: cl->send_list)
         {
@@ -609,11 +169,11 @@ copy_ops:
         }
         if (use_zc)
         {
-            io_uring_prep_sendmsg_zc(sqe, cl->peer_fd, &cl->write_msg, MSG_WAITALL);
+            io_uring_prep_sendmsg_zc(sqe, peer_fd, &cl->write_msg, MSG_WAITALL);
         }
         else
         {
-            io_uring_prep_sendmsg(sqe, cl->peer_fd, &cl->write_msg, MSG_WAITALL);
+            io_uring_prep_sendmsg(sqe, peer_fd, &cl->write_msg, MSG_WAITALL);
         }
         if (iothread)
         {
@@ -625,7 +185,7 @@ copy_ops:
         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++;
-        int result = sendmsg(cl->peer_fd, &cl->write_msg, MSG_NOSIGNAL);
+        int result = sendmsg(peer_fd, &cl->write_msg, MSG_NOSIGNAL);
         if (result < 0)
         {
             result = -errno;
@@ -636,81 +196,12 @@ copy_ops:
     return true;
 }
 
-size_t osd_messenger_t::copy_ops_to(osd_client_t *cl, uint8_t *dst, size_t dst_len)
-{
-    if (cl->gcm_enabled)
-    {
-        if (cl->hs)
-        {
-            // Send handshake message
-            size_t n = 0;
-            if (cl->hs->out_size())
-            {
-                n = cl->hs->out_size() < dst_len ? cl->hs->out_size() : dst_len;
-                memcpy(dst, cl->hs->get_out(), n);
-                cl->hs->eat_out(n);
-            }
-            if (!cl->hs->out_size() && cl->hs->done())
-            {
-                delete cl->hs;
-                cl->hs = NULL;
-                n += copy_ops_to_with<gcm_op_writer_t>(cl, dst+n, dst_len-n);
-            }
-            return n;
-        }
-        return copy_ops_to_with<gcm_op_writer_t>(cl, dst, dst_len);
-    }
-    return copy_ops_to_with<copy_op_writer_t>(cl, dst, dst_len);
-}
-
-template<typename T>
-size_t osd_messenger_t::copy_ops_to_with(osd_client_t *cl, uint8_t *dst, size_t dst_len)
-{
-    T wr(this, cl, dst, dst_len);
-    while (cl->write_op || cl->write_ops.size())
-    {
-        if (!cl->write_op)
-        {
-            wr.reset();
-            next_write_op(cl);
-        }
-        osd_op_t *op = cl->write_op;
-        if (!op_write_to(cl, wr))
-        {
-            if (cl->io_error)
-                return 0;
-            break;
-        }
-        if (!cl->write_op && op->op_type == OSD_OP_IN)
-        {
-            // this is a reply, free the op after sending it
-            cl->send_free_ops.push_back(op);
-        }
-    }
-    return wr.get_done();
-}
-
-void osd_messenger_t::next_write_op(osd_client_t *cl)
-{
-    cl->write_op = cl->write_ops.front();
-    cl->write_ops.pop_front();
-    if (cl->proto_csum_status == MSGR_CSUM_FULL || cl->proto_csum_status == MSGR_CSUM_PAYLOAD)
-    {
-        if (!cl->write_csum_state)
-            cl->write_csum_state = XXH3_createState();
-        if (cl->my_key.size() == AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE + XXH_SECRET_DEFAULT_SIZE)
-            XXH3_64bits_reset_withSecret(cl->write_csum_state, cl->my_key.data() + AES_256_GCM_KEY_SIZE + AES_256_GCM_IV_SIZE, XXH_SECRET_DEFAULT_SIZE);
-        else
-            XXH3_64bits_reset(cl->write_csum_state);
-    }
-}
-
 void osd_messenger_t::send_replies()
 {
     for (int i = 0; i < write_ready_clients.size(); i++)
     {
-        uint64_t client_id = write_ready_clients[i];
-        auto cl_it = clients.find(client_id);
+        int peer_fd = write_ready_clients[i];
+        auto cl_it = clients.find(peer_fd);
         if (cl_it != clients.end() && cl_it->second->peer_state != PEER_RDMA && !try_send(cl_it->second))
         {
             write_ready_clients.erase(write_ready_clients.begin(), write_ready_clients.begin() + i);
@@ -735,15 +226,15 @@ void osd_messenger_t::handle_send(int result, bool prev, bool more, osd_client_t
     {
         if (cl->refs <= 0)
         {
-            destroy_client(cl);
+            delete cl;
         }
         return;
     }
     if (result < 0 && result != -EAGAIN && result != -EINTR)
     {
         // this is a client socket, so don't panic. just disconnect it
-        fprintf(stderr, "Client %ju socket write error: %d (%s). Disconnecting client\n", cl->client_id, -result, strerror(-result));
-        stop_client(cl->client_id);
+        fprintf(stderr, "Client %d socket write error: %d (%s). Disconnecting client\n", cl->peer_fd, -result, strerror(-result));
+        stop_client(cl->peer_fd);
         return;
     }
     if (result >= 0)
@@ -753,50 +244,36 @@ void osd_messenger_t::handle_send(int result, bool prev, bool more, osd_client_t
             // 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++)
-            {
-                if (!((size_t)cl->zc_free_list[i] & 7))
-                    delete cl->zc_free_list[i];
-                else
-                    free((void*)((size_t)cl->zc_free_list[i] & ~(size_t)7));
-            }
+                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;
         }
         if (cl->send_list_size > result)
         {
-            fprintf(stderr, "Client %ju socket write error: expected to send "
-                "%zu bytes with MSG_WAITALL but sent %u. Disconnecting client\n", cl->client_id, cl->send_list_size, result);
-            stop_client(cl->client_id);
+            fprintf(stderr, "Client %d socket write error: expected to send "
+                "%zu bytes with MSG_WAITALL but sent %u. Disconnecting client\n", cl->peer_fd, cl->send_list_size, result);
+            stop_client(cl->peer_fd);
             return;
         }
         for (auto op: cl->send_free_ops)
         {
             if (more)
                 cl->zc_free_list.push_back(op);
-            else if (!((size_t)op & 7))
-                delete op;
             else
-                free((void*)((size_t)op & ~(size_t)7));
+                delete op;
         }
         if (more)
             cl->zc_free_list.push_back(NULL); // end marker
         cl->send_free_ops.clear();
-        cl->write_state = 0;
-        if (cl->write_op || cl->write_ops.size())
-            cl->write_state = CL_WRITE_READY;
-        if ((cl->proto_csum_status & MSGR_CSUM_NEG) && !cl->write_op && !cl->write_ops.size())
-        {
-            // Checksums negotiated, enable
-            cl->proto_csum_status = cl->proto_csum_status & (~MSGR_CSUM_NEG);
-        }
+        cl->write_state = cl->write_op || cl->write_ops.size() ? CL_WRITE_READY : 0;
 #ifdef WITH_RDMA
         if (cl->rdma_conn && !cl->write_op && !cl->write_ops.size() && cl->peer_state == PEER_RDMA_CONNECTING)
         {
             // FIXME: Ignore pings during RDMA state transition
             if (log_level > 0)
             {
-                fprintf(stderr, "Successfully connected with client %ju using RDMA\n", cl->client_id);
+                fprintf(stderr, "Successfully connected with client %d using RDMA\n", cl->peer_fd);
             }
             cl->peer_state = PEER_RDMA;
             // Add the initial receive request
@@ -806,103 +283,161 @@ void osd_messenger_t::handle_send(int result, bool prev, bool more, osd_client_t
     }
     if (cl->write_state != 0)
     {
-        write_ready_clients.push_back(cl->client_id);
+        write_ready_clients.push_back(cl->peer_fd);
     }
 }
 
-static inline bool op_has_data_for_ssl(osd_op_t *op)
+static inline bool op_write_headers(osd_op_t *op, std::function<bool(uint8_t*, size_t)> op_write_buf)
+{
+    // Header
+    if (!op_write_buf((op->op_type == OSD_OP_IN ? op->reply.buf : op->req.buf), OSD_PACKET_SIZE))
+        return false;
+    // Bitmap
+    if (op->op_type == OSD_OP_IN &&
+        op->req.hdr.opcode == OSD_OP_SEC_READ &&
+        op->reply.sec_rw.attr_len > 0)
+    {
+        if (!op_write_buf((uint8_t*)op->bitmap, op->reply.sec_rw.attr_len))
+            return false;
+    }
+    else if (op->op_type == OSD_OP_OUT &&
+        (op->req.hdr.opcode == OSD_OP_SEC_WRITE || op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE) &&
+        op->req.sec_rw.attr_len > 0)
+    {
+        if (!op_write_buf((uint8_t*)op->bitmap, op->req.sec_rw.attr_len))
+            return false;
+    }
+    if (op->req.hdr.opcode == OSD_OP_SEC_READ_BMP)
+    {
+        if (op->op_type == OSD_OP_IN && op->reply.hdr.retval > 0)
+        {
+            if (!op_write_buf((uint8_t*)op->buf, (size_t)op->reply.hdr.retval))
+                return false;
+        }
+        else if (op->op_type == OSD_OP_OUT && op->req.sec_read_bmp.len > 0)
+        {
+            if (!op_write_buf((uint8_t*)op->buf, (size_t)op->req.sec_read_bmp.len))
+                return false;
+        }
+    }
+    return true;
+}
+
+static inline bool op_has_data(osd_op_t *op)
 {
     return (op->op_type == OSD_OP_IN
-        ? (op->req.hdr.opcode == OSD_OP_SEC_LIST ||
+        ? (op->req.hdr.opcode == OSD_OP_READ ||
+        op->req.hdr.opcode == OSD_OP_SEC_READ ||
+        op->req.hdr.opcode == OSD_OP_SEC_LIST ||
         op->req.hdr.opcode == OSD_OP_SHOW_CONFIG ||
         op->req.hdr.opcode == OSD_OP_DESCRIBE)
-        : (op->req.hdr.opcode == OSD_OP_SEC_STABILIZE ||
+        : (op->req.hdr.opcode == OSD_OP_WRITE ||
+        op->req.hdr.opcode == OSD_OP_SEC_WRITE ||
+        op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE ||
+        op->req.hdr.opcode == OSD_OP_SEC_STABILIZE ||
         op->req.hdr.opcode == OSD_OP_SEC_ROLLBACK ||
         op->req.hdr.opcode == OSD_OP_SHOW_CONFIG)) && op->iov.count > 0;
 }
 
-static inline bool op_has_data_for_nonssl(osd_op_t *op)
+size_t osd_messenger_t::op_copy_to(osd_client_t *cl, uint8_t *dst, size_t dst_len)
 {
-    return (op->op_type == OSD_OP_IN
-        ? (op->req.hdr.opcode == OSD_OP_READ ||
-        op->req.hdr.opcode == OSD_OP_SEC_READ)
-        : (op->req.hdr.opcode == OSD_OP_WRITE ||
-        op->req.hdr.opcode == OSD_OP_SEC_WRITE ||
-        op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE)) && op->iov.count > 0;
-}
-
-bool osd_messenger_t::op_write_to(osd_client_t *cl, msgr_op_writer_t & wr)
-{
-    osd_op_t *op = cl->write_op;
-    // Header
-    if (!wr.write((op->op_type == OSD_OP_IN ? op->reply.buf : op->req.buf), OSD_PACKET_SIZE,
-        WR_GCM | (cl->proto_csum_status == MSGR_CSUM_PAYLOAD ? WR_NO_CSUM : 0)))
+    size_t done = 0;
+    size_t from = cl->write_op_pos;
+    auto op_write_buf = [&](uint8_t *src, size_t src_len)
     {
-        return false;
-    }
-    // Bitmap
-    if (op->op_type == OSD_OP_IN)
+        if (from < src_len)
+        {
+            size_t n = src_len-from;
+            if (n > dst_len-done)
+                n = dst_len-done;
+            memcpy(dst+done, src+from, n);
+            done += n;
+            cl->write_op_pos += n;
+            from += n;
+            if (from < src_len)
+                return false;
+            from = 0;
+        }
+        else
+            from -= src_len;
+        return true;
+    };
+    if (!op_write_headers(cl->write_op, op_write_buf))
     {
-        if (op->req.hdr.opcode == OSD_OP_SEC_READ && op->reply.sec_rw.attr_len > 0)
-        {
-            if (!wr.write((uint8_t*)op->bitmap, op->reply.sec_rw.attr_len, WR_GCM))
-                return false;
-        }
-        else if (op->req.hdr.opcode == OSD_OP_SEC_READ_BMP && op->reply.hdr.retval > 0)
-        {
-            if (!wr.write((uint8_t*)op->buf, (size_t)op->reply.hdr.retval, WR_GCM))
-                return false;
-        }
-        else if (op->req.hdr.opcode == OSD_OP_READ && op->reply.rw.bitmap_len > 0)
-        {
-            if (!wr.write((uint8_t*)op->bitmap, op->reply.rw.bitmap_len, WR_GCM))
-                return false;
-        }
-    }
-    else if (op->op_type == OSD_OP_OUT)
-    {
-        if ((op->req.hdr.opcode == OSD_OP_SEC_WRITE || op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE) &&
-            op->req.sec_rw.attr_len > 0)
-        {
-            if (!wr.write((uint8_t*)op->bitmap, op->req.sec_rw.attr_len, WR_GCM))
-                return false;
-        }
-        else if (op->req.hdr.opcode == OSD_OP_SEC_READ_BMP && op->req.sec_read_bmp.len > 0)
-        {
-            if (!wr.write((uint8_t*)op->buf, (size_t)op->req.sec_read_bmp.len, WR_GCM))
-                return false;
-        }
+        return done;
     }
     // Operation data
-    if (op_has_data_for_ssl(op))
+    if (op_has_data(cl->write_op))
     {
-        for (int i = 0; i < cl->write_op->iov.count; i++)
+        if (cl->write_op->enc)
         {
-            auto & iov = cl->write_op->iov.buf[i];
-            if (!wr.write((uint8_t*)iov.iov_base, iov.iov_len, WR_GCM))
-                return false;
+            if (!op_encrypted_copy_data_to(cl, dst, dst_len, from, done))
+            {
+                return done;
+            }
+        }
+        else
+        {
+            for (int i = 0; i < cl->write_op->iov.count; i++)
+            {
+                if (!op_write_buf((uint8_t*)cl->write_op->iov.buf[i].iov_base, cl->write_op->iov.buf[i].iov_len))
+                    return done;
+            }
+        }
+    }
+    cl->write_op = NULL;
+    cl->write_op_pos = 0;
+    return done;
+}
+
+void osd_messenger_t::op_get_write_buffers(osd_client_t *cl, std::vector<iovec> & lst)
+{
+    size_t from = cl->write_op_pos;
+    auto op_write_buf = [&](uint8_t *src, size_t src_len)
+    {
+        if (lst.size() >= IOV_MAX)
+            return false;
+        if (from < src_len)
+        {
+            lst.push_back((iovec){ .iov_base = src+from, .iov_len = src_len-from });
+            cl->write_op_pos += src_len-from;
+            from = 0;
+        }
+        else
+            from -= src_len;
+        return true;
+    };
+    if (!op_write_headers(cl->write_op, op_write_buf))
+    {
+        return;
+    }
+    // Operation data
+    if (op_has_data(cl->write_op))
+    {
+        if (cl->write_op->enc)
+        {
+            if (lst.size() >= IOV_MAX)
+                return;
+            // No way except to allocate a temporary buffer and encrypt data to it
+            assert(cl->write_op->req.hdr.opcode == OSD_OP_WRITE);
+            size_t remsize = cl->write_op->req.rw.len - from + (from % 16);
+            assert(remsize > 0);
+            assert(!cl->write_op->enc_buf);
+            cl->write_op->enc_buf = (uint8_t*)malloc_or_die(remsize);
+            size_t done = 0;
+            bool end = op_encrypted_copy_data_to(cl, cl->write_op->enc_buf, remsize, from, done);
+            assert(end);
+            lst.push_back((iovec){ .iov_base = cl->write_op->enc_buf, .iov_len = remsize });
+        }
+        else
+        {
+            for (int i = 0; i < cl->write_op->iov.count; i++)
+            {
+                if (!op_write_buf((uint8_t*)cl->write_op->iov.buf[i].iov_base, cl->write_op->iov.buf[i].iov_len))
+                    return;
+            }
         }
     }
-    else if (op_has_data_for_nonssl(op))
-    {
-        for (int i = 0; i < cl->write_op->iov.count; i++)
-        {
-            auto & iov = cl->write_op->iov.buf[i];
-            if (!wr.write((uint8_t*)iov.iov_base, iov.iov_len, (op->enc ? WR_XTS : 0) | (cl->proto_csum_status == MSGR_CSUM_GCM ? WR_GCM : 0)))
-                return false;
-        }
-    }
-    if (cl->proto_csum_status == MSGR_CSUM_FULL ||
-        cl->proto_csum_status == MSGR_CSUM_PAYLOAD && cl->write_op_pos > OSD_PACKET_SIZE)
-    {
-        cl->write_op->csum = XXH3_64bits_digest(cl->write_csum_state);
-        if (!wr.write((uint8_t*)&cl->write_op->csum, 8, WR_GCM|WR_NO_CSUM))
-            return false;
-    }
-    if (!wr.finish())
-        return false;
-    op_encrypt_free(cl);
     cl->write_op = NULL;
     cl->write_op_pos = 0;
-    return true;
 }

src/client/msgr_stop.cpp

@@ -5,9 +5,9 @@
 #include <assert.h>
 
 #include "messenger.h"
-#include "../util/xxh_x86dispatch.h"
-#include <openssl/evp.h>
-#include <openssl/pem.h>
+#ifdef WITH_RDMA
+#include "msgr_rdma.h"
+#endif
 
 void osd_client_t::cancel_ops()
 {
@@ -43,57 +43,51 @@ void osd_op_t::cancel()
     }
 }
 
-// force_delete means stop the client anyway, even if there are refs to it in the event loop.
-// the flag should be used in the destructor.
-// why? - because yes, we could close the FD first and let it fail all requests in the event loop,
-// but in that case it can be quickly reopened and we can get old failed responses for the new FD.
-void osd_messenger_t::stop_client(uint64_t client_id, bool force_delete)
+void osd_messenger_t::stop_client(int peer_fd, bool force, bool force_delete)
 {
-    auto it = clients.find(client_id);
-    if (!client_id || it == clients.end())
+    assert(peer_fd != 0);
+    auto it = clients.find(peer_fd);
+    if (it == clients.end())
     {
         return;
     }
     osd_client_t *cl = it->second;
-    if (cl->peer_state == PEER_STOPPED)
+    // FIXME: This 'force' flag is probably an ugly reenterability hack - check its logic and maybe remove it
+    if (cl->peer_state == PEER_CONNECTING && !force || cl->peer_state == PEER_STOPPED)
     {
-        if (force_delete)
-        {
-            destroy_client(cl);
-        }
         return;
     }
-    cl->received_ops.clear();
+    clear_immediate_ops(peer_fd);
     if (log_level > 0)
     {
         if (cl->osd_num)
         {
-            fprintf(stderr, "[OSD %ju] Stopping client %ju (OSD peer %ju)\n", osd_num, client_id, cl->osd_num);
+            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 %ju (incoming OSD peer %ju)\n", osd_num, client_id, 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 %ju (regular client)\n", osd_num, client_id);
+            fprintf(stderr, "[OSD %ju] Stopping client %d (regular client)\n", osd_num, peer_fd);
         }
     }
-    if (cl->xts_enc_ctx)
+    if (cl->encrypt_ctx)
     {
-        if (encrypt_xts_pool.size() > max_cipher_pool_size)
-            destroy_aes_xts_encrypt(cl->xts_enc_ctx);
+        if (encrypt_ctx_pool.size() > max_aes_xts_pool_size)
+            destroy_aes_xts_encrypt(cl->encrypt_ctx);
         else
-            encrypt_xts_pool.push_back(cl->xts_enc_ctx);
-        cl->xts_enc_ctx = NULL;
+            encrypt_ctx_pool.push_back(cl->encrypt_ctx);
+        cl->encrypt_ctx = NULL;
     }
-    if (cl->xts_dec_ctx)
+    if (cl->decrypt_ctx)
     {
-        if (decrypt_xts_pool.size() > max_cipher_pool_size)
-            destroy_aes_xts_decrypt(cl->xts_dec_ctx);
+        if (decrypt_ctx_pool.size() > max_aes_xts_pool_size)
+            destroy_aes_xts_decrypt(cl->decrypt_ctx);
         else
-            decrypt_xts_pool.push_back(cl->xts_dec_ctx);
-        cl->xts_dec_ctx = NULL;
+            decrypt_ctx_pool.push_back(cl->decrypt_ctx);
+        cl->decrypt_ctx = NULL;
     }
     // First set state to STOPPED so another stop_client() call doesn't try to free it again
     cl->refs++;
@@ -101,18 +95,48 @@ void osd_messenger_t::stop_client(uint64_t client_id, bool force_delete)
     cl->peer_state = PEER_STOPPED;
     if (cl->osd_num)
     {
-        auto osd_it = osd_peers.find(cl->osd_num);
-        if (osd_it != osd_peers.end() && osd_it->second == cl)
+        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_peers.erase(osd_it);
+            osd_peer_fds.erase(osd_it);
         }
     }
+#ifdef WITH_RDMA
+    if (cl->rdma_conn && cl->rdma_conn->cmid)
+    {
+        auto rdma_it = rdmacm_connections.find(cl->rdma_conn->cmid);
+        if (rdma_it != rdmacm_connections.end() && rdma_it->second == cl)
+        {
+            rdmacm_connections.erase(rdma_it);
+        }
+    }
+#endif
+#ifndef __MOCK__
+    // Then remove FD from the eventloop so we don't accidentally read something
+    tfd->set_fd_handler(peer_fd, false, NULL);
     if (cl->connect_timeout_id >= 0)
     {
         tfd->clear_timer(cl->connect_timeout_id);
         cl->connect_timeout_id = -1;
     }
+    for (auto rit = read_ready_clients.begin(); rit != read_ready_clients.end(); rit++)
+    {
+        if (*rit == peer_fd)
+        {
+            read_ready_clients.erase(rit);
+            break;
+        }
+    }
+    for (auto wit = write_ready_clients.begin(); wit != write_ready_clients.end(); wit++)
+    {
+        if (*wit == peer_fd)
+        {
+            write_ready_clients.erase(wit);
+            break;
+        }
+    }
+#endif
     if (cl->in_osd_num && break_pg_locks)
     {
         // Break PG locks
@@ -126,56 +150,19 @@ void osd_messenger_t::stop_client(uint64_t client_id, bool force_delete)
         // so do not repeer on it.
         repeer_pgs(cl->osd_num);
     }
-    if (cl->peer_fd >= 0)
+    // Find the item again because it can be invalidated at this point
+    it = clients.find(peer_fd);
+    if (it != clients.end())
     {
-        int r = shutdown(cl->peer_fd, SHUT_RDWR);
-        if (r != 0 && errno != ENOTCONN)
-        {
-            fprintf(stderr, "[OSD %ju] failed to shutdown a socket: %s (code %d)\n", osd_num, strerror(errno), errno);
-        }
+        clients.erase(it);
     }
     cl->refs--;
     if (cl->refs <= 0 || force_delete)
     {
-        destroy_client(cl);
+        delete cl;
     }
 }
 
-void osd_messenger_t::destroy_client(osd_client_t *cl)
-{
-    // Find the item again because it can be invalidated at this point
-    clients.erase(cl->client_id);
-    if (cl->peer_fd >= 0)
-    {
-        tfd->set_fd_handler(cl->peer_fd, false, NULL);
-        for (auto rit = read_ready_clients.begin(); rit != read_ready_clients.end(); rit++)
-        {
-            if (*rit == cl->client_id)
-            {
-                read_ready_clients.erase(rit);
-                break;
-            }
-        }
-        for (auto wit = write_ready_clients.begin(); wit != write_ready_clients.end(); wit++)
-        {
-            if (*wit == cl->client_id)
-            {
-                write_ready_clients.erase(wit);
-                break;
-            }
-        }
-        clients_by_fd.erase(cl->peer_fd);
-    }
-#ifdef WITH_RDMA
-    if (cl->rdma_conn)
-    {
-        destroy_rdma_conn(cl->rdma_conn);
-        cl->rdma_conn = NULL;
-    }
-#endif
-    delete cl;
-}
-
 osd_client_t::~osd_client_t()
 {
     free(in_buf);
@@ -202,58 +189,23 @@ osd_client_t::~osd_client_t()
     {
         if (op)
         {
-            if (!((size_t)op & 7))
-                delete op;
-            else
-                free((void*)((size_t)op & ~(size_t)7));
+            delete op;
         }
     }
     for (osd_op_t *op: zc_free_list)
     {
         if (op)
         {
-            if (!((size_t)op & 7))
-                delete op;
-            else
-                free((void*)((size_t)op & ~(size_t)7));
+            delete op;
         }
     }
-    if (read_csum_state)
+#ifndef __MOCK__
+#ifdef WITH_RDMA
+    if (rdma_conn)
     {
-        XXH3_freeState(read_csum_state);
-        read_csum_state = NULL;
+        delete rdma_conn;
+        rdma_conn = NULL;
     }
-    if (write_csum_state)
-    {
-        XXH3_freeState(write_csum_state);
-        write_csum_state = NULL;
-    }
-    if (enc_ctx)
-    {
-#ifdef WITH_ISAL_CRYPTO
-        free(enc_ctx);
-#else
-        EVP_CIPHER_CTX_free(enc_ctx);
 #endif
-        enc_ctx = NULL;
-    }
-    if (dec_ctx)
-    {
-#ifdef WITH_ISAL_CRYPTO
-        free(dec_ctx);
-#else
-        EVP_CIPHER_CTX_free(dec_ctx);
 #endif
-        dec_ctx = NULL;
-    }
-    if (hs)
-    {
-        delete hs;
-        hs = NULL;
-    }
-    if (hs_result.peer_cert)
-    {
-        X509_free(hs_result.peer_cert);
-        hs_result.peer_cert = NULL;
-    }
 }

src/client/osd_ops.h

@@ -231,25 +231,12 @@ struct __attribute__((__packed__)) osd_op_rw_t
     uint32_t len;
     // flags
     // OSD_OP_RETURN_CHAIN for chained reads: return parent number in chain for each block
-    // read_chain size comes after bitmap, takes 0 bytes / 1 byte / 2 byte / 4 byte per each block,
-    // depending on the number of parent inodes (0 parents = 0 bytes, up to 255 parents = 1 byte, etc)
     uint32_t flags;
     // inode metadata revision for chained reads
     uint64_t meta_revision;
     // object version for atomic "CAS" (compare-and-set) writes
     // writes and deletes fail with -EINTR if object version differs from (version-1)
     uint64_t version;
-
-    static inline size_t chain_info_bytes(size_t chain_size)
-    {
-        if (chain_size <= 1)
-            return 0;
-        if (chain_size <= 256)
-            return 1;
-        if (chain_size <= 65536)
-            return 2;
-        return 4;
-    }
 };
 
 struct __attribute__((__packed__)) osd_reply_rw_t
@@ -260,6 +247,15 @@ struct __attribute__((__packed__)) osd_reply_rw_t
     uint32_t pad0;
     // for reads and writes: object version
     uint64_t version;
+    // for reads: chain info size for OSD_OP_RETURN_CHAIN
+    // (parent number is returned as a variable 2^N number of bits)
+    // i.e. 0 bits = everything is read from the inode itself
+    // 1 bit = inode(0) or its parent(1)
+    // 2 bits = inode(0) or its 1-3 parents
+    // 4 bits = inode(0) or its 1-7 parents
+    // and etc
+    // chain size in bits is (op->req.rw.len / bitmap_granularity * chain_bits_per_block + 7) / 8
+    uint32_t chain_bits_per_block;
 };
 
 struct __attribute__((__packed__)) osd_reply_del_t

src/client/qemu_driver.c

@@ -1049,7 +1049,7 @@ static int coroutine_fn vitastor_co_block_status(BlockDriverState *bs,
     {
         // Get larger allocated extents, possibly with false positives
         uint64_t bmp_pos = (offset-task.offset) / task.bitmap_granularity;
-        uint64_t bmp_end = (offset+bytes-task.offset) / task.bitmap_granularity;
+        uint64_t bmp_end = (offset+bytes-task.offset) / task.bitmap_granularity - bmp_pos;
         while (bmp_pos < bmp_end)
         {
             if (!(bmp_pos & 7) && bmp_end >= bmp_pos+8)

src/client/ublk_server.cpp

@@ -282,7 +282,7 @@ help:
                 exit(1);
             }
         }
-        const bool writeback = !cli->get_immediate_commit(inode);
+        const bool writeback = cli->get_immediate_commit(inode);
         auto pool_it = cli->st_cli.pool_config.find(INODE_POOL(inode ? inode : watch->cfg.num));
         if (pool_it == cli->st_cli.pool_config.end())
         {

src/client/vitastor.pc.in

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

src/cmd/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8...3.30)
+cmake_minimum_required(VERSION 2.8.12)
 
 project(vitastor)
 
@@ -15,14 +15,15 @@ add_custom_command(
 add_library(vitastor_cli STATIC
 	cli_common.cpp
 	cli_alloc_osd.cpp
+	cli_status.cpp
 	cli_describe.cpp
 	cli_fix.cpp
 	cli_ls.cpp
 	cli_create.cpp
+	cli_create_user.cpp
 	cli_dd.cpp
 	cli_modify.cpp
 	cli_modify_osd.cpp
-	cli_modify_user.cpp
 	cli_osd_tree.cpp
 	cli_pg_ls.cpp
 	cli_flatten.cpp
@@ -36,10 +37,7 @@ add_library(vitastor_cli STATIC
 	cli_pool_ls.cpp
 	cli_pool_modify.cpp
 	cli_pool_rm.cpp
-	cli_raw_ls.cpp
 	cli_serve.cpp
-	cli_status.cpp
-	cli_user_ls.cpp
 	${OPENAPI_JSON_H}
 )
 target_compile_options(vitastor_cli PUBLIC -fPIC)