HTTP "hello, world!"

WIP TLS
Auto-select the only RDMA device/port if there is only one
2026-04-09 12:14:56 +03:00 · 2026-04-09 11:42:18 +03:00 · 2026-04-05 16:16:54 +03:00 · 2026-04-05 11:40:00 +03:00 · 2026-04-04 19:03:27 +03:00 · 2026-04-04 19:03:01 +03:00
240 changed files with 19218 additions and 8914 deletions
@@ -234,6 +234,60 @@ jobs:
          echo ""
        done

+  test_etcd_fail_https:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 10
+      run: ETCD_SCHEME=https /root/vitastor/tests/test_etcd_fail.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_etcd_fail_https_antietcd:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 10
+      run: ETCD_SCHEME=https ANTIETCD=1 /root/vitastor/tests/test_etcd_fail.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_snapshot_https:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: ETCD_SCHEME=https /root/vitastor/tests/test_snapshot.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_interrupted_rebalance:
    runs-on: ubuntu-latest
    needs: build
@@ -306,78 +360,6 @@ jobs:
          echo ""
        done

-  test_dump_load:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 3
-      run: /root/vitastor/tests/test_dump_load.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_dump_load_32k:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 3
-      run: TEST_NAME=32k OSD_ARGS="--data_csum_type crc32c --csum_block_size 32k" OFFSET_ARGS="$OSD_ARGS" /root/vitastor/tests/test_dump_load.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_dump_load:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 3
-      run: OLD=1 /root/vitastor/tests/test_dump_load.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_dump_load_old_32k:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 3
-      run: TEST_NAME=old_32k OLD=1 OSD_ARGS="--data_csum_type crc32c --csum_block_size 32k" OFFSET_ARGS="$OSD_ARGS" /root/vitastor/tests/test_dump_load.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_interrupted_rebalance:
    runs-on: ubuntu-latest
    needs: build
@@ -720,6 +702,24 @@ jobs:
          echo ""
        done

+  test_snapshot_chain_encrypted:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: ENCRYPTED=1 /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,6 +1296,24 @@ jobs:
          echo ""
        done

+  test_checksum_xxhash:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: TEST_NAME=xxhash OSD_ARGS="--data_csum_type xxh3_32" /root/vitastor/tests/test_checksum.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_checksum:
    runs-on: ubuntu-latest
    needs: build
@@ -1530,24 +1548,6 @@ jobs:
          echo ""
        done

-  test_resize_last:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 3
-      run: /root/vitastor/tests/test_resize_last.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_resize_auto:
    runs-on: ubuntu-latest
    needs: build
@@ -1584,24 +1584,6 @@ jobs:
          echo ""
        done

-  test_old_resize_last:
-    runs-on: ubuntu-latest
-    needs: build
-    container: ${{env.TEST_IMAGE}}:${{github.sha}}
-    steps:
-    - name: Run test
-      id: test
-      timeout-minutes: 3
-      run: OLD=1 /root/vitastor/tests/test_resize_last.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_resize_auto:
    runs-on: ubuntu-latest
    needs: build
@@ -2160,3 +2142,39 @@ jobs:
          echo ""
        done

+  test_write_encrypted:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: /root/vitastor/tests/test_write_encrypted.sh
+    - name: Print logs
+      if: always() && steps.test.outcome == 'failure'
+      run: |
+        for i in /root/vitastor/testdata/*.log /root/vitastor/testdata/*.txt; do
+          echo "-------- $i --------"
+          cat $i
+          echo ""
+        done
+
+  test_write_encrypted_ec:
+    runs-on: ubuntu-latest
+    needs: build
+    container: ${{env.TEST_IMAGE}}:${{github.sha}}
+    steps:
+    - name: Run test
+      id: test
+      timeout-minutes: 3
+      run: SCHEME=ec /root/vitastor/tests/test_write_encrypted.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
+
@@ -38,6 +38,14 @@ for my $line (<>)
            {
                $test_name .= '_antietcd';
            }
+            elsif ($1 eq 'ETCD_SCHEME' && $2 eq 'https')
+            {
+                $test_name .= '_https';
+            }
+            elsif ($1 eq 'ENCRYPTED')
+            {
+                $test_name .= '_encrypted';
+            }
            elsif ($1 eq 'OLD')
            {
                $test_name =~ s/^test_/test_old_/s;
@@ -3,3 +3,4 @@
 package-lock.json
 fio
 qemu
+node_modules
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.8...3.30)

 project(vitastor)

-set(VITASTOR_VERSION "3.0.15")
+set(VITASTOR_VERSION "3.0.9")

 include(CTest)

@@ -62,6 +62,7 @@ Vitastor поддерживает QEMU-драйвер, протоколы UBLK,
    - [Дисковые параметры OSD](docs/config/layout-osd.ru.md)
    - [Прочие параметры OSD](docs/config/osd.ru.md)
    - [Параметры мониторов](docs/config/monitor.ru.md)
+    - [Безопасность](docs/config/security.ru.md)
  - [Настройки пулов](docs/config/pool.ru.md)
  - [Метаданные образов в etcd](docs/config/inode.ru.md)
 - Использование
@@ -62,6 +62,7 @@ Read more details in the documentation. You can start from here: [Quick Start](d
    - [OSD Disk Layout](docs/config/layout-osd.en.md)
    - [OSD Runtime Parameters](docs/config/osd.en.md)
    - [Monitor](docs/config/monitor.en.md)
+    - [Security](docs/config/security.en.md)
  - [Pool configuration](docs/config/pool.en.md)
  - [Image metadata in etcd](docs/config/inode.en.md)
 - Usage
@@ -1,4 +1,4 @@
-VITASTOR_VERSION ?= v3.0.15
+VITASTOR_VERSION ?= v3.0.9

 all: build push

@@ -49,7 +49,7 @@ spec:
            capabilities:
              add: ["SYS_ADMIN"]
            allowPrivilegeEscalation: true
-          image: vitalif/vitastor-csi:v3.0.15
+          image: vitalif/vitastor-csi:v3.0.9
          args:
            - "--node=$(NODE_ID)"
            - "--endpoint=$(CSI_ENDPOINT)"
@@ -121,7 +121,7 @@ spec:
            privileged: true
            capabilities:
              add: ["SYS_ADMIN"]
-          image: vitalif/vitastor-csi:v3.0.15
+          image: vitalif/vitastor-csi:v3.0.9
          args:
            - "--node=$(NODE_ID)"
            - "--endpoint=$(CSI_ENDPOINT)"
@@ -5,7 +5,7 @@ package vitastor

 const (
    vitastorCSIDriverName    = "csi.vitastor.io"
-    vitastorCSIDriverVersion = "3.0.15"
+    vitastorCSIDriverVersion = "3.0.9"
 )

 // Config struct fills the parameters of request or user input
@@ -1,4 +1,4 @@
-vitastor (3.0.15-1) unstable; urgency=medium
+vitastor (3.0.9-1) unstable; urgency=medium

  * Bugfixes

@@ -3,7 +3,7 @@ Section: admin
 Priority: optional
 Maintainer: Vitaliy Filippov <vitalif@yourcmc.ru>
 Build-Depends: debhelper, g++ (>= 8), libstdc++6 (>= 8),
-  linux-libc-dev, libgoogle-perftools-dev, libjerasure-dev, libgf-complete-dev,
+  linux-libc-dev, libgoogle-perftools-dev, libjerasure-dev, libgf-complete-dev, libc-ares-dev,
  libibverbs-dev, librdmacm-dev, libisal-dev, cmake, pkg-config, libnl-3-dev, libnl-genl-3-dev,
  node-bindings <!nocheck>, node-gyp, node-nan
 Standards-Version: 4.5.0
@@ -11,7 +11,6 @@ override_dh_install:
 	cp -v node-binding/package.json node-binding/index.js node-binding/addon.cc node-binding/addon.h node-binding/client.cc node-binding/client.h debian/tmp/usr/lib/x86_64-linux-gnu/nodejs/vitastor
 	cp -v node-binding/build/Release/addon.node debian/tmp/usr/lib/x86_64-linux-gnu/nodejs/vitastor/build/Release
 	dh_install
-	cd debian/vitastor-mon/usr/lib/vitastor/mon && npm install --production

 override_dh_installdeb:
 	cat debian/fio_version >> debian/vitastor-fio.substvars
@@ -37,6 +37,12 @@ rm -rf a b

 echo "dep:fio=$FIO" > debian/fio_version

+cd /root/vitastor/packages/vitastor-$REL/vitastor-$VER
+mkdir mon/node_modules
+cd mon/node_modules
+curl -s https://git.yourcmc.ru/vitalif/antietcd/archive/master.tar.gz | tar -zx
+curl -s https://git.yourcmc.ru/vitalif/tinyraft/archive/master.tar.gz | tar -zx
+
 cd /root/vitastor/packages/vitastor-$REL
 if [[ ( "$REL" = "trixie" || "$REL" = "resolute" ) && -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)
@@ -25,7 +25,7 @@ RUN set -e -x; \
    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 \
+    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
@@ -1,4 +1,4 @@
-VITASTOR_VERSION ?= v3.0.15
+VITASTOR_VERSION ?= v3.0.9

 all: build push

@@ -4,7 +4,7 @@
 #

 # Desired Vitastor version
-VITASTOR_VERSION=v3.0.15
+VITASTOR_VERSION=v3.0.9

 # Additional arguments for all containers
 # For example, you may want to specify a custom logging driver here
@@ -38,3 +38,4 @@ In the future, additional configuration methods may be added:
 - [OSD Disk Layout](config/layout-osd.en.md)
 - [OSD Runtime Parameters](config/osd.en.md)
 - [Monitor](config/monitor.en.md)
+- [Security Parameters](config/security.en.md)
@@ -41,3 +41,4 @@
 - [Дисковые параметры OSD](config/layout-osd.ru.md)
 - [Прочие параметры OSD](config/osd.ru.md)
 - [Параметры мониторов](config/monitor.ru.md)
+- [Параметры безопасности](config/security.ru.md)
@@ -198,8 +198,14 @@ put a modified value into etcd key /vitastor/config/global.
 - Type: string
 - Default: none

-Data checksum type to use. May be "crc32c" or "none". Set to "crc32c" to
-enable data checksums.
+Data and metadata checksum type to use. May be "crc32c", "xxh3_32" or "none".
+Select crc32c or xxh3_32 and set csum_block_size to enable data checksums.
+
+Both crc32c and xxh3_32 are almost equally fast, xxh3_32 is safer. xxh3_32 is
+the xxhash3 algorithm truncated from 64 to 32 bits (which is still a good hash).
+
+Note that enabled data checksums either increase memory usage or reduce
+performance. Check details in [csum_block_size](#csum_block_size) description.

 ## csum_block_size

@@ -209,8 +209,12 @@ journal_block_size и meta_block_size. Однако на данный момен
 - Тип: строка
 - Значение по умолчанию: none

-Тип используемых OSD контрольных сумм данных. Может быть "crc32c" или "none".
-Установите в "crc32c", чтобы включить расчёт и проверку контрольных сумм данных.
+Тип используемых OSD контрольных сумм данных и метаданных. Может быть "crc32c",
+"xxh3_32" или "none". Выберите crc32c или xxh3_32 и установите csum_block_size,
+чтобы включить контрольные суммы данных.
+
+И crc32c, и xxh3_32 примерно одинаково быстры, xxh3_32 надёжней. xxh3_32 - это
+алгоритм xxhash3, обрезанный с 64 до 32 бит (это всё равно хороший хеш).

 Следует понимать, что контрольные суммы в зависимости от размера блока их
 расчёта либо увеличивают потребление памяти, либо снижают производительность.
@@ -0,0 +1,150 @@
+[Documentation](../../README.md#documentation) → [Configuration](../config.en.md) → Security Parameters
+
+-----
+
+[Читать на русском](security.ru.md)
+
+# Security Parameters
+
+These parameters affect your Vitastor installation security and apply to OSDs, monitors and clients.
+
+Most of them can be set in /etc/vitastor/vitastor.conf and in etcd, but don't support online modification.
+
+- [etcd_client_cert](#etcd_client_cert)
+- [etcd_client_key](#etcd_client_key)
+- [etcd_ca](#etcd_ca)
+- [osd_etcd_client_cert](#osd_etcd_client_cert)
+- [osd_etcd_client_key](#osd_etcd_client_key)
+- [mon_etcd_client_cert](#mon_etcd_client_cert)
+- [mon_etcd_client_key](#mon_etcd_client_key)
+- [vault_url](#vault_url)
+- [vault_secret_api_path](#vault_secret_api_path)
+- [vault_client_cert](#vault_client_cert)
+- [vault_client_key](#vault_client_key)
+- [vault_ca](#vault_ca)
+- [vault_timeout_ms](#vault_timeout_ms)
+- [vault_error_timeout_sec](#vault_error_timeout_sec)
+- [vault_refresh_leeway_sec](#vault_refresh_leeway_sec)
+- [max_aes_xts_pool_size](#max_aes_xts_pool_size)
+
+## etcd_client_cert
+
+- Type: string
+
+Client TLS certificate to use for Vitastor client (not OSD and not monitor)
+etcd https connections. May be path to a file or just a PEM string with certificate.
+In the latter case, string must begin with "-----BEGIN CERTIFICATE-----".
+
+## etcd_client_key
+
+- Type: string
+
+Private key for etcd_client_cert (also a file or a PEM string).
+
+## etcd_ca
+
+- Type: string
+
+Trusted TLS CA to verify etcd server certificate. May be path to a file,
+directory or just a PEM string with certificate.
+
+## osd_etcd_client_cert
+
+- Type: string
+
+Same as [etcd_client_cert](#etcd_client_cert), but only for OSDs.
+OSDs, clients and monitors should have different permissions, so they should
+use different certificates.
+
+## osd_etcd_client_key
+
+- Type: string
+
+Same as [etcd_client_key](#etcd_client_key), but only for OSDs.
+
+## mon_etcd_client_cert
+
+- Type: string
+
+Same as [etcd_client_cert](#etcd_client_cert), but only for Vitastor monitors.
+
+## mon_etcd_client_key
+
+- Type: string
+
+Same as [etcd_client_key](#etcd_client_key), but only for Vitastor monitors.
+
+## vault_url
+
+- Type: string
+
+Vault base URL.
+
+Vitastor clients support AES-256-XTS image data encryption with different per-image keys.
+Encryption is performed by the client, OSDs don't have access to decrypted data.
+
+Encryption keys may be stored in etcd or, for the increased security level, in an external
+[HashiCorp Vault](https://developer.hashicorp.com/vault/) or [OpenBao](https://openbao.org/)
+instance.
+
+Vitastor clients use [v1 k/v secrets engine](https://openbao.org/api-docs/secret/kv/kv-v1/)
+and [TLS authentication engine](https://openbao.org/api-docs/auth/cert/) in Vault.
+
+In that case, only key IDs are stored in etcd.
+
+## vault_secret_api_path
+
+- Type: string
+- Default: /v1/secret/
+
+Vault v1 secret API mount path to use.
+
+## vault_client_cert
+
+- Type: string
+
+Client TLS certificate to use for Vault connections. Just like [etcd_client_cert](#etcd_client_cert),
+may be path to a file or just a certificate in PEM string.
+
+## vault_client_key
+
+- Type: string
+
+Private key for vault_client_cert (also a file or a PEM string).
+
+## vault_ca
+
+- Type: string
+
+Trusted TLS CA to verify Vault server certificate. May be path to a file,
+directory or just a PEM string with certificate.
+
+## vault_timeout_ms
+
+- Type: integer
+- Default: 5000
+
+Timeout for Vault requests in milliseconds.
+
+## vault_error_timeout_sec
+
+- Type: integer
+- Default: 60
+
+Time (in seconds) to wait before retrying after receiving an error from Vault.
+
+## vault_refresh_leeway_sec
+
+- Type: integer
+- Default: 60
+
+Extra time (in seconds) before real Vault token lease_timeout to refresh it, just
+in case of system clock drift.
+
+## max_aes_xts_pool_size
+
+- Type: integer
+- Default: 256
+
+Maximum number of OpenSSL encryption contexts cached in OSD memory. Probably
+doesn't require modification.
@@ -0,0 +1,154 @@
+[Документация](../../README-ru.md#документация) → [Конфигурация](../config.ru.md) → Параметры безопасности
+
+-----
+
+[Read in English](security.en.md)
+
+# Параметры безопасности
+
+Данные параметры затрагивают безопасность инсталляций Vitastor и используются
+OSD, мониторами и клиентами.
+
+Большая их часть может задаваться в /etc/vitastor/vitastor.conf и в etcd, но не
+поддерживает онлайн-изменение.
+
+- [etcd_client_cert](#etcd_client_cert)
+- [etcd_client_key](#etcd_client_key)
+- [etcd_ca](#etcd_ca)
+- [osd_etcd_client_cert](#osd_etcd_client_cert)
+- [osd_etcd_client_key](#osd_etcd_client_key)
+- [mon_etcd_client_cert](#mon_etcd_client_cert)
+- [mon_etcd_client_key](#mon_etcd_client_key)
+- [vault_url](#vault_url)
+- [vault_secret_api_path](#vault_secret_api_path)
+- [vault_client_cert](#vault_client_cert)
+- [vault_client_key](#vault_client_key)
+- [vault_ca](#vault_ca)
+- [vault_timeout_ms](#vault_timeout_ms)
+- [vault_error_timeout_sec](#vault_error_timeout_sec)
+- [vault_refresh_leeway_sec](#vault_refresh_leeway_sec)
+- [max_aes_xts_pool_size](#max_aes_xts_pool_size)
+
+## etcd_client_cert
+
+- Тип: строка
+
+Клиентский TLS сертификат для https-подключений к etcd для клиентов Vitastor
+(не OSD и не мониторов). Может быть путём к файлу или просто строкой с
+сертификатом в формате PEM. В последнем случае строка должна начинаться с
+"-----BEGIN CERTIFICATE-----".
+
+## etcd_client_key
+
+- Тип: строка
+
+Закрытый ключ для сертификата etcd_client_cert (также путь к файлу или PEM строка).
+
+## etcd_ca
+
+- Тип: строка
+
+Доверенный корневой TLS-сертификат для проверки сертификата сервера etcd.
+Может быть путём к файлу, директории или просто строкой с сертификатом в
+формате PEM.
+
+## osd_etcd_client_cert
+
+- Тип: строка
+
+Аналогично [etcd_client_cert](#etcd_client_cert), но только для OSD.
+OSD, клиенты и мониторы должны иметь разные привилегии, поэтому они должны
+использовать разные сертификаты.
+
+## osd_etcd_client_key
+
+- Тип: строка
+
+Аналогично [etcd_client_key](#etcd_client_key), но только для OSD.
+
+## mon_etcd_client_cert
+
+- Тип: строка
+
+Аналогично [etcd_client_cert](#etcd_client_cert), но только для мониторов Vitastor.
+
+## mon_etcd_client_key
+
+- Тип: строка
+
+Аналогично [etcd_client_key](#etcd_client_key), но только для мониторов Vitastor.
+
+## vault_url
+
+- Тип: строка
+
+Базовый адрес Vault.
+
+Клиенты Vitastor поддерживают AES-256-XTS шифрование данных образов с отдельными ключами на
+каждый образ. Данные шифруются клиентами, OSD не имеют доступа к незашифрованным данным.
+
+Ключи шифрования могут храниться в etcd или, для повышенного уровня безопасности, во внешнем
+[HashiCorp Vault](https://developer.hashicorp.com/vault/) или [OpenBao](https://openbao.org/).
+
+Клиенты Vitastor используют [движок секретов v1](https://openbao.org/api-docs/secret/kv/kv-v1/)
+и [TLS-аутентификацию](https://openbao.org/api-docs/auth/cert/) в Vault.
+
+В этом случае, только ID ключей хранятся в etcd.
+
+## vault_secret_api_path
+
+- Тип: строка
+- Значение по умолчанию: /v1/secret/
+
+Путь к API секретов v1 для использования клиентами.
+
+## vault_client_cert
+
+- Тип: строка
+
+Клиентский TLS сертификат для подключений к Vault. Как и [etcd_client_cert](#etcd_client_cert),
+может быть путём к файлу или просто PEM-строкой с сертификатом.
+
+## vault_client_key
+
+- Тип: строка
+
+Закрытый ключ для сертификата vault_client_cert (также путь к файлу или PEM строка).
+
+## vault_ca
+
+- Тип: строка
+
+Доверенный корневой TLS-сертификат для проверки сертификата сервера Vault.
+Может быть путём к файлу, директории или просто строкой с сертификатом в
+формате PEM.
+
+## vault_timeout_ms
+
+- Тип: целое число
+- Значение по умолчанию: 5000
+
+Максимально время выполнения Vault-запросов в миллисекундах.
+
+## vault_error_timeout_sec
+
+- Тип: целое число
+- Значение по умолчанию: 60
+
+Время (в секундах) для ожидания перед повторной попыткой при получении ошибки от Vault.
+
+## vault_refresh_leeway_sec
+
+- Тип: целое число
+- Значение по умолчанию: 60
+
+Зазор времени (в секундах), чтобы обновлять токены Vault чуть раньше их реального
+lease_timeout, на случай "ухода" системных часов.
+
+## max_aes_xts_pool_size
+
+- Тип: целое число
+- Значение по умолчанию: 256
+
+Максимальное количество кэшируемых в памяти OSD контекстов шифрования OpenSSL.
+Вряд ли требует изменения.
@@ -44,6 +44,8 @@

 {{../../config/monitor.en.md|indent=2}}

+{{../../config/security.en.md|indent=2}}
+
 {{../../config/pool.en.md|indent=2}}

 {{../../config/inode.en.md|indent=2}}
@@ -44,6 +44,8 @@

 {{../../config/monitor.ru.md|indent=2}}

+{{../../config/security.ru.md|indent=2}}
+
 {{../../config/pool.ru.md|indent=2}}

 {{../../config/inode.ru.md|indent=2}}
@@ -233,11 +233,21 @@
  type: string
  default: none
  info: |
-    Data checksum type to use. May be "crc32c" or "none". Set to "crc32c" to
-    enable data checksums.
+    Data and metadata checksum type to use. May be "crc32c", "xxh3_32" or "none".
+    Select crc32c or xxh3_32 and set csum_block_size to enable data checksums.
+
+    Both crc32c and xxh3_32 are almost equally fast, xxh3_32 is safer. xxh3_32 is
+    the xxhash3 algorithm truncated from 64 to 32 bits (which is still a good hash).
+
+    Note that enabled data checksums either increase memory usage or reduce
+    performance. Check details in [csum_block_size](#csum_block_size) description.
  info_ru: |
-    Тип используемых OSD контрольных сумм данных. Может быть "crc32c" или "none".
-    Установите в "crc32c", чтобы включить расчёт и проверку контрольных сумм данных.
+    Тип используемых OSD контрольных сумм данных и метаданных. Может быть "crc32c",
+    "xxh3_32" или "none". Выберите crc32c или xxh3_32 и установите csum_block_size,
+    чтобы включить контрольные суммы данных.
+
+    И crc32c, и xxh3_32 примерно одинаково быстры, xxh3_32 надёжней. xxh3_32 - это
+    алгоритм xxhash3, обрезанный с 64 до 32 бит (это всё равно хороший хеш).

    Следует понимать, что контрольные суммы в зависимости от размера блока их
    расчёта либо увеличивают потребление памяти, либо снижают производительность.
@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "yaml": "^2.8.2"
+  }
+}
@@ -0,0 +1,5 @@
+# Security Parameters
+
+These parameters affect your Vitastor installation security and apply to OSDs, monitors and clients.
+
+Most of them can be set in /etc/vitastor/vitastor.conf and in etcd, but don't support online modification.
@@ -0,0 +1,7 @@
+# Параметры безопасности
+
+Данные параметры затрагивают безопасность инсталляций Vitastor и используются
+OSD, мониторами и клиентами.
+
+Большая их часть может задаваться в /etc/vitastor/vitastor.conf и в etcd, но не
+поддерживает онлайн-изменение.
@@ -0,0 +1,131 @@
+- name: etcd_client_cert
+  type: string
+  info: |
+    Client TLS certificate to use for Vitastor client (not OSD and not monitor)
+    etcd https connections. May be path to a file or just a PEM string with certificate.
+    In the latter case, string must begin with "-----BEGIN CERTIFICATE-----".
+  info_ru: |
+    Клиентский TLS сертификат для https-подключений к etcd для клиентов Vitastor
+    (не OSD и не мониторов). Может быть путём к файлу или просто строкой с
+    сертификатом в формате PEM. В последнем случае строка должна начинаться с
+    "-----BEGIN CERTIFICATE-----".
+- name: etcd_client_key
+  type: string
+  info: Private key for etcd_client_cert (also a file or a PEM string).
+  info_ru: Закрытый ключ для сертификата etcd_client_cert (также путь к файлу или PEM строка).
+- name: etcd_ca
+  type: string
+  info: |
+    Trusted TLS CA to verify etcd server certificate. May be path to a file,
+    directory or just a PEM string with certificate.
+  info_ru: |
+    Доверенный корневой TLS-сертификат для проверки сертификата сервера etcd.
+    Может быть путём к файлу, директории или просто строкой с сертификатом в
+    формате PEM.
+- name: osd_etcd_client_cert
+  type: string
+  info: |
+    Same as [etcd_client_cert](#etcd_client_cert), but only for OSDs.
+    OSDs, clients and monitors should have different permissions, so they should
+    use different certificates.
+  info_ru: |
+    Аналогично [etcd_client_cert](#etcd_client_cert), но только для OSD.
+    OSD, клиенты и мониторы должны иметь разные привилегии, поэтому они должны
+    использовать разные сертификаты.
+- name: osd_etcd_client_key
+  type: string
+  info: Same as [etcd_client_key](#etcd_client_key), but only for OSDs.
+  info_ru: Аналогично [etcd_client_key](#etcd_client_key), но только для OSD.
+- name: mon_etcd_client_cert
+  type: string
+  info: Same as [etcd_client_cert](#etcd_client_cert), but only for Vitastor monitors.
+  info_ru: Аналогично [etcd_client_cert](#etcd_client_cert), но только для мониторов Vitastor.
+- name: mon_etcd_client_key
+  type: string
+  info: Same as [etcd_client_key](#etcd_client_key), but only for Vitastor monitors.
+  info_ru: Аналогично [etcd_client_key](#etcd_client_key), но только для мониторов Vitastor.
+- name: vault_url
+  type: string
+  info: |
+    Vault base URL.
+
+    Vitastor clients support AES-256-XTS image data encryption with different per-image keys.
+    Encryption is performed by the client, OSDs don't have access to decrypted data.
+
+    Encryption keys may be stored in etcd or, for the increased security level, in an external
+    [HashiCorp Vault](https://developer.hashicorp.com/vault/) or [OpenBao](https://openbao.org/)
+    instance.
+
+    Vitastor clients use [v1 k/v secrets engine](https://openbao.org/api-docs/secret/kv/kv-v1/)
+    and [TLS authentication engine](https://openbao.org/api-docs/auth/cert/) in Vault.
+
+    In that case, only key IDs are stored in etcd.
+  info_ru: |
+    Базовый адрес Vault.
+
+    Клиенты Vitastor поддерживают AES-256-XTS шифрование данных образов с отдельными ключами на
+    каждый образ. Данные шифруются клиентами, OSD не имеют доступа к незашифрованным данным.
+
+    Ключи шифрования могут храниться в etcd или, для повышенного уровня безопасности, во внешнем
+    [HashiCorp Vault](https://developer.hashicorp.com/vault/) или [OpenBao](https://openbao.org/).
+
+    Клиенты Vitastor используют [движок секретов v1](https://openbao.org/api-docs/secret/kv/kv-v1/)
+    и [TLS-аутентификацию](https://openbao.org/api-docs/auth/cert/) в Vault.
+
+    В этом случае, только ID ключей хранятся в etcd.
+- name: vault_secret_api_path
+  type: string
+  default: /v1/secret/
+  info: Vault v1 secret API mount path to use.
+  info_ru: Путь к API секретов v1 для использования клиентами.
+- name: vault_client_cert
+  type: string
+  info: |
+    Client TLS certificate to use for Vault connections. Just like [etcd_client_cert](#etcd_client_cert),
+    may be path to a file or just a certificate in PEM string.
+  info_ru: |
+    Клиентский TLS сертификат для подключений к Vault. Как и [etcd_client_cert](#etcd_client_cert),
+    может быть путём к файлу или просто PEM-строкой с сертификатом.
+- name: vault_client_key
+  type: string
+  info: Private key for vault_client_cert (also a file or a PEM string).
+  info_ru: Закрытый ключ для сертификата vault_client_cert (также путь к файлу или PEM строка).
+- name: vault_ca
+  type: string
+  info: |
+    Trusted TLS CA to verify Vault server certificate. May be path to a file,
+    directory or just a PEM string with certificate.
+  info_ru: |
+    Доверенный корневой TLS-сертификат для проверки сертификата сервера Vault.
+    Может быть путём к файлу, директории или просто строкой с сертификатом в
+    формате PEM.
+- name: vault_timeout_ms
+  type: int
+  default: 5000
+  info: Timeout for Vault requests in milliseconds.
+  info_ru: Максимально время выполнения Vault-запросов в миллисекундах.
+- name: vault_error_timeout_sec
+  type: int
+  default: 60
+  info: |
+    Time (in seconds) to wait before retrying after receiving an error from Vault.
+  info_ru: |
+    Время (в секундах) для ожидания перед повторной попыткой при получении ошибки от Vault.
+- name: vault_refresh_leeway_sec
+  type: int
+  default: 60
+  info: |
+    Extra time (in seconds) before real Vault token lease_timeout to refresh it, just
+    in case of system clock drift.
+  info_ru: |
+    Зазор времени (в секундах), чтобы обновлять токены Vault чуть раньше их реального
+    lease_timeout, на случай "ухода" системных часов.
+- name: max_aes_xts_pool_size
+  type: int
+  default: 256
+  info: |
+    Maximum number of OpenSSL encryption contexts cached in OSD memory. Probably
+    doesn't require modification.
+  info_ru: |
+    Максимальное количество кэшируемых в памяти OSD контекстов шифрования OpenSSL.
+    Вряд ли требует изменения.
@@ -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.15`
+   `docker pull vitalif/vitastor:v3.0.9`
 2. Install scripts to the host system: \
-   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v3.0.15 install.sh`
+   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v3.0.9 install.sh`
 3. Reload udev rules: \
   `udevadm control --reload-rules`
 4. Enable the vitastor-host service: \
@@ -25,9 +25,9 @@ Vitastor можно установить в Docker/Podman. При этом etcd,
 Инструкция по установке максимально простая.

 1. Скачайте Docker-образ желаемой версии: \
-   `docker pull vitalif/vitastor:v3.0.15`
+   `docker pull vitalif/vitastor:v3.0.9`
 2. Установите скрипты в хост-систему командой: \
-   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v3.0.15 install.sh`
+   `docker run --rm -it -v /etc:/host-etc -v /usr/bin:/host-bin vitalif/vitastor:v3.0.9 install.sh`
 3. Перезагрузите правила udev: \
   `udevadm control --reload-rules`
 4. Включите сервис vitastor-host: \
@@ -15,8 +15,9 @@
 - gcc and g++ 8 or newer, clang 10 or newer, or other compiler with C++11 plus
  designated initializers support from C++20
 - CMake
- jerasure headers and libraries
+- jerasure, c-ares headers and libraries
 - ISA-L, libibverbs, librdmacm, libnl3 headers and libraries (optional)
+- tcmalloc (google-perftools-dev)

 ## Basic instructions

@@ -15,8 +15,9 @@
 - gcc и g++ >= 8, либо clang >= 10, либо другой компилятор с поддержкой C++11 плюс
  назначенных инициализаторов (designated initializers) из C++20
 - CMake
- Заголовки и библиотеки jerasure
+- Заголовки и библиотеки jerasure, c-ares
 - Опционально - заголовки и библиотеки ISA-L, libibverbs, librdmacm, libnl3
+- tcmalloc (google-perftools-dev)

 ## Базовая инструкция

@@ -41,6 +41,8 @@
 - [Built-in Prometheus metric exporter](../config/monitor.en.md#enable_prometheus)
 - [NFS RDMA support](../usage/nfs.en.md#rdma) (probably also usable for GPUDirect)
 - [S3](../installation/s3.en.md)
+- [TLS support for etcd connections](../config/security.en.md)
+- [AES-256-XTS image encryption](../usage/cli.en.md#create) and [Vault support](../config/security.en.md#vault_url) for key storage

 ## Plugins and tools

@@ -43,6 +43,8 @@
 - [Встроенный Prometheus-экспортер метрик](../config/monitor.ru.md#enable_prometheus)
 - [Поддержка NFS RDMA](../usage/nfs.ru.md#rdma) (вероятно, также подходящая для GPUDirect)
 - [S3](../installation/s3.ru.md)
+- [Поддержка TLS-соединений с etcd](../config/security.ru.md)
+- [AES-256-XTS шифрование данных](../usage/cli.ru.md#create) и [поддержка Vault](../config/security.ru.md#vault_url) для хранения ключей

 ## Драйверы и инструменты

@@ -125,18 +125,31 @@ bench-kaveri         kaveri    10 G  10 G    0 B/s  0     0      0 us  0 B/s  0

 ## create

-`vitastor-cli create -s|--size <size> [-p|--pool <id|name>] [--parent <parent_name>[@<snapshot>]] <name>`
+`vitastor-cli create -s|--size SIZE [OPTIONS] <name>`

-Create an image. You may use K/M/G/T suffixes for `<size>`. If `--parent` is specified,
-a copy-on-write image clone is created. Parent must be a snapshot (readonly image).
-Pool must be specified if there is more than one pool.
+Create an image. Options:
+
+* `-s|--size SIZE` - New image size in bytes or with a K/M/G/T unit suffix.
+* `-p|--pool POOL` - Specify pool for the new image (may be omitted if there is only 1 pool).
+* `--parent PARENT` - Create a copy-on-write image clone based on PARENT (or PARENT@SNAPSHOT).
+  If parent is not a snapshot, it must be a read-only image.
+* `--enc-key random` - Generate a new random AES-256-XTS encryption key for the new image.
+* `--enc-key HEX` - Set a specified AES-256-XTS key (64 bytes in hex) for the new image.
+* `--enc-key vault:ID` - Use an encryption key from an external Vault secret with specified ID.

 ```
-vitastor-cli create --snapshot <snapshot> [-p|--pool <id|name>] <image>
-vitastor-cli snap-create [-p|--pool <id|name>] <image>@<snapshot>
+vitastor-cli create --snapshot <snapshot> [OPTIONS] <image>
+vitastor-cli snap-create [OPTIONS] <image>@<snapshot>
 ```

-Create a snapshot of image `<name>` (either form can be used). May be used live if only a single writer is active.
+Create a snapshot of image `<image>`. May be used live if only a single writer is active.
+
+Options:
+
+* `-p|--pool POOL` - Move image to pool POOL, leaving the snapshot in the old pool.
+* `--enc-key random` - Change image encryption key to a new random AES-256-XTS key.
+* `--enc-key KEY` - Change image encryption key to a specified key, Vault key or to an empty key.
+  By default, the image retains its old encryption key when taking a snapshot.

 See also about [how to export snapshots](qemu.en.md#exporting-snapshots).

@@ -151,6 +164,7 @@ You should resize file system in the image, if present, before shrinking it.
 * `--deleted 1|0` - Set/clear 'deleted image' flag (set automatically during unfinished deletes).
 * `-f|--force` - Proceed with shrinking or setting readwrite flag even if the image has children.
 * `--down-ok` - Proceed with shrinking even if some data will be left on unavailable OSDs.
+* `--enc-key HEX` - Change image encryption key (allowed only with `--force`).

 ## dd

@@ -127,19 +127,32 @@ bench-kaveri         kaveri    10 G  10 G    0 B/s  0     0      0 us  0 B/s  0

 ## create

-`vitastor-cli create -s|--size <size> [-p|--pool <id|name>] [--parent <parent_name>[@<snapshot>]] <name>`
+`vitastor-cli create -s|--size SIZE [ОПЦИИ] <name>`

-Создать образ. Для размера `<size>` можно использовать суффиксы K/M/G/T (килобайт-мегабайт-гигабайт-терабайт).
-Если указана опция `--parent`, создаётся клон образа. Родитель `<parent_name>[@<snapshot>]` должен быть
-снимком (или просто немодифицируемым образом). Пул обязательно указывать, если в кластере больше одного пула.
+Создать образ. Опции:
+
+* `-s|--size SIZE` - Размер нового образа в байтах или с суффиксом K/M/G/T (кило/мега/гига/терабайт).
+* `-p|--pool POOL` - Создать образ в заданном пуле (можно не указывать, если пул всего один).
+* `--parent PARENT` - Создать легковесный клон на основе образа `PARENT` или снимка `PARENT@SNAP`.
+  Если `PARENT` - не снимок, он должен быть помечен как образ только для чтения.
+* `--enc-key random` - Сгенерировать случайный ключ шифрования AES-256-XTS для нового образа.
+* `--enc-key HEX` - Установить заданный ключ AES-256-XTS (64 байта в hex) для нового образа.
+* `--enc-key vault:ID` - Использовать ключ из внешнего секрета с заданным ID из Vault.

 ```
-vitastor-cli create --snapshot <snapshot> [-p|--pool <id|name>] <image>
-vitastor-cli snap-create [-p|--pool <id|name>] <image>@<snapshot>
+vitastor-cli create --snapshot <snapshot> [ОПЦИИ] <image>
+vitastor-cli snap-create [ОПЦИИ] <image>@<snapshot>
 ```

-Создать снимок образа `<name>` (можно использовать любую форму команды). Снимок можно создавать без остановки
-клиентов, если пишущий клиент максимум 1.
+Создать снимок образа `<image>` (можно использовать любую форму команды).
+Снимок можно создавать без остановки клиентов, если пишущих клиентов не больше одного.
+
+Опции:
+
+* `-p|--pool POOL` - Переместить образ в пул POOL, оставив снимок в старом пуле.
+* `--enc-key random` - Изменить ключ шифрования образа на новый случайный ключ AES-256-XTS.
+* `--enc-key KEY` - Изменить ключ шифрования образа на заданный ключ, ключ из Vault или пустой ключ.
+  По умолчанию шифрованные образы сохраняют старый ключ при снятии снимка.

 Смотрите также информацию о том, [как экспортировать снимки](qemu.ru.md#экспорт-снимков).

@@ -156,6 +169,7 @@ vitastor-cli snap-create [-p|--pool <id|name>] <image>@<snapshot>
 * `--deleted 1|0` - Установить/снять флаг "образ удалён" (устанавливается при незавершённом удалении).
 * `-f|--force` - Разрешить уменьшение или перевод в чтение-запись образа, у которого есть клоны.
 * `--down-ok` - Разрешить уменьшение, даже если часть данных останется неудалённой на недоступных OSD.
+* `--enc-key HEX` - Изменить ключ шифрования образа (разрешено только с `--force`).

 ## dd

@@ -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                                   |
@@ -274,4 +274,3 @@ VitastorFS из GPUDirect.
 | `--logfile <FILE>` | записывать логи в заданный файл                         |
 | `--enforce 1`      | проверять права доступа на стороне сервера (по умолчанию нет) |
 | `--foreground 1`   | не уходить в фон после запуска                          |
-| `--trace`          | логгировать все запросы NFS                             |
@@ -27,17 +27,7 @@ class AntiEtcdAdapter
            is_local['::'] = true;
            is_local[''] = true;
            // split :, 3 -> <schema>:<//ip>:<port>
-            const selected = [];
-            for (let i = 0; i < cluster.length; i++)
-            {
-                const m = /^(https?:\/\/)?(?:\[(.*)\]|([^\[\:]+))(?::(\d+))?$/.exec(cluster[i]);
-                if (!m)
-                    continue;
-                const ip = m[3] || m[2];
-                const port = m[4] || 2379;
-                if (is_local[ip] && (!cfg_port || port == cfg_port))
-                    selected.push({ idx: i, ip, 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, please specify port');
@@ -46,17 +36,30 @@ class AntiEtcdAdapter
            else if (selected.length == 1)
            {
                const antietcd_config = {
-                    ip: selected[0].ip,
-                    port: selected[0].port,
-                    data: config.antietcd_data_file || ((config.antietcd_data_dir || '/var/lib/vitastor') + '/mon_'+selected[0].port+'.json.gz'),
+                    ip: selected[0][1].substr(2),
+                    port: selected[0][2],
+                    cert: config.antietcd_cert,
+                    key: config.antietcd_key,
+                    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: cluster[selected[0].idx].replace(/^(https?:\/\/)/, ''), // same as in <cluster> below
+                    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,
-                    logs: { cluster: true },
                };
+                if (config.use_auth)
+                {
+                    antietcd_config.client_cert_auth = true;
+                    antietcd_config.auth_filter = require('./vitastor_auth_filter.js');
+                    antietcd_config.peer_ca = config.antietcd_server_ca;
+                    if (!config.antietcd_server_ca || config.antietcd_server_ca == config.etcd_ca)
+                    {
+                        console.error('Secure setup requires separate antietcd_server_ca (for signing antietcd server certificates) and etcd_ca (for signing client certificates)');
+                        process.exit(1);
+                    }
+                }
                for (const key in config)
                {
                    if (key.substr(0, 9) === 'antietcd_')
@@ -181,7 +184,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);
+                const res = await this.antietcd.api(path.replace(/^\/+/, '').replace(/\/+$/, '').replace(/\/+/g, '_'), body, { username: 'root' });
                if (res.error)
                {
                    console.error('Failed to query antietcd '+path+' (retry '+retry+'/'+retries+'): '+res.error);
@@ -1,7 +1,9 @@
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: VNPL-1.1 (see README.md for details)

+const fs = require('fs');
 const http = require('http');
+const https = require('https');
 const WebSocket = require('ws');
 const { b64, local_ips } = require('./utils.js');

@@ -15,11 +17,30 @@ class EtcdAdapter
        this.ws = null;
        this.ws_alive = false;
        this.ws_keepalive_timer = null;
+        this.opts = {};
    }

    parse_config(config)
    {
        this.parse_etcd_addresses(config.etcd_address||config.etcd_url);
+        if (config.mon_etcd_client_cert || config.etcd_client_cert)
+        {
+            this.opts.cert = config.mon_etcd_client_cert || config.etcd_client_cert;
+            if (this.opts.cert.substr(0, 5) != '-----')
+                this.opts.cert = fs.readFileSync(this.opts.cert, { encoding: 'utf-8' });
+        }
+        if (config.mon_etcd_client_key || config.etcd_client_key)
+        {
+            this.opts.key = config.mon_etcd_client_key || config.etcd_client_key;
+            if (this.opts.key.substr(0, 5) != '-----')
+                this.opts.key = fs.readFileSync(this.opts.key, { encoding: 'utf-8' });
+        }
+        if (config.etcd_ca)
+        {
+            this.opts.ca = config.etcd_ca;
+            if (this.opts.ca.substr(0, 5) != '-----')
+                this.opts.ca = fs.readFileSync(this.opts.ca, { encoding: 'utf-8' });
+        }
    }

    parse_etcd_addresses(addrs)
@@ -39,7 +60,7 @@ class EtcdAdapter
        for (let url of addrs)
        {
            let scheme = 'http';
-            url = url.trim().replace(/^(https?):\/\//, (m, m1) => { scheme = m1; return ''; });
+            url = url.trim().replace(/^(https?):\/\//i, (m, m1) => { scheme = m1.toLowerCase(); return ''; });
            const slash = url.indexOf('/');
            const colon = url.indexOf(':');
            const is_local = is_local_ip[colon >= 0 ? url.substr(0, colon) : (slash >= 0 ? url.substr(0, slash) : url)];
@@ -130,7 +151,7 @@ class EtcdAdapter
                    }
                    ok(false);
                }, this.mon.config.etcd_mon_timeout);
-                this.ws = new WebSocket(base+'/watch');
+                this.ws = new WebSocket(base+'/watch', this.opts);
                this.ws_used_url = cur_addr;
                const fail = () =>
                {
@@ -272,7 +293,7 @@ class EtcdAdapter
            {
                throw new Error(MON_STOPPED);
            }
-            const res = await POST(base+path, body, timeout);
+            const res = await POST(base+path, body, timeout, this.opts);
            if (this.mon.stopped)
            {
                throw new Error(MON_STOPPED);
@@ -298,7 +319,7 @@ class EtcdAdapter
    }
 }

-function POST(url, body, timeout)
+function POST(url, body, timeout, opts)
 {
    return new Promise(ok =>
    {
@@ -310,10 +331,10 @@ function POST(url, body, timeout)
            req = null;
            ok({ error: 'timeout' });
        }, timeout) : null;
-        let req = http.request(url, { method: 'POST', headers: {
+        let req = (url.substr(0, 5) == 'https' ? https : http).request(url, { method: 'POST', headers: {
            'Content-Type': 'application/json',
            'Content-Length': body_text.length,
-        } }, (res) =>
+        }, ...(opts||{}) }, (res) =>
        {
            if (!req)
            {
@@ -16,6 +16,7 @@ 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*',
@@ -45,7 +46,14 @@ const etcd_tree = {
            config_path: "/etc/vitastor/vitastor.conf",
            etcd_prefix: "/vitastor",
            // etcd connection - configurable online
-            etcd_address: "10.0.115.10:2379/v3",
+            etcd_address: "http://10.0.115.10:2379/v3",
+            etcd_client_cert: "",
+            etcd_client_key: "",
+            osd_etcd_client_cert: "",
+            osd_etcd_client_key: "",
+            mon_etcd_client_cert: "",
+            mon_etcd_client_key: "",
+            etcd_ca: "",
            // mon
            etcd_mon_ttl: 5, // min: 1
            etcd_mon_timeout: 1000, // ms. min: 0
@@ -201,6 +209,8 @@ const etcd_tree = {
                primary_affinity_tags?: 'nvme' | [ 'nvme', ... ],
                // scrub interval
                scrub_interval?: '30d',
+                // users allowed to create images in this pool
+                creator_group?: '',
            },
            ...
        }, */
@@ -217,10 +227,21 @@ const etcd_tree = {
                    parent_id?: <inode_t>,
                    readonly?: boolean,
                    deleted?: boolean,
+                    enc_key?: string,
+                    owner?: string,
+                    owner_group?: string,
+                    reader_group?: string,
                }
            }
        }, */
        inode: {},
+        /* user: {
+            <username>: {
+                type: 'osd'|'mon'|'admin'|'client',
+                groups: string[],
+            },
+        }, */
+        user: {},
    },
    osd: {
        state: {
@@ -112,10 +112,9 @@ function make_cyclic(pgs, parity_space)
 {
    if (parity_space > 1)
    {
-        for (const id in pgs)
+        for (const pg in pgs)
        {
-            const pg = pgs[id];
-            for (let i = 1; i < pg.length; i++)
+            for (let i = 1; i < pg.size; i++)
            {
                const cyclic = [ ...pg.slice(i), ...pg.slice(0, i) ];
                pgs['pg_'+cyclic.join('_')] = cyclic;
@@ -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);
        }
    }

@@ -1,6 +1,6 @@
 {
  "name": "vitastor-mon",
-  "version": "3.0.15",
+  "version": "3.0.9",
  "description": "Vitastor SDS monitor service",
  "main": "mon-main.js",
  "scripts": {
@@ -9,7 +9,7 @@
  "author": "Vitaliy Filippov",
  "license": "UNLICENSED",
  "dependencies": {
-    "antietcd": "^1.3.1",
+    "antietcd": "^1.2.4",
    "sprintf-js": "^1.1.2",
    "ws": "^7.2.5"
  },
@@ -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)
@@ -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] = {};
@@ -0,0 +1,471 @@
+// 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: osd, mon, admin, client.
+//      osd, mon types should be used by OSDs/monitors.
+//      admin should be used for administrative access from vitastor-cli.
+//      client should be used for regular clients.
+//    - 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
+
+const static_perms = {
+    invalid: {
+        keys: {},
+        prefixes: {},
+    },
+    osd: {
+        keys: { '/pg/config': false },
+        prefixes: { '/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/stats/': false, '/pg/state/': false, '/index/maxid/': false },
+    },
+};
+
+const api_perms = {
+    osd: { lease_grant: true, lease_revoke: true, lease_keepalive: true },
+    mon: { lease_grant: true, lease_revoke: true, lease_keepalive: true },
+    admin: { maintenance_status: true },
+    client: {},
+};
+
+class VitastorAuthFilter
+{
+    constructor(antietcd)
+    {
+        this.cfg = antietcd.cfg;
+        this.antietcd = antietcd;
+        this.prefix = this.cfg.vitastor_prefix || '/vitastor';
+        this.prefix_parts = this.prefix.split('/');
+    }
+
+    _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;
+            }
+        }
+        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(username)
+    {
+        if (!username)
+        {
+            return null;
+        }
+        let userInfo = this._get([ ...this.prefix_parts, 'config', 'user', username ], true);
+        if (!userInfo)
+        {
+            userInfo = { type: 'client' };
+        }
+        userInfo.perms = static_perms[userInfo.type] || static_perms['invalid'];
+        userInfo.name = 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(username, api/*, data*/)
+    {
+        if (username === 'root')
+        {
+            return true;
+        }
+        const userInfo = this._get([ ...this.prefix_parts, 'config', 'user', username ], true);
+        return userInfo && api_perms[userInfo.type] && api_perms[userInfo.type][api];
+    }
+
+    filter_txn(username, txn)
+    {
+        if (username === 'root')
+        {
+            return true;
+        }
+        const userInfo = this._get_user(username);
+        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(username, txn, res)
+    {
+        if (!res.responses || username === 'root')
+        {
+            return;
+        }
+        const userInfo = this._get_user(username);
+        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(username, msg)
+    {
+        if (!msg.result || !msg.result.events || username === 'root')
+        {
+            return;
+        }
+        const userInfo = this._get_user(username);
+        if (!userInfo)
+        {
+            msg.result.events = [];
+            return;
+        }
+        msg.result.events = msg.result.events.filter(ev => this._check_read(ev.kv, userInfo));
+    }
+}
+
+module.exports = VitastorAuthFilter;
@@ -1,6 +1,6 @@
 {
  "name": "vitastor",
-  "version": "3.0.15",
+  "version": "3.0.9",
  "description": "Low-level native bindings to Vitastor client library",
  "main": "index.js",
  "keywords": [
@@ -366,38 +366,15 @@ sub map_volume
    my $prefix = defined $scfg->{vitastor_prefix} ? $scfg->{vitastor_prefix} : 'pve/';

    my ($vtype, $img_name, $vmid) = $class->parse_volname($volname);
-    my $name = $prefix.$img_name;
+    my $name = $img_name;
    $name .= '@'.$snapname if $snapname;

    my $mapped = run_cli($scfg, [ 'ls' ], binary => '/usr/bin/vitastor-nbd');
-    my ($kerneldev) = grep {
-        $mapped->{$_} && $mapped->{$_}->{image} && $mapped->{$_}->{image} eq $name
-    } keys %$mapped;
+    my ($kerneldev) = grep { $mapped->{$_}->{image} eq $prefix.$name } keys %$mapped;
+    return $kerneldev if $kerneldev && -b $kerneldev; # already mapped

-    if ($kerneldev && -b $kerneldev)
-    {
-        my $size = `/usr/sbin/blockdev --getsize64 $kerneldev`;
-        return $kerneldev if $size && $size > 0;
-    }
-
-    my $map_out = run_cli($scfg, [ 'map', '--image', $name ], binary => '/usr/bin/vitastor-nbd', json => 0);
-    $map_out =~ s/^\s+|\s+$//gso;
-
-    # Wait until the device is started
-    for (my $i = 0; $i < 100; $i++)
-    {
-        $mapped = run_cli($scfg, [ 'ls' ], binary => '/usr/bin/vitastor-nbd');
-        ($kerneldev) = grep { $mapped->{$_} && $mapped->{$_}->{image} && $mapped->{$_}->{image} eq $name } keys %$mapped;
-        if ($kerneldev && -b $kerneldev)
-        {
-            my $size = `/usr/sbin/blockdev --getsize64 $kerneldev`;
-            return $kerneldev if $size && $size > 0;
-        }
-        select(undef, undef, undef, 0.1);
-    }
-
-    die "Failed to map Vitastor image $name via NBD".
-        ($map_out ? ", vitastor-nbd map returned '$map_out'" : "")."\n";
+    $kerneldev = run_cli($scfg, [ 'map', '--image', $prefix.$name ], binary => '/usr/bin/vitastor-nbd', json => 0);
+    return $kerneldev;
 }

 sub unmap_volume
@@ -406,19 +383,13 @@ sub unmap_volume
    my $prefix = defined $scfg->{vitastor_prefix} ? $scfg->{vitastor_prefix} : 'pve/';

    my ($vtype, $name, $vmid) = $class->parse_volname($volname);
-    $name = $prefix.$name;
    $name .= '@'.$snapname if $snapname;
+
    my $mapped = run_cli($scfg, [ 'ls' ], binary => '/usr/bin/vitastor-nbd');
-
-    my @kerneldevs = grep {
-        $mapped->{$_} && $mapped->{$_}->{image} && $mapped->{$_}->{image} eq $name
-    } keys %$mapped;
-
-    for my $kerneldev (@kerneldevs)
+    my ($kerneldev) = grep { $mapped->{$_}->{image} eq $prefix.$name } keys %$mapped;
+    if ($kerneldev && -b $kerneldev)
    {
-        next if !$kerneldev || !-b $kerneldev;
-        eval { run_cli($scfg, [ 'unmap', $kerneldev ], binary => '/usr/bin/vitastor-nbd', json => 0); };
-        warn "Failed to unmap Vitastor image $name from $kerneldev: $@" if $@;
+        run_cli($scfg, [ 'unmap', $kerneldev ], binary => '/usr/bin/vitastor-nbd', json => 0);
    }

    return 1;
@@ -434,13 +405,7 @@ sub activate_volume
 sub deactivate_volume
 {
    my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_;
-
-    # Even with vitastor_nbd=0, Proxmox may call map_volume() for special
-    # volumes like tpmstate0 because swtpm needs a local file/block path.
-    # Therefore, always try to unmap an existing NBD mapping here.
-    # unmap_volume() is a no-op if the volume is not currently mapped.
-    $class->unmap_volume($storeid, $scfg, $volname, $snapname);
-
+    $class->unmap_volume($storeid, $scfg, $volname, $snapname) if $scfg->{vitastor_nbd};
    return 1;
 }

@@ -50,7 +50,7 @@ from cinder.volume import configuration
 from cinder.volume import driver
 from cinder.volume import volume_utils

-VITASTOR_VERSION = '3.0.15'
+VITASTOR_VERSION = '3.0.9'

 LOG = logging.getLogger(__name__)

@@ -11,7 +11,7 @@ WORKDIR /root
 RUN sed -i 's/enabled=0/enabled=1/' /etc/yum.repos.d/*.repo
 RUN dnf -y install epel-release dnf-plugins-core
 RUN dnf -y install https://vitastor.io/rpms/centos/10/vitastor-release-1.0-1.el10.noarch.rpm
-RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel isa-l-devel gf-complete-devel rdma-core-devel cmake libnl3-devel
+RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel isa-l-devel gf-complete-devel rdma-core-devel cmake libnl3-devel c-ares-devel
 RUN dnf download --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN cd ~/rpmbuild/SPECS && dnf builddep -y --spec fio.spec
@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.15
+Version:        3.0.9
 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.15.el10.tar.gz
+Source0:        vitastor-3.0.9.el10.tar.gz

 BuildRequires:  gperftools-devel
 BuildRequires:  gcc-c++
@@ -16,6 +16,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -15,7 +15,7 @@ RUN yum -y --enablerepo=extras install centos-release-scl epel-release yum-utils
 RUN perl -i -pe 's!mirrorlist=!#mirrorlist=!s; s!#\s*baseurl=http://mirror.centos.org!baseurl=http://vault.centos.org!' /etc/yum.repos.d/CentOS-SCLo-scl*.repo
 RUN yum -y install https://vitastor.io/rpms/centos/7/vitastor-release-1.0-1.el7.noarch.rpm
 RUN yum -y install devtoolset-9-gcc-c++ devtoolset-9-libatomic-devel gcc make cmake gperftools-devel \
-    fio rh-nodejs12 jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libnl3-devel
+    fio rh-nodejs12 jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libnl3-devel c-ares-devel
 RUN yumdownloader --disablerepo=centos-sclo-rh --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN rm -f /etc/yum.repos.d/CentOS-Media.repo
@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.15
+Version:        3.0.9
 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.15.el7.tar.gz
+Source0:        vitastor-3.0.9.el7.tar.gz

 BuildRequires:  gperftools-devel
 BuildRequires:  devtoolset-9-gcc-c++
@@ -17,6 +17,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake3
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -13,7 +13,7 @@ RUN dnf -y install centos-release-advanced-virtualization epel-release dnf-plugi
 RUN sed -i 's/^mirrorlist=/#mirrorlist=/; s!#baseurl=.*!baseurl=http://vault.centos.org/centos/8.4.2105/virt/$basearch/$avdir/!; s!^baseurl=.*Source/.*!baseurl=http://vault.centos.org/centos/8.4.2105/virt/Source/advanced-virtualization/!' /etc/yum.repos.d/CentOS-Advanced-Virtualization.repo
 RUN yum -y install https://vitastor.io/rpms/centos/8/vitastor-release-1.0-1.el8.noarch.rpm
 RUN dnf -y install gcc-toolset-9 gcc-toolset-9-gcc-c++ gperftools-devel \
-    fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel libibverbs-devel libarchive cmake libnl3-devel
+    fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel libibverbs-devel libarchive cmake libnl3-devel c-ares-devel
 RUN dnf download --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN cd ~/rpmbuild/SPECS && dnf builddep -y --enablerepo=powertools --spec fio.spec
@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.15
+Version:        3.0.9
 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.15.el8.tar.gz
+Source0:        vitastor-3.0.9.el8.tar.gz

 BuildRequires:  gperftools-devel
 BuildRequires:  gcc-toolset-9-gcc-c++
@@ -16,6 +16,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -10,7 +10,7 @@ WORKDIR /root
 RUN sed -i 's/enabled=0/enabled=1/' /etc/yum.repos.d/*.repo
 RUN dnf -y install epel-release dnf-plugins-core
 RUN dnf -y install https://vitastor.io/rpms/centos/9/vitastor-release-1.0-1.el9.noarch.rpm
-RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libarchive cmake libnl3-devel
+RUN dnf -y install gcc-c++ gperftools-devel fio nodejs rpm-build jerasure-devel libisa-l-devel gf-complete-devel rdma-core-devel libarchive cmake libnl3-devel c-ares-devel
 RUN dnf download --source fio
 RUN rpm --nomd5 -i fio*.src.rpm
 RUN cd ~/rpmbuild/SPECS && dnf builddep -y --spec fio.spec
@@ -1,11 +1,11 @@
 Name:           vitastor
-Version:        3.0.15
+Version:        3.0.9
 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.15.el9.tar.gz
+Source0:        vitastor-3.0.9.el9.tar.gz

 BuildRequires:  gperftools-devel
 BuildRequires:  gcc-c++
@@ -16,6 +16,7 @@ BuildRequires:  gf-complete-devel
 BuildRequires:  rdma-core-devel
 BuildRequires:  cmake
 BuildRequires:  libnl3-devel
+BuildRequires:  c-ares-devel
 Requires:       vitastor-osd = %{version}-%{release}
 Requires:       vitastor-mon = %{version}-%{release}
 Requires:       vitastor-client = %{version}-%{release}
@@ -20,7 +20,7 @@ if("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/local/?$")
 endif()
 set(ENABLE_COVERAGE false CACHE BOOL "Enable code coverage")

-add_definitions(-DVITASTOR_VERSION="3.0.15")
+add_definitions(-DVITASTOR_VERSION="3.0.9")
 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})
@@ -74,6 +74,14 @@ if (RDMACM_LIBRARIES)
 	add_definitions(-DWITH_RDMACM)
 endif (RDMACM_LIBRARIES)

+find_package(OpenSSL REQUIRED)
+if (OPENSSL_FOUND)
+	add_definitions(-DWITH_OPENSSL)
+endif (OPENSSL_FOUND)
+
+pkg_check_modules(CARES REQUIRED libcares)
+include_directories(${CARES_INCLUDE_DIRS})
+
 if (${WITH_SYSTEM_LIBURING})
 	pkg_check_modules(LIBURING REQUIRED liburing>=2.10)
 	include_directories(${LIBURING_INCLUDE_DIRS})
@@ -83,20 +83,23 @@ void blockstore_disk_t::parse_config(std::map<std::string, std::string> & config
    {
        data_csum_type = BLOCKSTORE_CSUM_CRC32C;
    }
+    else if (config["data_csum_type"] == "xxh3_32")
+    {
+        data_csum_type = BLOCKSTORE_CSUM_XXH3_32;
+    }
    else if (config["data_csum_type"] == "" || config["data_csum_type"] == "none")
    {
        data_csum_type = BLOCKSTORE_CSUM_NONE;
    }
    else
    {
-        throw std::runtime_error("data_csum_type="+config["data_csum_type"]+" is unsupported, only \"crc32c\" and \"none\" are supported");
+        throw std::runtime_error("data_csum_type="+config["data_csum_type"]+" is unsupported, only \"crc32c\", \"xxh3_32\" and \"none\" are supported");
    }
    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;
@@ -517,7 +520,7 @@ void blockstore_disk_t::close_all()

 // Sadly DISCARD only works through ioctl(), but it seems to always block the device queue,
 // so it's not a big deal that we can only run it synchronously.
-int blockstore_disk_t::trim_data(std::function<bool(uint64_t)> is_used)
+int blockstore_disk_t::trim_data(std::function<bool(uint64_t)> is_free)
 {
    if (mock_mode)
    {
@@ -528,7 +531,7 @@ int blockstore_disk_t::trim_data(std::function<bool(uint64_t)> is_used)
    uint64_t discarded = 0;
    for (; i <= block_count; i++)
    {
-        if (i >= block_count || is_used(i))
+        if (i >= block_count || is_free(i))
        {
            if (i > j && (i-j)*data_block_size >= min_discard_size)
            {
@@ -541,21 +544,17 @@ int blockstore_disk_t::trim_data(std::function<bool(uint64_t)> is_used)
                    if (range[0] % discard_granularity)
                        range[0] = range[0] + discard_granularity - (range[0] % discard_granularity);
                    if (range[0] >= range[1])
-                        range[1] = 0;
-                    else
-                        range[1] -= range[0];
+                        continue;
+                    range[1] -= range[0];
                }
-                if (range[1] > 0)
+                r = ioctl(data_fd, BLKDISCARD, &range);
+                if (r != 0)
                {
-                    r = ioctl(data_fd, BLKDISCARD, &range);
-                    if (r != 0)
-                    {
-                        fprintf(stderr, "Failed to execute BLKDISCARD %ju+%ju on %s: %s (code %d)\n",
-                            range[0], range[1], data_device.c_str(), strerror(-r), r);
-                        return -errno;
-                    }
-                    discarded += range[1];
+                    fprintf(stderr, "Failed to execute BLKDISCARD %ju+%ju on %s: %s (code %d)\n",
+                        range[0], range[1], data_device.c_str(), strerror(-r), r);
+                    return -errno;
                }
+                discarded += range[1];
            }
            j = i+1;
        }
@@ -16,6 +16,7 @@
 #define BLOCKSTORE_CSUM_NONE 0
 // Lower byte of checksum type is its length
 #define BLOCKSTORE_CSUM_CRC32C 0x104
+#define BLOCKSTORE_CSUM_XXH3_32 0x204

 #define MOCK_DATA_FD 1000
 #define MOCK_META_FD 1001
@@ -59,8 +60,6 @@ struct blockstore_disk_t
    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;

@@ -83,7 +82,7 @@ struct blockstore_disk_t
    void calc_lengths(bool skip_meta_check = false);
    void check_lengths();
    void close_all();
-    int trim_data(std::function<bool(uint64_t)> is_used);
+    int trim_data(std::function<bool(uint64_t)> is_free);

    inline uint64_t dirty_dyn_size(uint64_t offset, uint64_t len)
    {
@@ -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,53 +273,30 @@ resume_1:
        bs->heap->unlock_entry(cur_oid);
        goto resume_0;
    }
+    mem_or(new_bmp, compact_info.clean_wr->get_int_bitmap(bs->heap), bs->dsk.clean_entry_bitmap_size);
+    if (!bitmap_copied)
+    {
+        memcpy(new_ext_bmp, compact_info.clean_wr->get_ext_bitmap(bs->heap), bs->dsk.clean_entry_bitmap_size);
+        bitmap_copied = true;
+    }
+    if (bs->dsk.csum_block_size && bs->dsk.csum_block_size <= bs->dsk.bitmap_granularity)
+    {
+        memcpy(new_csums, compact_info.clean_wr->get_checksums(bs->heap), bs->dsk.data_block_size/bs->dsk.csum_block_size * (bs->dsk.data_csum_type & 0xFF));
+        for (size_t i = csum_copy.size(); i > 0; i--)
+        {
+            auto wr = csum_copy[i-1];
+            memcpy(new_csums + wr->small().offset/bs->dsk.csum_block_size*(bs->dsk.data_csum_type & 0xFF),
+                wr->get_checksums(bs->heap), wr->small().len/bs->dsk.csum_block_size*(bs->dsk.data_csum_type & 0xFF));
+        }
+        csum_copy.clear();
+    }
+    clean_loc = compact_info.clean_wr->big_location(bs->heap);
    flusher->active_flushers++;
-    for (i = 0; i < read_vec.size(); i++)
+    if (bs->log_level > 10)
    {
-        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 (compact_info.do_delete)
-    {
-        if (bs->log_level > 10)
-        {
-            printf("Compacting %jx:%jx up to l%ju (delete)\n", cur_oid.inode, cur_oid.stripe, compact_info.compact_lsn);
-        }
-        clean_loc = UINT64_MAX;
-    }
-    else
-    {
-        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)
-        {
-            memcpy(new_ext_bmp, compact_info.clean_wr->get_ext_bitmap(bs->heap), bs->dsk.clean_entry_bitmap_size);
-            bitmap_copied = true;
-        }
-        if (bs->dsk.csum_block_size && bs->dsk.csum_block_size <= bs->dsk.bitmap_granularity)
-        {
-            memcpy(new_csums, compact_info.clean_wr->get_checksums(bs->heap), bs->dsk.data_block_size/bs->dsk.csum_block_size * (bs->dsk.data_csum_type & 0xFF));
-            for (size_t i = csum_copy.size(); i > 0; i--)
-            {
-                auto wr = csum_copy[i-1];
-                memcpy(new_csums + wr->small().offset/bs->dsk.csum_block_size*(bs->dsk.data_csum_type & 0xFF),
-                    wr->get_checksums(bs->heap), wr->small().len/bs->dsk.csum_block_size*(bs->dsk.data_csum_type & 0xFF));
-            }
-            csum_copy.clear();
-        }
-        clean_loc = compact_info.clean_wr->big_location(bs->heap);
+        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)
@@ -362,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--;
@@ -382,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)
        {
@@ -411,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++;
        }
@@ -429,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
@@ -449,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;
    }
@@ -465,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;
    }
@@ -630,13 +586,13 @@ 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;
 }

 bool journal_flusher_co::calc_block_checksums()
 {
-    if (bs->dsk.csum_block_size <= bs->dsk.bitmap_granularity || compact_info.do_delete)
+    if (bs->dsk.csum_block_size <= bs->dsk.bitmap_granularity)
    {
        return true;
    }
@@ -743,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;
@@ -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;
@@ -43,7 +43,7 @@ struct __attribute__((__packed__)) heap_entry_t
 {
    uint16_t size;
    uint16_t entry_type;
-    uint32_t crc32c;
+    uint32_t checksum;
    uint64_t lsn;
    uint64_t inode;
    uint64_t stripe;
@@ -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);
@@ -69,7 +69,8 @@ struct __attribute__((__packed__)) heap_entry_t
    uint32_t *get_checksum(blockstore_heap_t *heap);
    uint64_t big_location(blockstore_heap_t *heap);
    void set_big_location(blockstore_heap_t *heap, uint64_t location);
-    uint32_t calc_crc32c();
+    uint32_t calc_checksum(blockstore_heap_t *heap);
+    uint32_t calc_checksum(blockstore_disk_t *dsk);
 };

 struct __attribute__((__packed__)) heap_small_write_t
@@ -80,7 +81,7 @@ struct __attribute__((__packed__)) heap_small_write_t
    uint32_t offset;
    uint32_t len;

-    // Also includes 1 bitmap and 1 crc32c after the bitmap if checksums are disabled
+    // Also includes 1 bitmap and 1 checksum after the bitmap if block checksums are disabled
 };

 struct __attribute__((__packed__)) heap_big_write_t
@@ -98,7 +99,7 @@ struct __attribute__((__packed__)) heap_big_intent_t
    uint32_t offset;
    uint32_t len;

-    // Also includes 2 bitmaps and 1 crc32c if checksums are disabled
+    // Also includes 2 bitmaps and 1 checksums if block checksums are disabled
 };

 struct __attribute__((__packed__)) heap_list_item_t
@@ -158,16 +159,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,
@@ -218,12 +209,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*> init_erase_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,12 +220,7 @@ 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);
@@ -245,9 +228,8 @@ class blockstore_heap_t

    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 insert_list_item(heap_list_item_t *li);
    void remove_list_item(heap_list_item_t *li);
-    void unlink_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);
@@ -362,7 +344,7 @@ public:

    // get metadata block data buffer and used space
    void get_meta_block(uint32_t block_num, uint8_t *buffer);
-    void fill_block_empty_space(uint8_t *buffer, uint64_t pos);
+    void fill_block_empty_space(uint8_t *buffer, uint32_t pos);
    uint32_t get_meta_block_used_space(uint32_t block_num);

    // get space usage statistics
@@ -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)
            {
@@ -117,12 +117,9 @@ public:

    journal_flusher_t *flusher;
    int write_iodepth = 0;
+    int inflight_big = 0;
    int intent_write_counter = 0;
-    uint64_t data_fsync_next = 0;
-    uint64_t data_fsync_cur = 0;
-    uint64_t data_fsync_sent = 0;
-    uint64_t data_fsync_done = 0;
-    std::deque<bool> data_fsyncs;
+    bool fsyncing_data = false;

    bool live = false, queue_stall = false;
    ring_loop_i *ringloop = NULL;
@@ -10,6 +10,7 @@
 #define INIT_META_EMPTY 0
 #define INIT_META_READING 1
 #define INIT_META_READ_DONE 2
+#define INIT_META_WRITING 3

 #define GET_SQE() \
    sqe = bs->get_sqe();\
@@ -22,15 +23,14 @@ blockstore_init_meta::blockstore_init_meta(blockstore_impl_t *bs)
    this->bs = bs;
 }

-void blockstore_init_meta::handle_event(ring_data_t *data, int buf_num, const char *op)
+void blockstore_init_meta::handle_event(ring_data_t *data, int buf_num)
 {
-    if (data->res != data->iov.iov_len)
+    if (data->res < 0)
    {
-        throw std::runtime_error(strprintf(
-            "%s failed at offset %ju: got %s (code %d), but expected %zu",
-            op, (buf_num >= 0 ? bufs[buf_num].offset : last_read_offset), strerror(-data->res),
-            data->res, data->iov.iov_len
-        ));
+        throw std::runtime_error(
+            std::string("read metadata failed at offset ") + std::to_string(buf_num >= 0 ? bufs[buf_num].offset : last_read_offset) +
+            std::string(": ") + strerror(-data->res)
+        );
    }
    if (buf_num >= 0)
    {
@@ -60,7 +60,7 @@ int blockstore_init_meta::loop()
    GET_SQE();
    last_read_offset = 0;
    data->iov = { bs->meta_superblock, (size_t)bs->dsk.meta_block_size };
-    data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read metadata header"); };
+    data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
    io_uring_prep_readv(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
    bs->ringloop->submit();
    submitted++;
@@ -72,19 +72,25 @@ resume_1:
    }
    if (is_zero((uint64_t*)bs->meta_superblock, bs->dsk.meta_block_size))
    {
-        assert(bs->dsk.meta_format == BLOCKSTORE_META_FORMAT_HEAP);
-        blockstore_meta_header_v3_t *hdr = (blockstore_meta_header_v3_t *)bs->meta_superblock;
-        hdr->zero = 0;
-        hdr->magic = BLOCKSTORE_META_MAGIC_V1;
-        hdr->version = bs->dsk.meta_format;
-        hdr->meta_block_size = bs->dsk.meta_block_size;
-        hdr->data_block_size = bs->dsk.data_block_size;
-        hdr->bitmap_granularity = bs->dsk.bitmap_granularity;
-        hdr->completed_lsn = 0;
-        hdr->data_csum_type = bs->dsk.data_csum_type;
-        hdr->csum_block_size = bs->dsk.csum_block_size;
-        hdr->meta_area_size = bs->dsk.meta_area_size;
-        hdr->set_crc32c();
+        {
+            blockstore_meta_header_v3_t *hdr = (blockstore_meta_header_v3_t *)bs->meta_superblock;
+            hdr->zero = 0;
+            hdr->magic = BLOCKSTORE_META_MAGIC_V1;
+            hdr->version = bs->dsk.meta_format;
+            hdr->meta_block_size = bs->dsk.meta_block_size;
+            hdr->data_block_size = bs->dsk.data_block_size;
+            hdr->bitmap_granularity = bs->dsk.bitmap_granularity;
+            if (bs->dsk.meta_format >= BLOCKSTORE_META_FORMAT_V2)
+            {
+                hdr->data_csum_type = bs->dsk.data_csum_type;
+                hdr->csum_block_size = bs->dsk.csum_block_size;
+            }
+            if (bs->dsk.meta_format >= BLOCKSTORE_META_FORMAT_HEAP)
+            {
+                hdr->meta_area_size = bs->dsk.meta_area_size;
+            }
+            hdr->set_crc32c();
+        }
        if (bs->readonly)
        {
            printf("Skipping metadata initialization because blockstore is readonly\n");
@@ -92,8 +98,21 @@ resume_1:
        else
        {
            printf("Initializing metadata area\n");
+            GET_SQE();
+            last_read_offset = 0;
+            data->iov = (struct iovec){ bs->meta_superblock, (size_t)bs->dsk.meta_block_size };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
+            io_uring_prep_writev(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
+            bs->ringloop->submit();
+            submitted++;
+        resume_2:
+            if (submitted > 0)
+            {
+                wait_state = 2;
+                return 1;
+            }
+            zero_on_init = true;
        }
-        zero_on_init = true;
    }
    else
    {
@@ -134,17 +153,9 @@ 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 && !zero_on_init)
+    if (bs->dsk.inmemory_journal)
    {
        // Read buffer area
        printf("Reading buffered data\n");
@@ -156,7 +167,7 @@ resume_1:
                bs->buffer_area + md_offset,
                (size_t)(bs->dsk.journal_len - md_offset < bs->metadata_buf_size ? bs->dsk.journal_len - md_offset : bs->metadata_buf_size),
            };
-            data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read buffer area"); };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
            io_uring_prep_readv(sqe, bs->dsk.journal_fd, &data->iov, 1, bs->dsk.journal_offset + md_offset);
            md_offset += data->iov.iov_len;
            submitted++;
@@ -175,7 +186,7 @@ resume_3:
    next_offset = md_offset;
    // Read the rest of the metadata
 resume_4:
-    if (next_offset < bs->dsk.meta_area_size && submitted == 0 && (!zero_on_init || !bs->readonly))
+    if (next_offset < bs->dsk.meta_area_size && submitted == 0)
    {
        // Submit one read
        for (int i = 0; i < 2; i++)
@@ -192,15 +203,12 @@ resume_4:
                GET_SQE();
                assert(bufs[i].size <= 0x7fffffff);
                data->iov = { bufs[i].buf, (size_t)bufs[i].size };
+                data->callback = [this, i](ring_data_t *data) { handle_event(data, i); };
                if (!zero_on_init)
-                {
-                    data->callback = [this, i](ring_data_t *data) { handle_event(data, i, "read metadata"); };
                    io_uring_prep_readv(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset + bufs[i].offset);
-                }
                else
                {
                    // Fill metadata with empty block pattern
-                    data->callback = [this, i](ring_data_t *data) { handle_event(data, i, "clear metadata"); };
                    memset(bufs[i].buf, 0, bufs[i].size);
                    for (uint64_t o = 0; o < bufs[i].size; o += bs->dsk.meta_block_size)
                        bs->heap->fill_block_empty_space(bufs[i].buf + o, 0);
@@ -216,14 +224,11 @@ resume_4:
        if (bufs[i].state == INIT_META_READ_DONE)
        {
            // Handle result
-            if (!zero_on_init)
-            {
-                uint64_t loaded = 0;
-                int r = bs->heap->load_blocks(bufs[i].offset-bs->dsk.meta_block_size, bufs[i].size, bufs[i].buf, bs->skip_corrupted_meta_entries, loaded);
-                if (r != 0)
-                    exit(1);
-                entries_loaded += loaded;
-            }
+            uint64_t loaded = 0;
+            int r = bs->heap->load_blocks(bufs[i].offset-bs->dsk.meta_block_size, bufs[i].size, bufs[i].buf, bs->skip_corrupted_meta_entries, loaded);
+            if (r != 0)
+                exit(1);
+            entries_loaded += loaded;
            bufs[i].state = 0;
            bs->ringloop->wakeup();
        }
@@ -233,9 +238,25 @@ resume_4:
        wait_state = 4;
        return 1;
    }
-    // metadata read/clear finished
+    // metadata read finished
    bs->heap->finish_load();
    printf("Metadata entries loaded: %ju, rechecking unfinished writes and garbage entries\n", entries_loaded);
+    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;
@@ -290,7 +311,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)
@@ -316,44 +337,6 @@ resume_9:
    }
    free(metadata_buffer);
    metadata_buffer = NULL;
-do_fsync:
-    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, "fsync metadata"); };
-        submitted++;
-        bs->ringloop->submit();
-    resume_5:
-        if (submitted > 0)
-        {
-            wait_state = 5;
-            return 1;
-        }
-    }
-    if (zero_on_init && !header_written && !bs->readonly)
-    {
-        GET_SQE();
-        header_written = true;
-        last_read_offset = 0;
-        data->iov = (struct iovec){ bs->meta_superblock, (size_t)bs->dsk.meta_block_size };
-        data->callback = [this](ring_data_t *data) { handle_event(data, -1, "write metadata header"); };
-        io_uring_prep_writev(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
-        bs->ringloop->submit();
-        submitted++;
-    resume_2:
-        if (submitted > 0)
-        {
-            wait_state = 2;
-            return 1;
-        }
-        if (!bs->dsk.disable_meta_fsync)
-        {
-            goto do_fsync;
-        }
-    }
    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(),
@@ -17,7 +17,6 @@ class blockstore_init_meta
    int wait_state = 0;
    int wait_count = 0;
    bool zero_on_init = false;
-    bool header_written = false;
    void *metadata_buffer = NULL;
    blockstore_init_meta_buf bufs[2] = {};
    int submitted = 0;
@@ -30,7 +29,7 @@ class blockstore_init_meta
    std::vector<uint32_t> recheck_mod;
    int i = 0, j = 0;
    bool handle_meta_block(uint8_t *buf, uint64_t count, uint64_t done_cnt);
-    void handle_event(ring_data_t *data, int buf_num, const char *op);
+    void handle_event(ring_data_t *data, int buf_num);
 public:
    blockstore_init_meta(blockstore_impl_t *bs);
    int loop();
@@ -1,113 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 (see README.md for details)
-
-#include "blockstore_mock.h"
-
-blockstore_mock_t::blockstore_mock_t(const blockstore_config_t & config)
-{
-}
-
-void blockstore_mock_t::parse_config(blockstore_config_t & config)
-{
-}
-
-void* blockstore_mock_t::reshard_start(pool_id_t pool, uint32_t pg_count, uint32_t pg_stripe_size, uint64_t chunk_limit)
-{
-    return NULL;
-}
-
-bool blockstore_mock_t::reshard_continue(void *reshard_state, uint64_t chunk_limit)
-{
-    return true;
-}
-
-void blockstore_mock_t::loop()
-{
-}
-
-bool blockstore_mock_t::is_started()
-{
-    return true;
-}
-
-bool blockstore_mock_t::is_stalled()
-{
-    return false;
-}
-
-bool blockstore_mock_t::is_safe_to_stop()
-{
-    return true;
-}
-
-void blockstore_mock_t::enqueue_op(blockstore_op_t *op)
-{
-}
-
-int blockstore_mock_t::read_bitmap(object_id oid, uint64_t target_version, void *bitmap, uint64_t *result_version)
-{
-    return -EIO;
-}
-
-const std::map<uint64_t, uint64_t> & blockstore_mock_t::get_inode_space_stats()
-{
-    return inode_space;
-}
-
-void blockstore_mock_t::set_no_inode_stats(const std::vector<uint64_t> & pool_ids)
-{
-}
-
-void blockstore_mock_t::dump_diagnostics()
-{
-}
-
-std::string blockstore_mock_t::get_op_diag(blockstore_op_t *op)
-{
-    return "";
-}
-
-uint32_t blockstore_mock_t::get_block_size()
-{
-    return block_size;
-}
-
-uint64_t blockstore_mock_t::get_block_count()
-{
-    return block_count;
-}
-
-uint64_t blockstore_mock_t::get_free_block_count()
-{
-    return block_count;
-}
-
-uint64_t blockstore_mock_t::get_journal_size()
-{
-    return 32*1024*1024;
-}
-
-uint32_t blockstore_mock_t::get_bitmap_granularity()
-{
-    return bitmap_granularity;
-}
-
-uint64_t blockstore_mock_t::get_live_entries()
-{
-    return 0;
-}
-
-uint64_t blockstore_mock_t::get_live_memory()
-{
-    return 0;
-}
-
-uint64_t blockstore_mock_t::get_garbage_entries()
-{
-    return 0;
-}
-
-uint64_t blockstore_mock_t::get_garbage_memory()
-{
-    return 0;
-}
@@ -1,39 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 (see README.md for details)
-
-#pragma once
-
-#include "blockstore.h"
-
-class blockstore_mock_t: public blockstore_i
-{
-public:
-    uint32_t block_size = 128*1024;
-    uint32_t bitmap_granularity = 4096;
-    uint64_t block_count = 100*1024*8;
-    std::map<uint64_t, uint64_t> inode_space;
-
-    blockstore_mock_t(const blockstore_config_t & config);
-    void parse_config(blockstore_config_t & config) override;
-    void* reshard_start(pool_id_t pool, uint32_t pg_count, uint32_t pg_stripe_size, uint64_t chunk_limit) override;
-    bool reshard_continue(void *reshard_state, uint64_t chunk_limit) override;
-    void loop() override;
-    bool is_started() override;
-    bool is_stalled() override;
-    bool is_safe_to_stop() override;
-    void enqueue_op(blockstore_op_t *op) override;
-    int read_bitmap(object_id oid, uint64_t target_version, void *bitmap, uint64_t *result_version = NULL) override;
-    const std::map<uint64_t, uint64_t> & get_inode_space_stats() override;
-    void set_no_inode_stats(const std::vector<uint64_t> & pool_ids) override;
-    void dump_diagnostics() override;
-    std::string get_op_diag(blockstore_op_t *op) override;
-    uint32_t get_block_size() override;
-    uint64_t get_block_count() override;
-    uint64_t get_free_block_count() override;
-    uint64_t get_journal_size() override;
-    uint32_t get_bitmap_granularity() override;
-    uint64_t get_live_entries() override;
-    uint64_t get_live_memory() override;
-    uint64_t get_garbage_entries() override;
-    uint64_t get_garbage_memory() override;
-};
@@ -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++)
    {
@@ -28,7 +27,6 @@ int blockstore_impl_t::dequeue_stable(blockstore_op_t *op)
                FINISH_OP(op);
                return 2;
            }
-            priv->modified_block2 = UINT32_MAX;
            int res = op->opcode == BS_OP_STABLE
                ? heap->add_commit(obj, v[priv->stab_pos].version, &priv->modified_block2)
                : heap->add_rollback(obj, v[priv->stab_pos].version, &priv->modified_block2);
@@ -38,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())
@@ -53,6 +45,11 @@ int blockstore_impl_t::dequeue_stable(blockstore_op_t *op)
                    FINISH_OP(op);
                    return 2;
                }
+                if (priv->modified_block2 != UINT32_MAX)
+                {
+                    priv->stab_pos--;
+                    goto resume_1;
+                }
                priv->wait_for = WAIT_COMPACTION;
                priv->wait_detail = heap->get_compacted_count();
                flusher->request_trim();
@@ -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)
@@ -29,12 +28,9 @@ bool blockstore_impl_t::has_unsynced()

 bool blockstore_impl_t::submit_fsyncs(int & wait_count)
 {
-    int n = (unsynced_meta_write_count > 0 && !dsk.disable_meta_fsync ? 1 : 0) +
-        (unsynced_buffer_write_count > 0 && !dsk.disable_journal_fsync &&
-            (!unsynced_meta_write_count || dsk.journal_fd != dsk.meta_fd) ? 1 : 0) +
-        (unsynced_data_write_count > 0 && !dsk.disable_data_fsync &&
-            (!unsynced_meta_write_count || dsk.data_fd != dsk.meta_fd) &&
-            (!unsynced_buffer_write_count || dsk.data_fd != dsk.journal_fd) ? 1 : 0);
+    int n = (unsynced_meta_write_count > 0 && !dsk.disable_meta_fsync) +
+        (unsynced_buffer_write_count > 0 && !dsk.disable_journal_fsync && dsk.journal_fd != dsk.meta_fd) +
+        (unsynced_data_write_count > 0 && !dsk.disable_data_fsync && dsk.data_fd != dsk.meta_fd && dsk.data_fd != dsk.journal_fd);
    if (ringloop->space_left() < n)
    {
        return false;
@@ -63,8 +59,7 @@ bool blockstore_impl_t::submit_fsyncs(int & wait_count)
        data->callback = cb;
        wait_count++;
    }
-    if (unsynced_buffer_write_count > 0 && !dsk.disable_journal_fsync &&
-        (!unsynced_meta_write_count || dsk.journal_fd != dsk.meta_fd))
+    if (unsynced_buffer_write_count > 0 && !dsk.disable_journal_fsync && dsk.meta_fd != dsk.journal_fd)
    {
        // fsync buffer
        io_uring_sqe *sqe = get_sqe();
@@ -75,9 +70,7 @@ bool blockstore_impl_t::submit_fsyncs(int & wait_count)
        data->callback = cb;
        wait_count++;
    }
-    if (unsynced_data_write_count > 0 && !dsk.disable_data_fsync &&
-        (!unsynced_meta_write_count || dsk.data_fd != dsk.meta_fd) &&
-        (!unsynced_buffer_write_count || dsk.data_fd != dsk.journal_fd))
+    if (unsynced_data_write_count > 0 && !dsk.disable_data_fsync && dsk.data_fd != dsk.meta_fd && dsk.data_fd != dsk.journal_fd)
    {
        // fsync data
        io_uring_sqe *sqe = get_sqe();
@@ -111,11 +104,9 @@ 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)->lsn = 0;
        PRIV(op)->wait_detail = 1;
        PRIV(op)->wait_for = WAIT_SQE;
        return 0;
@@ -127,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;
 }
@@ -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,18 +177,14 @@ 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);
-        if (!dsk.disable_data_fsync)
-        {
-            // use PRIV->lsn for fsync_data_id
-            PRIV(op)->lsn = ++data_fsync_next;
-            data_fsyncs.push_back(false);
-        }
        PRIV(op)->pending_ops++;
        write_iodepth++;
        if (PRIV(op)->write_type == BS_HEAP_BIG_WRITE)
+        {
            PRIV(op)->op_state = 1;
+            inflight_big++;
+        }
        else
            PRIV(op)->op_state = 3;
    }
@@ -269,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++;
        }
@@ -300,6 +294,8 @@ again:
        goto resume_10;
    else if (op_state == 11)
        goto resume_11;
+    else if (op_state == 12)
+        goto resume_12;
    else
    {
        // In progress
@@ -318,44 +314,38 @@ again:
 resume_2:
    // We must fsync all big writes to avoid complex write workflows
    // It's OK for all HDDs and for server SSDs, but slightly worse for desktop SSDs
+    inflight_big--;
    if (!dsk.disable_data_fsync)
    {
-        // Mark our data write as completed and advance data_fsync_cur
-        data_fsyncs[PRIV(op)->lsn - data_fsync_cur - 1] = true;
-        while (data_fsyncs.size() > 0 && data_fsyncs.front())
-        {
-            data_fsyncs.pop_front();
-            data_fsync_cur++;
-        }
-        PRIV(op)->op_state = 11;
-        // Then wait for all other data writes currently in progress to do less fsync calls
-        // I.e. to fsync data in batches
-        PRIV(op)->lsn = data_fsync_cur + data_fsyncs.size();
+        // fsync data in a batch
 resume_11:
-        if (data_fsync_cur < PRIV(op)->lsn)
+        if (inflight_big > 0)
        {
+            PRIV(op)->op_state = 11;
            return 1;
        }
-        if (PRIV(op)->lsn > data_fsync_sent)
+        if (fsyncing_data)
        {
-            BS_SUBMIT_GET_SQE(sqe, data);
-            io_uring_prep_fsync(sqe, dsk.data_fd, IORING_FSYNC_DATASYNC);
-            data->iov = { 0 };
-            data->callback = [this, op, fs = data_fsync_cur](ring_data_t *data)
+resume_12:
+            if (fsyncing_data)
            {
-                if (fs > data_fsync_done)
-                {
-                    data_fsync_done = fs;
-                    ringloop->wakeup();
-                }
-            };
-            data_fsync_sent = data_fsync_cur;
+                PRIV(op)->op_state = 12;
+                return 1;
+            }
+            goto resume_4;
        }
-        if (PRIV(op)->lsn > data_fsync_done)
+        fsyncing_data = true;
+        BS_SUBMIT_GET_SQE(sqe, data);
+        io_uring_prep_fsync(sqe, dsk.data_fd, IORING_FSYNC_DATASYNC);
+        data->iov = { 0 };
+        data->callback = [this, op](ring_data_t *data)
        {
-            return 1;
-        }
-        PRIV(op)->lsn = 0;
+            fsyncing_data = false;
+            handle_write_event(data, op);
+        };
+        PRIV(op)->pending_ops++;
+        PRIV(op)->op_state = 3;
+        return 1;
    }
 resume_4:
    {
@@ -463,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;
@@ -12,7 +12,7 @@ multilist_alloc_t::multilist_alloc_t(uint32_t count, uint32_t maxn):
    count(count), maxn(maxn)
 {
    // not-so-memory-efficient: 16 MB memory per 1 GB buffer space, but buffer spaces are small, so OK
-    assert(count > 1 && count < 0x80000000 && count >= maxn);
+    assert(count > 1 && count < 0x80000000);
    sizes.resize(count);
    nexts.resize(count); // nexts[i] = 0 -> area is used; nexts[i] = 1 -> no next; nexts[i] >= 2 -> next item
    prevs.resize(count);
@@ -171,7 +171,7 @@ void multilist_alloc_t::print()
    printf("\n");
 }

-bool multilist_alloc_t::use(uint32_t pos, uint32_t size)
+void multilist_alloc_t::use(uint32_t pos, uint32_t size)
 {
    assert(pos+size <= count && size > 0);
    if (sizes[pos] <= 0)
@@ -182,8 +182,7 @@ bool multilist_alloc_t::use(uint32_t pos, uint32_t size)
        else
            while (start > 0 && !sizes[start])
                start--;
-        if (sizes[start] < size+(pos-start))
-            return false;
+        assert(sizes[start] >= size);
        use_full(start);
        uint32_t full = sizes[start];
        sizes[pos-1] = -pos+start;
@@ -200,8 +199,7 @@ bool multilist_alloc_t::use(uint32_t pos, uint32_t size)
    }
    else
    {
-        if (sizes[pos] < size)
-            return false;
+        assert(sizes[pos] >= size);
        use_full(pos);
        if (sizes[pos] > size)
        {
@@ -216,13 +214,12 @@ bool multilist_alloc_t::use(uint32_t pos, uint32_t size)
 #ifdef MULTILIST_TRACE
    print();
 #endif
-    return true;
 }

 void multilist_alloc_t::use_full(uint32_t pos)
 {
    uint32_t prevsize = sizes[pos];
-    assert(prevsize > 0);
+    assert(prevsize);
    assert(nexts[pos]);
    uint32_t pi = (prevsize < maxn ? prevsize : maxn)-1;
    if (heads[pi] == pos+1)
@@ -17,7 +17,7 @@ struct multilist_alloc_t
    bool is_free(uint32_t pos);
    uint32_t find(uint32_t size);
    void use_full(uint32_t pos);
-    bool use(uint32_t pos, uint32_t size);
+    void use(uint32_t pos, uint32_t size);
    void do_free(uint32_t pos);
    void free(uint32_t pos);
    void verify();
@@ -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"
@@ -71,11 +71,6 @@ bool journal_flusher_t::is_active()
    return active_flushers > 0 || dequeuing;
 }

-size_t journal_flusher_t::get_queue_size()
-{
-    return flush_queue.size();
-}
-
 void journal_flusher_t::loop()
 {
    target_flusher_count = bs->write_iodepth*2;
@@ -389,7 +384,6 @@ stop_flusher:
        wait_state = 0;
        return true;
    }
-    copy_count = 0;
    try_trim = true;
    cur.oid = flusher->flush_queue.front();
    cur.version = flusher->flush_versions[cur.oid];
@@ -517,31 +511,6 @@ resume_2:
            {
                uo_it->second.was_changed = true;
            }
-            if (!bs->journal.inmemory)
-            {
-                // Verify journaled data checksums (but not COALESCED)
-                for (it = v.begin(); it != v.end(); it++)
-                {
-                    if (it->copy_flags == COPY_BUF_JOURNAL)
-                    {
-                        iovec iov = { .iov_base = it->buf, .iov_len = it->len };
-                        bs->verify_journal_checksums(
-                            it->csum_buf, it->offset, &iov, 1,
-                            [&](uint32_t bad_block, uint32_t calc_csum, uint32_t stored_csum)
-                            {
-                                printf(
-                                    "Checksum mismatch in object %jx:%jx v%ju in journal at 0x%jx, checksum block #%u: got %08x, expected %08x\n",
-                                    cur.oid.inode, cur.oid.stripe, cur.version, it->disk_offset,
-                                    bad_block / bs->dsk.csum_block_size, calc_csum, stored_csum
-                                );
-                                bad_block += it->offset;
-                                assert(!(bad_block % bs->dsk.csum_block_size) && bad_block < bs->dsk.data_block_size);
-                                mangle_csum_blocks.insert(bad_block);
-                            }
-                        );
-                    }
-                }
-            }
        }
        // Submit data writes
        for (it = v.begin(); it != v.end(); it++)
@@ -551,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
                );
@@ -665,7 +633,6 @@ resume_2:
        }
        // All done
        flusher->active_flushers--;
-        copy_count = 0; // used by is_mutated()...
        wait_state = 0;
        goto resume_0;
    }
@@ -782,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
    );
@@ -847,21 +813,35 @@ bool journal_flusher_co::clear_incomplete_csum_block_bits(int wait_base)
                bs->verify_padded_checksums(new_clean_bitmap, new_clean_bitmap + 2*bs->dsk.clean_entry_bitmap_size,
                    v[i].offset, &iov, 1, [&](uint32_t bad_block, uint32_t calc_csum, uint32_t stored_csum)
                {
-                    printf("Checksum mismatch in object %jx:%jx v%ju in data area at offset 0x%jx+0x%x during flush: got %08x, expected %08x\n",
+                    printf("Checksum mismatch in object %jx:%jx v%ju in data area at offset 0x%jx+0x%x: got %08x, expected %08x\n",
                        cur.oid.inode, cur.oid.stripe, old_clean_ver, old_clean_loc, bad_block, calc_csum, stored_csum);
-                    assert(!(bad_block % bs->dsk.csum_block_size) && bad_block < bs->dsk.data_block_size);
-                    mangle_csum_blocks.insert(bad_block);
+                    for (uint32_t j = 0; j < bs->dsk.csum_block_size; j += bs->dsk.bitmap_granularity)
+                    {
+                        // Simplest method of mangling: flip one byte in every sector
+                        ((uint8_t*)v[i].buf)[j+bad_block-v[i].offset] ^= 0xff;
+                    }
                });
            }
            else
            {
                bs->verify_journal_checksums(v[i].csum_buf, v[i].offset, &iov, 1, [&](uint32_t bad_block, uint32_t calc_csum, uint32_t stored_csum)
                {
-                    printf("Checksum mismatch in object %jx:%jx v%ju in journal at offset 0x%jx+0x%x (block offset 0x%jx) during flush: got %08x, expected %08x\n",
+                    printf("Checksum mismatch in object %jx:%jx v%ju in journal at offset 0x%jx+0x%x (block offset 0x%jx): got %08x, expected %08x\n",
                        cur.oid.inode, cur.oid.stripe, old_clean_ver,
                        v[i].disk_offset, bad_block, v[i].offset, calc_csum, stored_csum);
-                    assert(!(bad_block % bs->dsk.csum_block_size) && bad_block < bs->dsk.data_block_size);
-                    mangle_csum_blocks.insert(bad_block);
+                    bad_block += (v[i].offset/bs->dsk.csum_block_size) * bs->dsk.csum_block_size;
+                    uint32_t bad_block_end = bad_block + bs->dsk.csum_block_size + (v[i].offset/bs->dsk.csum_block_size) * bs->dsk.csum_block_size;
+                    if (bad_block < v[i].offset)
+                        bad_block = v[i].offset;
+                    if (bad_block_end > v[i].offset+v[i].len)
+                        bad_block_end = v[i].offset+v[i].len;
+                    bad_block -= v[i].offset;
+                    bad_block_end -= v[i].offset;
+                    for (uint32_t j = bad_block; j < bad_block_end; j += bs->dsk.bitmap_granularity)
+                    {
+                        // Simplest method of mangling: flip one byte in every sector
+                        ((uint8_t*)v[i].buf)[j] ^= 0xff;
+                    }
                });
            }
        }
@@ -970,11 +950,6 @@ void journal_flusher_co::calc_block_checksums(uint32_t *new_data_csums, bool ski
    }
    // `v` should contain aligned items, possibly split into pieces
    assert(!block_done);
-    for (uint32_t mangle_block: mangle_csum_blocks)
-    {
-        // Flip 1 bit
-        new_data_csums[mangle_block / bs->dsk.csum_block_size] ^= 1;
-    }
 }

 void journal_flusher_co::scan_dirty()
@@ -1111,8 +1086,7 @@ void journal_flusher_co::scan_dirty()
            last--;
        read_to_fill_incomplete = bs->fill_partial_checksum_blocks(
            v, fulfilled, bmp_ptr, NULL, false, NULL, v[0].offset/bs->dsk.csum_block_size * bs->dsk.csum_block_size,
-            ((v[last].offset+v[last].len-1) / bs->dsk.csum_block_size + 1) * bs->dsk.csum_block_size,
-            0, bs->dsk.data_block_size
+            ((v[last].offset+v[last].len-1) / bs->dsk.csum_block_size + 1) * bs->dsk.csum_block_size
        );
    }
    else if (fill_incomplete && clean_init_bitmap)
@@ -1142,7 +1116,6 @@ bool journal_flusher_co::read_dirty(int wait_base)
    if (wait_state == wait_base)        goto resume_0;
    else if (wait_state == wait_base+1) goto resume_1;
    wait_count = wait_journal_count = 0;
-    mangle_csum_blocks.clear();
    if (bs->journal.inmemory && !read_to_fill_incomplete)
    {
        // Happy path: nothing to read :)
@@ -1374,7 +1347,7 @@ bool journal_flusher_co::fsync_batch(bool fsync_meta, int wait_base)
        cur_sync->ready_count++;
        flusher->syncing_flushers++;
    resume_1:
-        if (cur_sync->state == 0)
+        if (!cur_sync->state)
        {
            if (flusher->syncing_flushers >= flusher->active_flushers || !flusher->flush_queue.size())
            {
@@ -1402,12 +1375,6 @@ bool journal_flusher_co::fsync_batch(bool fsync_meta, int wait_base)
                return false;
            }
        }
-        else if (cur_sync->state == 1)
-        {
-            // Wait for fsync completion
-            wait_state = wait_base+1;
-            return false;
-        }
        flusher->syncing_flushers--;
        cur_sync->ready_count--;
        if (cur_sync->ready_count == 0)
@@ -66,7 +66,6 @@ class journal_flusher_co
    uint64_t clean_bitmap_offset, clean_bitmap_len;
    uint8_t *clean_init_dyn_ptr;
    uint8_t *new_clean_bitmap;
-    std::unordered_set<uint32_t> mangle_csum_blocks;

    uint64_t new_trim_pos;

@@ -124,7 +123,6 @@ public:
    void loop();
    bool is_trim_wanted() { return trim_wanted; }
    bool is_active();
-    size_t get_queue_size();
    void mark_trim_possible();
    void request_trim();
    void release_trim();
@@ -6,12 +6,11 @@

 namespace v1 {

-blockstore_impl_t::blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd, bool mock_mode)
+blockstore_impl_t::blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd)
 {
    assert(sizeof(blockstore_op_private_t) <= BS_OP_PRIVATE_DATA_SIZE);
    this->tfd = tfd;
    this->ringloop = ringloop;
-    dsk.mock_mode = mock_mode;
    ring_consumer.loop = [this]() { loop(); };
    ringloop->register_consumer(&ring_consumer);
    initialized = 0;
@@ -36,11 +35,6 @@ blockstore_impl_t::blockstore_impl_t(blockstore_config_t & config, ring_loop_i *

 blockstore_impl_t::~blockstore_impl_t()
 {
-    for (auto& obj: dirty_db)
-    {
-        if (obj.second.dyn_data)
-            free(obj.second.dyn_data);
-    }
    delete data_alloc;
    delete flusher;
    if (zero_object)
@@ -30,8 +30,6 @@

 //#define BLOCKSTORE_DEBUG

-struct bs_test_t;
-
 namespace v1 {

 #include "journal.h"
@@ -98,7 +96,7 @@ struct blockstore_op_private_t
    int op_state;

    // Read
-    uint64_t clean_loc_used;
+    uint64_t clean_block_used;
    std::vector<copy_buffer_t> read_vec;

    // Sync, write
@@ -124,7 +122,6 @@ typedef uint64_t pool_pg_id_t;

 class blockstore_impl_t: public blockstore_i
 {
-    friend struct ::bs_test_t;
    blockstore_disk_t dsk;

    /******* OPTIONS *******/
@@ -223,7 +220,6 @@ class blockstore_impl_t: public blockstore_i

    // Read
    int dequeue_read(blockstore_op_t *read_op);
-    void release_clean(blockstore_op_t *op);
    void find_holes(std::vector<copy_buffer_t> & read_vec, uint32_t item_start, uint32_t item_end,
        std::function<int(int, bool, uint32_t, uint32_t)> callback);
    int fulfill_read(blockstore_op_t *read_op,
@@ -234,8 +230,7 @@ class blockstore_impl_t: public blockstore_i
        uint8_t *clean_entry_bitmap, int *dyn_data,
        uint32_t item_start, uint32_t item_end, uint64_t clean_loc, uint64_t clean_ver);
    int fill_partial_checksum_blocks(std::vector<copy_buffer_t> & rv, uint64_t & fulfilled,
-        uint8_t *clean_entry_bitmap, int *dyn_data, bool from_journal, uint8_t *read_buf,
-        uint32_t read_offset, uint32_t read_end, uint32_t item_start, uint32_t item_end);
+        uint8_t *clean_entry_bitmap, int *dyn_data, bool from_journal, uint8_t *read_buf, uint64_t read_offset, uint64_t read_end);
    int pad_journal_read(std::vector<copy_buffer_t> & rv, copy_buffer_t & cp,
        uint64_t dirty_offset, uint64_t dirty_end, uint64_t dirty_loc, uint8_t *csum_ptr, int *dyn_data,
        uint64_t offset, uint64_t submit_len, uint64_t & blk_begin, uint64_t & blk_end, uint8_t* & blk_buf);
@@ -286,7 +281,7 @@ class blockstore_impl_t: public blockstore_i

 public:

-    blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd, bool mock_mode = false);
+    blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd);
    ~blockstore_impl_t();

    void parse_config(blockstore_config_t & config);
@@ -1,7 +1,6 @@
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: VNPL-1.1 (see README.md for details)

-#include "str_util.h"
 #include "impl.h"
 #include "internal.h"

@@ -31,15 +30,14 @@ blockstore_init_meta::blockstore_init_meta(blockstore_impl_t *bs)
    this->bs = bs;
 }

-void blockstore_init_meta::handle_event(ring_data_t *data, int buf_num, const char *op)
+void blockstore_init_meta::handle_event(ring_data_t *data, int buf_num)
 {
-    if (data->res != data->iov.iov_len)
+    if (data->res < 0)
    {
-        throw std::runtime_error(strprintf(
-            "%s failed at offset %ju: got %s (code %d), but expected %zu",
-            op, (buf_num >= 0 ? bufs[buf_num].offset : last_read_offset), strerror(-data->res),
-            data->res, data->iov.iov_len
-        ));
+        throw std::runtime_error(
+            std::string("read metadata failed at offset ") + std::to_string(buf_num >= 0 ? bufs[buf_num].offset : last_read_offset) +
+            std::string(": ") + strerror(-data->res)
+        );
    }
    if (buf_num >= 0)
    {
@@ -67,11 +65,10 @@ int blockstore_init_meta::loop()
    if (!metadata_buffer)
        throw std::runtime_error("Failed to allocate metadata read buffer");
    // Read superblock
-    hdr = (blockstore_meta_header_v2_t *)memalign_or_die(MEM_ALIGNMENT, bs->dsk.meta_block_size);
    GET_SQE();
    last_read_offset = 0;
-    data->iov = { hdr, (size_t)bs->dsk.meta_block_size };
-    data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read metadata header"); };
+    data->iov = { metadata_buffer, (size_t)bs->dsk.meta_block_size };
+    data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
    io_uring_prep_readv(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
    bs->ringloop->submit();
    submitted++;
@@ -81,8 +78,24 @@ resume_1:
        wait_state = 1;
        return 1;
    }
-    if (iszero((uint64_t*)hdr, bs->dsk.meta_block_size / sizeof(uint64_t)))
+    if (iszero((uint64_t*)metadata_buffer, bs->dsk.meta_block_size / sizeof(uint64_t)))
    {
+        {
+            blockstore_meta_header_v2_t *hdr = (blockstore_meta_header_v2_t *)metadata_buffer;
+            hdr->zero = 0;
+            hdr->magic = BLOCKSTORE_META_MAGIC_V1;
+            hdr->version = bs->dsk.meta_format;
+            hdr->meta_block_size = bs->dsk.meta_block_size;
+            hdr->data_block_size = bs->dsk.data_block_size;
+            hdr->bitmap_granularity = bs->dsk.bitmap_granularity;
+            if (bs->dsk.meta_format >= BLOCKSTORE_META_FORMAT_V2)
+            {
+                hdr->data_csum_type = bs->dsk.data_csum_type;
+                hdr->csum_block_size = bs->dsk.csum_block_size;
+                hdr->header_csum = 0;
+                hdr->header_csum = crc32c(0, hdr, sizeof(*hdr));
+            }
+        }
        if (bs->readonly)
        {
            printf("Skipping metadata initialization because blockstore is readonly\n");
@@ -90,11 +103,25 @@ resume_1:
        else
        {
            printf("Initializing metadata area\n");
+            GET_SQE();
+            last_read_offset = 0;
+            data->iov = (struct iovec){ metadata_buffer, (size_t)bs->dsk.meta_block_size };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
+            io_uring_prep_writev(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
+            bs->ringloop->submit();
+            submitted++;
+        resume_3:
+            if (submitted > 0)
+            {
+                wait_state = 3;
+                return 1;
+            }
+            zero_on_init = true;
        }
-        zero_on_init = true;
    }
    else
    {
+        blockstore_meta_header_v2_t *hdr = (blockstore_meta_header_v2_t *)metadata_buffer;
        if (hdr->zero != 0 || hdr->magic != BLOCKSTORE_META_MAGIC_V1 || hdr->version < BLOCKSTORE_META_FORMAT_V1)
        {
            printf(
@@ -196,15 +223,12 @@ resume_2:
                GET_SQE();
                assert(bufs[i].size <= 0x7fffffff);
                data->iov = { bufs[i].buf, (size_t)bufs[i].size };
+                data->callback = [this, i](ring_data_t *data) { handle_event(data, i); };
                if (!zero_on_init)
-                {
-                    data->callback = [this, i](ring_data_t *data) { handle_event(data, i, "read metadata"); };
                    io_uring_prep_readv(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset + bufs[i].offset);
-                }
                else
                {
                    // Fill metadata with zeroes
-                    data->callback = [this, i](ring_data_t *data) { handle_event(data, i, "clear metadata"); };
                    memset(data->iov.iov_base, 0, data->iov.iov_len);
                    io_uring_prep_writev(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset + bufs[i].offset);
                }
@@ -232,7 +256,7 @@ resume_2:
                GET_SQE();
                assert(bufs[i].size <= 0x7fffffff);
                data->iov = { bufs[i].buf, (size_t)bufs[i].size };
-                data->callback = [this, i](ring_data_t *data) { handle_event(data, i, "write metadata"); };
+                data->callback = [this, i](ring_data_t *data) { handle_event(data, i); };
                io_uring_prep_writev(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset + bufs[i].offset);
                bs->ringloop->submit();
                bufs[i].state = INIT_META_WRITING;
@@ -261,7 +285,7 @@ resume_2:
            GET_SQE();
            last_read_offset = (1+next_offset)*bs->dsk.meta_block_size;
            data->iov = { metadata_buffer, (size_t)bs->dsk.meta_block_size };
-            data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read metadata"); };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
            io_uring_prep_readv(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset + (1+next_offset)*bs->dsk.meta_block_size);
            bs->ringloop->submit();
            submitted++;
@@ -278,7 +302,7 @@ resume_5:
            }
            GET_SQE();
            data->iov = { metadata_buffer, (size_t)bs->dsk.meta_block_size };
-            data->callback = [this](ring_data_t *data) { handle_event(data, -1, "write metadata"); };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
            io_uring_prep_writev(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset + (1+next_offset)*bs->dsk.meta_block_size);
            bs->ringloop->submit();
            submitted++;
@@ -293,64 +317,27 @@ resume_6:
    }
    // metadata read finished
    printf("Metadata entries loaded: %ju, free blocks: %ju / %ju\n", entries_loaded, bs->data_alloc->get_free_count(), bs->dsk.block_count);
-    if (zero_on_init && !bs->readonly)
-    {
-do_fsync:
-        if (!bs->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, "fsync metadata"); };
-            submitted++;
-            bs->ringloop->submit();
-resume_4:
-            if (submitted > 0)
-            {
-                wait_state = 4;
-                return 1;
-            }
-        }
-        if (!header_written)
-        {
-            GET_SQE();
-            hdr->zero = 0;
-            hdr->magic = BLOCKSTORE_META_MAGIC_V1;
-            hdr->version = bs->dsk.meta_format;
-            hdr->meta_block_size = bs->dsk.meta_block_size;
-            hdr->data_block_size = bs->dsk.data_block_size;
-            hdr->bitmap_granularity = bs->dsk.bitmap_granularity;
-            if (bs->dsk.meta_format >= BLOCKSTORE_META_FORMAT_V2)
-            {
-                hdr->data_csum_type = bs->dsk.data_csum_type;
-                hdr->csum_block_size = bs->dsk.csum_block_size;
-                hdr->header_csum = 0;
-                hdr->header_csum = crc32c(0, hdr, sizeof(*hdr));
-            }
-            header_written = true;
-            last_read_offset = 0;
-            data->iov = (struct iovec){ hdr, (size_t)bs->dsk.meta_block_size };
-            data->callback = [this](ring_data_t *data) { handle_event(data, -1, "write metadata header"); };
-            io_uring_prep_writev(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
-            bs->ringloop->submit();
-            submitted++;
-resume_3:
-            if (submitted > 0)
-            {
-                wait_state = 3;
-                return 1;
-            }
-            goto do_fsync;
-        }
-    }
    if (!bs->inmemory_meta)
    {
        free(metadata_buffer);
        metadata_buffer = NULL;
    }
-    free(hdr);
-    hdr = NULL;
+    if (zero_on_init && !bs->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_4:
+        if (submitted > 0)
+        {
+            wait_state = 4;
+            return 1;
+        }
+    }
    return 0;
 }

@@ -358,8 +345,6 @@ bool blockstore_init_meta::handle_meta_block(uint8_t *buf, uint64_t entries_per_
 {
    bool updated = false;
    uint64_t max_i = entries_per_block;
-    if (done_cnt > bs->dsk.block_count)
-        return false;
    if (max_i > bs->dsk.block_count-done_cnt)
        max_i = bs->dsk.block_count-done_cnt;
    for (uint64_t i = 0; i < max_i; i++)
@@ -470,21 +455,21 @@ blockstore_init_journal::blockstore_init_journal(blockstore_impl_t *bs)
    };
 }

-void blockstore_init_journal::handle_event(ring_data_t *data)
+void blockstore_init_journal::handle_event(ring_data_t *data1)
 {
-    if (data->res != data->iov.iov_len)
+    if (data1->res <= 0)
    {
-        throw std::runtime_error(strprintf(
-            "read journal failed at offset %ju: got %s (code %d), but expected %zu",
-            journal_pos, strerror(-data->res), data->res, data->iov.iov_len
-        ));
+        throw std::runtime_error(
+            std::string("read journal failed at offset ") + std::to_string(journal_pos) +
+            std::string(": ") + strerror(-data1->res)
+        );
    }
    done.push_back({
        .buf = submitted_buf,
        .pos = journal_pos,
-        .len = (uint64_t)data->res,
+        .len = (uint64_t)data1->res,
    });
-    journal_pos += data->res;
+    journal_pos += data1->res;
    if (journal_pos >= bs->journal.len)
    {
        // Continue from the beginning
@@ -16,9 +16,7 @@ class blockstore_init_meta
    blockstore_impl_t *bs;
    int wait_state = 0;
    bool zero_on_init = false;
-    bool header_written = false;
    void *metadata_buffer = NULL;
-    blockstore_meta_header_v2_t *hdr = NULL;
    blockstore_init_meta_buf bufs[2] = {};
    int submitted = 0;
    struct io_uring_sqe *sqe;
@@ -31,7 +29,7 @@ class blockstore_init_meta
    int i = 0, j = 0;
    std::vector<uint64_t> entries_to_zero;
    bool handle_meta_block(uint8_t *buf, uint64_t count, uint64_t done_cnt);
-    void handle_event(ring_data_t *data, int buf_num, const char *op);
+    void handle_event(ring_data_t *data, int buf_num);
 public:
    blockstore_init_meta(blockstore_impl_t *bs);
    int loop();
@@ -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
        );
@@ -101,8 +101,8 @@ int blockstore_impl_t::fulfill_read(blockstore_op_t *read_op,
                    .copy_flags = COPY_BUF_JOURNAL|COPY_BUF_CSUM_FILL,
                    .offset = blk_begin,
                    .len = blk_end-blk_begin,
-                    .csum_buf = (!csum ? NULL : (csum + (blk_begin/dsk.csum_block_size -
-                        item_start/dsk.csum_block_size) * (dsk.data_csum_type & 0xFF))),
+                    .csum_buf = (csum + (blk_begin/dsk.csum_block_size -
+                        item_start/dsk.csum_block_size) * (dsk.data_csum_type & 0xFF)),
                    .dyn_data = dyn_data,
                });
                if (dyn_data)
@@ -134,7 +134,7 @@ int blockstore_impl_t::fulfill_read(blockstore_op_t *read_op,
                // If we don't track it then we may IN THEORY read another object's data:
                // submit read -> remove the object -> flush remove -> overwrite with another object -> finish read
                // Very improbable, but possible
-                PRIV(read_op)->clean_loc_used = UINT64_MAX;
+                PRIV(read_op)->clean_block_used = 1;
            }
            rv.insert(rv.begin() + pos, el);
            fulfilled += el.len;
@@ -167,8 +167,7 @@ uint8_t* blockstore_impl_t::get_clean_entry_bitmap(uint64_t block_loc, int offse
 }

 int blockstore_impl_t::fill_partial_checksum_blocks(std::vector<copy_buffer_t> & rv, uint64_t & fulfilled,
-    uint8_t *clean_entry_bitmap, int *dyn_data, bool from_journal, uint8_t *read_buf,
-    uint32_t read_offset, uint32_t read_end, uint32_t item_start, uint32_t item_end)
+    uint8_t *clean_entry_bitmap, int *dyn_data, bool from_journal, uint8_t *read_buf, uint64_t read_offset, uint64_t read_end)
 {
    if (read_end == read_offset)
        return 0;
@@ -176,38 +175,10 @@ int blockstore_impl_t::fill_partial_checksum_blocks(std::vector<copy_buffer_t> &
    read_buf -= read_offset;
    uint32_t last_block = (read_end-1)/dsk.csum_block_size;
    uint32_t start_block = read_offset/dsk.csum_block_size;
-    uint32_t item_start_block = item_start/dsk.csum_block_size;
    uint32_t end_block = 0;
-    auto zero_range = [&](int pos, bool alloc, uint32_t cur_start, uint32_t cur_end)
-    {
-        if (alloc)
-            return 0;
-        copy_buffer_t el = {
-            .copy_flags = COPY_BUF_ZERO,
-            .offset = cur_start,
-            .len = cur_end-cur_start,
-        };
-        rv.insert(rv.begin() + pos, el);
-        if (read_buf)
-            memset(read_buf + el.offset - read_offset, 0, el.len);
-        fulfilled += el.len;
-        return 1;
-    };
-    if (read_offset < item_start)
-    {
-        // Zero-fill the beginning
-        find_holes(rv, read_offset, item_start, zero_range);
-        read_offset = item_start;
-    }
-    if (read_end > item_end)
-    {
-        // Zero-fill the end
-        find_holes(rv, item_end, read_end, zero_range);
-        read_end = item_end;
-    }
    while (start_block <= last_block)
    {
-        if (read_range_fulfilled(rv, fulfilled, read_buf, from_journal ? NULL : clean_entry_bitmap,
+        if (read_range_fulfilled(rv, fulfilled, read_buf, clean_entry_bitmap,
            start_block*dsk.csum_block_size < read_offset ? read_offset : start_block*dsk.csum_block_size,
            (start_block+1)*dsk.csum_block_size > read_end ? read_end : (start_block+1)*dsk.csum_block_size))
        {
@@ -219,7 +190,7 @@ int blockstore_impl_t::fill_partial_checksum_blocks(std::vector<copy_buffer_t> &
            // Find a sequence of checksum blocks required to be read
            end_block = start_block;
            while ((end_block+1)*dsk.csum_block_size < read_end &&
-                !read_range_fulfilled(rv, fulfilled, read_buf, from_journal ? NULL : clean_entry_bitmap,
+                !read_range_fulfilled(rv, fulfilled, read_buf, clean_entry_bitmap,
                    (end_block+1)*dsk.csum_block_size < read_offset ? read_offset : (end_block+1)*dsk.csum_block_size,
                    (end_block+2)*dsk.csum_block_size > read_end ? read_end : (end_block+2)*dsk.csum_block_size))
            {
@@ -231,10 +202,8 @@ int blockstore_impl_t::fill_partial_checksum_blocks(std::vector<copy_buffer_t> &
                .copy_flags = COPY_BUF_CSUM_FILL | (from_journal ? COPY_BUF_JOURNALED_BIG : 0),
                .offset = start_block*dsk.csum_block_size,
                .len = (end_block-start_block)*dsk.csum_block_size,
-                // save checksum reference if we're reading clean data from the journal
-                .csum_buf = from_journal
-                    ? clean_entry_bitmap + dsk.clean_entry_bitmap_size + (start_block-item_start_block)*(dsk.data_csum_type & 0xFF)
-                    : NULL,
+                // save clean_entry_bitmap if we're reading clean data from the journal
+                .csum_buf = from_journal ? clean_entry_bitmap : NULL,
                .dyn_data = dyn_data,
            });
            if (dyn_data)
@@ -257,11 +226,6 @@ bool blockstore_impl_t::read_range_fulfilled(std::vector<copy_buffer_t> & rv, ui
    {
        if (alloc)
            return 0;
-        if (!clean_entry_bitmap)
-        {
-            all_done = false;
-            return 0;
-        }
        int diff = 0;
        uint32_t bmp_start = cur_start/dsk.bitmap_granularity;
        uint32_t bmp_end = cur_end/dsk.bitmap_granularity;
@@ -359,7 +323,7 @@ bool blockstore_impl_t::read_checksum_block(blockstore_op_t *op, int rv_pos, uin
            {
                iov[n_iov++] = (struct iovec){ (uint8_t*)op->buf+cur_start-op->offset, lim_end-cur_start };
                rv.insert(rv.begin() + pos, (copy_buffer_t){
-                    .copy_flags = COPY_BUF_DATA|COPY_BUF_COALESCED,
+                    .copy_flags = COPY_BUF_DATA,
                    .offset = cur_start,
                    .len = lim_end-cur_start,
                });
@@ -397,10 +361,10 @@ bool blockstore_impl_t::read_checksum_block(blockstore_op_t *op, int rv_pos, uin
        PRIV(op)->pending_ops++;
        io_uring_prep_readv(sqe, submit_fd, iov + n_pos, n_cur, submit_offset + clean_loc + item_start + d_pos);
        data->callback = [this, op](ring_data_t *data) { handle_read_event(data, op); };
-        if (n_pos > 0 || n_iov > IOV_MAX)
+        if (n_pos > 0 || n_pos + IOV_MAX < n_iov)
        {
            uint32_t d_len = 0;
-            for (int i = 0; i < n_cur; i++)
+            for (int i = 0; i < IOV_MAX; i++)
                d_len += iov[n_pos+i].iov_len;
            data->iov.iov_len = d_len;
            d_pos += d_len;
@@ -412,7 +376,7 @@ bool blockstore_impl_t::read_checksum_block(blockstore_op_t *op, int rv_pos, uin
    {
        // Reads running parallel to flushes of the same clean block may read
        // a mixture of old and new data. So we don't verify checksums for such blocks.
-        PRIV(op)->clean_loc_used = UINT64_MAX;
+        PRIV(op)->clean_block_used = 1;
    }
    return true;
 }
@@ -438,7 +402,7 @@ int blockstore_impl_t::dequeue_read(blockstore_op_t *read_op)
    }
    uint64_t fulfilled = 0;
    PRIV(read_op)->pending_ops = 0;
-    PRIV(read_op)->clean_loc_used = 0;
+    PRIV(read_op)->clean_block_used = 0;
    auto & rv = PRIV(read_op)->read_vec;
    uint64_t result_version = 0;
    if (dirty_found)
@@ -551,50 +515,26 @@ int blockstore_impl_t::dequeue_read(blockstore_op_t *read_op)
    return 2;
 undo_read:
    // need to wait. undo added requests, don't dequeue op
-    release_clean(read_op);
-    for (auto & vec: rv)
+    if (dsk.csum_block_size > dsk.bitmap_granularity)
    {
-        if ((vec.copy_flags & COPY_BUF_CSUM_FILL) && vec.buf)
+        for (auto & vec: rv)
        {
-            free(vec.buf);
-            vec.buf = NULL;
-        }
-        if (vec.dyn_data && --(*vec.dyn_data) == 0) // refcount
-        {
-            free(vec.dyn_data);
-            vec.dyn_data = NULL;
+            if ((vec.copy_flags & COPY_BUF_CSUM_FILL) && vec.buf)
+            {
+                free(vec.buf);
+                vec.buf = NULL;
+            }
+            if (vec.dyn_data && --(*vec.dyn_data) == 0) // refcount
+            {
+                free(vec.dyn_data);
+                vec.dyn_data = NULL;
+            }
        }
    }
    rv.clear();
    return 0;
 }

-void blockstore_impl_t::release_clean(blockstore_op_t *op)
-{
-    if (PRIV(op)->clean_loc_used == UINT64_MAX)
-    {
-        PRIV(op)->clean_loc_used = 0;
-    }
-    if (PRIV(op)->clean_loc_used)
-    {
-        // Release clean data block
-        auto uo_it = used_clean_objects.find(PRIV(op)->clean_loc_used - 1);
-        if (uo_it != used_clean_objects.end())
-        {
-            uo_it->second.refs--;
-            if (uo_it->second.refs <= 0)
-            {
-                if (uo_it->second.was_freed)
-                {
-                    data_alloc->set((PRIV(op)->clean_loc_used - 1) / dsk.data_block_size, false);
-                }
-                used_clean_objects.erase(uo_it);
-            }
-        }
-        PRIV(op)->clean_loc_used = 0;
-    }
-}
-
 int blockstore_impl_t::pad_journal_read(std::vector<copy_buffer_t> & rv, copy_buffer_t & cp,
    // FIXME Passing dirty_entry& would be nicer
    uint64_t dirty_offset, uint64_t dirty_end, uint64_t dirty_loc, uint8_t *csum_ptr, int *dyn_data,
@@ -658,15 +598,11 @@ bool blockstore_impl_t::fulfill_clean_read(blockstore_op_t *read_op, uint64_t &
    {
        auto & rv = PRIV(read_op)->read_vec;
        int req = fill_partial_checksum_blocks(rv, fulfilled, clean_entry_bitmap, dyn_data, from_journal,
-            (uint8_t*)read_op->buf, read_op->offset, read_op->offset+read_op->len, item_start, item_end);
+            (uint8_t*)read_op->buf, read_op->offset, read_op->offset+read_op->len);
        if (!inmemory_meta && !from_journal && req > 0)
        {
            // Read checksums from disk
            uint8_t *csum_buf = read_clean_meta_block(read_op, clean_loc, rv.size()-req);
-            if (!csum_buf)
-            {
-                return false;
-            }
            for (int i = req; i > 0; i--)
            {
                rv[rv.size()-i].csum_buf = csum_buf;
@@ -679,7 +615,7 @@ bool blockstore_impl_t::fulfill_clean_read(blockstore_op_t *read_op, uint64_t &
                return false;
            }
        }
-        PRIV(read_op)->clean_loc_used = req > 0 ? UINT64_MAX : 0;
+        PRIV(read_op)->clean_block_used = req > 0;
    }
    else if (from_journal)
    {
@@ -729,10 +665,6 @@ bool blockstore_impl_t::fulfill_clean_read(blockstore_op_t *read_op, uint64_t &
                {
                    // Read checksums from disk
                    csum_buf = read_clean_meta_block(read_op, clean_loc, PRIV(read_op)->read_vec.size());
-                    if (!csum_buf)
-                    {
-                        return false;
-                    }
                    csum_done = true;
                }
                uint8_t *csum = !dsk.csum_block_size ? 0 : (csum_buf + 2*dsk.clean_entry_bitmap_size + bmp_start*(dsk.data_csum_type & 0xFF));
@@ -747,13 +679,13 @@ bool blockstore_impl_t::fulfill_clean_read(blockstore_op_t *read_op, uint64_t &
        }
    }
    // Increment reference counter if clean data is being read from the disk
-    if (PRIV(read_op)->clean_loc_used == UINT64_MAX)
+    if (PRIV(read_op)->clean_block_used)
    {
        auto & uo = used_clean_objects[clean_loc];
        uo.refs++;
        if (dsk.csum_block_size && flusher->is_mutated(clean_loc))
            uo.was_changed = true;
-        PRIV(read_op)->clean_loc_used = clean_loc + 1;
+        PRIV(read_op)->clean_block_used = clean_loc;
    }
    return true;
 }
@@ -793,18 +725,12 @@ bool blockstore_impl_t::verify_padded_checksums(uint8_t *clean_entry_bitmap, uin
        while (pos < iov[i].iov_len)
        {
            uint32_t start = pos;
-            uint8_t bit = 1;
-            if (clean_entry_bitmap)
+            uint8_t bit = (clean_entry_bitmap[bmp_pos >> 3] >> (bmp_pos & 0x7)) & 1;
+            while (pos < iov[i].iov_len && ((clean_entry_bitmap[bmp_pos >> 3] >> (bmp_pos & 0x7)) & 1) == bit)
            {
-                bit = (clean_entry_bitmap[bmp_pos >> 3] >> (bmp_pos & 0x7)) & 1;
-                while (pos < iov[i].iov_len && ((clean_entry_bitmap[bmp_pos >> 3] >> (bmp_pos & 0x7)) & 1) == bit)
-                {
-                    pos += dsk.bitmap_granularity;
-                    bmp_pos++;
-                }
+                pos += dsk.bitmap_granularity;
+                bmp_pos++;
            }
-            else
-                pos = iov[i].iov_len;
            uint32_t len = pos-start;
            auto buf = (uint8_t*)iov[i].iov_base+start;
            while (block_done+len >= dsk.csum_block_size)
@@ -881,7 +807,7 @@ bool blockstore_impl_t::verify_clean_padded_checksums(blockstore_op_t *op, uint6
 {
    uint32_t offset = clean_loc % dsk.data_block_size;
    if (from_journal)
-        return verify_padded_checksums(NULL, dyn_data, offset, iov, n_iov, bad_block_cb);
+        return verify_padded_checksums(dyn_data, dyn_data + dsk.clean_entry_bitmap_size, offset, iov, n_iov, bad_block_cb);
    clean_loc = (clean_loc / dsk.data_block_size) * dsk.data_block_size;
    if (!dyn_data)
    {
@@ -909,7 +835,7 @@ void blockstore_impl_t::handle_read_event(ring_data_t *data, blockstore_op_t *op
            void *meta_block = NULL;
            if (dsk.csum_block_size > dsk.bitmap_granularity)
            {
-                for (int i = 0; i < rv.size(); i++)
+                for (int i = rv.size()-1; i >= 0 && (rv[i].copy_flags & COPY_BUF_CSUM_FILL); i--)
                {
                    if (rv[i].copy_flags & COPY_BUF_META_BLOCK)
                    {
@@ -919,41 +845,8 @@ void blockstore_impl_t::handle_read_event(ring_data_t *data, blockstore_op_t *op
                        rv[i].buf = NULL;
                        continue;
                    }
-                    if (rv[i].copy_flags & COPY_BUF_ZERO)
-                    {
-                        // Zero read
-                        continue;
-                    }
-                    if (rv[i].copy_flags & COPY_BUF_COALESCED)
-                    {
-                        // Sub-block shared with another read. Skip
-                        continue;
-                    }
-                    if ((rv[i].copy_flags & COPY_BUF_JOURNAL) && journal.inmemory)
-                    {
-                        // Do not check journal checksums in-memory
-                        continue;
-                    }
-                    iovec single_iov = {};
-                    iovec *iov = NULL;
-                    int n_iov = 0;
-                    if (rv[i].copy_flags & COPY_BUF_CSUM_FILL)
-                    {
-                        // Padded, buffer list passed using a 'creepy way'
-                        iov = (struct iovec*)((uint8_t*)rv[i].buf + (rv[i].len & 0xFFFFFFFF));
-                        n_iov = rv[i].len >> 32;
-                    }
-                    else
-                    {
-                        // Not padded, buffer is fully within the input buffer
-                        assert(op->buf);
-                        assert(rv[i].csum_buf);
-                        iov = &single_iov;
-                        n_iov = 1;
-                        assert(rv[i].offset >= op->offset);
-                        assert(rv[i].offset + rv[i].len <= op->offset + op->len);
-                        single_iov = { .iov_base = op->buf + rv[i].offset - op->offset, .iov_len = rv[i].len };
-                    }
+                    struct iovec *iov = (struct iovec*)((uint8_t*)rv[i].buf + (rv[i].len & 0xFFFFFFFF));
+                    int n_iov = rv[i].len >> 32;
                    bool ok = true;
                    if (rv[i].copy_flags & COPY_BUF_JOURNAL)
                    {
@@ -1051,7 +944,23 @@ void blockstore_impl_t::handle_read_event(ring_data_t *data, blockstore_op_t *op
                meta_block = NULL;
            }
        }
-        release_clean(op);
+        if (PRIV(op)->clean_block_used)
+        {
+            // Release clean data block
+            auto uo_it = used_clean_objects.find(PRIV(op)->clean_block_used);
+            if (uo_it != used_clean_objects.end())
+            {
+                uo_it->second.refs--;
+                if (uo_it->second.refs <= 0)
+                {
+                    if (uo_it->second.was_freed)
+                    {
+                        data_alloc->set(PRIV(op)->clean_block_used, false);
+                    }
+                    used_clean_objects.erase(uo_it);
+                }
+            }
+        }
        if (!journal.inmemory)
        {
            // Release journal sector usage
@@ -491,7 +491,7 @@ void blockstore_impl_t::mark_stable(obj_ver_id v, bool forget_dirty)
                    if (!exists)
                    {
                        uint64_t space_id = dirty_it->first.oid.inode;
-                        if (no_inode_stats.find(dirty_it->first.oid.inode >> (64-POOL_ID_BITS)) != no_inode_stats.end())
+                        if (no_inode_stats[dirty_it->first.oid.inode >> (64-POOL_ID_BITS)])
                            space_id = space_id & ~(((uint64_t)1 << (64-POOL_ID_BITS)) - 1);
                        inode_space_stats[space_id] += dsk.data_block_size;
                        used_blocks++;
@@ -501,7 +501,7 @@ void blockstore_impl_t::mark_stable(obj_ver_id v, bool forget_dirty)
                else if (IS_DELETE(dirty_it->second.state))
                {
                    uint64_t space_id = dirty_it->first.oid.inode;
-                    if (no_inode_stats.find(dirty_it->first.oid.inode >> (64-POOL_ID_BITS)) != no_inode_stats.end())
+                    if (no_inode_stats[dirty_it->first.oid.inode >> (64-POOL_ID_BITS)])
                        space_id = space_id & ~(((uint64_t)1 << (64-POOL_ID_BITS)) - 1);
                    auto & sp = inode_space_stats[space_id];
                    if (sp > dsk.data_block_size)
@@ -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
@@ -3,22 +3,6 @@ cmake_minimum_required(VERSION 2.8...3.30)
 project(vitastor)

 # libvitastor_common.a
-add_library(vitastor_common STATIC
-	etcd_state_client.cpp
-	msgr_stop.cpp
-	msgr_op.cpp
-	../../json11/json11.cpp
-	osd_ops.cpp
-	pg_states.cpp
-	../util/allocator.cpp
-	../util/addr_util.cpp
-	../util/timerfd_manager.cpp
-	../util/str_util.cpp
-	../util/json_util.cpp
-)
-target_compile_options(vitastor_common PUBLIC -fPIC)
-
-# libvitastor_net.a
 set(MSGR_RDMA "")
 if (IBVERBS_LIBRARIES)
 	set(MSGR_RDMA "msgr_rdma.cpp")
@@ -27,36 +11,30 @@ set(MSGR_RDMACM "")
 if (RDMACM_LIBRARIES)
 	set(MSGR_RDMACM "msgr_rdmacm.cpp")
 endif (RDMACM_LIBRARIES)
-add_library(vitastor_net STATIC
-	../util/epoll_manager.cpp
-	etcd_state_client_http.cpp
-	messenger.cpp
-	msgr_iothread.cpp
-	msgr_send.cpp
-	msgr_receive.cpp
-	../util/ringloop.cpp
-	http_client.cpp
-	${MSGR_RDMA}
-	${MSGR_RDMACM}
+add_library(vitastor_common STATIC
+	../util/epoll_manager.cpp etcd_state_client.cpp messenger.cpp ../util/addr_util.cpp ../util/xxh_x86dispatch.c
+	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_net pthread vitastor_common)
-target_compile_options(vitastor_net PUBLIC -fPIC)
+target_link_libraries(vitastor_common pthread ${OPENSSL_LIBRARIES} ${CARES_LIBRARIES})
+target_compile_options(vitastor_common PUBLIC -fPIC)

 # libvitastor_client.so
 add_library(vitastor_client SHARED
 	cluster_client.cpp
-	cluster_client_real.cpp
 	cluster_client_list.cpp
 	cluster_client_wb.cpp
+	cluster_client_icache.cpp
 	vitastor_c.cpp
 )
 set_target_properties(vitastor_client PROPERTIES PUBLIC_HEADER "client/vitastor_c.h")
 target_link_libraries(vitastor_client
-	vitastor_net
+	vitastor_common
 	vitastor_cli
 	${LIBURING_LIBRARIES}
 	${IBVERBS_LIBRARIES}
 	${RDMACM_LIBRARIES}
+	${OPENSSL_LIBRARIES}
 )
 set_target_properties(vitastor_client PROPERTIES VERSION ${VITASTOR_VERSION} SOVERSION 0)
 configure_file(vitastor.pc.in vitastor.pc @ONLY)
@@ -76,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
@@ -119,13 +100,11 @@ endif (${WITH_QEMU})
 add_executable(test_cluster_client
 	EXCLUDE_FROM_ALL
 	../test/test_cluster_client.cpp
-	cluster_client.cpp
-	cluster_client_list.cpp
-	cluster_client_wb.cpp
-	../test/mock/messenger.cpp
-	etcd_state_client_mock.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 ../../json11/json11.cpp
 )
-target_link_libraries(test_cluster_client vitastor_common ${LIBURING_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)
 add_test(NAME test_cluster_client COMMAND test_cluster_client)
@@ -11,7 +11,7 @@
 #define TRY_SEND_CONNECTING 1
 #define TRY_SEND_OK 2

-cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config, std::unique_ptr<etcd_state_client_t> st_cli_ptr)
+cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config)
 {
    wb = new writeback_cache_t();

@@ -53,30 +53,29 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
    };
    msgr.parse_config(config);

-    st_cli = std::move(st_cli_ptr);
-    st_cli->on_load_config_hook = [this](json11::Json::object & cfg) { on_load_config_hook(cfg); };
-    st_cli->on_change_osd_state_hook = [this](uint64_t peer_osd) { on_change_osd_state_hook(peer_osd); };
-    st_cli->on_change_pool_config_hook = [this]() { on_change_pool_config_hook(); };
-    st_cli->on_change_pg_config_hook = [this]() { on_change_pool_config_hook(); };
-    st_cli->on_change_pg_state_hook = [this](pool_id_t pool_id, pg_num_t pg_num, osd_num_t prev_primary) { on_change_pg_state_hook(pool_id, pg_num, prev_primary); };
-    st_cli->on_change_node_placement_hook = [this]() { on_change_node_placement_hook(); };
-    st_cli->on_load_pgs_hook = [this](bool success) { on_load_pgs_hook(success); };
-    st_cli->on_reload_hook = [this]() { this->st_cli->load_global_config(); };
+    st_cli.tfd = tfd;
+    st_cli.on_load_config_hook = [this](json11::Json::object & cfg) { on_load_config_hook(cfg); };
+    st_cli.on_change_osd_state_hook = [this](uint64_t peer_osd) { on_change_osd_state_hook(peer_osd); };
+    st_cli.on_change_pool_config_hook = [this]() { on_change_pool_config_hook(); };
+    st_cli.on_change_pg_config_hook = [this]() { on_change_pool_config_hook(); };
+    st_cli.on_change_pg_state_hook = [this](pool_id_t pool_id, pg_num_t pg_num, osd_num_t prev_primary) { on_change_pg_state_hook(pool_id, pg_num, prev_primary); };
+    st_cli.on_change_node_placement_hook = [this]() { on_change_node_placement_hook(); };
+    st_cli.on_load_pgs_hook = [this](bool success) { on_load_pgs_hook(success); };
+    st_cli.on_reload_hook = [this]() { st_cli.load_global_config(); };
+    st_cli.on_inode_change_hook = [this](uint64_t inode, bool removed) { on_change_inode_hook(inode, removed); };

-    st_cli->parse_config(config);
-    st_cli->infinite_start = false;
+    st_cli.parse_config(config);
+    st_cli.infinite_start = false;
    if (!config["client_infinite_start"].is_null())
    {
-        st_cli->infinite_start = config["client_infinite_start"].bool_value();
+        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);
+    st_cli.load_global_config();
 }

 cluster_client_t::~cluster_client_t()
 {
+    vault_destroy();
    if (retry_timeout_id >= 0)
    {
        tfd->clear_timer(retry_timeout_id);
@@ -94,7 +93,6 @@ cluster_client_t::~cluster_client_t()
    {
        ringloop->unregister_consumer(&consumer);
    }
-    free(scrap_buffer);
    delete wb;
    wb = NULL;
 }
@@ -469,7 +467,7 @@ void cluster_client_t::on_load_config_hook(json11::Json::object & etcd_global_co
        auto etcd_report_interval = config["etcd_report_interval"].uint64_value();
        if (!etcd_report_interval)
            etcd_report_interval = 5;
-        client_wait_up_timeout = 1+etcd_report_interval+(st_cli->max_etcd_attempts*(2*st_cli->etcd_quick_timeout)+999)/1000;
+        client_wait_up_timeout = 1+etcd_report_interval+(st_cli.max_etcd_attempts*(2*st_cli.etcd_quick_timeout)+999)/1000;
    }
    // log_level
    log_level = config["log_level"].uint64_value();
@@ -481,9 +479,11 @@ void cluster_client_t::on_load_config_hook(json11::Json::object & etcd_global_co
        self_tree_metrics.clear();
        client_hostname = new_hostname;
    }
+    // vault
+    vault_parse_config();
    msgr.parse_config(config);
-    st_cli->parse_config(config);
-    st_cli->load_pgs();
+    st_cli.parse_config(config);
+    st_cli.load_pgs();
 }

 osd_num_t cluster_client_t::select_random_osd(const std::vector<osd_num_t> & osds)
@@ -492,7 +492,7 @@ osd_num_t cluster_client_t::select_random_osd(const std::vector<osd_num_t> & osd
    int alive_count = 0;
    for (auto & osd_num: osds)
    {
-        if (!st_cli->peer_states[osd_num].is_null())
+        if (!st_cli.peer_states[osd_num].is_null())
            alive_set[alive_count++] = osd_num;
    }
    if (!alive_count)
@@ -509,7 +509,7 @@ osd_num_t cluster_client_t::select_nearest_osd(const std::vector<osd_num_t> & os
        while (self_tree_metrics.find(cur_id) == self_tree_metrics.end())
        {
            self_tree_metrics[cur_id] = metric++;
-            json11::Json cur_placement = st_cli->node_placement[cur_id];
+            json11::Json cur_placement = st_cli.node_placement[cur_id];
            cur_id = cur_placement["parent"].string_value();
        }
        if (cur_id != "")
@@ -529,7 +529,7 @@ osd_num_t cluster_client_t::select_nearest_osd(const std::vector<osd_num_t> & os
        }
        else
        {
-            auto & peer_state = st_cli->peer_states[osd_num];
+            auto & peer_state = st_cli.peer_states[osd_num];
            if (!peer_state.is_null())
            {
                metric = self_tree_metrics[""];
@@ -539,7 +539,7 @@ osd_num_t cluster_client_t::select_nearest_osd(const std::vector<osd_num_t> & os
                while (seen.find(cur_id) == seen.end())
                {
                    seen.insert(cur_id);
-                    json11::Json cur_placement = st_cli->node_placement[cur_id];
+                    json11::Json cur_placement = st_cli.node_placement[cur_id];
                    std::string cur_parent = cur_placement["parent"].string_value();
                    cur_id = (!first || cur_parent != "" ? cur_parent : peer_state["host"].string_value());
                    first = false;
@@ -564,7 +564,7 @@ osd_num_t cluster_client_t::select_nearest_osd(const std::vector<osd_num_t> & os

 void cluster_client_t::on_load_pgs_hook(bool success)
 {
-    for (auto & pool_item: st_cli->pool_config)
+    for (auto & pool_item: st_cli.pool_config)
    {
        pg_counts[pool_item.first] = pool_item.second.real_pg_count;
    }
@@ -584,13 +584,13 @@ void cluster_client_t::on_load_pgs_hook(bool success)

 void cluster_client_t::on_change_pool_config_hook()
 {
-    for (auto & pool_item: st_cli->pool_config)
+    for (auto & pool_item: st_cli.pool_config)
    {
        if (pg_counts[pool_item.first] != pool_item.second.real_pg_count)
        {
            if (log_level > 2 && pg_counts[pool_item.first])
            {
-                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
@@ -607,12 +607,15 @@ void cluster_client_t::on_change_pool_config_hook()
            pg_counts[pool_item.first] = pool_item.second.real_pg_count;
        }
    }
+    inode_cache.clear();
+    inode_cache_children.clear();
+    vault_keys.clear();
    continue_ops();
 }

 void cluster_client_t::on_change_pg_state_hook(pool_id_t pool_id, pg_num_t pg_num, osd_num_t prev_primary)
 {
-    auto & pg_cfg = st_cli->pool_config[pool_id].pg_config[pg_num];
+    auto & pg_cfg = st_cli.pool_config[pool_id].pg_config[pg_num];
    if (pg_cfg.cur_primary != prev_primary)
    {
        // Repeat this PG operations because an OSD which stopped being primary may not fsync operations
@@ -630,8 +633,8 @@ bool cluster_client_t::get_immediate_commit(uint64_t inode)
    pool_id_t pool_id = INODE_POOL(inode);
    if (!pool_id)
        return true;
-    auto pool_it = st_cli->pool_config.find(pool_id);
-    if (pool_it == st_cli->pool_config.end())
+    auto pool_it = st_cli.pool_config.find(pool_id);
+    if (pool_it == st_cli.pool_config.end())
        return true;
    return pool_it->second.immediate_commit == IMMEDIATE_ALL;
 }
@@ -641,7 +644,7 @@ void cluster_client_t::on_change_osd_state_hook(uint64_t peer_osd)
    osd_tree_metrics.erase(peer_osd);
    if (msgr.wanted_peers.find(peer_osd) != msgr.wanted_peers.end())
    {
-        msgr.connect_peer(peer_osd, st_cli->peer_states[peer_osd]);
+        msgr.connect_peer(peer_osd, st_cli.peer_states[peer_osd]);
        continue_lists();
    }
 }
@@ -673,6 +676,10 @@ bool cluster_client_t::flush()
 {
    if (!ringloop)
    {
+        if (vault_loading)
+        {
+            return false;
+        }
        if (wb->writeback_queue.size())
        {
            wb->start_writebacks(this, 0);
@@ -695,7 +702,7 @@ bool cluster_client_t::flush()
        sync_done = true;
    };
    execute(sync);
-    while (!sync_done)
+    while (!sync_done || vault_loading)
    {
        ringloop->loop();
        if (!sync_done)
@@ -936,8 +943,8 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
        cb(op);
        return false;
    }
-    auto pool_it = st_cli->pool_config.find(pool_id);
-    if (pool_it == st_cli->pool_config.end() || pool_it->second.real_pg_count == 0)
+    auto pool_it = st_cli.pool_config.find(pool_id);
+    if (pool_it == st_cli.pool_config.end() || pool_it->second.real_pg_count == 0)
    {
        // Pools are loaded, but this one is unknown
        op->retval = -EINVAL;
@@ -958,10 +965,40 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
    {
        op->flags |= OP_IMMEDIATE_COMMIT;
    }
+    bool searched = false;
+    std::shared_ptr<inode_cache_t> icache;
+    if (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_WRITE)
+    {
+        if (!searched)
+        {
+            icache = inode_cache_get(op->inode);
+            searched = true;
+        }
+        if (icache && icache->has_parent_loop && op->opcode == OSD_OP_READ)
+        {
+            op->retval = -EINVAL;
+            auto cb = std::move(op->callback);
+            cb(op);
+            return false;
+        }
+        if (icache && icache->op_enc)
+        {
+            // Use shared_ptr aliasing to attach op_enc to the inode cache entry
+            op->enc = std::shared_ptr<osd_op_enc_t>(icache, icache->op_enc);
+        }
+        else
+            op->enc.reset();
+    }
+    else
+        op->enc.reset();
    if ((op->opcode == OSD_OP_WRITE || op->opcode == OSD_OP_DELETE) && !(op->flags & OSD_OP_IGNORE_READONLY))
    {
-        auto ino_it = st_cli->inode_config.find(op->inode);
-        if (ino_it != st_cli->inode_config.end() && ino_it->second.readonly)
+        if (!searched)
+        {
+            icache = inode_cache_get(op->inode);
+            searched = true;
+        }
+        if (icache && icache->readonly)
        {
            op->retval = -EROFS;
            auto cb = std::move(op->callback);
@@ -972,33 +1009,39 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
    op->deoptimise_snapshot = false;
    if (enable_writeback && (op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP))
    {
-        auto ino_it = st_cli->inode_config.find(op->inode);
-        if (ino_it != st_cli->inode_config.end())
+        if (!searched)
        {
-            int chain_size = 0;
-            while (ino_it != st_cli->inode_config.end() && ino_it->second.parent_id)
+            icache = inode_cache_get(op->inode);
+            searched = true;
+        }
+        if (icache)
+        {
+            for (auto & parent: icache->chain)
            {
-                // Check for loops - FIXME check it in etcd_state_client
-                if (ino_it->second.parent_id == op->inode ||
-                    chain_size > st_cli->inode_config.size())
-                {
-                    op->retval = -EINVAL;
-                    auto cb = std::move(op->callback);
-                    cb(op);
-                    return false;
-                }
-                if (INODE_POOL(ino_it->second.parent_id) == INODE_POOL(ino_it->first) &&
-                    wb->has_inode(ino_it->second.parent_id))
+                if (INODE_POOL(parent) == INODE_POOL(op->inode) && wb->has_inode(parent))
                {
                    // Deoptimise reads - we have dirty data for one of the parent layer(s).
                    op->deoptimise_snapshot = true;
                    break;
                }
-                chain_size++;
-                ino_it = st_cli->inode_config.find(ino_it->second.parent_id);
            }
        }
    }
+    if (icache && icache->err_code)
+    {
+        if (icache->err_code == EPERM)
+        {
+            op->retval = -EPERM;
+            auto cb = std::move(op->callback);
+            cb(op);
+            return false;
+        }
+        else if (icache->err_code == EAGAIN)
+        {
+            key_wait_ops.push_back(op);
+            return false;
+        }
+    }
    return true;
 }

@@ -1014,7 +1057,7 @@ void cluster_client_t::execute_raw(osd_num_t osd_num, osd_op_t *op)
    else
    {
        if (msgr.wanted_peers.find(osd_num) == msgr.wanted_peers.end())
-            msgr.connect_peer(osd_num, st_cli->peer_states[osd_num]);
+            msgr.connect_peer(osd_num, st_cli.peer_states[osd_num]);
        raw_ops.emplace(osd_num, op);
    }
 }
@@ -1119,40 +1162,35 @@ 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)
        {
-            // Check parent inode
-            auto ino_it = st_cli->inode_config.find(op->cur_inode);
-            // Skip parents from the same pool
-            int skipped = 0;
-            while (!op->deoptimise_snapshot &&
-                ino_it != st_cli->inode_config.end() && ino_it->second.parent_id &&
-                INODE_POOL(ino_it->second.parent_id) == INODE_POOL(op->cur_inode))
+            uint64_t next_inode = 0;
+            auto icache = inode_cache_get(op->cur_inode);
+            if (icache)
            {
-                // Check for loops - FIXME check it in etcd_state_client
-                if (ino_it->second.parent_id == op->inode ||
-                    skipped > st_cli->inode_config.size())
+                if (icache->has_parent_loop)
                {
                    op->retval = -EINVAL;
                    erase_op(op);
                    return 1;
                }
-                skipped++;
-                ino_it = st_cli->inode_config.find(ino_it->second.parent_id);
+                if (op->deoptimise_snapshot)
+                {
+                    if (icache->chain.size() > 1)
+                        next_inode = icache->chain[1];
+                }
+                else
+                {
+                    if (icache->other_pool_parent_id)
+                        next_inode = icache->other_pool_parent_id;
+                }
            }
-            if (ino_it != st_cli->inode_config.end() &&
-                ino_it->second.parent_id &&
-                ino_it->second.parent_id != op->inode)
+            if (next_inode)
            {
                // Continue reading from the parent inode
-                op->cur_inode = ino_it->second.parent_id;
+                icache = inode_cache_get(next_inode);
+                op->cur_inode = next_inode;
+                op->enc = (icache && icache->op_enc ? std::shared_ptr<osd_op_enc_t>(icache, icache->op_enc) : nullptr);
                op->parts.clear();
                op->done_count = 0;
                goto resume_0;
@@ -1161,7 +1199,7 @@ resume_2:
        op->retval = op->len;
        if (op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP)
        {
-            auto & pool_cfg = st_cli->pool_config.at(INODE_POOL(op->inode));
+            auto & pool_cfg = st_cli.pool_config.at(INODE_POOL(op->inode));
            op->retval = op->len / pool_cfg.bitmap_granularity;
        }
        if (op->flush_id)
@@ -1171,7 +1209,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)
@@ -1203,7 +1241,7 @@ resume_2:
    return 0;
 }

-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)
+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)
 {
    int left = size;
    while (left > 0 && iov_idx < op->iov.count)
@@ -1211,7 +1249,7 @@ static void add_iov(int size, bool 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)
+            if (skip == 0)
            {
                iov.push_back((uint8_t*)op->iov.buf[iov_idx].iov_base + iov_pos, cur_left);
            }
@@ -1221,7 +1259,7 @@ static void add_iov(int size, bool skip, cluster_op_t *op, int &iov_idx, size_t
        }
        else
        {
-            if (!skip)
+            if (skip == 0)
            {
                iov.push_back((uint8_t*)op->iov.buf[iov_idx].iov_base + iov_pos, left);
            }
@@ -1230,16 +1268,10 @@ static void add_iov(int size, bool skip, cluster_op_t *op, int &iov_idx, size_t
        }
    }
    assert(left == 0);
-    if (skip && scrap_len > 0)
+    if (skip == 1)
    {
-        // 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;
-        }
+        // data read into a NULL buffer will be discarded by messenger
+        iov.push_back(NULL, size);
    }
 }

@@ -1247,7 +1279,7 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
 {
    // Slice the request into individual object stripe requests
    // Primary OSDs still operate individual stripes, but their size is multiplied by PG minsize in case of EC
-    auto & pool_cfg = st_cli->pool_config.at(INODE_POOL(op->cur_inode));
+    auto & pool_cfg = st_cli.pool_config.at(INODE_POOL(op->cur_inode));
    uint32_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
    uint64_t pg_block_size = pool_cfg.data_block_size * pg_data_size;
    uint64_t first_stripe = (op->offset / pg_block_size) * pg_block_size;
@@ -1259,7 +1291,11 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
        // Allocate memory for the bitmap
        unsigned object_bitmap_size = ((op->len / pool_cfg.bitmap_granularity + 7) / 8);
        object_bitmap_size = (object_bitmap_size < 8 ? 8 : object_bitmap_size);
-        unsigned bitmap_mem = object_bitmap_size + (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8 * pg_data_size) * op->parts.size();
+        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 - 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);
@@ -1301,10 +1337,10 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
                        {
                            begin = cur;
                            // Just advance iov_idx & iov_pos
-                            add_iov(cur-prev, true, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
+                            add_iov(cur-prev, 2, op, iov_idx, iov_pos, op->parts[i].iov);
                        }
                        else
-                            add_iov(cur-prev, skip_prev, op, iov_idx, iov_pos, op->parts[i].iov, scrap_buffer, scrap_buffer_size);
+                            add_iov(cur-prev, skip_prev ? 1 : 0, op, iov_idx, iov_pos, op->parts[i].iov);
                    }
                    skip_prev = skip;
                    prev = cur;
@@ -1315,11 +1351,11 @@ void cluster_client_t::slice_rw(cluster_op_t *op)
            if (skip_prev)
            {
                // Just advance iov_idx & iov_pos
-                add_iov(end-prev, true, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
+                add_iov(end-prev, 2, op, iov_idx, iov_pos, op->parts[i].iov);
                end = prev;
            }
            else
-                add_iov(cur-prev, skip_prev, op, iov_idx, iov_pos, op->parts[i].iov, scrap_buffer, scrap_buffer_size);
+                add_iov(cur-prev, skip_prev ? 1 : 0, op, iov_idx, iov_pos, op->parts[i].iov);
            if (end == begin)
            {
                op->done_count++;
@@ -1328,7 +1364,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, false, op, iov_idx, iov_pos, op->parts[i].iov, NULL, 0);
+            add_iov(end-begin, 0, op, iov_idx, iov_pos, op->parts[i].iov);
        }
        op->parts[i].parent = op;
        op->parts[i].offset = begin;
@@ -1346,7 +1382,7 @@ bool cluster_client_t::affects_pg(uint64_t inode, uint64_t offset, uint64_t len,
    {
        return false;
    }
-    auto & pool_cfg = st_cli->pool_config.at(INODE_POOL(inode));
+    auto & pool_cfg = st_cli.pool_config.at(INODE_POOL(inode));
    uint32_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
    uint64_t pg_block_size = pool_cfg.data_block_size * pg_data_size;
    uint64_t first_stripe = (offset / pg_block_size) * pg_block_size;
@@ -1365,7 +1401,7 @@ bool cluster_client_t::affects_pg(uint64_t inode, uint64_t offset, uint64_t len,

 bool cluster_client_t::affects_osd(uint64_t inode, uint64_t offset, uint64_t len, osd_num_t osd)
 {
-    auto & pool_cfg = st_cli->pool_config.at(INODE_POOL(inode));
+    auto & pool_cfg = st_cli.pool_config.at(INODE_POOL(inode));
    uint32_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
    uint64_t pg_block_size = pool_cfg.data_block_size * pg_data_size;
    uint64_t first_stripe = (offset / pg_block_size) * pg_block_size;
@@ -1389,7 +1425,7 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
        init_msgr();
    }
    auto part = &op->parts[i];
-    auto & pool_cfg = st_cli->pool_config.at(INODE_POOL(op->cur_inode));
+    auto & pool_cfg = st_cli.pool_config.at(INODE_POOL(op->cur_inode));
    auto pg_it = pool_cfg.pg_config.find(part->pg_num);
    if (pg_it != pool_cfg.pg_config.end() &&
        !pg_it->second.pause && pg_it->second.cur_primary &&
@@ -1414,14 +1450,14 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
            osd_client_t *cl = peer_it->second;
            part->flags |= PART_SENT|PART_VALID;
            op->inflight_count++;
-            uint64_t pg_bitmap_size = (pool_cfg.data_block_size / pool_cfg.bitmap_granularity / 8) * (
-                pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks
-            );
+            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
+                + (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)
            {
-                auto ino_it = st_cli->inode_config.find(op->cur_inode);
-                if (ino_it != st_cli->inode_config.end())
+                auto ino_it = st_cli.inode_config.find(op->cur_inode);
+                if (ino_it != st_cli.inode_config.end())
                    meta_rev = ino_it->second.mod_revision;
            }
            part->op = (osd_op_t){
@@ -1435,6 +1471,7 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
                    .inode = op->cur_inode,
                    .offset = part->offset,
                    .len = part->len,
+                    .flags = op->opcode == OSD_OP_READ && op->enc && !op->deoptimise_snapshot ? OSD_OP_RETURN_CHAIN : 0,
                    .meta_revision = meta_rev,
                    .version = op->opcode == OSD_OP_WRITE || op->opcode == OSD_OP_DELETE ? op->version : 0,
                } },
@@ -1442,6 +1479,7 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
                    ? (uint8_t*)op->part_bitmaps + pg_bitmap_size*i : NULL),
                .bitmap_len = (unsigned)(op->opcode == OSD_OP_READ || op->opcode == OSD_OP_READ_BITMAP || op->opcode == OSD_OP_READ_CHAIN_BITMAP
                    ? pg_bitmap_size : 0),
+                .enc = op->enc,
                .callback = cb ? cb : [this, part](osd_op_t *op_part)
                {
                    handle_op_part(part);
@@ -1453,7 +1491,7 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
        }
        else if (msgr.wanted_peers.find(primary_osd) == msgr.wanted_peers.end())
        {
-            msgr.connect_peer(primary_osd, st_cli->peer_states[primary_osd]);
+            msgr.connect_peer(primary_osd, st_cli.peer_states[primary_osd]);
            return TRY_SEND_CONNECTING;
        }
    }
@@ -1637,6 +1675,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)) == (PART_SENT|PART_VALID|PART_DONE))
+                        copy_part_bitmap(op, &part);
+            }
            if (op->opcode == OSD_OP_SYNC)
                continue_sync(op);
            else
@@ -1648,7 +1693,7 @@ void cluster_client_t::handle_op_part(cluster_op_part_t *part)
 void cluster_client_t::copy_part_bitmap(cluster_op_t *op, cluster_op_part_t *part)
 {
    // Copy (OR) bitmap
-    auto & pool_cfg = st_cli->pool_config.at(INODE_POOL(op->cur_inode));
+    auto & pool_cfg = st_cli.pool_config.at(INODE_POOL(op->cur_inode));
    uint32_t pg_block_size = pool_cfg.data_block_size * (
        pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks
    );
@@ -4,7 +4,8 @@
 #pragma once

 #include "messenger.h"
-#include "etcd_state_client_http.h"
+#include "etcd_state_client.h"
+#include "../util/robin_hood.h"

 #define DEFAULT_CLIENT_MAX_DIRTY_BYTES 32*1024*1024
 #define DEFAULT_CLIENT_MAX_DIRTY_OPS 1024
@@ -71,6 +72,7 @@ protected:
    cluster_op_t *prev = NULL, *next = NULL;
    int prev_wait = 0;
    uint64_t flush_id = 0;
+    std::shared_ptr<osd_op_enc_t> enc;
    friend class cluster_client_t;
    friend class writeback_cache_t;
 };
@@ -80,14 +82,36 @@ struct inode_list_osd_t;
 struct inode_list_pg_t;
 class writeback_cache_t;

+struct inode_cache_t
+{
+    std::vector<inode_t> chain;
+    uint8_t *key_data = NULL;
+    osd_op_enc_t *op_enc = NULL;
+    bool readonly = false;
+    bool has_parent_loop = false;
+    inode_t other_pool_parent_id = 0;
+    int err_code = 0;
+
+    ~inode_cache_t();
+};
+
+struct vault_load_key_t
+{
+    int key_state = 0;
+    std::string key;
+};
+
 // 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;

-    std::map<pool_id_t, uint64_t> pg_counts;
-    std::map<pool_pg_num_t, osd_num_t> pg_primary;
+    // config:
+
    // client_max_dirty_* is actually "max unsynced", for the case when immediate_commit is off
    uint64_t client_max_dirty_bytes = 0;
    uint64_t client_max_dirty_ops = 0;
@@ -99,12 +123,23 @@ class __attribute__((visibility("default"))) cluster_client_t
    uint64_t client_max_writeback_iodepth = 0;
    std::string conf_hostname;

+    std::string vault_url;
+    std::string vault_client_cert;
+    std::string vault_client_key;
+    std::string vault_ca;
+    std::string vault_secret_api_path;
+    uint64_t vault_timeout_ms = 0;
+    uint64_t vault_error_timeout_sec = 0;
+    uint64_t vault_refresh_leeway_sec = 0;
+
    int log_level = 0;
    int client_retry_interval = 50; // ms
    int client_eio_retry_interval = 1000; // ms
    bool client_retry_enospc = true;
    int client_wait_up_timeout = 16; // sec (for listings)

+    // state:
+
    std::string client_hostname;
    std::map<std::string, int> self_tree_metrics;
    std::map<osd_num_t, int> osd_tree_metrics;
@@ -112,15 +147,28 @@ class __attribute__((visibility("default"))) cluster_client_t
    int retry_timeout_id = -1;
    int retry_timeout_duration = 0;
    std::vector<cluster_op_t*> offline_ops;
+    std::vector<cluster_op_t*> key_wait_ops;
    cluster_op_t *op_queue_head = NULL, *op_queue_tail = NULL;
    writeback_cache_t *wb = NULL;
    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;
+    std::set<std::pair<inode_t, inode_t>> inode_cache_children;
+
+    http_context_t *vault_http_ctx = NULL;
+    http_co_t *vault_http_cli = NULL;
+    bool vault_loading = false;
+    std::string vault_token;
+    bool vault_auth_error = false;
+    timespec vault_token_expire = {};
+    std::vector<std::string> vault_key_load_queue;
+    std::map<std::string, vault_load_key_t> vault_keys;

    bool pgs_loaded = false;
+    std::map<pool_id_t, uint64_t> pg_counts;
    ring_consumer_t consumer;
    std::vector<std::function<void(void)>> on_ready_hooks;
    int list_retry_timeout_id = -1;
@@ -131,7 +179,7 @@ class __attribute__((visibility("default"))) cluster_client_t
    bool msgr_initialized = false;

 public:
-    std::unique_ptr<etcd_state_client_t> st_cli;
+    etcd_state_client_t st_cli;

    osd_messenger_t msgr;
    void init_msgr();
@@ -139,8 +187,7 @@ public:
    json11::Json::object cli_config, file_config, etcd_global_config;
    json11::Json::object config;

-    static cluster_client_t* create(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config);
-    cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config, std::unique_ptr<etcd_state_client_t> st_cli);
+    cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config);
    ~cluster_client_t();
    void execute(cluster_op_t *op);
    void execute_raw(osd_num_t osd_num, osd_op_t *op);
@@ -153,9 +200,22 @@ 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);
+    void vault_parse_config();
+    bool vault_check_token();
+    void vault_load_keys();
+    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);

@@ -165,6 +225,7 @@ protected:
    void on_change_pg_state_hook(pool_id_t pool_id, pg_num_t pg_num, osd_num_t prev_primary);
    void on_change_osd_state_hook(uint64_t peer_osd);
    void on_change_node_placement_hook();
+    void on_change_inode_hook(uint64_t inode, bool removed);

    void execute_internal(cluster_op_t *op);
    void execute_cas(cluster_op_t *op);
@@ -181,6 +242,7 @@ protected:
    void erase_op(cluster_op_t *op);
    void calc_wait(cluster_op_t *op);
    void inc_wait(uint64_t opcode, uint64_t flags, cluster_op_t *next, int inc);
+
    void continue_lists();
    bool continue_listing(inode_list_t *lst);
    bool restart_listing(inode_list_t* lst);
@@ -196,5 +258,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;
 };
@@ -0,0 +1,367 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#include <stdexcept>
+#include <assert.h>
+#include "cluster_client_impl.h"
+#include "http_client.h"
+#include "str_util.h"
+
+#define VAULT_KEY_NOT_LOADED 0
+#define VAULT_KEY_LOADING 1
+#define VAULT_KEY_LOADED 2
+#define VAULT_KEY_ERROR 3
+
+inode_cache_t::~inode_cache_t()
+{
+    if (key_data)
+    {
+        free(key_data);
+        key_data = NULL;
+        op_enc = NULL;
+    }
+}
+
+void cluster_client_t::vault_destroy()
+{
+    if (vault_http_ctx)
+    {
+#ifndef __MOCK__
+        http_destroy(vault_http_cli);
+        http_context_destroy(vault_http_ctx);
+        vault_http_cli = NULL;
+        vault_http_ctx = NULL;
+#endif
+    }
+}
+
+void cluster_client_t::vault_parse_config()
+{
+    vault_url = config["vault_url"].string_value();
+    vault_client_cert = config["vault_client_cert"].string_value();
+    vault_client_key = config["vault_client_key"].string_value();
+    vault_ca = config["vault_ca"].string_value();
+    vault_secret_api_path = "/v1/secret/";
+    if (config["vault_secret_api_path"].is_string())
+        vault_secret_api_path = config["vault_secret_api_path"].string_value();
+    vault_timeout_ms = config["vault_timeout_ms"].uint64_value();
+    if (!vault_timeout_ms)
+        vault_timeout_ms = 5000;
+    vault_error_timeout_sec = config["vault_error_timeout_sec"].uint64_value();
+    if (!vault_error_timeout_sec)
+        vault_error_timeout_sec = 60;
+    vault_refresh_leeway_sec = config["vault_refresh_leeway_sec"].uint64_value();
+    if (!vault_refresh_leeway_sec)
+        vault_refresh_leeway_sec = 60;
+}
+
+// FIXME: Rework client API by adding open/close and cache inode information in the "FD" (maybe)
+void cluster_client_t::on_change_inode_hook(uint64_t inode, bool removed)
+{
+    std::vector<inode_t> children = { inode };
+    for (size_t i = 0; i < children.size(); i++)
+    {
+        auto it = inode_cache_children.lower_bound(std::make_pair(children[i], (inode_t)0));
+        while (it != inode_cache_children.end() && it->first == children[i])
+        {
+            children.push_back(it->second);
+            it++;
+        }
+    }
+    for (auto & inode: children)
+    {
+        auto it = inode_cache.find(inode);
+        if (it != inode_cache.end())
+        {
+            auto icache = it->second;
+            for (auto & parent: icache->chain)
+            {
+                inode_cache_children.erase(std::make_pair(parent, inode));
+            }
+            inode_cache.erase(it);
+        }
+    }
+}
+
+std::shared_ptr<inode_cache_t> cluster_client_t::inode_cache_get(inode_t ino)
+{
+    auto icache_it = inode_cache.find(ino);
+    if (icache_it != inode_cache.end())
+    {
+        return icache_it->second;
+    }
+    // Fill inode cache
+    auto ino_it = st_cli.inode_config.find(ino);
+    if (ino_it == st_cli.inode_config.end())
+    {
+        inode_cache[ino] = NULL;
+        return NULL;
+    }
+    auto pool_it = st_cli.pool_config.find(INODE_POOL(ino));
+    if (pool_it == st_cli.pool_config.end())
+    {
+        inode_cache[ino] = NULL;
+        return NULL;
+    }
+    auto & inode_cfg = ino_it->second;
+    auto & pool_cfg = pool_it->second;
+    std::shared_ptr<inode_cache_t> icache = std::make_shared<inode_cache_t>();
+    icache->readonly = inode_cfg.readonly;
+    icache->chain.push_back(ino);
+    std::vector<inode_config_t*> chain_cfg;
+    // FIXME: Allow unencrypted read & write when all chain is encrypted with the same key
+    int enc_key_count = !inode_cfg.enc_key.empty() ? 1 : 0;
+    if (inode_cfg.parent_id)
+    {
+        // Check for loops and cache the chain
+        robin_hood::unordered_flat_set<inode_t> seen;
+        seen.insert(ino);
+        uint64_t parent_id = inode_cfg.parent_id;
+        while (parent_id)
+        {
+            if (seen.find(parent_id) != seen.end())
+            {
+                icache->has_parent_loop = true;
+                break;
+            }
+            seen.insert(parent_id);
+            ino_it = st_cli.inode_config.find(parent_id);
+            if (INODE_POOL(parent_id) == INODE_POOL(ino))
+            {
+                icache->chain.push_back(parent_id);
+                if (ino_it == st_cli.inode_config.end())
+                    chain_cfg.push_back(NULL);
+                else
+                {
+                    chain_cfg.push_back(&ino_it->second);
+                    if (!ino_it->second.enc_key.empty())
+                        enc_key_count++;
+                }
+            }
+            else if (!icache->other_pool_parent_id)
+                icache->other_pool_parent_id = parent_id;
+            if (ino_it == st_cli.inode_config.end())
+                break;
+            parent_id = ino_it->second.parent_id;
+        }
+    }
+    // Check external keys and wait for loading, if required
+    if (enc_key_count)
+    {
+        for (size_t i = 0; i <= chain_cfg.size(); i++)
+        {
+            inode_config_t *cfg = !i ? &inode_cfg : chain_cfg[i-1];
+            if (cfg && cfg->enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) == VAULT_KEY_PREFIX)
+            {
+                auto & ik = vault_keys[inode_cfg.enc_key];
+                if (ik.key_state == VAULT_KEY_ERROR || vault_url.empty())
+                {
+                    icache->err_code = EPERM;
+                    enc_key_count = 0;
+                }
+                else if (ik.key_state == VAULT_KEY_NOT_LOADED)
+                {
+                    ik.key_state = VAULT_KEY_LOADING;
+                    vault_key_load_queue.push_back(inode_cfg.enc_key);
+                    vault_load_keys();
+                    icache->err_code = EAGAIN;
+                    enc_key_count = 0;
+                }
+                else if (ik.key_state == VAULT_KEY_LOADING)
+                {
+                    icache->err_code = EAGAIN;
+                    enc_key_count = 0;
+                }
+                else
+                {
+                    assert(ik.key_state == VAULT_KEY_LOADED);
+                }
+            }
+        }
+    }
+    // Generate encryption key chain, if applicable
+    if (enc_key_count)
+    {
+        uint8_t *key_data = (uint8_t*)malloc_or_die(
+            AES_256_XTS_KEY_SIZE * enc_key_count +
+            sizeof(uint8_t*) * icache->chain.size() +
+            sizeof(osd_op_enc_t)
+        );
+        uint8_t **keys = (uint8_t**)(key_data + AES_256_XTS_KEY_SIZE * enc_key_count);
+        osd_op_enc_t *enc = (osd_op_enc_t*)((uint8_t*)keys + sizeof(uint8_t*)*icache->chain.size());
+        size_t key_pos = 0;
+        for (size_t i = 0; i <= chain_cfg.size(); i++)
+        {
+            inode_config_t *cfg = !i ? &inode_cfg : chain_cfg[i-1];
+            if (cfg && !cfg->enc_key.empty())
+            {
+                const auto & key = cfg->enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) == VAULT_KEY_PREFIX
+                    ? vault_keys.at(cfg->enc_key).key
+                    : cfg->enc_key;
+                assert(key_pos < AES_256_XTS_KEY_SIZE * enc_key_count);
+                assert(key.size() == 2*AES_256_XTS_KEY_SIZE);
+                keys[i] = key_data + key_pos;
+                fromhexstr(key, AES_256_XTS_KEY_SIZE, key_data + key_pos);
+                key_pos += AES_256_XTS_KEY_SIZE;
+            }
+            else
+                keys[i] = NULL;
+        }
+        enc->key_chain = keys;
+        enc->chain_size = icache->chain.size();
+        enc->read_chain_bitmap_pos = pool_cfg.data_block_size/pool_cfg.bitmap_granularity/8;
+        enc->bitmap_granularity = pool_cfg.bitmap_granularity;
+        icache->key_data = key_data;
+        icache->op_enc = enc;
+    }
+    inode_cache[ino] = icache;
+    for (auto & parent: icache->chain)
+    {
+        if (parent != ino)
+            inode_cache_children.insert(std::make_pair(parent, ino));
+    }
+    return icache;
+}
+
+#ifndef __MOCK__
+bool cluster_client_t::vault_check_token()
+{
+    timespec now;
+    clock_gettime(CLOCK_REALTIME, &now);
+    if (!vault_token_expire.tv_sec || vault_token_expire.tv_sec < now.tv_sec)
+    {
+        vault_loading = true;
+        http_json_post(
+            vault_http_cli, vault_url+"/v1/auth/cert/login", json11::Json::object{}, "",
+            (http_options_t){ .timeout = (int)vault_timeout_ms, .keepalive = true },
+            [this](http_message_t *response)
+            {
+                clock_gettime(CLOCK_REALTIME, &vault_token_expire);
+                vault_loading = false;
+                std::string err;
+                json11::Json data;
+                response->parse_json_response(err, data);
+                if (err != "")
+                {
+                    vault_token_expire.tv_sec += vault_error_timeout_sec;
+                    fprintf(stderr, "Vault request failed: %s\n", err.c_str());
+                }
+                else
+                {
+                    uint64_t ttl = data["auth"]["lease_duration"].uint64_value();
+                    vault_token = data["auth"]["client_token"].string_value();
+                    if (vault_token.empty() || !ttl)
+                    {
+                        vault_token_expire.tv_sec += vault_error_timeout_sec;
+                        fprintf(stderr, "No token or lease_duration in Vault response: %s\n", data.dump().c_str());
+                    }
+                    else
+                    {
+                        if (ttl < vault_refresh_leeway_sec)
+                            vault_token_expire.tv_sec += ttl/2;
+                        else
+                            vault_token_expire.tv_sec += ttl - vault_refresh_leeway_sec;
+                    }
+                }
+                vault_load_keys();
+            }
+        );
+        return false;
+    }
+    if (vault_token.empty())
+    {
+        // Auth error happened, mark all loads as failed
+        for (auto & key_id: vault_key_load_queue)
+        {
+            auto & k = vault_keys[key_id];
+            k.key_state = VAULT_KEY_ERROR;
+        }
+        vault_key_load_queue.clear();
+        auto ops = std::move(key_wait_ops);
+        for (cluster_op_t *op: ops)
+            inode_cache.erase(op->inode);
+        for (cluster_op_t *op: ops)
+            execute_internal(op);
+        return false;
+    }
+    return true;
+}
+#endif
+
+void cluster_client_t::vault_load_keys()
+{
+    if (vault_loading || !vault_key_load_queue.size())
+    {
+        return;
+    }
+#ifdef __MOCK__
+    vault_loading = true;
+#else
+    if (!vault_http_ctx)
+    {
+        std::string error;
+        vault_http_ctx = http_context_init(tfd, vault_client_cert, vault_client_key, vault_ca, true, error);
+        if (!vault_http_ctx)
+        {
+            fprintf(stderr, "Failed to initialize HTTP context for Vault: %s\n", error.c_str());
+            exit(1);
+        }
+        vault_http_cli = http_init(vault_http_ctx);
+    }
+    if (!vault_check_token())
+    {
+        return;
+    }
+    std::string key_id = vault_key_load_queue[0];
+    vault_key_load_queue.erase(vault_key_load_queue.begin());
+    vault_loading = true;
+    http_get(
+        vault_http_cli, vault_url+vault_secret_api_path+key_id.substr(strlen(VAULT_KEY_PREFIX)), "X-Vault-Token: "+vault_token+"\r\n",
+        (http_options_t){ .timeout = (int)vault_timeout_ms, .keepalive = true },
+        [this, key_id](http_message_t *response)
+        {
+            vault_loading = false;
+            std::string err;
+            json11::Json data;
+            response->parse_json_response(err, data);
+            vault_parse_secret(key_id, err, data);
+        }
+    );
+#endif
+}
+
+void cluster_client_t::vault_parse_secret(const std::string & key_id, const std::string & err, json11::Json data)
+{
+    vault_loading = false;
+    auto & k = vault_keys[key_id];
+    if (err != "")
+    {
+        k.key_state = VAULT_KEY_ERROR;
+        fprintf(stderr, "Vault %s%s%s request failed: %s\n", vault_url.c_str(),
+            vault_secret_api_path.c_str(), key_id.c_str()+strlen(VAULT_KEY_PREFIX), err.c_str());
+    }
+    else
+    {
+        auto hexkey = data["data"]["key"].string_value();
+        if (hexkey.empty() || !ishexstr(hexkey) || hexkey.size() != 2*AES_256_XTS_KEY_SIZE)
+        {
+            k.key_state = VAULT_KEY_ERROR;
+            fprintf(stderr, "Vault /v1/secret/%s request failed: 'key' is empty or has invalid format\n", key_id.c_str());
+        }
+        else
+        {
+            k.key_state = VAULT_KEY_LOADED;
+            k.key = hexkey;
+        }
+    }
+    if (vault_key_load_queue.empty())
+    {
+        auto ops = std::move(key_wait_ops);
+        for (cluster_op_t *op: ops)
+            inode_cache.erase(op->inode);
+        for (cluster_op_t *op: ops)
+            execute_internal(op);
+    }
+    else
+        vault_load_keys();
+}
@@ -5,7 +5,6 @@

 #include "cluster_client.h"

-#define SCRAP_BUFFER_SIZE 4*1024*1024
 #define PART_SENT 1
 #define PART_DONE 2
 #define PART_ERROR 4
@@ -63,14 +63,14 @@ void cluster_client_t::list_inode(inode_t inode, uint64_t min_offset, uint64_t m
 {
    init_msgr();
    pool_id_t pool_id = INODE_POOL(inode);
-    if (!pool_id || st_cli->pool_config.find(pool_id) == st_cli->pool_config.end())
+    if (!pool_id || st_cli.pool_config.find(pool_id) == st_cli.pool_config.end())
    {
        if (log_level > 0)
            fprintf(stderr, "Pool %u does not exist\n", pool_id);
        pg_callback(-EINVAL, 0, 0, std::set<object_id>());
        return;
    }
-    auto pg_stripe_size = st_cli->pool_config.at(pool_id).pg_stripe_size;
+    auto pg_stripe_size = st_cli.pool_config.at(pool_id).pg_stripe_size;
    if (min_offset)
        min_offset = (min_offset/pg_stripe_size) * pg_stripe_size;
    inode_list_t *lst = new inode_list_t();
@@ -110,13 +110,13 @@ bool cluster_client_t::continue_listing(inode_list_t *lst)

 bool cluster_client_t::restart_listing(inode_list_t* lst)
 {
-    auto pool_it = st_cli->pool_config.find(lst->pool_id);
+    auto pool_it = st_cli.pool_config.find(lst->pool_id);
    // We want listing to be consistent. To achieve it we should:
    // 1) retry listing of each PG if its state changes
    // 2) abort listing if PG count changes during listing
    // 3) ideally, only talk to the primary OSD - this will be done separately
    // So first we add all PGs without checking their state
-    if (pool_it == st_cli->pool_config.end() ||
+    if (pool_it == st_cli.pool_config.end() ||
        lst->real_pg_count != pool_it->second.real_pg_count)
    {
        for (auto pg: lst->pgs)
@@ -136,7 +136,7 @@ bool cluster_client_t::restart_listing(inode_list_t* lst)
            fprintf(stderr, "PG count in pool %u changed during listing\n", lst->pool_id);
        }
        lst->pgs.clear();
-        if (pool_it == st_cli->pool_config.end())
+        if (pool_it == st_cli.pool_config.end())
        {
            // Unknown pool
            lst->callback(-EINVAL, 0, 0, std::set<object_id>());
@@ -248,7 +248,7 @@ void cluster_client_t::set_list_retry_timeout(int ms, timespec new_time)

 int cluster_client_t::start_pg_listing(inode_list_pg_t *pg)
 {
-    auto & pool_cfg = st_cli->pool_config.at(pg->lst->pool_id);
+    auto & pool_cfg = st_cli.pool_config.at(pg->lst->pool_id);
    auto pg_it = pool_cfg.pg_config.find(pg->pg_num);
    assert(pg->lst->real_pg_count == pool_cfg.real_pg_count);
    if (pg_it == pool_cfg.pg_config.end() ||
@@ -277,7 +277,7 @@ int cluster_client_t::start_pg_listing(inode_list_pg_t *pg)
        for (auto peer_it = all_peers.begin(); peer_it != all_peers.end(); )
        {
            if (*peer_it != pg_it->second.cur_primary &&
-                st_cli->peer_states[*peer_it].is_null())
+                st_cli.peer_states[*peer_it].is_null())
            {
                pg->inactive_osds.push_back(*peer_it);
                all_peers.erase(peer_it++);
@@ -298,11 +298,11 @@ int cluster_client_t::start_pg_listing(inode_list_pg_t *pg)
        if (msgr.osd_peers.find(peer_osd) == msgr.osd_peers.end())
        {
            // Initiate connection
-            if (st_cli->peer_states[peer_osd].is_null())
+            if (st_cli.peer_states[peer_osd].is_null())
            {
                return LIST_PG_WAIT_ACTIVE;
            }
-            msgr.connect_peer(peer_osd, st_cli->peer_states[peer_osd]);
+            msgr.connect_peer(peer_osd, st_cli.peer_states[peer_osd]);
            conn = false;
        }
    }
@@ -336,7 +336,7 @@ void cluster_client_t::send_list(inode_list_osd_t *cur_list)
    if (!cur_list->pg->inflight_ops)
        cur_list->pg->lst->inflight_pgs++;
    cur_list->pg->inflight_ops++;
-    auto & pool_cfg = st_cli->pool_config[cur_list->pg->lst->pool_id];
+    auto & pool_cfg = st_cli.pool_config[cur_list->pg->lst->pool_id];
    osd_op_t *op = new osd_op_t();
    op->op_type = OSD_OP_OUT;
    // Already checked that it exists above, but anyway
@@ -1,11 +0,0 @@
-// Copyright (c) Vitaliy Filippov, 2019+
-// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
-
-#include "cluster_client.h"
-#include "etcd_state_client_http.h"
-
-cluster_client_t* cluster_client_t::create(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config)
-{
-    auto st_cli = new etcd_state_client_http_t(tfd);
-    return new cluster_client_t(ringloop, tfd, config, std::unique_ptr<etcd_state_client_t>(st_cli));
-}
@@ -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);
@@ -131,7 +126,6 @@ void writeback_cache_t::copy_write(cluster_op_t *op, int state, uint64_t new_flu
                        writeback_bytes -= op->len;
                    }
                    writeback_queue_size++;
-                    writeback_queue.push_back({ op->inode, new_end });
                }
                break;
            }
@@ -166,7 +160,6 @@ void writeback_cache_t::copy_write(cluster_op_t *op, int state, uint64_t new_flu
                {
                    writeback_queue_size++;
                }
-                writeback_queue.push_back({ op->inode, new_end });
            }
            auto new_dirty_it = dirty_buffers.emplace_hint(dirty_it, (object_id){
                .inode = op->inode,
@@ -251,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++;
@@ -451,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);
    }
@@ -2,11 +2,15 @@
 // License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)

 #include <assert.h>
-
+#include "malloc_or_die.h"
 #include "osd_ops.h"
+#include "msgr_op.h"
 #include "pg_states.h"
 #include "etcd_state_client.h"
+#ifndef __MOCK__
 #include "addr_util.h"
+#include "http_client.h"
+#endif
 #include "str_util.h"

 etcd_state_client_t::~etcd_state_client_t()
@@ -16,8 +20,33 @@ etcd_state_client_t::~etcd_state_client_t()
        delete watch;
    }
    watches.clear();
+    etcd_watches_initialised = -1;
+#ifndef __MOCK__
+    stop_ws_keepalive();
+    if (etcd_watch_ws)
+    {
+        http_destroy(etcd_watch_ws);
+        etcd_watch_ws = NULL;
+    }
+    if (keepalive_client)
+    {
+        http_destroy(keepalive_client);
+        keepalive_client = NULL;
+    }
+    if (http_ctx)
+    {
+        http_context_destroy(http_ctx);
+        http_ctx = NULL;
+    }
+#endif
+    if (load_pgs_timer_id >= 0)
+    {
+        tfd->clear_timer(load_pgs_timer_id);
+        load_pgs_timer_id = -1;
+    }
 }

+#ifndef __MOCK__
 etcd_kv_t etcd_state_client_t::parse_etcd_kv(const json11::Json & kv_json)
 {
    etcd_kv_t kv;
@@ -51,48 +80,146 @@ std::vector<std::string> etcd_state_client_t::get_addresses()
    return addrs;
 }

-void etcd_state_client_t::add_etcd_url(std::string addr)
+http_context_t *etcd_state_client_t::get_http_ctx()
 {
-    if (addr.length() > 0)
+    if (!http_ctx)
    {
-        if (strtolower(addr.substr(0, 7)) == "http://")
-            addr = addr.substr(7);
-        else if (strtolower(addr.substr(0, 8)) == "https://")
+        std::string error;
+        http_ctx = http_context_init(tfd, etcd_client_cert, etcd_client_key, etcd_ca, true, error);
+        if (!http_ctx)
        {
-            fprintf(stderr, "HTTPS is unsupported for etcd. Either use plain HTTP or setup a local proxy for etcd interaction\n");
+            fprintf(stderr, "Failed to initialize HTTP context: %s\n", error.c_str());
            exit(1);
        }
-        if (!local_ips.size())
-            local_ips = getifaddr_list(std::vector<addr_mask_t>(), true);
-        std::string check_addr;
-        int pos = addr.find('/');
-        int pos2 = addr.find(':');
-        if (pos2 >= 0)
-            check_addr = addr.substr(0, pos2);
-        else if (pos >= 0)
-            check_addr = addr.substr(0, pos);
-        else
-            check_addr = addr;
-        if (pos == std::string::npos)
-            addr += "/v3";
-        bool local = false;
-        int i;
-        for (i = 0; i < local_ips.size(); i++)
+    }
+    return http_ctx;
+}
+
+void etcd_state_client_t::etcd_call_oneshot(const std::string & etcd_url, const std::string & api, json11::Json payload,
+    int timeout, std::function<void(std::string, json11::Json)> callback)
+{
+    auto http_cli = http_init(get_http_ctx());
+    http_json_post(http_cli, etcd_url+api, payload, "", { .timeout = timeout }, [http_cli, callback](http_message_t *response)
+    {
+        std::string err;
+        json11::Json data;
+        response->parse_json_response(err, data);
+        callback(err, data);
+        http_destroy(http_cli);
+    });
+}
+
+void etcd_state_client_t::etcd_call(const std::string & api, json11::Json payload, int timeout,
+    int retries, int interval, std::function<void(std::string, json11::Json)> callback)
+{
+    pick_next_etcd([=]()
+    {
+        etcd_call_selected(api, payload, timeout, retries, interval, callback);
+    });
+}
+
+void etcd_state_client_t::etcd_call_selected(const std::string & api, json11::Json payload, int timeout,
+    int retries, int interval, std::function<void(std::string, json11::Json)> callback)
+{
+    const auto & url = selected_etcd_url;
+    std::string req = payload.dump();
+    req = "POST "+url.path+api+" HTTP/1.1\r\n"
+        "Host: "+url.hostname+"\r\n"
+        "Content-Type: application/json\r\n"
+        "Content-Length: "+std::to_string(req.size())+"\r\n"
+        "Connection: keep-alive\r\n"
+        "Keep-Alive: timeout="+std::to_string(etcd_keepalive_timeout)+"\r\n"
+        "\r\n"+req;
+    retries--;
+    auto cb = [this, api, payload, timeout, retries, interval, callback,
+        cur_addr = url.addr](http_message_t *response)
+    {
+        std::string err;
+        json11::Json data;
+        response->parse_json_response(err, data);
+        if (err != "")
        {
-            if (local_ips[i] == check_addr)
+            if (cur_addr == selected_etcd_url.addr)
+                selected_etcd_url = (http_url_t){};
+            if (retries > 0)
            {
-                local = true;
-                break;
+                if (this->log_level > 0)
+                {
+                    fprintf(
+                        stderr, "Warning: etcd request failed: %s, retrying %d more times\n",
+                        err.c_str(), retries
+                    );
+                }
+                if (interval > 0)
+                {
+                    // FIXME: Prevent destruction of etcd_state_client if timers or requests are active
+                    tfd->set_timer(interval, false, [this, api, payload, timeout, retries, interval, callback](int)
+                    {
+                        etcd_call(api, payload, timeout, retries, interval, callback);
+                    });
+                }
+                else
+                    etcd_call(api, payload, timeout, retries, interval, callback);
            }
+            else
+                callback(err, data);
        }
-        auto & to = local ? this->etcd_local : this->etcd_addresses;
+        else
+            callback(err, data);
+    };
+    if (!keepalive_client)
+        keepalive_client = http_init(get_http_ctx());
+    http_request(keepalive_client, url.addr, req, { .timeout = timeout, .keepalive = true, .ssl = url.ssl }, cb);
+}
+
+
+void etcd_state_client_t::add_etcd_url(std::string etcd_address)
+{
+    if (etcd_address.size() > 0)
+    {
+        if (!local_ips.size())
+        {
+            // Fill local_ips
+            for (auto & ip: getifaddr_list(std::vector<addr_mask_t>(), true))
+                local_ips.insert(ip);
+        }
+        std::string etcd_api_path;
+        bool ssl = false;
+        if (etcd_address.substr(0, 8) == "https://")
+        {
+            ssl = true;
+            etcd_address = etcd_address.substr(8);
+        }
+        else if (etcd_address.substr(0, 7) == "http://")
+            etcd_address = etcd_address.substr(7);
+        auto pos = etcd_address.find('/');
+        if (pos != std::string::npos)
+        {
+            etcd_api_path = etcd_address.substr(pos);
+            etcd_address = etcd_address.substr(0, pos);
+        }
+        else
+            etcd_api_path = "/v3";
+        pos = etcd_address.find(':');
+        auto check_addr = (pos != std::string::npos ? etcd_address.substr(0, pos) : etcd_address);
+        bool is_local = local_ips.find(check_addr) != local_ips.end();
+        auto & to = (is_local ? etcd_local : etcd_addresses);
+        check_addr = (ssl ? "https://" : "http://") + etcd_address + etcd_api_path;
+        size_t i;
        for (i = 0; i < to.size(); i++)
        {
-            if (to[i] == addr)
+            if (to[i] == check_addr)
                break;
        }
        if (i >= to.size())
-            to.push_back(addr);
+        {
+            to.push_back(check_addr);
+            // Check if it's a domain name
+            sockaddr_storage ss;
+            bool is_name = !is_local && !string_to_addr(etcd_address, true, 0, &ss);
+            auto & to_addr = (is_local ? etcd_local_addr_urls : (is_name ? etcd_name_urls : etcd_nonlocal_addr_urls));
+            to_addr.push_back((http_url_t){ .ssl = ssl, .addr = etcd_address, .hostname = etcd_address, .path = etcd_api_path });
+        }
    }
 }

@@ -100,6 +227,9 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
 {
    this->etcd_local.clear();
    this->etcd_addresses.clear();
+    this->etcd_local_addr_urls.clear();
+    this->etcd_nonlocal_addr_urls.clear();
+    this->etcd_name_urls.clear();
    if (config["etcd_address"].is_string())
    {
        std::string ea = config["etcd_address"].string_value();
@@ -120,7 +250,19 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
            add_etcd_url(ea.string_value());
        }
    }
+    if (this->osd_num)
+    {
+        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["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();
+    this->use_auth = config["use_auth"].bool_value();
    if (this->etcd_prefix == "")
    {
        this->etcd_prefix = "/vitastor";
@@ -137,6 +279,7 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
        if (this->etcd_keepalive_timeout < 30)
            this->etcd_keepalive_timeout = 30;
    }
+    auto old_etcd_ws_keepalive_interval = this->etcd_ws_keepalive_interval;
    this->etcd_ws_keepalive_interval = config["etcd_ws_keepalive_interval"].uint64_value();
    if (this->etcd_ws_keepalive_interval <= 0)
    {
@@ -162,9 +305,347 @@ void etcd_state_client_t::parse_config(const json11::Json & config)
    {
        this->etcd_min_reload_interval = 50;
    }
+    if (this->etcd_ws_keepalive_interval != old_etcd_ws_keepalive_interval && ws_keepalive_timer >= 0)
+    {
+#ifndef __MOCK__
+        stop_ws_keepalive();
+        start_ws_keepalive();
+#endif
+    }
 }

-void etcd_state_client_t::load_global_config(std::function<void(const std::string & error)> cb)
+void etcd_state_client_t::pick_next_etcd(std::function<void()> cb)
+{
+    if (!etcd_addresses.size() && !etcd_local.size())
+    {
+        fprintf(stderr, "etcd_address is missing in Vitastor configuration\n");
+        exit(1);
+    }
+    if (selected_etcd_url.addr != "")
+    {
+        cb();
+        return;
+    }
+    if (etcd_urls_to_try.size() != 0)
+    {
+        selected_etcd_url = std::move(etcd_urls_to_try[0]);
+        etcd_urls_to_try.erase(etcd_urls_to_try.begin());
+        cb();
+        return;
+    }
+    on_resolve_queue.push_back(std::move(cb));
+    if (on_resolve_queue.size() > 1)
+    {
+        // Already resolving
+        return;
+    }
+    assert(!resolve_count);
+    local_to_try = 0;
+    for (auto & url: etcd_local_addr_urls)
+    {
+        // Prefer local IPs, if any
+        etcd_urls_to_try.push_back(url);
+        local_to_try++;
+    }
+    for (auto & url: etcd_nonlocal_addr_urls)
+    {
+        etcd_urls_to_try.push_back(url);
+    }
+    resolve_count++;
+    for (auto & url: etcd_name_urls)
+    {
+        resolve_count++;
+        http_resolve(get_http_ctx(), url.ssl, url.addr, [this, url](const std::string & error, const std::vector<std::string>& addresses)
+        {
+            if (error != "")
+                fprintf(stderr, "Error resolving %s: %s\n", url.addr.c_str(), error.c_str());
+            for (auto & addr: addresses)
+            {
+                auto url_copy = url;
+                url_copy.addr = addr;
+                if (local_ips.find(addr) != local_ips.end())
+                {
+                    etcd_urls_to_try.insert(etcd_urls_to_try.begin(), std::move(url_copy));
+                    local_to_try++;
+                }
+                else
+                    etcd_urls_to_try.push_back(std::move(url_copy));
+            }
+            resolve_count--;
+            if (!resolve_count)
+                pick_next_etcd_on_resolve();
+        });
+    }
+    resolve_count--;
+    if (!resolve_count)
+    {
+        pick_next_etcd_on_resolve();
+    }
+}
+
+void etcd_state_client_t::pick_next_etcd_on_resolve()
+{
+    if (!etcd_urls_to_try.size())
+    {
+        fprintf(stderr, "None of etcd_address could be resolved\n");
+        exit(1);
+    }
+    if (!rand_initialized)
+    {
+        timespec tv;
+        clock_gettime(CLOCK_REALTIME, &tv);
+        srand48(tv.tv_sec*1000000000 + tv.tv_nsec);
+        rand_initialized = true;
+    }
+    // Shuffle addresses
+    for (size_t i = etcd_urls_to_try.size()-1; i > local_to_try; i--)
+    {
+        size_t j = local_to_try + lrand48() % (i - local_to_try);
+        if (j != i)
+            std::swap(etcd_urls_to_try[i], etcd_urls_to_try[j]);
+    }
+    selected_etcd_url = std::move(etcd_urls_to_try[0]);
+    etcd_urls_to_try.erase(etcd_urls_to_try.begin());
+    auto cbs = std::move(on_resolve_queue);
+    for (auto cb: cbs)
+    {
+        cb();
+    }
+}
+
+void etcd_state_client_t::start_etcd_watcher()
+{
+    pick_next_etcd([this]()
+    {
+        start_etcd_watcher_selected();
+    });
+}
+
+void etcd_state_client_t::start_etcd_watcher_selected()
+{
+    const auto & url = selected_etcd_url;
+    etcd_watches_initialised = 0;
+    ws_alive = 1;
+    if (this->log_level > 1)
+    {
+        fprintf(stderr, "Trying to connect to etcd websocket at %s%s%s (hostname %s), watch from revision %ju/%ju/%ju\n",
+            url.ssl ? "https://" : "http://", url.addr.c_str(), url.path.c_str(), url.hostname.c_str(),
+            etcd_watch_revision_config, etcd_watch_revision_osd, etcd_watch_revision_pg);
+    }
+    if (!etcd_watch_ws)
+        etcd_watch_ws = http_init(get_http_ctx());
+    else
+        http_close(etcd_watch_ws);
+    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)
+    {
+        if (msg->body.length())
+        {
+            ws_alive = 1;
+            std::string json_err;
+            json11::Json data = json11::Json::parse(msg->body, json_err);
+            if (json_err != "")
+            {
+                fprintf(stderr, "Bad JSON in etcd event: %s, ignoring event\n", json_err.c_str());
+            }
+            else
+            {
+                uint64_t watch_id = data["result"]["watch_id"].uint64_value();
+                if (data["result"]["created"].bool_value())
+                {
+                    if (watch_id == ETCD_CONFIG_WATCH_ID ||
+                        watch_id == ETCD_PG_STATE_WATCH_ID ||
+                        watch_id == ETCD_OSD_STATE_WATCH_ID)
+                    {
+                        etcd_watches_initialised++;
+                    }
+                    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);
+                    }
+                }
+                if (data["result"]["canceled"].bool_value())
+                {
+                    // etcd watch canceled, maybe because the revision was compacted
+                    if (data["result"]["compact_revision"].uint64_value())
+                    {
+                        // we may miss events if we proceed
+                        // so we should restart from the beginning if we can
+                        if (on_reload_hook != NULL)
+                        {
+                            // check to not trigger on_reload_hook multiple times
+                            if (etcd_watch_ws != NULL)
+                            {
+                                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;
+                                on_reload_hook();
+                            }
+                            return;
+                        }
+                        else
+                        {
+                            fprintf(stderr, "Revisions before %ju were compacted by etcd, exiting\n",
+                                data["result"]["compact_revision"].uint64_value());
+                            exit(1);
+                        }
+                    }
+                    else
+                    {
+                        fprintf(stderr, "Watch canceled by etcd, reason: %s, exiting\n", data["result"]["cancel_reason"].string_value().c_str());
+                        exit(1);
+                    }
+                }
+                // 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 &&
+                    !data["result"]["header"]["revision"].is_null() &&
+                    !data["result"]["created"].bool_value())
+                {
+                    // Restart watchers from the same revision number as in the last received message,
+                    // not from the next one to protect against revision being split into multiple messages,
+                    // even though etcd guarantees not to do that **within a single watcher** without fragment=true:
+                    // https://etcd.io/docs/v3.5/learning/api_guarantees/#watch-apis
+                    // Revision contents are ALWAYS split into separate messages for different watchers though!
+                    // So generally we have to resume each watcher from its own revision...
+                    // Progress messages may have watch_id=-1 if sent on behalf of multiple watchers though.
+                    // And antietcd has an advanced semantic which merges the same revision for all watchers
+                    // into one message and just omits watch_id.
+                    // So we also have to handle the case where watch_id is -1 or not present (0).
+                    auto watch_rev = data["result"]["header"]["revision"].uint64_value();
+                    if (!watch_id || watch_id == UINT64_MAX)
+                        etcd_watch_revision_config = etcd_watch_revision_osd = etcd_watch_revision_pg = watch_rev;
+                    else if (watch_id == ETCD_CONFIG_WATCH_ID)
+                        etcd_watch_revision_config = watch_rev;
+                    else if (watch_id == ETCD_PG_STATE_WATCH_ID)
+                        etcd_watch_revision_pg = watch_rev;
+                    else if (watch_id == ETCD_OSD_STATE_WATCH_ID)
+                        etcd_watch_revision_osd = watch_rev;
+                    etcd_urls_to_try.clear();
+                }
+                // First gather all changes into a hash to remove multiple overwrites
+                std::map<std::string, etcd_kv_t> changes;
+                for (auto & ev: data["result"]["events"].array_items())
+                {
+                    auto kv = parse_etcd_kv(ev["kv"]);
+                    if (kv.key != "")
+                    {
+                        changes[kv.key] = kv;
+                    }
+                }
+                for (auto & kv: changes)
+                {
+                    if (this->log_level > 3)
+                    {
+                        fprintf(stderr, "Incoming event: %s -> %s\n", kv.first.c_str(), kv.second.value.dump().c_str());
+                    }
+                    parse_state(kv.second);
+                }
+                // React to changes
+                if (on_change_hook != NULL)
+                {
+                    on_change_hook(changes);
+                }
+            }
+        }
+        if (msg->eof)
+        {
+            fprintf(stderr, "Disconnected from etcd %s\n", cur_addr.c_str());
+            if (cur_addr == selected_etcd_url.addr)
+                selected_etcd_url = (http_url_t){};
+            if (etcd_watches_initialised == 0)
+            {
+                // Connection not established, retry in <etcd_quick_timeout>
+                tfd->set_timer(etcd_quick_timeout, false, [this](int)
+                {
+                    start_etcd_watcher();
+                });
+            }
+            else if (etcd_watches_initialised > 0)
+            {
+                // Connection was live, retry immediately
+                etcd_watches_initialised = 0;
+                start_etcd_watcher();
+            }
+        }
+    });
+    http_post_message(etcd_watch_ws, WS_TEXT, json11::Json(json11::Json::object {
+        { "create_request", json11::Json::object {
+            { "key", base64_encode(etcd_prefix+"/config/") },
+            { "range_end", base64_encode(etcd_prefix+"/config0") },
+            { "start_revision", etcd_watch_revision_config },
+            { "watch_id", ETCD_CONFIG_WATCH_ID },
+            { "progress_notify", true },
+        } }
+    }).dump());
+    http_post_message(etcd_watch_ws, WS_TEXT, json11::Json(json11::Json::object {
+        { "create_request", json11::Json::object {
+            { "key", base64_encode(etcd_prefix+"/osd/state/") },
+            { "range_end", base64_encode(etcd_prefix+"/osd/state0") },
+            { "start_revision", etcd_watch_revision_osd },
+            { "watch_id", ETCD_OSD_STATE_WATCH_ID },
+            { "progress_notify", true },
+        } }
+    }).dump());
+    http_post_message(etcd_watch_ws, WS_TEXT, json11::Json(json11::Json::object {
+        { "create_request", json11::Json::object {
+            { "key", base64_encode(etcd_prefix+"/pg/") },
+            { "range_end", base64_encode(etcd_prefix+"/pg0") },
+            { "start_revision", etcd_watch_revision_pg },
+            { "watch_id", ETCD_PG_STATE_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)
+    {
+        on_start_watcher_hook(etcd_watch_ws);
+    }
+    start_ws_keepalive();
+}
+
+void etcd_state_client_t::stop_ws_keepalive()
+{
+    if (ws_keepalive_timer >= 0)
+    {
+        tfd->clear_timer(ws_keepalive_timer);
+        ws_keepalive_timer = -1;
+    }
+}
+
+void etcd_state_client_t::start_ws_keepalive()
+{
+    if (ws_keepalive_timer < 0)
+    {
+        ws_keepalive_timer = tfd->set_timer(etcd_ws_keepalive_interval*1000, true, [this](int)
+        {
+            if (!etcd_watch_ws || etcd_watches_initialised < ETCD_TOTAL_WATCHES)
+            {
+                // Do nothing
+            }
+            else if (!ws_alive)
+            {
+                if (this->log_level > 0)
+                {
+                    fprintf(stderr, "Websocket ping failed, disconnecting from etcd %s\n", selected_etcd_url.addr.c_str());
+                }
+                start_etcd_watcher();
+            }
+            else
+            {
+                ws_alive = 0;
+                http_post_message(etcd_watch_ws, WS_TEXT, json11::Json(json11::Json::object {
+                    { "progress_request", json11::Json::object { } }
+                }).dump());
+            }
+        });
+    }
+}
+
+void etcd_state_client_t::load_global_config()
 {
    json11::Json::object req = { { "success", json11::Json::array {
        json11::Json::object {
@@ -178,12 +659,22 @@ void etcd_state_client_t::load_global_config(std::function<void(const std::strin
            } }
        },
    } } };
-    etcd_txn(req, etcd_quick_timeout, max_etcd_attempts, 0, [this, cb](std::string err, json11::Json data)
+    etcd_txn(req, etcd_quick_timeout, max_etcd_attempts, 0, [this](std::string err, json11::Json data)
    {
        if (err != "")
        {
            fprintf(stderr, "Error reading configuration from etcd: %s\n", err.c_str());
-            cb(err);
+            if (infinite_start)
+            {
+                tfd->set_timer(etcd_slow_timeout, false, [this](int timer_id)
+                {
+                    load_global_config();
+                });
+            }
+            else
+            {
+                exit(1);
+            }
            return;
        }
        json11::Json config_kv = data["responses"][0]["response_range"]["kvs"][0];
@@ -214,12 +705,28 @@ void etcd_state_client_t::load_global_config(std::function<void(const std::strin
            parse_state(kv);
        }
        on_load_config_hook(global_config);
-        cb("");
    });
 }

-void etcd_state_client_t::load_pgs(std::function<void(const std::string &)> cb)
+void etcd_state_client_t::load_pgs()
 {
+    timespec tv;
+    clock_gettime(CLOCK_REALTIME, &tv);
+    uint64_t ms_passed = (tv.tv_sec-etcd_last_reload.tv_sec)*1000 + (tv.tv_nsec-etcd_last_reload.tv_nsec)/1000000;
+    if (ms_passed < etcd_min_reload_interval)
+    {
+        if (load_pgs_timer_id < 0)
+        {
+            load_pgs_timer_id = tfd->set_timer(etcd_min_reload_interval+50-ms_passed, false, [this](int) { load_pgs(); });
+        }
+        return;
+    }
+    etcd_last_reload = tv;
+    if (load_pgs_timer_id >= 0)
+    {
+        tfd->clear_timer(load_pgs_timer_id);
+        load_pgs_timer_id = -1;
+    }
    json11::Json::array txn = {
        json11::Json::object {
            { "request_range", json11::Json::object {
@@ -267,13 +774,16 @@ void etcd_state_client_t::load_pgs(std::function<void(const std::string &)> cb)
    {
        req["compare"] = checks;
    }
-    etcd_txn_slow(req, [this, cb](std::string err, json11::Json data)
+    etcd_txn_slow(req, [this](std::string err, json11::Json data)
    {
        if (err != "")
        {
            // Retry indefinitely
            fprintf(stderr, "Error loading PGs from etcd: %s\n", err.c_str());
-            cb(err);
+            tfd->set_timer(etcd_slow_timeout, false, [this](int timer_id)
+            {
+                load_pgs();
+            });
            return;
        }
        if (!data["succeeded"].bool_value())
@@ -301,9 +811,24 @@ void etcd_state_client_t::load_pgs(std::function<void(const std::string &)> cb)
        }
        clean_nonexistent_pgs();
        on_load_pgs_hook(true);
-        cb("");
+        start_etcd_watcher();
    });
 }
+#else
+void etcd_state_client_t::parse_config(const json11::Json & config)
+{
+}
+
+void etcd_state_client_t::load_global_config()
+{
+    json11::Json::object global_config;
+    on_load_config_hook(global_config);
+}
+
+void etcd_state_client_t::load_pgs()
+{
+}
+#endif

 void etcd_state_client_t::reset_pg_exists()
 {
@@ -416,8 +941,7 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
            if (pc.pg_size < 1 ||
                pool_item.second["pg_size"].uint64_value() < 3 &&
                (pc.scheme == POOL_SCHEME_XOR || pc.scheme == POOL_SCHEME_EC) ||
-                // limit is 64 because osd_peering_pg.cpp uses a 64-bit mask for has_roles
-                pool_item.second["pg_size"].uint64_value() > 64)
+                pool_item.second["pg_size"].uint64_value() > 256)
            {
                fprintf(stderr, "Pool %u has invalid pg_size, skipping pool\n", pool_id);
                continue;
@@ -494,6 +1018,8 @@ 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")
@@ -737,6 +1263,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 ||
@@ -745,6 +1272,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;
@@ -757,14 +1285,8 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
    else if (key.substr(0, etcd_prefix.length()+11) == etcd_prefix+"/osd/state/")
    {
        // <etcd_prefix>/osd/state/%d
-        osd_num_t peer_osd = 0;
-        char null_byte = 0;
-        int scanned = sscanf(key.c_str() + etcd_prefix.length()+11, "%ju%c", &peer_osd, &null_byte);
-        if (scanned != 1 || !peer_osd)
-        {
-            fprintf(stderr, "Bad etcd key %s, ignoring\n", key.c_str());
-        }
-        else
+        osd_num_t peer_osd = std::stoull(key.substr(etcd_prefix.length()+11));
+        if (peer_osd > 0)
        {
            if (value.is_object() && value["state"] == "up")
            {
@@ -821,33 +1343,7 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
            }
            else
            {
-                inode_t parent_inode_num = value["parent_id"].uint64_value();
-                if (parent_inode_num && !(parent_inode_num >> (64-POOL_ID_BITS)))
-                {
-                    uint64_t parent_pool_id = value["parent_pool"].uint64_value();
-                    if (!parent_pool_id)
-                        parent_inode_num |= pool_id << (64-POOL_ID_BITS);
-                    else if (parent_pool_id >= POOL_ID_MAX)
-                    {
-                        fprintf(
-                            stderr, "Inode %ju/%ju parent_pool value is invalid, ignoring parent setting\n",
-                            inode_num >> (64-POOL_ID_BITS), inode_num & (((uint64_t)1 << (64-POOL_ID_BITS)) - 1)
-                        );
-                        parent_inode_num = 0;
-                    }
-                    else
-                        parent_inode_num |= parent_pool_id << (64-POOL_ID_BITS);
-                }
-                insert_inode_config((inode_config_t){
-                    .num = inode_num,
-                    .name = value["name"].string_value(),
-                    .size = value["size"].uint64_value(),
-                    .parent_id = parent_inode_num,
-                    .readonly = value["readonly"].bool_value(),
-                    .deleted = value["deleted"].bool_value(),
-                    .meta = value["meta"],
-                    .mod_revision = kv.mod_revision,
-                });
+                insert_inode_config(deserialize_inode_cfg(inode_num, kv.value, kv.mod_revision));
            }
        }
    }
@@ -858,6 +1354,14 @@ 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 (use_auth && key.substr(0, etcd_prefix.length()+13) == etcd_prefix+"/config/user/")
+    {
+        // <etcd_prefix>/config/user/<username>
+        if (!value.is_object())
+            user_info.erase(key.substr(etcd_prefix.length()+13));
+        else
+            user_info[key.substr(etcd_prefix.length()+13)] = value;
+    }
 }

 uint32_t etcd_state_client_t::parse_immediate_commit(const std::string & immediate_commit_str, uint32_t default_value)
@@ -936,6 +1440,10 @@ json11::Json::object etcd_state_client_t::serialize_inode_cfg(inode_config_t *cf
            new_cfg["parent_pool"] = (uint64_t)INODE_POOL(cfg->parent_id);
        new_cfg["parent_id"] = (uint64_t)INODE_NO_POOL(cfg->parent_id);
    }
+    if (!cfg->enc_key.empty())
+    {
+        new_cfg["enc_key"] = cfg->enc_key;
+    }
    if (cfg->readonly)
    {
        new_cfg["readonly"] = true;
@@ -944,6 +1452,18 @@ 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;
@@ -951,6 +1471,53 @@ json11::Json::object etcd_state_client_t::serialize_inode_cfg(inode_config_t *cf
    return new_cfg;
 }

+inode_config_t etcd_state_client_t::deserialize_inode_cfg(uint64_t inode_num, json11::Json value, uint64_t mod_revision)
+{
+    inode_t parent_inode_num = value["parent_id"].uint64_value();
+    if (parent_inode_num && !INODE_POOL(parent_inode_num))
+    {
+        uint64_t parent_pool_id = value["parent_pool"].uint64_value();
+        if (!parent_pool_id)
+            parent_inode_num = INODE_WITH_POOL(INODE_POOL(inode_num), parent_inode_num);
+        else if (parent_pool_id >= POOL_ID_MAX)
+        {
+            fprintf(
+                stderr, "Inode %u/%ju parent_pool value is invalid, ignoring parent setting\n",
+                INODE_POOL(inode_num), INODE_NO_POOL(inode_num)
+            );
+            parent_inode_num = 0;
+        }
+        else
+            parent_inode_num |= parent_pool_id << (64-POOL_ID_BITS);
+    }
+    std::string enc_key;
+    if (!value["enc_key"].is_null())
+    {
+        enc_key = value["enc_key"].string_value();
+        if (enc_key.substr(0, strlen(VAULT_KEY_PREFIX)) != VAULT_KEY_PREFIX &&
+            (enc_key.size() != 2*AES_256_XTS_KEY_SIZE || !ishexstr(enc_key)))
+        {
+            enc_key = "";
+            fprintf(stderr, "Inode %u/%ju has invalid enc_key, should be %u bit hex string or Vault key reference\n",
+                INODE_POOL(inode_num), INODE_NO_POOL(inode_num), AES_256_XTS_KEY_SIZE);
+        }
+    }
+    return (inode_config_t){
+        .num = inode_num,
+        .name = value["name"].string_value(),
+        .size = value["size"].uint64_value(),
+        .parent_id = parent_inode_num,
+        .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,
+    };
+}
+
 int etcd_state_client_t::address_count()
 {
    return etcd_addresses.size() + etcd_local.size();
@@ -4,6 +4,7 @@
 #pragma once

 #include <set>
+#include <memory>

 #include "json11/json11.hpp"
 #include "object_id.h"
@@ -19,6 +20,8 @@
 #define MAX_DATA_BLOCK_SIZE 128*1024*1024
 #define DEFAULT_BITMAP_GRANULARITY 4096

+#define VAULT_KEY_PREFIX "vault:"
+
 #ifndef IMMEDIATE_NONE
 #define IMMEDIATE_NONE 0
 #define IMMEDIATE_SMALL 1
@@ -66,6 +69,7 @@ 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;

@@ -83,6 +87,9 @@ struct inode_config_t
    inode_t parent_id = 0;
    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
@@ -95,21 +102,41 @@ struct inode_watch_t
    inode_config_t cfg = {};
 };

+struct http_url_t
+{
+    bool ssl;
+    std::string addr;
+    std::string hostname;
+    std::string path;
+};
+
 struct http_co_t;
+struct http_context_t;

 struct __attribute__((visibility("default"))) etcd_state_client_t
 {
 protected:
-    std::vector<std::string> local_ips;
-    std::vector<std::string> etcd_addresses;
+    std::set<std::string> local_ips;
    std::vector<std::string> etcd_local;
+    std::vector<std::string> etcd_addresses;
+    std::vector<http_url_t> etcd_local_addr_urls;
+    std::vector<http_url_t> etcd_nonlocal_addr_urls;
+    std::vector<http_url_t> etcd_name_urls;
+    size_t local_to_try = 0;
+    std::vector<http_url_t> etcd_urls_to_try;
+    http_url_t selected_etcd_url;
+    size_t resolve_count = 0;
    std::vector<inode_watch_t*> watches;
-    std::set<osd_num_t> seen_peers;
+    std::vector<std::function<void()>> on_resolve_queue;
    bool new_pg_config = false;
-
+    int ws_keepalive_timer = -1;
+    int ws_alive = 0;
+    bool rand_initialized = false;
    void add_etcd_url(std::string);
-    void reset_pg_exists();
-    void clean_nonexistent_pgs();
+    void pick_next_etcd(std::function<void()> cb);
+    void pick_next_etcd_on_resolve();
+    void etcd_call_selected(const std::string & api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);
+    void start_etcd_watcher_selected();
 public:
    int etcd_keepalive_timeout = 30;
    int etcd_ws_keepalive_interval = 5;
@@ -118,20 +145,33 @@ public:
    int etcd_slow_timeout = 5000;
    int etcd_min_reload_interval = 1000;
    bool infinite_start = true;
+    bool use_auth = false;
    uint64_t global_block_size = DEFAULT_BLOCK_SIZE;
    uint32_t global_bitmap_granularity = DEFAULT_BITMAP_GRANULARITY;
    uint32_t global_immediate_commit = IMMEDIATE_NONE;
-    std::string etcd_prefix;
-    int log_level = 0;

+    uint64_t osd_num = 0;
+    std::string etcd_prefix;
+    std::string etcd_client_cert;
+    std::string etcd_client_key;
+    std::string etcd_ca;
+    int log_level = 0;
+    timerfd_manager_t *tfd = NULL;
+
+    http_context_t *http_ctx = NULL;
+    http_co_t *etcd_watch_ws = NULL, *keepalive_client = NULL;
+    int etcd_watches_initialised = 0;
    uint64_t etcd_watch_revision_config = 0;
    uint64_t etcd_watch_revision_osd = 0;
    uint64_t etcd_watch_revision_pg = 0;
-
+    timespec etcd_last_reload = {};
+    int load_pgs_timer_id = -1;
    std::map<pool_id_t, pool_config_t> pool_config;
    std::map<osd_num_t, json11::Json> peer_states;
+    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;
+    std::map<std::string, json11::Json> user_info;
    json11::Json node_placement;

    std::function<void(std::map<std::string, etcd_kv_t> &)> on_change_hook;
@@ -150,24 +190,28 @@ public:
    std::function<void(http_co_t *)> on_start_watcher_hook;

    json11::Json::object serialize_inode_cfg(inode_config_t *cfg);
+    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();
-    virtual void etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload, int timeout, std::function<void(std::string, json11::Json)> callback) = 0;
-    virtual void etcd_call(std::string api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback) = 0;
+    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);
    void etcd_txn(json11::Json txn, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);
    void etcd_txn_slow(json11::Json txn, std::function<void(std::string, json11::Json)> callback);
-    virtual void etcd_add_watch(json11::Json watch) = 0;
-    void load_global_config(std::function<void(const std::string &)> cb);
-    virtual void load_global_config() = 0;
-    void load_pgs(std::function<void(const std::string &)> cb);
-    virtual void load_pgs() = 0;
+    void start_etcd_watcher();
+    void stop_ws_keepalive();
+    void start_ws_keepalive();
+    void load_global_config();
+    void load_pgs();
+    void reset_pg_exists();
+    void clean_nonexistent_pgs();
    void parse_state(const etcd_kv_t & kv);
-    virtual void parse_config(const json11::Json & config);
+    void parse_config(const json11::Json & config);
    void insert_inode_config(const inode_config_t & cfg);
    inode_watch_t* watch_inode(std::string name);
    void close_watch(inode_watch_t* watch);
    int address_count();
-    virtual ~etcd_state_client_t();
+    ~etcd_state_client_t();

    static uint32_t parse_immediate_commit(const std::string & immediate_commit_str, uint32_t default_value);
    static uint32_t parse_scheme(const std::string & scheme_str);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vitaliy Filippov	6b28e10660	HTTP "hello, world!"	2026-04-09 12:14:56 +03:00
Vitaliy Filippov	f5d19b657a	WIP TLS	2026-04-09 11:42:18 +03:00
Vitaliy Filippov	82f9515bf1	Auto-select the only RDMA device/port if there is only one	2026-04-05 16:16:54 +03:00
Vitaliy Filippov	dc13f2dd45	Allow to skip checksums for headers	2026-04-05 11:40:00 +03:00
Vitaliy Filippov	d54f73195b	Implement protocol-level checksums (xxhash3)	2026-04-04 19:03:27 +03:00
Vitaliy Filippov	6c584df3ca	Include xxhash3 x86dispatch	2026-04-04 19:03:01 +03:00
Vitaliy Filippov	b2effacbc1	Do not use scrap_buffer in the client (it would block protocol checksum support)	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	440a722827	Support TLS CN authentication and per-image permissions in vitastor-cli serve	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	e478139e4d	Add VitastorAuthFilter	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	7d68443235	Implement vitastor-cli ls-user, modify-user, remove-user commands	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	ff6519a005	Add image owner/owner_group/reader_group support (for antietcd VitastorAuthFilter)	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	34a98e4dcc	Add security parameter documentation	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	1ebac51110	Support inline (string PEM) certificates and pkeys	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	2e261ac2cf	Show encryption keys (only IDs) in the listing	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	405a8c3f53	Support storing image encryption keys in Vault	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	8d4d49dad3	Prefer local etcd addresses and correctly cycle over them even when they need resolving Seems slightly overcomplicated...	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	6a646be234	Support DNS resolving via libc-ares	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	bc0aa48bc7	Batch handle_immediate_ops more	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	df08f4e4d2	Add vitastor-cli create & modify --enc-key parameter	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	2669ba96ad	Support reading from snapshots encrypted with different keys	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	b5b3c95bfd	Support decryption with multiple keys	2026-04-04 19:01:50 +03:00
Vitaliy Filippov	0d5530f89a	Allow to return chain_info in response to reads	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	0b32d76f75	Add basic AES-XTS client-side encryption support	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	67132a29ae	Rework msgr send/receive to allow encryption support	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	6d22ab77ec	Move fromhexstr() to str_util	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	b2bcf2734c	Add openapi description	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	04e4fcd14d	Slightly fix API return and input types	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	2dbfc8548a	Implement vitastor-cli serve command to serve simple HTTP API	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	74a826d0be	Implement HTTP server support O_o	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	4aa9c8bf2b	Rename http_response_t to http_message_t	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	5a51415d2c	Extract common HTTP context	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	2be8dfbb48	Support xxhash 32-bit checksums (data_csum_type=xxh3_32)	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	49db218f73	Detect block checksums using csum_block_size, not data_csum_type	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	b04a2d62b2	Add client certificate support	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	dcd545a1a5	Do not re-initialize TLS context every connection	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	553e153c16	Add https support to antietcd	2026-04-04 19:01:49 +03:00
Vitaliy Filippov	cc420ca32d	Implement etcd SSL support via OpenSSL Maybe I should remove all of this and use libwebsockets :)	2026-04-04 19:01:49 +03:00