Update stock/hsx.vn.md

- QEMU virtual disk migration with enabled iothread is finally fixed correctly.
- Fixed operation of Proxmox VMs with swTPM without enabling NBD for all disks.
- Debian packages are now again built with stable Antietcd released instead of
  the unstable master branch.
- Antietcd cluster mode previously broken in that master branch is fixed. The
  symptom was Antietcd being unable to elect the leader in a cluster.
- Fixed monitor startup with embedded Antietcd when using IPv6.
- Fixed space statistics calculation for FS and S3 pools in the new storage ([PR #127](https://github.com/vitalif/vitastor/pull/127)).

.gitea/workflows/test.yml

@@ -306,6 +306,78 @@ 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
@@ -1458,6 +1530,24 @@ 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
@@ -1494,6 +1584,24 @@ 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

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.8...3.30)
 
 project(vitastor)
 
-set(VITASTOR_VERSION "3.0.10")
+set(VITASTOR_VERSION "3.0.15")
 
 include(CTest)
 

README.md

@@ -1,112 +1,183 @@
-# Vitastor
+# tromcho.net
 
-[Читать на русском](README-ru.md)
+Repository này chứa toàn bộ source code của website **tromcho.net**.
 
-## The Idea
+## Giới thiệu
 
-Make Clustered Block Storage Fast Again.
+`tromcho.net` là mã nguồn website được tổ chức để phục vụ phát triển, triển khai và vận hành theo quy trình chuẩn trên GitHub.
+README này đóng vai trò tài liệu khởi đầu cho lập trình viên, DevOps engineer và cộng tác viên khi tiếp cận repository.
 
-Vitastor is a distributed block, file and object SDS, direct replacement of Ceph RBD, CephFS and RGW,
-and also internal SDS's of public clouds. However, in contrast to them, Vitastor is fast
-and simple at the same time. The only thing is it's slightly young :-).
+## Mục tiêu repository
 
-Vitastor is architecturally similar to Ceph which means strong consistency,
-primary-replication, symmetric clustering and automatic data distribution over any
-number of drives of any size with configurable redundancy (replication or erasure codes/XOR).
+- Quản lý tập trung toàn bộ source code của website.
+- Chuẩn hóa quy trình phát triển, review và triển khai.
+- Tạo nền tảng rõ ràng cho việc CI/CD, kiểm thử và vận hành production.
+- Hỗ trợ onboarding nhanh cho thành viên mới.
 
-Vitastor targets primarily SSD and SSD+HDD clusters with at least 10 Gbit/s network,
-supports TCP and RDMA and may achieve 4 KB read and write latency as low as ~0.1 ms
-with proper hardware which is ~10 times faster than other popular SDS's like Ceph
-or internal systems of public clouds.
+## Cấu trúc thư mục đề xuất
 
-Vitastor supports QEMU, UBLK, NBD, NFS protocols, OpenStack, OpenNebula, Proxmox, Kubernetes drivers.
-More drivers may be created easily.
+```text
+.
+├── app/                # Source code ứng dụng chính
+├── public/             # Static files, images, favicon, robots.txt
+├── config/             # Cấu hình môi trường, app, service integration
+├── database/           # Migration, seed, schema
+├── tests/              # Unit test, integration test, e2e test
+├── scripts/            # Script hỗ trợ build, deploy, backup, maintenance
+├── docs/               # Tài liệu kỹ thuật, kiến trúc, quy trình
+├── .github/            # GitHub Actions, issue template, PR template
+├── Dockerfile          # Build image ứng dụng
+├── docker-compose.yml  # Chạy local/dev bằng container
+├── .env.example        # Biến môi trường mẫu
+└── README.md
+```
 
-Read more details in the documentation. You can start from here: [Quick Start](docs/intro/quickstart.en.md).
+> Cấu trúc thực tế có thể thay đổi theo framework đang sử dụng.
 
-## Talks and presentations
+## Yêu cầu môi trường
 
-- KuberConf'2025: [video](https://vitastor.io/presentation/kuberconf.webm)
-- Highload'2025: [video](https://vitastor.io/presentation/hl2025/hl2025.webm),
-  [youtube](https://www.youtube.com/watch?v=0R8MLjFtz7g), presentation
-  ([in Russian](https://vitastor.io/presentation/hl2025/), [in English](https://vitastor.io/presentation/hl2025/en.html))
-- Highload'2022: presentation ([in Russian](https://vitastor.io/presentation/highload/highload.html)),
-  [video](https://vitastor.io/presentation/highload/talk.webm)
-- DevOpsConf'2021: presentation ([in Russian](https://vitastor.io/presentation/devopsconf/devopsconf.html),
-  [in English](https://vitastor.io/presentation/devopsconf/devopsconf_en.html)),
-  [video](https://vitastor.io/presentation/devopsconf/talk.webm)
+Tùy theo stack công nghệ của website, môi trường phát triển nên có:
 
-## Documentation
+- Git
+- Docker và Docker Compose
+- Node.js / PHP / Python / runtime phù hợp với dự án
+- Make (khuyến nghị)
+- Truy cập vào file cấu hình môi trường `.env`
 
-- Introduction
-  - [Quick Start](docs/intro/quickstart.en.md)
-  - [Features](docs/intro/features.en.md)
-  - [Architecture](docs/intro/architecture.en.md)
-  - [Author and license](docs/intro/author.en.md)
-- Installation
-  - [Packages](docs/installation/packages.en.md)
-  - [Docker](docs/installation/docker.en.md)
-  - [Proxmox](docs/installation/proxmox.en.md)
-  - [OpenNebula](docs/installation/opennebula.en.md)
-  - [OpenStack](docs/installation/openstack.en.md)
-  - [Kubernetes CSI](docs/installation/kubernetes.en.md)
-  - [S3](docs/installation/s3.en.md)
-  - [Building from Source](docs/installation/source.en.md)
-- Configuration
-  - [Overview](docs/config.en.md)
-  - Parameter Reference
-    - [Common](docs/config/common.en.md)
-    - [Network](docs/config/network.en.md)
-    - [Client](docs/config/client.en.md)
-    - [Global Disk Layout](docs/config/layout-cluster.en.md)
-    - [OSD Disk Layout](docs/config/layout-osd.en.md)
-    - [OSD Runtime Parameters](docs/config/osd.en.md)
-    - [Monitor](docs/config/monitor.en.md)
-  - [Pool configuration](docs/config/pool.en.md)
-  - [Image metadata in etcd](docs/config/inode.en.md)
-- Usage
-  - [vitastor-cli](docs/usage/cli.en.md) (command-line interface)
-  - [vitastor-disk](docs/usage/disk.en.md) (disk management tool)
-  - [fio](docs/usage/fio.en.md) for benchmarks
-  - [UBLK](docs/usage/ublk.en.md) for kernel mounts
-  - [NBD](docs/usage/nbd.en.md) - old interface for kernel mounts
-  - [QEMU, qemu-img and VDUSE](docs/usage/qemu.en.md)
-  - [NFS](docs/usage/nfs.en.md) clustered file system and pseudo-FS proxy
-  - [Administration](docs/usage/admin.en.md)
-- Performance
-  - [Understanding storage performance](docs/performance/understanding.en.md)
-  - [Theoretical performance](docs/performance/theoretical.en.md)
-  - [Example comparison with Ceph](docs/performance/comparison1.en.md)
-  - [Newer benchmark of Vitastor 1.3.1](docs/performance/bench2.en.md)
+## Bắt đầu nhanh
 
-## Author and License
+### 1. Clone repository
 
-Copyright (c) Vitaliy Filippov (vitalif [at] yourcmc.ru), 2019+
+```bash
+git clone https://github.com/<your-org>/tromcho.net.git
+cd tromcho.net
+```
 
-Join Vitastor Telegram Chat: https://t.me/vitastor
+### 2. Tạo file môi trường
 
-All server-side code (OSD, Monitor and so on) is licensed under the terms of
-Vitastor Network Public License 1.1 (VNPL 1.1), a copyleft license based on
-GNU GPLv3.0 with the additional "Network Interaction" clause which requires
-opensourcing all programs directly or indirectly interacting with Vitastor
-through a computer network and expressly designed to be used in conjunction
-with it ("Proxy Programs"). Proxy Programs may be made public not only under
-the terms of the same license, but also under the terms of any GPL-Compatible
-Free Software License, as listed by the Free Software Foundation.
-This is a stricter copyleft license than the Affero GPL.
+```bash
+cp .env.example .env
+```
 
-Please note that VNPL doesn't require you to open the code of proprietary
-software running inside a VM if it's not specially designed to be used with
-Vitastor.
+Sau đó cập nhật các biến cấu hình cần thiết trong file `.env`.
 
-Basically, you can't use the software in a proprietary environment to provide
-its functionality to users without opensourcing all intermediary components
-standing between the user and Vitastor or purchasing a commercial license
-from the author 😀.
+### 3. Chạy môi trường local
 
-Client libraries (cluster_client and so on) are dual-licensed under the same
-VNPL 1.1 and also GNU GPL 2.0 or later to allow for compatibility with GPLed
-software like QEMU and fio.
+Nếu dự án dùng Docker:
 
-You can find the full text of VNPL-1.1 in the file [VNPL-1.1.txt](VNPL-1.1.txt).
-GPL 2.0 is also included in this repository as [GPL-2.0.txt](GPL-2.0.txt).
+```bash
+docker compose up -d --build
+```
+
+Nếu dự án chạy trực tiếp theo framework, sử dụng lệnh tương ứng của stack hiện tại.
+
+## Quy trình phát triển
+
+- Tạo branch mới từ `main` hoặc `develop`.
+- Đặt tên branch rõ ràng, ví dụ: `feature/homepage-banner`, `fix/login-timeout`.
+- Commit ngắn gọn, đúng ngữ cảnh thay đổi.
+- Tạo Pull Request để review trước khi merge.
+- Không commit file bí mật như `.env`, private key hoặc credential.
+
+## Quy ước commit
+
+Khuyến nghị dùng convention sau:
+
+```text
+feat: thêm chức năng mới
+fix: sửa lỗi
+refactor: tái cấu trúc mã nguồn
+chore: cập nhật tác vụ phụ trợ
+ci: thay đổi pipeline CI/CD
+docs: cập nhật tài liệu
+test: bổ sung hoặc cập nhật kiểm thử
+```
+
+## CI/CD
+
+Repository nên tích hợp các bước tự động sau:
+
+- Lint source code
+- Chạy unit test / integration test
+- Build artifact hoặc Docker image
+- Scan bảo mật dependency/container
+- Deploy tới staging hoặc production theo rule xác định
+
+Ví dụ vị trí cấu hình pipeline:
+
+```text
+.github/workflows/
+```
+
+## Biến môi trường
+
+Không commit file `.env` thật lên GitHub.
+Nên cung cấp `.env.example` với:
+
+- Danh sách biến bắt buộc
+- Giá trị mẫu an toàn
+- Ghi chú ngắn cho từng biến quan trọng
+
+Ví dụ:
+
+```env
+APP_ENV=local
+APP_DEBUG=true
+APP_URL=http://localhost
+DB_HOST=127.0.0.1
+DB_PORT=3306
+DB_NAME=tromcho
+DB_USER=user
+DB_PASSWORD=change_me
+```
+
+## Triển khai
+
+Khuyến nghị tách rõ các môi trường:
+
+- local
+- development
+- staging
+- production
+
+Các thành phần nên được chuẩn hóa khi triển khai:
+
+- Biến môi trường
+- Reverse proxy / web server
+- TLS certificate
+- Database migration
+- Backup strategy
+- Log rotation và monitoring
+
+## Bảo mật
+
+- Không đưa secrets vào source code.
+- Bật branch protection cho nhánh quan trọng.
+- Review dependency định kỳ.
+- Áp dụng nguyên tắc least privilege cho tài khoản deploy.
+- Theo dõi log, audit và cảnh báo bất thường.
+
+## Đóng góp
+
+Khi đóng góp vào repository:
+
+1. Fork hoặc tạo branch làm việc.
+2. Cập nhật mã nguồn theo phạm vi thay đổi.
+3. Kiểm tra local trước khi tạo Pull Request.
+4. Viết mô tả PR rõ ràng: mục tiêu, phạm vi ảnh hưởng, cách kiểm thử.
+
+## Tài liệu nên bổ sung
+
+Repository này nên có thêm các tài liệu sau trong thư mục `docs/`:
+
+- Kiến trúc hệ thống
+- Sơ đồ database
+- Luồng deploy
+- Quy trình backup/restore
+- Hướng dẫn xử lý sự cố
+- Checklist release
+
+## License
+
+Copyright 2026 Trộm Chó chấm Nét
+---

csi/Makefile

@@ -1,4 +1,4 @@
-VITASTOR_VERSION ?= v3.0.10
+VITASTOR_VERSION ?= v3.0.15
 
 all: build push
 

csi/deploy/004-csi-nodeplugin.yaml

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

csi/deploy/007-csi-provisioner.yaml

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

csi/src/config.go

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

debian/changelog

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

debian/rules

@@ -11,6 +11,7 @@ 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

debian/vitastor-build.sh

@@ -37,12 +37,6 @@ 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)

docker/Makefile

@@ -1,4 +1,4 @@
-VITASTOR_VERSION ?= v3.0.10
+VITASTOR_VERSION ?= v3.0.15
 
 all: build push
 

docker/etc/vitastor/docker.conf

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

docs/installation/docker.en.md

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

docs/installation/docker.ru.md

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

docs/installation/source.en.md

@@ -16,8 +16,7 @@
   designated initializers support from C++20
 - CMake
 - jerasure headers and libraries
-- ISA-L, libibverbs and librdmacm headers and libraries (optional)
-- tcmalloc (google-perftools-dev)
+- ISA-L, libibverbs, librdmacm, libnl3 headers and libraries (optional)
 
 ## Basic instructions
 

docs/installation/source.ru.md

@@ -16,8 +16,7 @@
   назначенных инициализаторов (designated initializers) из C++20
 - CMake
 - Заголовки и библиотеки jerasure
-- Опционально - заголовки и библиотеки ISA-L, libibverbs, librdmacm
-- tcmalloc (google-perftools-dev)
+- Опционально - заголовки и библиотеки ISA-L, libibverbs, librdmacm, libnl3
 
 ## Базовая инструкция
 

mon/antietcd_adapter.js

@@ -18,7 +18,7 @@ class AntiEtcdAdapter
                 cluster = cluster ? (''+(cluster||'')).split(/,+/) : [];
             cluster = Object.keys(cluster.reduce((a, url) =>
             {
-                a[url.toLowerCase().replace(/^(https?:\/\/)/, '').replace(/\/.*$/, '')] = true;
+                a[url.toLowerCase().replace(/^(https?:\/\/)?(.*?)(\/.*)?$/, (m, m1, m2) => (m1||'http://')+m2)] = true;
                 return a;
             }, {}));
             const cfg_port = config.antietcd_port;
@@ -26,7 +26,18 @@ class AntiEtcdAdapter
             is_local['0.0.0.0'] = true;
             is_local['::'] = true;
             is_local[''] = true;
-            const selected = cluster.map(s => s.split(':', 2)).filter(ip => is_local[ip[0]] && (!cfg_port || ip[1] == cfg_port));
+            // 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 });
+            }
             if (selected.length > 1)
             {
                 console.error('More than 1 etcd_address matches local IPs, please specify port');
@@ -35,15 +46,16 @@ class AntiEtcdAdapter
             else if (selected.length == 1)
             {
                 const antietcd_config = {
-                    ip: selected[0][0],
-                    port: selected[0][1],
-                    data: config.antietcd_data_file || ((config.antietcd_data_dir || '/var/lib/vitastor') + '/mon_'+selected[0][1]+'.json.gz'),
+                    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'),
                     persist_filter: vitastor_persist_filter({ vitastor_prefix: config.etcd_prefix || '/vitastor' }),
-                    node_id: selected[0][0]+':'+selected[0][1], // node_id = ip:port
-                    cluster: (cluster.length == 1 ? null : cluster.reduce((a, c) => { a[c] = "http://"+c; return a; }, {})),
+                    node_id: cluster[selected[0].idx].replace(/^(https?:\/\/)/, ''), // same as in <cluster> below
+                    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 },
                 };
                 for (const key in config)
                 {

mon/lp_optimizer/lp_optimizer.js

@@ -112,9 +112,10 @@ function make_cyclic(pgs, parity_space)
 {
     if (parity_space > 1)
     {
-        for (const pg in pgs)
+        for (const id in pgs)
         {
-            for (let i = 1; i < pg.size; i++)
+            const pg = pgs[id];
+            for (let i = 1; i < pg.length; i++)
             {
                 const cyclic = [ ...pg.slice(i), ...pg.slice(0, i) ];
                 pgs['pg_'+cyclic.join('_')] = cyclic;

mon/mon.js

@@ -627,7 +627,7 @@ class Mon
                 if (this.state.pg.history[pool_id] &&
                     this.state.pg.history[pool_id][pg])
                 {
-                    pg_history[pg-1] = this.state.pg.history[pool_id][pg];
+                    pg_history[pg-1] = JSON.parse(JSON.stringify(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();
-            }, now-this.next_recheck_at);
+            }, (this.next_recheck_at-now)*1000);
         }
     }
 

mon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitastor-mon",
-  "version": "3.0.10",
+  "version": "3.0.15",
   "description": "Vitastor SDS monitor service",
   "main": "mon-main.js",
   "scripts": {
@@ -9,7 +9,7 @@
   "author": "Vitaliy Filippov",
   "license": "UNLICENSED",
   "dependencies": {
-    "antietcd": "^1.2.4",
+    "antietcd": "^1.3.1",
     "sprintf-js": "^1.1.2",
     "ws": "^7.2.5"
   },

mon/pg_utils.js

@@ -84,7 +84,7 @@ function scale_pg_history(prev_pg_history, prev_pgs, new_pgs)
         finish_pg_history(merged_history[1]);
         for (let i = 0; i < new_pg_count; i++)
         {
-            new_pg_history[i] = { ...merged_history[1] };
+            new_pg_history[i] = JSON.parse(JSON.stringify(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)

node-binding/package.json

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

patches/VitastorPlugin.pm

@@ -366,15 +366,38 @@ sub map_volume
     my $prefix = defined $scfg->{vitastor_prefix} ? $scfg->{vitastor_prefix} : 'pve/';
 
     my ($vtype, $img_name, $vmid) = $class->parse_volname($volname);
-    my $name = $img_name;
+    my $name = $prefix.$img_name;
     $name .= '@'.$snapname if $snapname;
 
     my $mapped = run_cli($scfg, [ 'ls' ], binary => '/usr/bin/vitastor-nbd');
-    my ($kerneldev) = grep { $mapped->{$_}->{image} eq $prefix.$name } keys %$mapped;
-    return $kerneldev if $kerneldev && -b $kerneldev; # already mapped
+    my ($kerneldev) = grep {
+        $mapped->{$_} && $mapped->{$_}->{image} && $mapped->{$_}->{image} eq $name
+    } keys %$mapped;
 
-    $kerneldev = run_cli($scfg, [ 'map', '--image', $prefix.$name ], binary => '/usr/bin/vitastor-nbd', json => 0);
-    return $kerneldev;
+    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";
 }
 
 sub unmap_volume
@@ -383,13 +406,19 @@ 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 ($kerneldev) = grep { $mapped->{$_}->{image} eq $prefix.$name } keys %$mapped;
-    if ($kerneldev && -b $kerneldev)
+
+    my @kerneldevs = grep {
+        $mapped->{$_} && $mapped->{$_}->{image} && $mapped->{$_}->{image} eq $name
+    } keys %$mapped;
+
+    for my $kerneldev (@kerneldevs)
     {
-        run_cli($scfg, [ 'unmap', $kerneldev ], binary => '/usr/bin/vitastor-nbd', json => 0);
+        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 $@;
     }
 
     return 1;
@@ -405,7 +434,13 @@ sub activate_volume
 sub deactivate_volume
 {
     my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_;
-    $class->unmap_volume($storeid, $scfg, $volname, $snapname) if $scfg->{vitastor_nbd};
+
+    # 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);
+
     return 1;
 }
 

patches/cinder-vitastor.py

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

rpm/vitastor-el10.spec

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

rpm/vitastor-el7.spec

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

rpm/vitastor-el8.spec

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

rpm/vitastor-el9.spec

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

src/CMakeLists.txt

@@ -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.10")
+add_definitions(-DVITASTOR_VERSION="3.0.15")
 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})

src/blockstore/blockstore_disk.cpp

@@ -96,6 +96,7 @@ void blockstore_disk_t::parse_config(std::map<std::string, std::string> & config
         (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;
@@ -516,7 +517,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_free)
+int blockstore_disk_t::trim_data(std::function<bool(uint64_t)> is_used)
 {
     if (mock_mode)
     {
@@ -527,7 +528,7 @@ int blockstore_disk_t::trim_data(std::function<bool(uint64_t)> is_free)
     uint64_t discarded = 0;
     for (; i <= block_count; i++)
     {
-        if (i >= block_count || is_free(i))
+        if (i >= block_count || is_used(i))
         {
             if (i > j && (i-j)*data_block_size >= min_discard_size)
             {
@@ -540,17 +541,21 @@ int blockstore_disk_t::trim_data(std::function<bool(uint64_t)> is_free)
                     if (range[0] % discard_granularity)
                         range[0] = range[0] + discard_granularity - (range[0] % discard_granularity);
                     if (range[0] >= range[1])
-                        continue;
-                    range[1] -= range[0];
+                        range[1] = 0;
+                    else
+                        range[1] -= range[0];
                 }
-                r = ioctl(data_fd, BLKDISCARD, &range);
-                if (r != 0)
+                if (range[1] > 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;
+                    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];
                 }
-                discarded += range[1];
             }
             j = i+1;
         }

src/blockstore/blockstore_disk.h

@@ -59,6 +59,8 @@ 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;
 
@@ -81,7 +83,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_free);
+    int trim_data(std::function<bool(uint64_t)> is_used);
 
     inline uint64_t dirty_dyn_size(uint64_t offset, uint64_t len)
     {

src/blockstore/blockstore_flush.cpp

@@ -174,14 +174,18 @@ 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:
@@ -196,6 +200,7 @@ 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:
@@ -259,11 +264,9 @@ resume_1:
         if (wr->type() == BS_HEAP_SMALL_WRITE ||
             wr->type() == BS_HEAP_INTENT_WRITE && bs->dsk.csum_block_size > bs->dsk.bitmap_granularity)
         {
-            auto res = bs->prepare_read(read_vec, cur_obj, wr, 0, bs->dsk.data_block_size,
+            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)
@@ -273,30 +276,53 @@ 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++;
-    if (bs->log_level > 10)
+    for (i = 0; i < read_vec.size(); i++)
     {
-        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);
+        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);
     }
     overwrite_start = overwrite_end = 0;
     if (read_vec.size() > 0)
@@ -336,6 +362,13 @@ 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--;
@@ -349,10 +382,7 @@ resume_4:
         if (res == ENOENT)
         {
             // Abort compaction
-            flusher->flushing.erase(cur_oid);
-            bs->heap->unlock_entry(cur_oid);
-            flusher->active_flushers--;
-            goto resume_0;
+            goto abort_compact;
         }
         if (res == EAGAIN)
         {
@@ -381,14 +411,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_PADDED)) // FIXME Shit, simplify these flags
+            !(read_vec[i].copy_flags & COPY_BUF_COALESCED))
         {
             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++;
         }
@@ -399,6 +429,17 @@ 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
@@ -408,12 +449,14 @@ resume_11:
     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;
     }
@@ -422,6 +465,7 @@ resume_11:
     if (res == EBUSY)
     {
         // Abort compaction, object is already overwritten by something else
+        flusher->active_flushers--;
         flusher->flushing.erase(cur_oid);
         goto resume_0;
     }
@@ -586,13 +630,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 add_punch_holes and then write the block to disk
+    // Modified, we should 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)
+    if (bs->dsk.csum_block_size <= bs->dsk.bitmap_granularity || compact_info.do_delete)
     {
         return true;
     }
@@ -699,6 +743,67 @@ resume_1:
     return true;
 }
 
+void journal_flusher_co::init_fsync_data()
+{
+    cur_sync = flusher->data_syncs.begin();
+    if (cur_sync == flusher->data_syncs.end() || cur_sync->ready_count > 0)
+    {
+        cur_sync = flusher->data_syncs.emplace(cur_sync);
+    }
+    cur_sync->member_count++;
+}
+
+bool journal_flusher_co::fsync_data(int wait_base)
+{
+    if (wait_state == wait_base)
+        goto resume_0;
+    else if (wait_state == wait_base+1)
+        goto resume_1;
+    else if (wait_state == wait_base+2)
+        goto resume_2;
+    else if (wait_state == wait_base+3)
+        goto resume_3;
+    cur_sync->ready_count++;
+resume_0:
+    if (cur_sync->ready_count < cur_sync->member_count)
+    {
+        wait_state = wait_base;
+        return false;
+    }
+    if (!cur_sync->sent)
+    {
+        // Sync batch is ready. Do it.
+        await_sqe(1);
+        data->iov = { 0 };
+        data->callback = simple_callback_w;
+        io_uring_prep_fsync(sqe, bs->dsk.data_fd, IORING_FSYNC_DATASYNC);
+        cur_sync->sent = true;
+        wait_count++;
+resume_2:
+        if (wait_count > 0)
+        {
+            wait_state = wait_base+2;
+            return false;
+        }
+        cur_sync->done = true;
+        // Wake up other flushers
+        bs->ringloop->wakeup();
+    }
+resume_3:
+    if (!cur_sync->done)
+    {
+        wait_state = wait_base+3;
+        return false;
+    }
+    cur_sync->done_count++;
+    if (cur_sync->done_count >= cur_sync->member_count)
+    {
+        flusher->data_syncs.erase(cur_sync);
+        cur_sync = flusher->data_syncs.end();
+    }
+    return true;
+}
+
 bool journal_flusher_co::fsync_meta(int wait_base)
 {
     if (wait_state == wait_base)        goto resume_0;

src/blockstore/blockstore_flush.h

@@ -25,6 +25,15 @@ 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
@@ -58,6 +67,7 @@ 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;
 
@@ -68,6 +78,8 @@ 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);
@@ -88,6 +100,7 @@ class journal_flusher_t
 
     robin_hood::unordered_flat_set<object_id> flushing;
     int active_flushers = 0;
+    std::list<flusher_data_sync_t> data_syncs;
     int wanting_meta_fsync = 0;
     bool fsyncing_meta = false;
     int syncing_buffer = 0;

src/blockstore/blockstore_heap.cpp

@@ -22,12 +22,13 @@
 
 #define HEAP_INFLIGHT_DONE 1
 #define HEAP_INFLIGHT_COMPACTABLE 2
-#define HEAP_INFLIGHT_COMPACTED 4
+#define HEAP_INFLIGHT_OVERWRITE 4
 #define HEAP_INFLIGHT_GC 8
 #define HEAP_INFLIGHT_EXPLICIT 16
 
 #define IMAP_MALLOC_LOW_BITS ((size_t)0x0F)
 #define IMAP_MAX_LOW 16
+#define POSTPONE_INSERT_COUNT 10
 
 #define list_item_overhead(a) (((a) + sizeof(heap_list_item_t) - sizeof(heap_entry_t) + sizeof(void*) + 15) & ~15)
 
@@ -121,31 +122,33 @@ uint32_t heap_entry_t::get_size(blockstore_heap_t *heap)
     }
     if (type() == BS_HEAP_SMALL_WRITE || type() == BS_HEAP_INTENT_WRITE)
     {
+        if (size < sizeof(heap_small_write_t))
+            return heap->get_small_entry_size(0, 0);
         return heap->get_small_entry_size(small().offset, small().len);
     }
     return heap->get_simple_entry_size();
 }
 
-bool heap_entry_t::is_overwrite()
+bool heap_entry_t::is_overwrite() const
 {
     return ((entry_type & ~BS_HEAP_GARBAGE) == (BS_HEAP_BIG_WRITE|BS_HEAP_STABLE) ||
         (entry_type & ~BS_HEAP_GARBAGE) == (BS_HEAP_BIG_INTENT|BS_HEAP_STABLE) ||
         (entry_type & ~BS_HEAP_GARBAGE) == (BS_HEAP_DELETE|BS_HEAP_STABLE));
 }
 
-bool heap_entry_t::is_compactable()
+bool heap_entry_t::is_compactable() const
 {
     return !is_overwrite() && (entry_type & BS_HEAP_STABLE) ||
         (entry_type & ~BS_HEAP_GARBAGE) == BS_HEAP_COMMIT ||
         (entry_type & ~BS_HEAP_GARBAGE) == BS_HEAP_ROLLBACK;
 }
 
-bool heap_entry_t::is_before(heap_entry_t *other)
+bool heap_entry_t::is_before(const heap_entry_t *other) const
 {
     return lsn < other->lsn || lsn == other->lsn && !is_overwrite() && other->is_overwrite();
 }
 
-bool heap_entry_t::is_garbage()
+bool heap_entry_t::is_garbage() const
 {
     return (entry_type & BS_HEAP_GARBAGE);
 }
@@ -363,14 +366,11 @@ corrupted_object:
                     return EDOM;
                 }
             }
-            if (((wr->entry_type & BS_HEAP_TYPE) == BS_HEAP_SMALL_WRITE ||
-                (wr->entry_type & BS_HEAP_TYPE) == BS_HEAP_INTENT_WRITE) &&
-                wr->size < sizeof(heap_small_write_t))
+            if (wr->size != wr->get_size(this))
             {
-                // Small writes require accessing offset & len to calculate correct length,
-                // so require at least sizeof(heap_small_write_t) for them
-                fprintf(stderr, "Error: entry %jx:%jx v%ju has invalid size in metadata block %u at %u (%u < min %zu bytes)\n",
-                    wr->inode, wr->stripe, wr->version, block_num, block_offset, wr->size, sizeof(heap_small_write_t));
+                // Check entry size
+                fprintf(stderr, "Error: entry %jx:%jx v%ju has invalid size in metadata block %u at %u (%u != %u bytes)\n",
+                    wr->inode, wr->stripe, wr->version, block_num, block_offset, wr->size, wr->get_size(this));
                 goto corrupted_object;
             }
             if (wr->entry_type == BS_HEAP_COMMIT && !wr->version)
@@ -408,6 +408,13 @@ corrupted_object:
                     wr->inode, wr->stripe, wr->version, wr->big_intent().offset, wr->big_intent().len);
                 goto corrupted_object;
             }
+            if ((wr->type() == BS_HEAP_BIG_INTENT || wr->type() == BS_HEAP_BIG_WRITE) &&
+                wr->big().block_num >= dsk->block_count)
+            {
+                fprintf(stderr, "Error: big_write or big_intent entry %jx:%jx v%ju block_num is too large: %u > %lu. Metadata is incompatible with current parameters. ",
+                    wr->inode, wr->stripe, wr->version, wr->big_intent().block_num, dsk->block_count);
+                goto corrupted_object;
+            }
             handle_write(block_num, wr);
             block_offset += wr->size;
         }
@@ -434,7 +441,7 @@ int blockstore_heap_t::load_blocks(uint64_t disk_offset, uint64_t size, uint8_t
             next_lsn = wr->lsn;
         }
         entries_loaded++;
-        loaded_list_items.push_back(li);
+        insert_list_items(&li, 1, true);
         modify_alloc(block_num, [&](heap_block_info_t & inf)
         {
             if (!inf.entries.size())
@@ -540,18 +547,26 @@ bool blockstore_heap_t::validate_object(heap_entry_t *obj)
 
 void blockstore_heap_t::finish_load()
 {
-    if (loaded_list_items.size())
+    if (postponed_items.size())
     {
-        // Sort everything and load in correct order
-        std::sort(loaded_list_items.begin(), loaded_list_items.end(), [this](const heap_list_item_t* a, const heap_list_item_t* b)
+        // Sort "postponed" items and load in batches
+        std::sort(postponed_items.begin(), postponed_items.end(), [this](const heap_list_item_t* a, const heap_list_item_t* b)
         {
-            return a->entry.lsn < b->entry.lsn;
+            return a->entry.inode < b->entry.inode || a->entry.inode == b->entry.inode &&
+                (a->entry.stripe < b->entry.stripe || a->entry.stripe == b->entry.stripe &&
+                    !a->entry.is_before(&b->entry)); // object ASC, lsn DESC
         });
-        for (auto & li: loaded_list_items)
+        size_t s = 0, e, n = postponed_items.size();
+        for (e = 1; e <= n; e++)
         {
-            insert_list_item(li);
+            if (e >= n || postponed_items[e]->entry.inode != postponed_items[s]->entry.inode ||
+                postponed_items[e]->entry.stripe != postponed_items[s]->entry.stripe)
+            {
+                insert_list_items(postponed_items.data()+s, e-s, false);
+                s = e;
+            }
         }
-        loaded_list_items.clear();
+        postponed_items.clear();
     }
 }
 
@@ -564,26 +579,11 @@ void blockstore_heap_t::fill_recheck_queue()
             inode_map_iterate(ip.second, [&](heap_list_item_t *li)
             {
                 auto obj = &li->entry;
-                // Add object to recheck queue
-                if (obj->type() == BS_HEAP_INTENT_WRITE || obj->type() == BS_HEAP_BIG_INTENT)
+                // Recheck only the latest intent_write (if after completed_lsn) or a series of small_writes
+                if ((obj->type() == BS_HEAP_INTENT_WRITE || obj->type() == BS_HEAP_BIG_INTENT)
+                    && obj->lsn > completed_lsn || obj->type() == BS_HEAP_SMALL_WRITE)
                 {
-                    // Recheck only the latest intent_write
-                    if (obj->lsn > completed_lsn)
-                    {
-                        // Do not recheck if it's already marked as completed in the superblock
-                        recheck_queue.push_back(obj);
-                    }
-                }
-                else
-                {
-                    // Or recheck a series of small_writes
-                    for (auto wr = obj; wr && wr->type() == BS_HEAP_SMALL_WRITE; wr = prev(wr))
-                    {
-                        if (wr->small().len > 0)
-                        {
-                            recheck_queue.push_back(wr);
-                        }
-                    }
+                    recheck_queue.push_back(obj);
                 }
             });
         }
@@ -593,6 +593,11 @@ void blockstore_heap_t::fill_recheck_queue()
 int blockstore_heap_t::mark_used_blocks()
 {
     int res = 0;
+    std::vector<heap_list_item_t*> used_by;
+    if (dsk->skip_double_claim)
+    {
+        used_by.resize(dsk->block_count);
+    }
     for (auto & pgp: block_index)
     {
         for (auto & ip: pgp.second)
@@ -646,17 +651,45 @@ int blockstore_heap_t::mark_used_blocks()
                     {
                         if (is_data_used(wr->big_location(this)))
                         {
-                            fprintf(stderr, "Error: double-claimed data block %u, second time by %jx:%jx l%ju\n",
-                                wr->big().block_num, wr->inode, wr->stripe, wr->lsn);
-                            res = EDOM;
-                            return;
+                            if (dsk->skip_double_claim)
+                            {
+                                // There is a BUG currently:
+                                // Sometimes (under unknown conditions) deletion entries are removed from the disk
+                                // earlier than previous big_writes.
+                                // Until it's fixed, we provide a way to ignore such objects on start.
+                                auto prev_li = used_by[wr->big().block_num];
+                                assert(prev_li);
+                                // Newer LSN must be trusted. Remove the older object.
+                                fprintf(stderr, "Block %u is double-claimed by entries %jx:%jx l%ju and %jx:%jx l%ju\n",
+                                    wr->big().block_num, prev_li->entry.inode, prev_li->entry.stripe, prev_li->entry.lsn, wr->inode, wr->stripe, wr->lsn);
+                                if (init_erase_double_claim(prev_li, li))
+                                {
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                fprintf(stderr, "Error: double-claimed data block %u, second time by %jx:%jx l%ju\n",
+                                    wr->big().block_num, wr->inode, wr->stripe, wr->lsn);
+                                res = EDOM;
+                                return;
+                            }
+                        }
+                        if (dsk->skip_double_claim)
+                        {
+                            // Record the object which uses the data block
+                            used_by[wr->big().block_num] = li;
                         }
                         use_data(wr->inode, wr->big_location(this));
                     }
-                    if (wr->is_compactable() && !added)
+                    if (wr->is_compactable())
                     {
-                        compact_queue.push_back((object_id){ .inode = wr->inode, .stripe = wr->stripe });
-                        added = true;
+                        to_compact_count++;
+                        if (!added)
+                        {
+                            compact_queue.push_back((object_id){ .inode = wr->inode, .stripe = wr->stripe });
+                            added = true;
+                        }
                     }
                     if (wr->is_overwrite())
                     {
@@ -666,6 +699,11 @@ int blockstore_heap_t::mark_used_blocks()
             });
         }
     }
+    for (auto li: init_erase_items)
+    {
+        unlink_list_item(li);
+    }
+    init_erase_items.clear();
     if (dsk->gc_on_start)
     {
         recheck_full_gc();
@@ -673,6 +711,121 @@ int blockstore_heap_t::mark_used_blocks()
     return res;
 }
 
+void blockstore_heap_t::init_free_bad_entry(heap_entry_t *wr)
+{
+    if (wr->type() == BS_HEAP_SMALL_WRITE)
+    {
+        free_buffer_area(wr->inode, wr->small().location, wr->small().len);
+    }
+    else if (wr->type() == BS_HEAP_BIG_WRITE || wr->type() == BS_HEAP_BIG_INTENT)
+    {
+        free_data(wr->inode, wr->big_location(this));
+    }
+}
+
+void blockstore_heap_t::init_erase_bad_entry(heap_list_item_t *li)
+{
+    modify_alloc(li->block_num, [&](heap_block_info_t & inf)
+    {
+        for (size_t i = 0; i < inf.entries.size(); i++)
+        {
+            if (inf.entries[i] == li)
+            {
+                inf.entries.erase(inf.entries.begin()+i);
+                break;
+            }
+        }
+        inf.used_space -= li->entry.size;
+        inf.garbage_space -= (li->entry.is_garbage() ? li->entry.size : 0);
+    });
+    recheck_modified_blocks.insert(li->block_num);
+}
+
+bool blockstore_heap_t::init_erase_double_claim(heap_list_item_t *prev_li, heap_list_item_t *cur_li)
+{
+    bool erase_prev = false;
+    bool erase_cur = false;
+    if (prev_li->entry.lsn < cur_li->entry.lsn)
+    {
+        erase_prev = true;
+        auto latest_li = prev_li;
+        while (latest_li->next)
+        {
+            latest_li = latest_li->next;
+        }
+        if (latest_li->entry.lsn >= cur_li->entry.lsn)
+        {
+            // LSN ranges intersect, erase both
+            erase_cur = true;
+        }
+    }
+    else
+    {
+        erase_cur = true;
+        auto latest_li = cur_li;
+        while (latest_li->next)
+        {
+            latest_li = latest_li->next;
+        }
+        if ((latest_li->entry.inode != prev_li->entry.inode ||
+            latest_li->entry.stripe != prev_li->entry.stripe) &&
+            latest_li->entry.lsn >= prev_li->entry.lsn)
+        {
+            // LSN ranges intersect, erase both
+            erase_prev = true;
+        }
+    }
+    if (erase_prev)
+    {
+        fprintf(stderr, "Erasing object %jx:%jx due to double-claim\n", prev_li->entry.inode, prev_li->entry.stripe);
+        auto erase_li = prev_li;
+        while (erase_li->next)
+        {
+            erase_li = erase_li->next;
+        }
+        bool overwritten = false;
+        while (erase_li)
+        {
+            auto prev_erase_li = erase_li->prev;
+            if (!overwritten)
+            {
+                init_free_bad_entry(&erase_li->entry);
+                overwritten = erase_li->entry.is_overwrite();
+            }
+            init_erase_bad_entry(erase_li);
+            // Can't erase (mutate map) while iterating, so postpone it
+            init_erase_items.push_back(erase_li);
+            erase_li = prev_erase_li;
+        }
+    }
+    if (erase_cur)
+    {
+        fprintf(stderr, "Erasing object %jx:%jx due to double-claim\n", cur_li->entry.inode, cur_li->entry.stripe);
+        auto erase_li = cur_li->next;
+        while (erase_li)
+        {
+            // Only newer entries are marked as used
+            auto next_erase_li = erase_li->next;
+            init_free_bad_entry(&erase_li->entry);
+            init_erase_bad_entry(erase_li);
+            // Can't erase (mutate map) while iterating, so postpone it
+            init_erase_items.push_back(erase_li);
+            erase_li = next_erase_li;
+        }
+        erase_li = cur_li;
+        // Older ones are not
+        while (erase_li)
+        {
+            auto prev_erase_li = erase_li->prev;
+            init_erase_bad_entry(erase_li);
+            // Can't erase (mutate map) while iterating, so postpone it
+            init_erase_items.push_back(erase_li);
+            erase_li = prev_erase_li;
+        }
+    }
+    return erase_cur;
+}
+
 void blockstore_heap_t::recheck_full_gc()
 {
     uint32_t block_num = 0;
@@ -713,80 +866,99 @@ void blockstore_heap_t::recheck_full_gc()
     }
 }
 
-void blockstore_heap_t::recheck_buffer(heap_entry_t *cwr, uint8_t *buf)
+void blockstore_heap_t::recheck_drop_entries(heap_entry_t *obj, heap_entry_t *bad_wr)
 {
-    auto free_entry = [&](heap_list_item_t *li)
+    // write entry is invalid, erase it and all newer entries
+    int bad_count = 1;
+    for (auto wr = obj; wr && wr != bad_wr; wr = prev(wr))
     {
-        uint32_t block_num = li->block_num;
-        auto wr_size = li->entry.size;
-        if (li->entry.is_garbage())
-        {
-            garbage_entries--;
-            garbage_memory -= list_item_overhead(wr_size);
-        }
-        live_entries--;
-        live_memory -= list_item_overhead(wr_size);
-        free(li);
-        modify_alloc(block_num, [&](heap_block_info_t & inf)
-        {
-            inf.used_space -= wr_size;
-            bool found = false;
-            for (auto it = inf.entries.begin(); it != inf.entries.end(); it++)
-            {
-                if (*it == li)
-                {
-                    found = true;
-                    inf.entries.erase(it);
-                    break;
-                }
-            }
-            assert(found);
-        });
-        recheck_modified_blocks.insert(block_num);
-    };
-    if (cwr->is_garbage())
-    {
-        // already freed after rechecking one of the previous small_write entries
-        free_entry(list_item(cwr));
+        bad_count++;
     }
-    else if (!calc_checksums(cwr, buf, false))
+    auto prev_wr = prev(bad_wr);
+    if (prev_wr)
     {
-        // write entry is invalid, erase it and mark newer entries with garbage bit
-        auto & pg_idx = block_index[get_pg_id(cwr->inode, cwr->stripe)];
-        auto & inode_idx = pg_idx[cwr->inode];
-        heap_inode_map_t::iterator li_it;
-        heap_list_item_t *li = NULL;
-        inode_map_get(inode_idx, li_it, li, cwr->stripe);
-        int rolled_back = 1;
-        while (li && cwr != &li->entry)
+        fprintf(stderr, "Notice: %u unfinished %s to %jx:%jx v%ju since good lsn %ju, rolling back\n",
+            bad_count, bad_count > 1 ? "writes" : "write", obj->inode, obj->stripe, obj->version, prev_wr->lsn);
+    }
+    else
+    {
+        fprintf(stderr, "Notice: the whole object %jx:%jx only has unfinished writes, rolling back\n", obj->inode, obj->stripe);
+    }
+    auto li = list_item(obj);
+    while (li && prev_wr != &li->entry)
+    {
+        auto prev = li->prev;
+        assert(li->entry.type() == bad_wr->type());
+        init_erase_bad_entry(li);
+        unlink_list_item(li);
+        li = prev;
+    }
+}
+
+void blockstore_heap_t::recheck_start_reads(heap_recheck_state_t *st)
+{
+    if (st->sent_reads >= st->total_reads)
+        return;
+    while (recheck_in_progress < recheck_queue_depth)
+    {
+        auto wr = st->next_wr;
+        st->next_wr = prev(st->next_wr);
+        uint64_t loc = 0, len = 0;
+        bool from_data = false;
+        if (wr->type() == BS_HEAP_SMALL_WRITE)
         {
-            assert(li->entry.entry_type == cwr->entry_type);
-            auto prev = li->prev;
-            li->next = li->prev = NULL;
-            if (!li->entry.is_garbage())
-            {
-                garbage_entries++;
-                garbage_memory += list_item_overhead(li->entry.size);
-                li->entry.set_garbage();
-            }
-            li = prev;
-            rolled_back++;
+            loc = wr->small().location;
+            len = wr->small().len;
         }
-        assert(li);
-        if (li->prev)
+        else if (wr->type() == BS_HEAP_BIG_INTENT)
         {
-            fprintf(stderr, "Notice: %u unfinished %s to %jx:%jx v%ju since lsn %ju, rolling back\n",
-                rolled_back, rolled_back > 1 ? "writes" : "write", cwr->inode, cwr->stripe, li->prev->entry.version, li->entry.lsn);
-            inode_map_replace(inode_idx, li_it, li->prev);
-            li->prev->next = NULL;
+            auto & bi = wr->big_intent();
+            loc = (uint64_t)bi.block_num * dsk->data_block_size + bi.offset;
+            len = bi.len;
+            from_data = true;
         }
         else
         {
-            fprintf(stderr, "Notice: the whole object %jx:%jx only has unfinished writes, rolling back\n",
-                cwr->inode, cwr->stripe);
-            inode_map_erase(pg_idx, inode_idx, li_it, li);
+            assert(wr->type() == BS_HEAP_INTENT_WRITE);
+            auto prev_wr = prev(wr);
+            while (prev_wr && prev_wr->entry_type == wr->entry_type)
+            {
+                // Skip other intent_writes
+                prev_wr = prev(prev_wr);
+            }
+            if (!prev_wr || prev_wr->entry_type != (BS_HEAP_BIG_WRITE | (wr->entry_type & BS_HEAP_STABLE)) &&
+                prev_wr->entry_type != (BS_HEAP_BIG_INTENT | (wr->entry_type & BS_HEAP_STABLE)))
+            {
+                fprintf(stderr, "Error: intent_write entry %jx:%jx v%ju l%ju is not written over a big_write\n",
+                    wr->inode, wr->stripe, wr->version, wr->lsn);
+                exit(1);
+            }
+            loc = wr->small().offset + prev_wr->big_location(this);
+            len = wr->small().len;
+            from_data = true;
         }
-        free_entry(li);
+        uint8_t *buf = (uint8_t*)memalign_or_die(MEM_ALIGNMENT, len);
+        st->sent_reads++;
+        recheck_in_progress++;
+        recheck_pending_reads--;
+        bool is_last = st->sent_reads >= st->total_reads;
+        recheck_cb(from_data, loc, len, buf, [this, st, wr, buf]()
+        {
+            st->checked_reads++;
+            if (!calc_checksums(wr, buf, false))
+                st->bad_wr = !st->bad_wr || st->bad_wr->lsn > wr->lsn ? wr : st->bad_wr;
+            if (st->checked_reads >= st->total_reads)
+            {
+                if (st->bad_wr)
+                    recheck_drop_entries(st->obj, st->bad_wr);
+                recheck_states.erase(st->obj);
+            }
+            free(buf);
+            recheck_in_progress--;
+            recheck_small_writes(NULL, 0);
+        });
+        if (is_last)
+            break;
     }
 }
 
@@ -809,70 +981,47 @@ bool blockstore_heap_t::recheck_small_writes(std::function<void(bool is_data, ui
         recheck_queue_depth = queue_depth;
     }
     in_recheck = true;
+    while (recheck_pending_reads > 0 && recheck_in_progress < recheck_queue_depth)
+    {
+        for (auto & sp: recheck_states)
+            recheck_start_reads(&sp.second);
+    }
     while (recheck_queue.size() > 0 && recheck_in_progress < recheck_queue_depth)
     {
-        heap_entry_t *wr = recheck_queue.front();
+        heap_entry_t *obj = recheck_queue.front();
         recheck_queue.pop_front();
-        bool from_data = false;
-        uint64_t loc = 0;
-        uint32_t len = 0;
-        if (wr->type() == BS_HEAP_INTENT_WRITE)
+        if (obj->type() == BS_HEAP_SMALL_WRITE && buffer_area)
         {
-            auto prev_wr = prev(wr);
-            while (prev_wr && prev_wr->entry_type == wr->entry_type)
+            // Check this object synchronously
+            heap_entry_t *bad_wr = NULL;
+            for (auto wr = obj; wr && wr->type() == BS_HEAP_SMALL_WRITE; wr = prev(wr))
             {
-                // Skip other intent_writes
-                prev_wr = prev(prev_wr);
+                fprintf(stderr, "Notice: rechecking %jx:%jx l%ju - %u bytes at %ju in buffer area\n",
+                    wr->inode, wr->stripe, wr->lsn, wr->small().len, wr->small().location);
+                if (!calc_checksums(wr, buffer_area + wr->small().location, false))
+                    bad_wr = wr;
             }
-            if (!prev_wr || prev_wr->entry_type != (BS_HEAP_BIG_WRITE | (wr->entry_type & BS_HEAP_STABLE)) &&
-                prev_wr->entry_type != (BS_HEAP_BIG_INTENT | (wr->entry_type & BS_HEAP_STABLE)))
-            {
-                fprintf(stderr, "Error: intent_write entry %jx:%jx v%ju l%ju is not written over a big_write\n",
-                    wr->inode, wr->stripe, wr->version, wr->lsn);
-                exit(1);
-            }
-            loc = wr->small().offset + prev_wr->big_location(this);
-            len = wr->small().len;
-            from_data = true;
-        }
-        else if (wr->type() == BS_HEAP_BIG_INTENT)
-        {
-            auto & bi = wr->big_intent();
-            loc = (uint64_t)bi.block_num * dsk->data_block_size + bi.offset;
-            len = bi.len;
-            from_data = true;
+            if (bad_wr)
+                recheck_drop_entries(obj, bad_wr);
         }
         else
         {
-            assert(wr->type() == BS_HEAP_SMALL_WRITE);
-            loc = wr->small().location;
-            len = wr->small().len;
-        }
-        if (log_level > 5)
-        {
-            fprintf(stderr, "Notice: rechecking %jx:%jx l%ju - %u bytes at %ju in %s area\n",
-                wr->inode, wr->stripe, wr->lsn, len, loc, from_data ? "data" : "buffer");
-        }
-        if (!from_data && buffer_area)
-        {
-            recheck_buffer(wr, buffer_area+loc);
-        }
-        else
-        {
-            recheck_in_progress++;
-            uint8_t *buf = (uint8_t*)memalign_or_die(MEM_ALIGNMENT, len);
-            recheck_cb(from_data, loc, len, buf, [this, wr, buf]()
-            {
-                recheck_buffer(wr, buf);
-                free(buf);
-                recheck_in_progress--;
-                recheck_small_writes(NULL, 0);
-            });
+            // Recheck will be asynchronous. Create state and start it
+            auto & st = recheck_states[obj];
+            st.obj = obj;
+            st.next_wr = obj;
+            st.total_reads = 1;
+            if (obj->type() == BS_HEAP_SMALL_WRITE)
+                for (auto wr = prev(obj); wr && wr->type() == BS_HEAP_SMALL_WRITE; wr = prev(wr))
+                    st.total_reads++;
+            recheck_pending_reads += st.total_reads;
+            recheck_start_reads(&st);
         }
     }
     in_recheck = false;
     if (!recheck_queue.size() && !recheck_in_progress)
     {
+        assert(!recheck_states.size());
         auto cb = std::move(recheck_cb);
         recheck_queue_depth = 0;
         if (cb)
@@ -1004,7 +1153,7 @@ bool blockstore_heap_t::calc_block_checksums(uint32_t *block_csums, uint8_t *bit
                 while (pos < end && pos < block_end && !(bitmap[pos/dsk->bitmap_granularity/8] & (1 << ((pos/dsk->bitmap_granularity) % 8))))
                     pos += dsk->bitmap_granularity;
                 // zero padding at the beginning or at the end of the block is not counted
-                if (pos > prev && prev > 0 && pos < block_end)
+                if (pos > prev && prev > blk_start && pos < block_end)
                     block_crc = crc32c_pad(block_crc, NULL, 0, pos-prev, 0);
                 prev = pos;
                 while (pos < end && pos < block_end && (bitmap[pos/dsk->bitmap_granularity/8] & (1 << ((pos/dsk->bitmap_granularity) % 8))))
@@ -1328,43 +1477,51 @@ int blockstore_heap_t::allocate_entry(uint32_t entry_size, uint32_t *block_num,
     return 0;
 }
 
-void blockstore_heap_t::insert_list_item(heap_list_item_t *li)
+void blockstore_heap_t::insert_list_items(heap_list_item_t** v, size_t count, bool postpone)
 {
-    auto & inode_idx = block_index[get_pg_id(li->entry.inode, li->entry.stripe)][li->entry.inode];
+    auto wr = &v[0]->entry;
+    auto & inode_idx = block_index[get_pg_id(wr->inode, wr->stripe)][wr->inode];
     heap_inode_map_t::iterator li_it;
     heap_list_item_t *old_head = NULL;
     if (inode_idx)
-        inode_map_get(inode_idx, li_it, old_head, li->entry.stripe);
-    if (old_head && !old_head->entry.is_before(&li->entry))
+        inode_map_get(inode_idx, li_it, old_head, wr->stripe);
+    heap_list_item_t *next_li = NULL;
+    heap_list_item_t *prev_li = old_head;
+    int skips = 0;
+    // Merge entry array and inode_idx linked list (both sorted in newest first order)
+    for (size_t i = 0; i < count; i++)
     {
         // BIG_WRITE may be inserted into the middle of the sequence during compaction
         // and it overrides SMALL_WRITEs and COMMITs with the same LSN
         // However, all entries of other types (say DELETE) override previous ones
-        auto next_li = old_head;
-        auto prev_li = old_head->prev;
+        auto li = v[i];
         while (prev_li && !prev_li->entry.is_before(&li->entry))
         {
             next_li = prev_li;
             prev_li = prev_li->prev;
+            skips++;
+        }
+        if (postpone && skips > POSTPONE_INSERT_COUNT)
+        {
+            postponed_items.push_back(li);
+            return;
+        }
+        if (next_li == NULL)
+        {
+            // Replace the latest entry pointer
+            if (old_head)
+                inode_map_replace(inode_idx, li_it, li);
+            else
+                inode_map_put(inode_idx, li);
         }
         // Insert <li> between <next_li> and <prev_li>
+        li->next = next_li;
+        if (next_li)
+            next_li->prev = li;
         li->prev = prev_li;
         if (prev_li)
             prev_li->next = li;
-        next_li->prev = li;
-        li->next = next_li;
-    }
-    else
-    {
-        li->prev = old_head;
-        li->next = NULL;
-        if (old_head)
-        {
-            old_head->next = li;
-            inode_map_replace(inode_idx, li_it, li);
-        }
-        else
-            inode_map_put(inode_idx, li);
+        next_li = li;
     }
 }
 
@@ -1394,9 +1551,9 @@ int blockstore_heap_t::add_entry(uint32_t wr_size, uint32_t *modified_block,
     // Remember the object as dirty and remove older entries when this block is written and fsynced
     push_inflight_lsn(next_lsn, new_wr,
         (explicit_complete ? HEAP_INFLIGHT_EXPLICIT : 0) |
-        (new_wr->is_overwrite() ? HEAP_INFLIGHT_COMPACTED : 0) |
+        (new_wr->is_overwrite() ? HEAP_INFLIGHT_OVERWRITE : 0) |
         (new_wr->is_compactable() ? HEAP_INFLIGHT_COMPACTABLE : 0));
-    insert_list_item(li);
+    insert_list_items(&li, 1, false);
     li->block_num = block_num;
     new_wr->size = wr_size;
     new_wr->crc32c = new_wr->calc_crc32c();
@@ -1428,10 +1585,22 @@ int blockstore_heap_t::add_small_write(object_id oid, heap_entry_t **obj_ptr, ui
         wr->small().location = location;
         if (bitmap)
             memcpy(wr->get_ext_bitmap(this), bitmap, dsk->clean_entry_bitmap_size);
-        else if (obj)
-            memcpy(wr->get_ext_bitmap(this), obj->get_ext_bitmap(this), dsk->clean_entry_bitmap_size);
         else
-            memset(wr->get_ext_bitmap(this), 0, dsk->clean_entry_bitmap_size);
+        {
+            bool found = false;
+            iterate_with_stable(obj, UINT64_MAX, [&](heap_entry_t *old_wr, bool stable)
+            {
+                if (old_wr->get_ext_bitmap(this))
+                {
+                    found = true;
+                    memcpy(wr->get_ext_bitmap(this), old_wr->get_ext_bitmap(this), dsk->clean_entry_bitmap_size);
+                    return false;
+                }
+                return true;
+            });
+            if (!found)
+                memset(wr->get_ext_bitmap(this), 0, dsk->clean_entry_bitmap_size);
+        }
         calc_checksums(wr, (uint8_t*)data, true);
         *obj_ptr = wr;
     });
@@ -1592,6 +1761,7 @@ int blockstore_heap_t::punch_holes(heap_entry_t *wr, uint8_t *new_bitmap, uint8_
     *modified_block = block_num;
     memcpy(wr->get_int_bitmap(this), new_bitmap, dsk->clean_entry_bitmap_size);
     memcpy(wr->get_checksums(this), new_csums, dsk->data_block_size/dsk->csum_block_size*(dsk->data_csum_type & 0xFF));
+    wr->crc32c = wr->calc_crc32c();
     return 0;
 }
 
@@ -1894,7 +2064,10 @@ void blockstore_heap_t::iterate_with_stable(heap_entry_t *obj, uint64_t max_lsn,
     {
         if (old_wr->type() == BS_HEAP_ROLLBACK)
         {
-            rollback_version = old_wr->version;
+            if (rollback_version > old_wr->version)
+            {
+                rollback_version = old_wr->version;
+            }
         }
         else if (old_wr->type() == BS_HEAP_COMMIT)
         {
@@ -1946,7 +2119,10 @@ heap_compact_t blockstore_heap_t::iterate_compaction(heap_entry_t *obj, uint64_t
                 res.compact_lsn = wr->lsn;
                 res.compact_version = wr->version;
             }
-            rollback_version = wr->version;
+            if (rollback_version > wr->version)
+            {
+                rollback_version = wr->version;
+            }
             continue;
         }
         if (wr->type() == BS_HEAP_COMMIT && wr->lsn <= fsynced_lsn)
@@ -2124,7 +2300,7 @@ void blockstore_heap_t::use_data(inode_t inode, uint64_t location)
 {
     auto sh_it = pool_shard_settings.find(INODE_POOL(inode));
     if (sh_it != pool_shard_settings.end() && sh_it->second.no_inode_stats)
-        inode = (INODE_POOL(inode) << POOL_ID_BITS);
+        inode = INODE_WITH_POOL(INODE_POOL(inode), 0);
     assert(!data_alloc->get(location / dsk->data_block_size));
     data_alloc->set(location / dsk->data_block_size, true);
     inode_space_stats[inode] += dsk->data_block_size;
@@ -2135,7 +2311,7 @@ void blockstore_heap_t::free_data(inode_t inode, uint64_t location)
 {
     auto sh_it = pool_shard_settings.find(INODE_POOL(inode));
     if (sh_it != pool_shard_settings.end() && sh_it->second.no_inode_stats)
-        inode = (INODE_POOL(inode) << POOL_ID_BITS);
+        inode = INODE_WITH_POOL(INODE_POOL(inode), 0);
     assert(data_alloc->get(location / dsk->data_block_size));
     data_alloc->set(location / dsk->data_block_size, false);
     auto sp_it = inode_space_stats.find(inode);
@@ -2172,7 +2348,8 @@ void blockstore_heap_t::use_buffer_area(inode_t inode, uint64_t location, uint64
         return;
     }
     assert(!(size % dsk->bitmap_granularity));
-    buffer_alloc->use(location / dsk->bitmap_granularity, size / dsk->bitmap_granularity);
+    bool ok = buffer_alloc->use(location / dsk->bitmap_granularity, size / dsk->bitmap_granularity);
+    assert(ok);
     buffer_area_used_space += size;
 }
 
@@ -2214,7 +2391,7 @@ void blockstore_heap_t::get_meta_block(uint32_t block_num, uint8_t *buffer)
     }
 }
 
-void blockstore_heap_t::fill_block_empty_space(uint8_t *buffer, uint32_t pos)
+void blockstore_heap_t::fill_block_empty_space(uint8_t *buffer, uint64_t pos)
 {
     if (pos > dsk->meta_block_size)
     {
@@ -2302,7 +2479,7 @@ uint64_t blockstore_heap_t::get_garbage_memory()
 void blockstore_heap_t::push_inflight_lsn(uint64_t lsn, heap_entry_t *wr, uint64_t flags)
 {
     uint64_t next_inf = first_inflight_lsn + inflight_lsn.size();
-    if (flags & (HEAP_INFLIGHT_COMPACTABLE|HEAP_INFLIGHT_COMPACTED))
+    if (flags & (HEAP_INFLIGHT_COMPACTABLE|HEAP_INFLIGHT_OVERWRITE))
     {
         to_compact_count++;
     }
@@ -2369,7 +2546,7 @@ void blockstore_heap_t::mark_lsn_fsynced(uint64_t lsn)
 void blockstore_heap_t::apply_inflight(heap_inflight_lsn_t & inflight)
 {
     auto wr = inflight.wr;
-    if (inflight.flags & HEAP_INFLIGHT_COMPACTED)
+    if (inflight.flags & HEAP_INFLIGHT_OVERWRITE)
     {
         // Mark previous entries as garbage, sequentially
         mark_garbage_up_to(wr);
@@ -2390,6 +2567,22 @@ void blockstore_heap_t::apply_inflight(heap_inflight_lsn_t & inflight)
 }
 
 void blockstore_heap_t::remove_list_item(heap_list_item_t *li)
+{
+    if (!li->next)
+    {
+        // The last freed entry must be a deletion
+        assert(!li->prev);
+        assert((li->entry.entry_type & ~BS_HEAP_GARBAGE) == (BS_HEAP_DELETE|BS_HEAP_STABLE));
+    }
+    else if (!li->prev && li->next->entry.entry_type == (BS_HEAP_DELETE|BS_HEAP_STABLE))
+    {
+        // free BS_HEAP_DELETEs when all previous entries are also freed
+        mark_garbage(li->next->block_num, &li->next->entry, UINT32_MAX);
+    }
+    unlink_list_item(li);
+}
+
+void blockstore_heap_t::unlink_list_item(heap_list_item_t *li)
 {
     auto prev = li->prev;
     auto next = li->next;
@@ -2399,25 +2592,20 @@ void blockstore_heap_t::remove_list_item(heap_list_item_t *li)
     }
     if (!next)
     {
-        // The last freed entry must be a deletion
-        assert(!prev);
         auto wr = &li->entry;
-        assert(wr->entry_type == BS_HEAP_DELETE|BS_HEAP_STABLE);
         auto & pg_idx = block_index[get_pg_id(wr->inode, wr->stripe)];
         auto & inode_idx = pg_idx[wr->inode];
         heap_inode_map_t::iterator li_it;
         heap_list_item_t *old_li = NULL;
         inode_map_get(inode_idx, li_it, old_li, wr->stripe);
-        inode_map_erase(pg_idx, inode_idx, li_it, old_li);
+        if (!prev)
+            inode_map_erase(pg_idx, inode_idx, li_it, old_li);
+        else
+            inode_map_replace(inode_idx, li_it, prev);
     }
     else
     {
         next->prev = prev;
-        if (!prev && next->entry.entry_type == (BS_HEAP_DELETE|BS_HEAP_STABLE))
-        {
-            // free BS_HEAP_DELETEs when all previous entries are also freed
-            mark_garbage(next->block_num, &next->entry, UINT32_MAX);
-        }
     }
     if (li->entry.is_garbage())
     {

src/blockstore/blockstore_heap.h

@@ -57,11 +57,11 @@ struct __attribute__((__packed__)) heap_entry_t
     inline heap_small_write_t& small() { return *(heap_small_write_t*)this; }
     inline heap_big_write_t& big() { return *(heap_big_write_t*)this; }
     inline heap_big_intent_t& big_intent() { return *(heap_big_intent_t*)this; }
-    bool is_garbage();
+    bool is_garbage() const;
     void set_garbage();
-    bool is_overwrite();
-    bool is_compactable();
-    bool is_before(heap_entry_t *other);
+    bool is_overwrite() const;
+    bool is_compactable() const;
+    bool is_before(const heap_entry_t *other) const;
     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);
@@ -158,6 +158,16 @@ 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,
@@ -208,9 +218,12 @@ class blockstore_heap_t
 
     bool marked_used_blocks = false;
     bool recheck_queue_filled = false;
-    std::vector<heap_list_item_t*> loaded_list_items;
+    std::vector<heap_list_item_t*> postponed_items;
+    std::vector<heap_list_item_t*> init_erase_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;
@@ -219,7 +232,12 @@ 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);
@@ -227,8 +245,9 @@ 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_item(heap_list_item_t *li);
+    void insert_list_items(heap_list_item_t** v, size_t count, bool postpone);
     void remove_list_item(heap_list_item_t *li);
+    void unlink_list_item(heap_list_item_t *li);
     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);
@@ -343,7 +362,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, uint32_t pos);
+    void fill_block_empty_space(uint8_t *buffer, uint64_t pos);
     uint32_t get_meta_block_used_space(uint32_t block_num);
 
     // get space usage statistics

src/blockstore/blockstore_impl.cpp

@@ -101,6 +101,7 @@ 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];
@@ -138,7 +139,13 @@ 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
-                wr_st = continue_sync(op);
+                if (!has_unfinished_sync)
+                {
+                    wr_st = continue_sync(op);
+                    has_unfinished_sync = (wr_st != 2);
+                }
+                else
+                    wr_st = 0;
             }
             else if (op->opcode == BS_OP_STABLE || op->opcode == BS_OP_ROLLBACK)
             {
@@ -154,9 +161,7 @@ void blockstore_impl_t::loop()
                     wr_st = 2;
                 }
                 else
-                {
                     wr_st = 0;
-                }
             }
             if (wr_st == 2)
             {

src/blockstore/blockstore_impl.h

@@ -117,9 +117,12 @@ public:
 
     journal_flusher_t *flusher;
     int write_iodepth = 0;
-    int inflight_big = 0;
     int intent_write_counter = 0;
-    bool fsyncing_data = false;
+    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 live = false, queue_stall = false;
     ring_loop_i *ringloop = NULL;

src/blockstore/blockstore_init.cpp

@@ -10,7 +10,6 @@
 #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();\
@@ -23,14 +22,15 @@ 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)
+void blockstore_init_meta::handle_event(ring_data_t *data, int buf_num, const char *op)
 {
-    if (data->res < 0)
+    if (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)
-        );
+        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
+        ));
     }
     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); };
+    data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read metadata header"); };
     io_uring_prep_readv(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
     bs->ringloop->submit();
     submitted++;
@@ -72,25 +72,19 @@ resume_1:
     }
     if (is_zero((uint64_t*)bs->meta_superblock, bs->dsk.meta_block_size))
     {
-        {
-            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();
-        }
+        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();
         if (bs->readonly)
         {
             printf("Skipping metadata initialization because blockstore is readonly\n");
@@ -98,21 +92,8 @@ 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
     {
@@ -153,9 +134,17 @@ 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)
+    if (bs->dsk.inmemory_journal && !zero_on_init)
     {
         // Read buffer area
         printf("Reading buffered data\n");
@@ -167,7 +156,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); };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read buffer area"); };
             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++;
@@ -186,7 +175,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)
+    if (next_offset < bs->dsk.meta_area_size && submitted == 0 && (!zero_on_init || !bs->readonly))
     {
         // Submit one read
         for (int i = 0; i < 2; i++)
@@ -203,12 +192,15 @@ 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);
@@ -224,11 +216,14 @@ resume_4:
         if (bufs[i].state == INIT_META_READ_DONE)
         {
             // Handle result
-            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;
+            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;
+            }
             bufs[i].state = 0;
             bs->ringloop->wakeup();
         }
@@ -238,25 +233,9 @@ resume_4:
         wait_state = 4;
         return 1;
     }
-    // metadata read finished
+    // metadata read/clear 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;
@@ -337,6 +316,44 @@ 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(),

src/blockstore/blockstore_init.h

@@ -17,6 +17,7 @@ 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;
@@ -29,7 +30,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);
+    void handle_event(ring_data_t *data, int buf_num, const char *op);
 public:
     blockstore_init_meta(blockstore_impl_t *bs);
     int loop();

src/blockstore/blockstore_mock.cpp

@@ -0,0 +1,113 @@
+// 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;
+}

src/blockstore/blockstore_mock.h

@@ -0,0 +1,39 @@
+// 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;
+};

src/blockstore/blockstore_stable.cpp

@@ -16,6 +16,7 @@ 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++)
     {
@@ -27,6 +28,7 @@ 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);
@@ -36,6 +38,12 @@ 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())
@@ -45,11 +53,6 @@ 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();

src/blockstore/blockstore_sync.cpp

@@ -9,6 +9,7 @@ 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)
@@ -28,9 +29,12 @@ 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) +
-        (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);
+    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);
     if (ringloop->space_left() < n)
     {
         return false;
@@ -59,7 +63,8 @@ bool blockstore_impl_t::submit_fsyncs(int & wait_count)
         data->callback = cb;
         wait_count++;
     }
-    if (unsynced_buffer_write_count > 0 && !dsk.disable_journal_fsync && dsk.meta_fd != dsk.journal_fd)
+    if (unsynced_buffer_write_count > 0 && !dsk.disable_journal_fsync &&
+        (!unsynced_meta_write_count || dsk.journal_fd != dsk.meta_fd))
     {
         // fsync buffer
         io_uring_sqe *sqe = get_sqe();
@@ -70,7 +75,9 @@ bool blockstore_impl_t::submit_fsyncs(int & wait_count)
         data->callback = cb;
         wait_count++;
     }
-    if (unsynced_data_write_count > 0 && !dsk.disable_data_fsync && dsk.data_fd != dsk.meta_fd && dsk.data_fd != dsk.journal_fd)
+    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))
     {
         // fsync data
         io_uring_sqe *sqe = get_sqe();
@@ -104,9 +111,11 @@ 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;
     }
-    PRIV(op)->modified_block = heap->get_completed_lsn();
+    assert(!PRIV(op)->lsn);
+    PRIV(op)->lsn = 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;
@@ -118,6 +127,6 @@ resume_1:
         return 1;
     }
 resume_2:
-    heap->mark_lsn_fsynced(PRIV(op)->modified_block);
+    heap->mark_lsn_fsynced(PRIV(op)->lsn);
     return 2;
 }

src/blockstore/blockstore_write.cpp

@@ -37,6 +37,7 @@ 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
     );
@@ -177,14 +178,18 @@ 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;
     }
@@ -264,6 +269,7 @@ 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++;
         }
@@ -294,8 +300,6 @@ again:
         goto resume_10;
     else if (op_state == 11)
         goto resume_11;
-    else if (op_state == 12)
-        goto resume_12;
     else
     {
         // In progress
@@ -314,38 +318,44 @@ 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)
     {
-        // fsync data in a batch
-resume_11:
-        if (inflight_big > 0)
+        // 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();
+resume_11:
+        if (data_fsync_cur < PRIV(op)->lsn)
         {
-            PRIV(op)->op_state = 11;
             return 1;
         }
-        if (fsyncing_data)
+        if (PRIV(op)->lsn > data_fsync_sent)
         {
-resume_12:
-            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)
             {
-                PRIV(op)->op_state = 12;
-                return 1;
-            }
-            goto resume_4;
+                if (fs > data_fsync_done)
+                {
+                    data_fsync_done = fs;
+                    ringloop->wakeup();
+                }
+            };
+            data_fsync_sent = data_fsync_cur;
         }
-        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)
+        if (PRIV(op)->lsn > data_fsync_done)
         {
-            fsyncing_data = false;
-            handle_write_event(data, op);
-        };
-        PRIV(op)->pending_ops++;
-        PRIV(op)->op_state = 3;
-        return 1;
+            return 1;
+        }
+        PRIV(op)->lsn = 0;
     }
 resume_4:
     {
@@ -453,6 +463,7 @@ resume_10:
     BS_SUBMIT_GET_SQE(sqe, data);
     data->iov = (struct iovec){ op->buf, op->len };
     data->callback = [this, op](ring_data_t *data) { handle_write_event(data, op); };
+    assert(PRIV(op)->location + op->offset <= dsk.block_count*dsk.data_block_size);
     io_uring_prep_writev(sqe, dsk.data_fd, &data->iov, 1, dsk.data_offset + PRIV(op)->location + op->offset);
     if (dsk.use_atomic_flag)
         sqe->rw_flags = RWF_ATOMIC;

src/blockstore/multilist.cpp

@@ -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);
+    assert(count > 1 && count < 0x80000000 && count >= maxn);
     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");
 }
 
-void multilist_alloc_t::use(uint32_t pos, uint32_t size)
+bool multilist_alloc_t::use(uint32_t pos, uint32_t size)
 {
     assert(pos+size <= count && size > 0);
     if (sizes[pos] <= 0)
@@ -182,7 +182,8 @@ void multilist_alloc_t::use(uint32_t pos, uint32_t size)
         else
             while (start > 0 && !sizes[start])
                 start--;
-        assert(sizes[start] >= size);
+        if (sizes[start] < size+(pos-start))
+            return false;
         use_full(start);
         uint32_t full = sizes[start];
         sizes[pos-1] = -pos+start;
@@ -199,7 +200,8 @@ void multilist_alloc_t::use(uint32_t pos, uint32_t size)
     }
     else
     {
-        assert(sizes[pos] >= size);
+        if (sizes[pos] < size)
+            return false;
         use_full(pos);
         if (sizes[pos] > size)
         {
@@ -214,12 +216,13 @@ void 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);
+    assert(prevsize > 0);
     assert(nexts[pos]);
     uint32_t pi = (prevsize < maxn ? prevsize : maxn)-1;
     if (heads[pi] == pos+1)

src/blockstore/multilist.h

@@ -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);
-    void use(uint32_t pos, uint32_t size);
+    bool use(uint32_t pos, uint32_t size);
     void do_free(uint32_t pos);
     void free(uint32_t pos);
     void verify();

src/blockstore/ondisk_formats.h

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

src/blockstore/v1/flush.cpp

@@ -71,6 +71,11 @@ 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;
@@ -384,6 +389,7 @@ 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];
@@ -511,6 +517,31 @@ 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++)
@@ -520,6 +551,7 @@ 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
                 );
@@ -633,6 +665,7 @@ resume_2:
         }
         // All done
         flusher->active_flushers--;
+        copy_count = 0; // used by is_mutated()...
         wait_state = 0;
         goto resume_0;
     }
@@ -749,6 +782,7 @@ 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
     );
@@ -813,35 +847,21 @@ 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: got %08x, expected %08x\n",
+                    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",
                         cur.oid.inode, cur.oid.stripe, old_clean_ver, old_clean_loc, bad_block, calc_csum, stored_csum);
-                    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;
-                    }
+                    assert(!(bad_block % bs->dsk.csum_block_size) && bad_block < bs->dsk.data_block_size);
+                    mangle_csum_blocks.insert(bad_block);
                 });
             }
             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): 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) during flush: 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);
-                    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;
-                    }
+                    assert(!(bad_block % bs->dsk.csum_block_size) && bad_block < bs->dsk.data_block_size);
+                    mangle_csum_blocks.insert(bad_block);
                 });
             }
         }
@@ -950,6 +970,11 @@ 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()
@@ -1086,7 +1111,8 @@ 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
+            ((v[last].offset+v[last].len-1) / bs->dsk.csum_block_size + 1) * bs->dsk.csum_block_size,
+            0, bs->dsk.data_block_size
         );
     }
     else if (fill_incomplete && clean_init_bitmap)
@@ -1116,6 +1142,7 @@ 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 :)
@@ -1347,7 +1374,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)
+        if (cur_sync->state == 0)
         {
             if (flusher->syncing_flushers >= flusher->active_flushers || !flusher->flush_queue.size())
             {
@@ -1375,6 +1402,12 @@ 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)

src/blockstore/v1/flush.h

@@ -66,6 +66,7 @@ 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;
 
@@ -123,6 +124,7 @@ 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();

src/blockstore/v1/impl.cpp

@@ -6,11 +6,12 @@
 
 namespace v1 {
 
-blockstore_impl_t::blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd)
+blockstore_impl_t::blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd, bool mock_mode)
 {
     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;
@@ -35,6 +36,11 @@ 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)

src/blockstore/v1/impl.h

@@ -30,6 +30,8 @@
 
 //#define BLOCKSTORE_DEBUG
 
+struct bs_test_t;
+
 namespace v1 {
 
 #include "journal.h"
@@ -96,7 +98,7 @@ struct blockstore_op_private_t
     int op_state;
 
     // Read
-    uint64_t clean_block_used;
+    uint64_t clean_loc_used;
     std::vector<copy_buffer_t> read_vec;
 
     // Sync, write
@@ -122,6 +124,7 @@ typedef uint64_t pool_pg_id_t;
 
 class blockstore_impl_t: public blockstore_i
 {
+    friend struct ::bs_test_t;
     blockstore_disk_t dsk;
 
     /******* OPTIONS *******/
@@ -220,6 +223,7 @@ 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,
@@ -230,7 +234,8 @@ 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, uint64_t read_offset, uint64_t read_end);
+        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);
     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);
@@ -281,7 +286,7 @@ class blockstore_impl_t: public blockstore_i
 
 public:
 
-    blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd);
+    blockstore_impl_t(blockstore_config_t & config, ring_loop_i *ringloop, timerfd_manager_t *tfd, bool mock_mode = false);
     ~blockstore_impl_t();
 
     void parse_config(blockstore_config_t & config);

src/blockstore/v1/init.cpp

@@ -1,6 +1,7 @@
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: VNPL-1.1 (see README.md for details)
 
+#include "str_util.h"
 #include "impl.h"
 #include "internal.h"
 
@@ -30,14 +31,15 @@ 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)
+void blockstore_init_meta::handle_event(ring_data_t *data, int buf_num, const char *op)
 {
-    if (data->res < 0)
+    if (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)
-        );
+        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
+        ));
     }
     if (buf_num >= 0)
     {
@@ -65,10 +67,11 @@ 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 = { metadata_buffer, (size_t)bs->dsk.meta_block_size };
-    data->callback = [this](ring_data_t *data) { handle_event(data, -1); };
+    data->iov = { hdr, (size_t)bs->dsk.meta_block_size };
+    data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read metadata header"); };
     io_uring_prep_readv(sqe, bs->dsk.meta_fd, &data->iov, 1, bs->dsk.meta_offset);
     bs->ringloop->submit();
     submitted++;
@@ -78,24 +81,8 @@ resume_1:
         wait_state = 1;
         return 1;
     }
-    if (iszero((uint64_t*)metadata_buffer, bs->dsk.meta_block_size / sizeof(uint64_t)))
+    if (iszero((uint64_t*)hdr, 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");
@@ -103,25 +90,11 @@ 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(
@@ -223,12 +196,15 @@ 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);
                 }
@@ -256,7 +232,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); };
+                data->callback = [this, i](ring_data_t *data) { handle_event(data, i, "write metadata"); };
                 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;
@@ -285,7 +261,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); };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1, "read metadata"); };
             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++;
@@ -302,7 +278,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); };
+            data->callback = [this](ring_data_t *data) { handle_event(data, -1, "write metadata"); };
             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++;
@@ -317,27 +293,64 @@ 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;
     }
-    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;
-        }
-    }
+    free(hdr);
+    hdr = NULL;
     return 0;
 }
 
@@ -345,6 +358,8 @@ 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++)
@@ -455,21 +470,21 @@ blockstore_init_journal::blockstore_init_journal(blockstore_impl_t *bs)
     };
 }
 
-void blockstore_init_journal::handle_event(ring_data_t *data1)
+void blockstore_init_journal::handle_event(ring_data_t *data)
 {
-    if (data1->res <= 0)
+    if (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)
-        );
+        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
+        ));
     }
     done.push_back({
         .buf = submitted_buf,
         .pos = journal_pos,
-        .len = (uint64_t)data1->res,
+        .len = (uint64_t)data->res,
     });
-    journal_pos += data1->res;
+    journal_pos += data->res;
     if (journal_pos >= bs->journal.len)
     {
         // Continue from the beginning

src/blockstore/v1/init.h

@@ -16,7 +16,9 @@ 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;
@@ -29,7 +31,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);
+    void handle_event(ring_data_t *data, int buf_num, const char *op);
 public:
     blockstore_init_meta(blockstore_impl_t *bs);
     int loop();

src/blockstore/v1/journal.cpp

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

src/blockstore/v1/read.cpp

@@ -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 + (blk_begin/dsk.csum_block_size -
-                        item_start/dsk.csum_block_size) * (dsk.data_csum_type & 0xFF)),
+                    .csum_buf = (!csum ? NULL : (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_block_used = 1;
+                PRIV(read_op)->clean_loc_used = UINT64_MAX;
             }
             rv.insert(rv.begin() + pos, el);
             fulfilled += el.len;
@@ -167,7 +167,8 @@ 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, uint64_t read_offset, uint64_t read_end)
+    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)
 {
     if (read_end == read_offset)
         return 0;
@@ -175,10 +176,38 @@ 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, clean_entry_bitmap,
+        if (read_range_fulfilled(rv, fulfilled, read_buf, from_journal ? NULL : 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))
         {
@@ -190,7 +219,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, clean_entry_bitmap,
+                !read_range_fulfilled(rv, fulfilled, read_buf, from_journal ? NULL : 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))
             {
@@ -202,8 +231,10 @@ 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 clean_entry_bitmap if we're reading clean data from the journal
-                .csum_buf = from_journal ? clean_entry_bitmap : NULL,
+                // 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,
                 .dyn_data = dyn_data,
             });
             if (dyn_data)
@@ -226,6 +257,11 @@ 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;
@@ -323,7 +359,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_flags = COPY_BUF_DATA|COPY_BUF_COALESCED,
                     .offset = cur_start,
                     .len = lim_end-cur_start,
                 });
@@ -361,10 +397,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_pos + IOV_MAX < n_iov)
+        if (n_pos > 0 || n_iov > IOV_MAX)
         {
             uint32_t d_len = 0;
-            for (int i = 0; i < IOV_MAX; i++)
+            for (int i = 0; i < n_cur; i++)
                 d_len += iov[n_pos+i].iov_len;
             data->iov.iov_len = d_len;
             d_pos += d_len;
@@ -376,7 +412,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_block_used = 1;
+        PRIV(op)->clean_loc_used = UINT64_MAX;
     }
     return true;
 }
@@ -402,7 +438,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_block_used = 0;
+    PRIV(read_op)->clean_loc_used = 0;
     auto & rv = PRIV(read_op)->read_vec;
     uint64_t result_version = 0;
     if (dirty_found)
@@ -515,26 +551,50 @@ 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
-    if (dsk.csum_block_size > dsk.bitmap_granularity)
+    release_clean(read_op);
+    for (auto & vec: rv)
     {
-        for (auto & vec: rv)
+        if ((vec.copy_flags & COPY_BUF_CSUM_FILL) && vec.buf)
         {
-            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;
-            }
+            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,
@@ -598,11 +658,15 @@ 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);
+            (uint8_t*)read_op->buf, read_op->offset, read_op->offset+read_op->len, item_start, item_end);
         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;
@@ -615,7 +679,7 @@ bool blockstore_impl_t::fulfill_clean_read(blockstore_op_t *read_op, uint64_t &
                 return false;
             }
         }
-        PRIV(read_op)->clean_block_used = req > 0;
+        PRIV(read_op)->clean_loc_used = req > 0 ? UINT64_MAX : 0;
     }
     else if (from_journal)
     {
@@ -665,6 +729,10 @@ 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));
@@ -679,13 +747,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_block_used)
+    if (PRIV(read_op)->clean_loc_used == UINT64_MAX)
     {
         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_block_used = clean_loc;
+        PRIV(read_op)->clean_loc_used = clean_loc + 1;
     }
     return true;
 }
@@ -725,12 +793,18 @@ 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 = (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)
+            uint8_t bit = 1;
+            if (clean_entry_bitmap)
             {
-                pos += dsk.bitmap_granularity;
-                bmp_pos++;
+                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++;
+                }
             }
+            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)
@@ -807,7 +881,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(dyn_data, dyn_data + dsk.clean_entry_bitmap_size, offset, iov, n_iov, bad_block_cb);
+        return verify_padded_checksums(NULL, dyn_data, offset, iov, n_iov, bad_block_cb);
     clean_loc = (clean_loc / dsk.data_block_size) * dsk.data_block_size;
     if (!dyn_data)
     {
@@ -835,7 +909,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 = rv.size()-1; i >= 0 && (rv[i].copy_flags & COPY_BUF_CSUM_FILL); i--)
+                for (int i = 0; i < rv.size(); i++)
                 {
                     if (rv[i].copy_flags & COPY_BUF_META_BLOCK)
                     {
@@ -845,8 +919,41 @@ void blockstore_impl_t::handle_read_event(ring_data_t *data, blockstore_op_t *op
                         rv[i].buf = NULL;
                         continue;
                     }
-                    struct iovec *iov = (struct iovec*)((uint8_t*)rv[i].buf + (rv[i].len & 0xFFFFFFFF));
-                    int n_iov = rv[i].len >> 32;
+                    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 };
+                    }
                     bool ok = true;
                     if (rv[i].copy_flags & COPY_BUF_JOURNAL)
                     {
@@ -944,23 +1051,7 @@ void blockstore_impl_t::handle_read_event(ring_data_t *data, blockstore_op_t *op
                 meta_block = NULL;
             }
         }
-        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);
-                }
-            }
-        }
+        release_clean(op);
         if (!journal.inmemory)
         {
             // Release journal sector usage

src/blockstore/v1/stable.cpp

@@ -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[dirty_it->first.oid.inode >> (64-POOL_ID_BITS)])
+                        if (no_inode_stats.find(dirty_it->first.oid.inode >> (64-POOL_ID_BITS)) != no_inode_stats.end())
                             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[dirty_it->first.oid.inode >> (64-POOL_ID_BITS)])
+                    if (no_inode_stats.find(dirty_it->first.oid.inode >> (64-POOL_ID_BITS)) != no_inode_stats.end())
                         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)

src/blockstore/v1/write.cpp

@@ -368,9 +368,9 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op)
         }
         data->iov.iov_len = op->len + stripe_offset + stripe_end; // to check it in the callback
         data->callback = [this, op](ring_data_t *data) { handle_write_event(data, op); };
-        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
-        );
+        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);
         PRIV(op)->pending_ops = 1;
         if (!(dirty_it->second.state & BS_ST_INSTANT))
         {
@@ -495,9 +495,8 @@ 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); };
-            io_uring_prep_writev(
-                sqe2, dsk.journal_fd, &data2->iov, 1, journal.offset + journal.next_free
-            );
+            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);
             PRIV(op)->pending_ops++;
         }
         else

src/client/CMakeLists.txt

@@ -3,6 +3,22 @@ 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")
@@ -11,24 +27,32 @@ set(MSGR_RDMACM "")
 if (RDMACM_LIBRARIES)
 	set(MSGR_RDMACM "msgr_rdmacm.cpp")
 endif (RDMACM_LIBRARIES)
-add_library(vitastor_common STATIC
-	../util/epoll_manager.cpp etcd_state_client.cpp messenger.cpp ../util/addr_util.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}
+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}
 )
-target_link_libraries(vitastor_common pthread)
-target_compile_options(vitastor_common PUBLIC -fPIC)
+target_link_libraries(vitastor_net pthread vitastor_common)
+target_compile_options(vitastor_net 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
 	vitastor_c.cpp
 )
 set_target_properties(vitastor_client PROPERTIES PUBLIC_HEADER "client/vitastor_c.h")
 target_link_libraries(vitastor_client
-	vitastor_common
+	vitastor_net
 	vitastor_cli
 	${LIBURING_LIBRARIES}
 	${IBVERBS_LIBRARIES}
@@ -52,9 +76,6 @@ if (${WITH_FIO})
 		../util/rw_blocking.cpp
 		../util/addr_util.cpp
 	)
-	target_link_libraries(fio_vitastor_sec
-		tcmalloc_minimal
-	)
 endif (${WITH_FIO})
 
 # vitastor-nbd
@@ -98,10 +119,13 @@ endif (${WITH_QEMU})
 add_executable(test_cluster_client
 	EXCLUDE_FROM_ALL
 	../test/test_cluster_client.cpp
-	pg_states.cpp osd_ops.cpp cluster_client.cpp cluster_client_list.cpp cluster_client_wb.cpp msgr_op.cpp ../test/mock/messenger.cpp msgr_stop.cpp
-	etcd_state_client.cpp ../util/timerfd_manager.cpp ../util/addr_util.cpp ../util/str_util.cpp ../util/json_util.cpp ../../json11/json11.cpp
+	cluster_client.cpp
+	cluster_client_list.cpp
+	cluster_client_wb.cpp
+	../test/mock/messenger.cpp
+	etcd_state_client_mock.cpp
 )
-target_compile_definitions(test_cluster_client PUBLIC -D__MOCK__)
+target_link_libraries(test_cluster_client vitastor_common ${LIBURING_LIBRARIES})
 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)

src/client/cluster_client.cpp

@@ -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)
+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)
 {
     wb = new writeback_cache_t();
 
@@ -53,23 +53,23 @@ cluster_client_t::cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd
     };
     msgr.parse_config(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 = 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.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();
+    st_cli->load_global_config();
 
     scrap_buffer_size = SCRAP_BUFFER_SIZE;
     scrap_buffer = malloc_or_die(scrap_buffer_size);
@@ -469,7 +469,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();
@@ -482,8 +482,8 @@ void cluster_client_t::on_load_config_hook(json11::Json::object & etcd_global_co
         client_hostname = new_hostname;
     }
     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,7 +584,7 @@ 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)
         {
@@ -612,7 +612,7 @@ void cluster_client_t::on_change_pool_config_hook()
 
 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 +630,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 +641,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();
     }
 }
@@ -936,8 +936,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;
@@ -960,8 +960,8 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
     }
     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)
+        auto ino_it = st_cli->inode_config.find(op->inode);
+        if (ino_it != st_cli->inode_config.end() && ino_it->second.readonly)
         {
             op->retval = -EROFS;
             auto cb = std::move(op->callback);
@@ -972,15 +972,15 @@ 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())
+        auto ino_it = st_cli->inode_config.find(op->inode);
+        if (ino_it != st_cli->inode_config.end())
         {
             int chain_size = 0;
-            while (ino_it != st_cli.inode_config.end() && ino_it->second.parent_id)
+            while (ino_it != st_cli->inode_config.end() && ino_it->second.parent_id)
             {
                 // 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())
+                    chain_size > st_cli->inode_config.size())
                 {
                     op->retval = -EINVAL;
                     auto cb = std::move(op->callback);
@@ -995,7 +995,7 @@ bool cluster_client_t::check_rw(cluster_op_t *op)
                     break;
                 }
                 chain_size++;
-                ino_it = st_cli.inode_config.find(ino_it->second.parent_id);
+                ino_it = st_cli->inode_config.find(ino_it->second.parent_id);
             }
         }
     }
@@ -1014,7 +1014,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,28 +1119,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);
+            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 &&
+                ino_it != st_cli->inode_config.end() && ino_it->second.parent_id &&
                 INODE_POOL(ino_it->second.parent_id) == INODE_POOL(op->cur_inode))
             {
                 // Check for loops - FIXME check it in etcd_state_client
                 if (ino_it->second.parent_id == op->inode ||
-                    skipped > st_cli.inode_config.size())
+                    skipped > st_cli->inode_config.size())
                 {
                     op->retval = -EINVAL;
                     erase_op(op);
                     return 1;
                 }
                 skipped++;
-                ino_it = st_cli.inode_config.find(ino_it->second.parent_id);
+                ino_it = st_cli->inode_config.find(ino_it->second.parent_id);
             }
-            if (ino_it != st_cli.inode_config.end() &&
+            if (ino_it != st_cli->inode_config.end() &&
                 ino_it->second.parent_id &&
                 ino_it->second.parent_id != op->inode)
             {
@@ -1154,7 +1161,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)
@@ -1164,7 +1171,7 @@ resume_2:
         erase_op(op);
         return 1;
     }
-    else if (op->retval != 0 && !(op->flags & OP_FLUSH_BUFFER) &&
+    else if (op->retval != 0 && op->opcode != OSD_OP_SYNC && !(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)
@@ -1240,7 +1247,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;
@@ -1339,7 +1346,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;
@@ -1358,7 +1365,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;
@@ -1382,7 +1389,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 &&
@@ -1413,8 +1420,8 @@ int cluster_client_t::try_send(cluster_op_t *op, int i, std::function<void(osd_o
             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){
@@ -1446,7 +1453,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;
         }
     }
@@ -1630,13 +1637,6 @@ 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 +1648,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
     );

src/client/cluster_client.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include "messenger.h"
-#include "etcd_state_client.h"
+#include "etcd_state_client_http.h"
 
 #define DEFAULT_CLIENT_MAX_DIRTY_BYTES 32*1024*1024
 #define DEFAULT_CLIENT_MAX_DIRTY_OPS 1024
@@ -83,9 +83,6 @@ class writeback_cache_t;
 // FIXME: Split into public and private interfaces
 class __attribute__((visibility("default"))) cluster_client_t
 {
-#ifdef __MOCK__
-public:
-#endif
     timerfd_manager_t *tfd = NULL;
     ring_loop_t *ringloop = NULL;
 
@@ -134,7 +131,7 @@ public:
     bool msgr_initialized = false;
 
 public:
-    etcd_state_client_t st_cli;
+    std::unique_ptr<etcd_state_client_t> st_cli;
 
     osd_messenger_t msgr;
     void init_msgr();
@@ -142,7 +139,8 @@ public:
     json11::Json::object cli_config, file_config, etcd_global_config;
     json11::Json::object config;
 
-    cluster_client_t(ring_loop_t *ringloop, timerfd_manager_t *tfd, json11::Json config);
+    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();
     void execute(cluster_op_t *op);
     void execute_raw(osd_num_t osd_num, osd_op_t *op);
@@ -155,15 +153,9 @@ 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);
 
-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);
 
@@ -204,4 +196,5 @@ protected:
     osd_num_t select_nearest_osd(const std::vector<osd_num_t> & osds);
 
     friend class writeback_cache_t;
+    friend class cluster_client_test_t;
 };

src/client/cluster_client_list.cpp

@@ -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

src/client/cluster_client_real.cpp

@@ -0,0 +1,11 @@
+// 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));
+}

src/client/cluster_client_wb.cpp

@@ -88,6 +88,11 @@ 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);
@@ -126,6 +131,7 @@ 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;
             }
@@ -160,6 +166,7 @@ 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,
@@ -244,12 +251,13 @@ void writeback_cache_t::copy_write(cluster_op_t *op, int state, uint64_t new_flu
             writeback_queue_size--;
         }
     }
-    if (!is_del)
+    if (!is_del && op->len > 0)
     {
         uint64_t pos = 0, len = op->len, iov_idx = 0;
-        while (len > 0 && iov_idx < op->iov.count)
+        while (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++;
@@ -443,7 +451,7 @@ void writeback_cache_t::start_writebacks(cluster_client_t *cli, int count)
         started++;
         assert(writeback_queue_size > 0);
         writeback_queue_size--;
-        writeback_bytes -= off - from_it->first.stripe;
+        writeback_bytes -= (is_del ? 0 : off - from_it->first.stripe);
         assert(writeback_queue_size > 0 || !writeback_bytes);
         flush_buffers(cli, from_it, to_it);
     }

src/client/etcd_state_client.cpp

@@ -1,13 +1,12 @@
 // Copyright (c) Vitaliy Filippov, 2019+
 // License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
 
+#include <assert.h>
+
 #include "osd_ops.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()
@@ -17,28 +16,8 @@ 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_close(etcd_watch_ws);
-        etcd_watch_ws = NULL;
-    }
-    if (keepalive_client)
-    {
-        http_close(keepalive_client);
-        keepalive_client = 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;
@@ -72,104 +51,6 @@ std::vector<std::string> etcd_state_client_t::get_addresses()
     return addrs;
 }
 
-void etcd_state_client_t::etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload,
-    int timeout, std::function<void(std::string, json11::Json)> callback)
-{
-    std::string etcd_api_path;
-    int pos = etcd_address.find('/');
-    if (pos >= 0)
-    {
-        etcd_api_path = etcd_address.substr(pos);
-        etcd_address = etcd_address.substr(0, pos);
-    }
-    std::string req = payload.dump();
-    req = "POST "+etcd_api_path+api+" HTTP/1.1\r\n"
-        "Host: "+etcd_address+"\r\n"
-        "Content-Type: application/json\r\n"
-        "Content-Length: "+std::to_string(req.size())+"\r\n"
-        "Connection: close\r\n"
-        "\r\n"+req;
-    auto http_cli = http_init(tfd);
-    auto cb = [http_cli, callback](const http_response_t *response)
-    {
-        std::string err;
-        json11::Json data;
-        response->parse_json_response(err, data);
-        callback(err, data);
-        http_close(http_cli);
-    };
-    http_request(http_cli, etcd_address, req, { .timeout = timeout }, cb);
-}
-
-void etcd_state_client_t::etcd_call(std::string api, json11::Json payload, int timeout,
-    int retries, int interval, std::function<void(std::string, json11::Json)> callback)
-{
-    if (!etcd_addresses.size() && !etcd_local.size())
-    {
-        fprintf(stderr, "etcd_address is missing in Vitastor configuration\n");
-        exit(1);
-    }
-    pick_next_etcd();
-    std::string etcd_address = selected_etcd_address;
-    std::string etcd_api_path;
-    int pos = etcd_address.find('/');
-    if (pos >= 0)
-    {
-        etcd_api_path = etcd_address.substr(pos);
-        etcd_address = etcd_address.substr(0, pos);
-    }
-    std::string req = payload.dump();
-    req = "POST "+etcd_api_path+api+" HTTP/1.1\r\n"
-        "Host: "+etcd_address+"\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 = selected_etcd_address](const http_response_t *response)
-    {
-        std::string err;
-        json11::Json data;
-        response->parse_json_response(err, data);
-        if (err != "")
-        {
-            if (cur_addr == selected_etcd_address)
-                selected_etcd_address = "";
-            if (retries > 0)
-            {
-                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);
-        }
-        else
-            callback(err, data);
-    };
-    if (!keepalive_client)
-    {
-        keepalive_client = http_init(tfd);
-    }
-    http_request(keepalive_client, etcd_address, req, { .timeout = timeout, .keepalive = true }, cb);
-}
-
 void etcd_state_client_t::add_etcd_url(std::string addr)
 {
     if (addr.length() > 0)
@@ -256,7 +137,6 @@ 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)
     {
@@ -282,294 +162,9 @@ 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::pick_next_etcd()
-{
-    if (selected_etcd_address != "")
-        return;
-    if (addresses_to_try.size() == 0)
-    {
-        // Prefer local etcd, if any
-        for (int i = 0; i < etcd_local.size(); i++)
-            addresses_to_try.push_back(etcd_local[i]);
-        std::vector<int> ns;
-        for (int i = 0; i < etcd_addresses.size(); i++)
-            ns.push_back(i);
-        if (!rand_initialized)
-        {
-            timespec tv;
-            clock_gettime(CLOCK_REALTIME, &tv);
-            srand48(tv.tv_sec*1000000000 + tv.tv_nsec);
-            rand_initialized = true;
-        }
-        while (ns.size())
-        {
-            int i = lrand48() % ns.size();
-            addresses_to_try.push_back(etcd_addresses[ns[i]]);
-            ns.erase(ns.begin()+i, ns.begin()+i+1);
-        }
-    }
-    selected_etcd_address = addresses_to_try[0];
-    addresses_to_try.erase(addresses_to_try.begin(), addresses_to_try.begin()+1);
-}
-
-void etcd_state_client_t::start_etcd_watcher()
-{
-    if (!etcd_addresses.size() && !etcd_local.size())
-    {
-        fprintf(stderr, "etcd_address is missing in Vitastor configuration\n");
-        exit(1);
-    }
-    pick_next_etcd();
-    std::string etcd_address = selected_etcd_address;
-    std::string etcd_api_path;
-    int pos = etcd_address.find('/');
-    if (pos >= 0)
-    {
-        etcd_api_path = etcd_address.substr(pos);
-        etcd_address = etcd_address.substr(0, pos);
-    }
-    etcd_watches_initialised = 0;
-    ws_alive = 1;
-    if (etcd_watch_ws)
-    {
-        http_close(etcd_watch_ws);
-        etcd_watch_ws = NULL;
-    }
-    if (this->log_level > 1)
-    {
-        fprintf(stderr, "Trying to connect to etcd websocket at %s, watch from revision %ju/%ju/%ju\n", etcd_address.c_str(),
-            etcd_watch_revision_config, etcd_watch_revision_osd, etcd_watch_revision_pg);
-    }
-    etcd_watch_ws = open_websocket(tfd, etcd_address, etcd_api_path+"/watch", etcd_slow_timeout,
-        [this, cur_addr = selected_etcd_address](const http_response_t *msg)
-    {
-        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_ws = NULL;
-                                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;
-                    addresses_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_address)
-                selected_etcd_address = "";
-            if (etcd_watch_ws)
-            {
-                http_close(etcd_watch_ws);
-                etcd_watch_ws = NULL;
-            }
-            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_address.c_str());
-                }
-                if (etcd_watch_ws)
-                {
-                    http_close(etcd_watch_ws);
-                    etcd_watch_ws = NULL;
-                }
-                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()
+void etcd_state_client_t::load_global_config(std::function<void(const std::string & error)> cb)
 {
     json11::Json::object req = { { "success", json11::Json::array {
         json11::Json::object {
@@ -583,22 +178,12 @@ void etcd_state_client_t::load_global_config()
             } }
         },
     } } };
-    etcd_txn(req, etcd_quick_timeout, max_etcd_attempts, 0, [this](std::string err, json11::Json data)
+    etcd_txn(req, etcd_quick_timeout, max_etcd_attempts, 0, [this, cb](std::string err, json11::Json data)
     {
         if (err != "")
         {
             fprintf(stderr, "Error reading configuration from etcd: %s\n", err.c_str());
-            if (infinite_start)
-            {
-                tfd->set_timer(etcd_slow_timeout, false, [this](int timer_id)
-                {
-                    load_global_config();
-                });
-            }
-            else
-            {
-                exit(1);
-            }
+            cb(err);
             return;
         }
         json11::Json config_kv = data["responses"][0]["response_range"]["kvs"][0];
@@ -629,28 +214,12 @@ void etcd_state_client_t::load_global_config()
             parse_state(kv);
         }
         on_load_config_hook(global_config);
+        cb("");
     });
 }
 
-void etcd_state_client_t::load_pgs()
+void etcd_state_client_t::load_pgs(std::function<void(const std::string &)> cb)
 {
-    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 {
@@ -698,16 +267,13 @@ void etcd_state_client_t::load_pgs()
     {
         req["compare"] = checks;
     }
-    etcd_txn_slow(req, [this](std::string err, json11::Json data)
+    etcd_txn_slow(req, [this, cb](std::string err, json11::Json data)
     {
         if (err != "")
         {
             // Retry indefinitely
             fprintf(stderr, "Error loading PGs from etcd: %s\n", err.c_str());
-            tfd->set_timer(etcd_slow_timeout, false, [this](int timer_id)
-            {
-                load_pgs();
-            });
+            cb(err);
             return;
         }
         if (!data["succeeded"].bool_value())
@@ -735,24 +301,9 @@ void etcd_state_client_t::load_pgs()
         }
         clean_nonexistent_pgs();
         on_load_pgs_hook(true);
-        start_etcd_watcher();
+        cb("");
     });
 }
-#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()
 {
@@ -865,7 +416,8 @@ 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) ||
-                pool_item.second["pg_size"].uint64_value() > 256)
+                // limit is 64 because osd_peering_pg.cpp uses a 64-bit mask for has_roles
+                pool_item.second["pg_size"].uint64_value() > 64)
             {
                 fprintf(stderr, "Pool %u has invalid pg_size, skipping pool\n", pool_id);
                 continue;
@@ -1185,7 +737,6 @@ 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 ||
@@ -1194,7 +745,6 @@ 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;
@@ -1207,8 +757,14 @@ 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 = std::stoull(key.substr(etcd_prefix.length()+11));
-        if (peer_osd > 0)
+        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
         {
             if (value.is_object() && value["state"] == "up")
             {

src/client/etcd_state_client.h

@@ -103,15 +103,13 @@ protected:
     std::vector<std::string> local_ips;
     std::vector<std::string> etcd_addresses;
     std::vector<std::string> etcd_local;
-    std::string selected_etcd_address;
-    std::vector<std::string> addresses_to_try;
     std::vector<inode_watch_t*> watches;
+    std::set<osd_num_t> seen_peers;
     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 pick_next_etcd();
+    void reset_pg_exists();
+    void clean_nonexistent_pgs();
 public:
     int etcd_keepalive_timeout = 30;
     int etcd_ws_keepalive_interval = 5;
@@ -123,21 +121,15 @@ public:
     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;
-    timerfd_manager_t *tfd = 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;
     json11::Json node_placement;
@@ -160,24 +152,22 @@ public:
     json11::Json::object serialize_inode_cfg(inode_config_t *cfg);
     etcd_kv_t parse_etcd_kv(const json11::Json & kv_json);
     std::vector<std::string> get_addresses();
-    void etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload, int timeout, std::function<void(std::string, json11::Json)> callback);
-    void etcd_call(std::string api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback);
+    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;
     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);
-    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();
+    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 parse_state(const etcd_kv_t & kv);
-    void parse_config(const json11::Json & config);
+    virtual 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();
-    ~etcd_state_client_t();
+    virtual ~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);

src/client/etcd_state_client_http.cpp

@@ -0,0 +1,487 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#include "etcd_state_client_http.h"
+#include "addr_util.h"
+#include "http_client.h"
+#include "str_util.h"
+
+etcd_state_client_http_t::etcd_state_client_http_t(timerfd_manager_t *tfd)
+{
+    this->tfd = tfd;
+}
+
+etcd_state_client_http_t::~etcd_state_client_http_t()
+{
+    stop_ws_keepalive();
+    if (etcd_watch_ws)
+    {
+        http_close(etcd_watch_ws);
+        etcd_watch_ws = NULL;
+    }
+    if (keepalive_client)
+    {
+        http_close(keepalive_client);
+        keepalive_client = NULL;
+    }
+    if (load_pgs_timer_id >= 0)
+    {
+        tfd->clear_timer(load_pgs_timer_id);
+        load_pgs_timer_id = -1;
+    }
+    etcd_watches_initialised = -1;
+}
+
+void etcd_state_client_http_t::etcd_add_watch(json11::Json watch)
+{
+    if (etcd_watch_ws)
+    {
+        http_post_message(etcd_watch_ws, WS_TEXT, watch.dump());
+    }
+}
+
+void etcd_state_client_http_t::etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload,
+    int timeout, std::function<void(std::string, json11::Json)> callback)
+{
+    std::string etcd_api_path;
+    int pos = etcd_address.find('/');
+    if (pos >= 0)
+    {
+        etcd_api_path = etcd_address.substr(pos);
+        etcd_address = etcd_address.substr(0, pos);
+    }
+    std::string req = payload.dump();
+    req = "POST "+etcd_api_path+api+" HTTP/1.1\r\n"
+        "Host: "+etcd_address+"\r\n"
+        "Content-Type: application/json\r\n"
+        "Content-Length: "+std::to_string(req.size())+"\r\n"
+        "Connection: close\r\n"
+        "\r\n"+req;
+    auto http_cli = http_init(tfd);
+    auto cb = [http_cli, callback](const http_response_t *response)
+    {
+        std::string err;
+        json11::Json data;
+        response->parse_json_response(err, data);
+        callback(err, data);
+        http_close(http_cli);
+    };
+    http_request(http_cli, etcd_address, req, { .timeout = timeout }, cb);
+}
+
+void etcd_state_client_http_t::etcd_call(std::string api, json11::Json payload, int timeout,
+    int retries, int interval, std::function<void(std::string, json11::Json)> callback)
+{
+    if (!etcd_addresses.size() && !etcd_local.size())
+    {
+        fprintf(stderr, "etcd_address is missing in Vitastor configuration\n");
+        exit(1);
+    }
+    pick_next_etcd();
+    std::string etcd_address = selected_etcd_address;
+    std::string etcd_api_path;
+    int pos = etcd_address.find('/');
+    if (pos >= 0)
+    {
+        etcd_api_path = etcd_address.substr(pos);
+        etcd_address = etcd_address.substr(0, pos);
+    }
+    std::string req = payload.dump();
+    req = "POST "+etcd_api_path+api+" HTTP/1.1\r\n"
+        "Host: "+etcd_address+"\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 = selected_etcd_address](const http_response_t *response)
+    {
+        std::string err;
+        json11::Json data;
+        response->parse_json_response(err, data);
+        if (err != "")
+        {
+            if (cur_addr == selected_etcd_address)
+                selected_etcd_address = "";
+            if (retries > 0)
+            {
+                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);
+        }
+        else
+            callback(err, data);
+    };
+    if (!keepalive_client)
+    {
+        keepalive_client = http_init(tfd);
+    }
+    http_request(keepalive_client, etcd_address, req, { .timeout = timeout, .keepalive = true }, cb);
+}
+
+void etcd_state_client_http_t::parse_config(const json11::Json & config)
+{
+    auto old_etcd_ws_keepalive_interval = this->etcd_ws_keepalive_interval;
+    etcd_state_client_t::parse_config(config);
+    if (this->etcd_ws_keepalive_interval != old_etcd_ws_keepalive_interval && ws_keepalive_timer >= 0)
+    {
+        stop_ws_keepalive();
+        start_ws_keepalive();
+    }
+}
+
+void etcd_state_client_http_t::pick_next_etcd()
+{
+    if (selected_etcd_address != "")
+        return;
+    if (addresses_to_try.size() == 0)
+    {
+        // Prefer local etcd, if any
+        for (int i = 0; i < etcd_local.size(); i++)
+            addresses_to_try.push_back(etcd_local[i]);
+        std::vector<int> ns;
+        for (int i = 0; i < etcd_addresses.size(); i++)
+            ns.push_back(i);
+        if (!rand_initialized)
+        {
+            timespec tv;
+            clock_gettime(CLOCK_REALTIME, &tv);
+            srand48(tv.tv_sec*1000000000 + tv.tv_nsec);
+            rand_initialized = true;
+        }
+        while (ns.size())
+        {
+            int i = lrand48() % ns.size();
+            addresses_to_try.push_back(etcd_addresses[ns[i]]);
+            ns.erase(ns.begin()+i, ns.begin()+i+1);
+        }
+    }
+    selected_etcd_address = addresses_to_try[0];
+    addresses_to_try.erase(addresses_to_try.begin(), addresses_to_try.begin()+1);
+}
+
+void etcd_state_client_http_t::start_etcd_watcher()
+{
+    if (!etcd_addresses.size() && !etcd_local.size())
+    {
+        fprintf(stderr, "etcd_address is missing in Vitastor configuration\n");
+        exit(1);
+    }
+    pick_next_etcd();
+    std::string etcd_address = selected_etcd_address;
+    std::string etcd_api_path;
+    int pos = etcd_address.find('/');
+    if (pos >= 0)
+    {
+        etcd_api_path = etcd_address.substr(pos);
+        etcd_address = etcd_address.substr(0, pos);
+    }
+    etcd_watches_initialised = 0;
+    ws_alive = 1;
+    if (etcd_watch_ws)
+    {
+        http_close(etcd_watch_ws);
+        etcd_watch_ws = NULL;
+    }
+    if (this->log_level > 1)
+    {
+        fprintf(stderr, "Trying to connect to etcd websocket at %s, watch from revision %ju/%ju/%ju\n", etcd_address.c_str(),
+            etcd_watch_revision_config, etcd_watch_revision_osd, etcd_watch_revision_pg);
+    }
+    etcd_watch_ws = open_websocket(tfd, etcd_address, etcd_api_path+"/watch", etcd_slow_timeout,
+        [this, cur_addr = selected_etcd_address](const http_response_t *msg)
+    {
+        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_ws = NULL;
+                                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;
+                    addresses_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_address)
+                selected_etcd_address = "";
+            if (etcd_watch_ws)
+            {
+                http_close(etcd_watch_ws);
+                etcd_watch_ws = NULL;
+            }
+            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_http_t::stop_ws_keepalive()
+{
+    if (ws_keepalive_timer >= 0)
+    {
+        tfd->clear_timer(ws_keepalive_timer);
+        ws_keepalive_timer = -1;
+    }
+}
+
+void etcd_state_client_http_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_address.c_str());
+                }
+                if (etcd_watch_ws)
+                {
+                    http_close(etcd_watch_ws);
+                    etcd_watch_ws = NULL;
+                }
+                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_http_t::load_global_config()
+{
+    etcd_state_client_t::load_global_config([this](const std::string & err)
+    {
+        if (err != "")
+        {
+            fprintf(stderr, "Error reading configuration from etcd: %s\n", err.c_str());
+            if (infinite_start)
+            {
+                tfd->set_timer(etcd_slow_timeout, false, [this](int timer_id)
+                {
+                    load_global_config();
+                });
+            }
+            else
+            {
+                exit(1);
+            }
+        }
+    });
+}
+
+void etcd_state_client_http_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;
+    }
+    etcd_state_client_t::load_pgs([this](const std::string & err)
+    {
+        if (err != "")
+        {
+            // Retry indefinitely
+            fprintf(stderr, "Error loading PGs from etcd: %s\n", err.c_str());
+            tfd->set_timer(etcd_slow_timeout, false, [this](int timer_id)
+            {
+                load_pgs();
+            });
+        }
+        else
+        {
+            start_etcd_watcher();
+        }
+    });
+}

src/client/etcd_state_client_http.h

@@ -0,0 +1,36 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#pragma once
+
+#include "etcd_state_client.h"
+
+struct __attribute__((visibility("default"))) etcd_state_client_http_t: public etcd_state_client_t
+{
+protected:
+    timerfd_manager_t *tfd = NULL;
+    std::string selected_etcd_address;
+    std::vector<std::string> addresses_to_try;
+    int ws_keepalive_timer = -1;
+    int ws_alive = 0;
+    bool rand_initialized = false;
+    int etcd_watches_initialised = 0;
+    timespec etcd_last_reload = {};
+    int load_pgs_timer_id = -1;
+    http_co_t *keepalive_client = NULL;
+
+    void pick_next_etcd();
+    void start_etcd_watcher();
+    void stop_ws_keepalive();
+    void start_ws_keepalive();
+public:
+    http_co_t *etcd_watch_ws = NULL;
+    etcd_state_client_http_t(timerfd_manager_t *tfd);
+    void etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload, int timeout, std::function<void(std::string, json11::Json)> callback) override;
+    void etcd_call(std::string api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback) override;
+    void etcd_add_watch(json11::Json watch) override;
+    void load_global_config() override;
+    void load_pgs() override;
+    void parse_config(const json11::Json & config) override;
+    ~etcd_state_client_http_t();
+};

src/client/etcd_state_client_mock.cpp

@@ -0,0 +1,205 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#include <assert.h>
+#include "etcd_state_client_mock.h"
+#include "str_util.h"
+
+etcd_state_client_mock_t::etcd_state_client_mock_t()
+{
+    timespec tv;
+    clock_gettime(CLOCK_REALTIME, &tv);
+    srand48(tv.tv_sec*1000000000 + tv.tv_nsec);
+}
+
+void etcd_state_client_mock_t::etcd_add_watch(json11::Json watch)
+{
+}
+
+void etcd_state_client_mock_t::etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload,
+    int timeout, std::function<void(std::string, json11::Json)> callback)
+{
+}
+
+void etcd_state_client_mock_t::pause()
+{
+    paused = true;
+}
+
+void etcd_state_client_mock_t::resume()
+{
+    paused = false;
+    auto queue = std::move(this->queue);
+    for (auto& req: queue)
+    {
+        etcd_call(req.api, req.payload, req.timeout, req.retries, req.interval, req.callback);
+    }
+}
+
+void etcd_state_client_mock_t::set(const std::string& key, json11::Json data, uint64_t mod_revision, uint64_t lease_id)
+{
+    if (!mod_revision)
+        mod_revision = ++this->mod_revision;
+    this->data[key] = (etcd_mock_key_data_t){ .value = data.dump(), .mod_revision = mod_revision, .lease_id = lease_id };
+}
+
+void etcd_state_client_mock_t::etcd_call(std::string api, json11::Json payload, int timeout,
+    int retries, int interval, std::function<void(std::string, json11::Json)> callback)
+{
+    if (paused)
+    {
+        queue.push_back({ api, payload, timeout, retries, interval, callback });
+        return;
+    }
+    printf("+ etcd: %s\n", api.c_str());
+    if (api == "/kv/txn")
+    {
+        bool ok = true;
+        for (auto& check: payload["compare"].array_items())
+        {
+            auto key = base64_decode(check["key"].string_value());
+            etcd_mock_key_data_t *key_data = data.find(key) != data.end() ? &data.at(key) : NULL;
+            auto target = check["target"].string_value();
+            auto res = check["result"].string_value();
+            assert(res == "LESS" || res == "");
+            bool less = res == "LESS";
+            if (target == "MOD")
+            {
+                uint64_t rev = check["mod_revision"].uint64_value();
+                assert(!less || rev);
+                ok = ok && (less ? (!key_data || key_data->mod_revision < rev) : (key_data && key_data->mod_revision == rev));
+            }
+            else if (target == "CREATE")
+            {
+                uint64_t rev = check["create_revision"].uint64_value();
+                assert(rev == 0 && !less);
+                ok = ok && !key_data;
+            }
+            else if (target == "VERSION")
+            {
+                uint64_t rev = check["version"].uint64_value();
+                assert(rev == 0 && !less);
+                ok = ok && !key_data;
+            }
+            else if (target == "LEASE")
+            {
+                assert(!less);
+                uint64_t lease_id = check["lease"].uint64_value();
+                ok = ok && key_data && key_data->lease_id == lease_id;
+            }
+            else
+                assert(0);
+        }
+        std::map<std::string, etcd_kv_t> changes;
+        bool has_mod = false;
+        for (auto& op: payload[ok ? "success" : "failure"].array_items())
+        {
+            auto& obj = op.object_items();
+            has_mod = has_mod || obj.find("request_put") != obj.end() ||
+                obj.find("request_delete_range") != obj.end();
+        }
+        if (has_mod)
+        {
+            mod_revision++;
+        }
+        json11::Json::array responses;
+        for (auto& op_ptr: payload[ok ? "success" : "failure"].array_items())
+        {
+            auto& op = op_ptr.object_items();
+            if (op.find("request_range") != op.end())
+            {
+                json11::Json::array kvs;
+                auto req = op.at("request_range");
+                auto key = base64_decode(req["key"].string_value());
+                auto range_end = base64_decode(req["range_end"].string_value());
+                auto begin_it = range_end.empty() ? data.find(key) : data.lower_bound(key);
+                auto end_it = range_end.empty() ? (begin_it == data.end() ? begin_it : std::next(begin_it)) : data.lower_bound(range_end);
+                for (auto it = begin_it; it != end_it; it++)
+                {
+                    printf("\\- get: %s = %s, rev %ju\n", it->first.c_str(), it->second.value.c_str(), it->second.mod_revision);
+                    kvs.push_back(json11::Json::object {
+                        { "key", base64_encode(it->first) },
+                        { "value", base64_encode(it->second.value) },
+                        { "mod_revision", it->second.mod_revision },
+                    });
+                }
+                responses.push_back(json11::Json::object {
+                    { "response_range", json11::Json::object{ { "header", json11::Json::object{ { "revision", mod_revision } } }, { "kvs", kvs } } },
+                });
+            }
+            else if (op.find("request_put") != op.end())
+            {
+                auto req = op.at("request_put");
+                auto key = base64_decode(req["key"].string_value());
+                auto value = base64_decode(req["value"].string_value());
+                auto lease_id = req["lease"].uint64_value();
+                printf("\\- put: %s = %s, rev %ju, lease %ju\n", key.c_str(), value.c_str(), mod_revision, lease_id);
+                data[key] = {
+                    .value = value,
+                    .mod_revision = mod_revision,
+                    .lease_id = lease_id,
+                };
+                std::string err;
+                json11::Json json_value = json11::Json::parse(value, err);
+                if (err != "")
+                {
+                    fprintf(stderr, "Invalid JSON in etcd key %s during test: %s\n", key.c_str(), value.c_str());
+                    exit(1);
+                }
+                changes[key] = { .key = key, .value = json_value, .mod_revision = mod_revision };
+                responses.push_back(json11::Json::object {
+                    { "response_put", json11::Json::object{ { "header", json11::Json::object{ { "revision", mod_revision } } } } },
+                });
+            }
+            else if (op.find("request_delete_range") != op.end())
+            {
+                auto req = op.at("request_delete_range");
+                auto key = base64_decode(req["key"].string_value());
+                auto range_end = base64_decode(req["range_end"].string_value());
+                uint64_t n_del = 0;
+                for (auto it = data.lower_bound(key); it != data.end() && (range_end == "" || it->first < range_end); )
+                {
+                    auto & key = it->first;
+                    printf("\\- del: %s\n", key.c_str());
+                    changes[key] = { .key = key, .mod_revision = mod_revision };
+                    n_del++;
+                    data.erase(it++);
+                }
+                responses.push_back(json11::Json::object {
+                    { "response_delete_range", json11::Json::object{ { "header", json11::Json::object{ { "revision", mod_revision } } }, { "deleted", n_del } } },
+                });
+            }
+        }
+        callback("", json11::Json::object{
+            { "header", json11::Json::object{ { "revision", mod_revision } } },
+            { "succeeded", ok },
+            { "responses", responses }
+        });
+        // Push changes to watcher
+        if (changes.size())
+        {
+            for (auto & kv: changes)
+                parse_state(kv.second);
+            if (on_change_hook != NULL)
+                on_change_hook(changes);
+        }
+    }
+    else if (api == "/lease/grant")
+    {
+        uint64_t lease_id = (((uint64_t)lrand48()) << 32) | lrand48();
+        leases[lease_id] = payload["TTL"].uint64_value();
+        callback("", json11::Json::object{ { "ID", std::to_string(lease_id) } });
+    }
+    else
+        callback("Unsupported", json11::Json());
+}
+
+void etcd_state_client_mock_t::load_global_config()
+{
+    etcd_state_client_t::load_global_config([this](const std::string & err) {});
+}
+
+void etcd_state_client_mock_t::load_pgs()
+{
+    etcd_state_client_t::load_pgs([this](const std::string & err) {});
+}

src/client/etcd_state_client_mock.h

@@ -0,0 +1,42 @@
+// Copyright (c) Vitaliy Filippov, 2019+
+// License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
+
+#pragma once
+
+#include "etcd_state_client.h"
+
+struct etcd_mock_key_data_t
+{
+    std::string value;
+    uint64_t mod_revision;
+    uint64_t lease_id;
+};
+
+struct etcd_mock_request_t
+{
+    std::string api;
+    json11::Json payload;
+    int timeout;
+    int retries;
+    int interval;
+    std::function<void(std::string, json11::Json)> callback;
+};
+
+struct etcd_state_client_mock_t: public etcd_state_client_t
+{
+    uint64_t mod_revision = 0;
+    bool paused = false;
+    std::vector<etcd_mock_request_t> queue;
+public:
+    std::map<uint64_t, uint64_t> leases;
+    std::map<std::string, etcd_mock_key_data_t> data;
+    etcd_state_client_mock_t();
+    void set(const std::string& key, json11::Json data, uint64_t mod_revision = 0, uint64_t lease_id = 0);
+    void pause();
+    void resume();
+    void etcd_call_oneshot(std::string etcd_address, std::string api, json11::Json payload, int timeout, std::function<void(std::string, json11::Json)> callback) override;
+    void etcd_call(std::string api, json11::Json payload, int timeout, int retries, int interval, std::function<void(std::string, json11::Json)> callback) override;
+    void etcd_add_watch(json11::Json watch) override;
+    void load_global_config() override;
+    void load_pgs() override;
+};

src/client/messenger.cpp

@@ -15,106 +15,6 @@
 #include "msgr_rdma.h"
 #endif
 
-#include <sys/poll.h>
-
-msgr_iothread_t::msgr_iothread_t():
-    ring(RINGLOOP_DEFAULT_SIZE, true),
-    thread(&msgr_iothread_t::run, this)
-{
-    eventfd = ring.register_eventfd();
-    if (eventfd < 0)
-    {
-        throw std::runtime_error(std::string("failed to register eventfd: ") + strerror(-eventfd));
-    }
-}
-
-msgr_iothread_t::~msgr_iothread_t()
-{
-    stop();
-}
-
-void msgr_iothread_t::add_sqe(io_uring_sqe & sqe)
-{
-    mu.lock();
-    queue.push_back((iothread_sqe_t){ .sqe = sqe, .data = std::move(*(ring_data_t*)sqe.user_data) });
-    if (queue.size() == 1)
-    {
-        cond.notify_all();
-    }
-    mu.unlock();
-}
-
-void msgr_iothread_t::stop()
-{
-    mu.lock();
-    if (stopped)
-    {
-        mu.unlock();
-        return;
-    }
-    stopped = true;
-    if (outer_loop_data)
-    {
-        outer_loop_data->callback = [](ring_data_t*){};
-    }
-    cond.notify_all();
-    close(eventfd);
-    mu.unlock();
-    thread.join();
-}
-
-void msgr_iothread_t::add_to_ringloop(ring_loop_t *outer_loop)
-{
-    assert(!this->outer_loop || this->outer_loop == outer_loop);
-    io_uring_sqe *sqe = outer_loop->get_sqe();
-    assert(sqe != NULL);
-    this->outer_loop = outer_loop;
-    this->outer_loop_data = ((ring_data_t*)sqe->user_data);
-    io_uring_prep_poll_add(sqe, eventfd, POLLIN);
-    outer_loop_data->callback = [this](ring_data_t *data)
-    {
-        if (data->res < 0)
-        {
-            throw std::runtime_error(std::string("eventfd poll failed: ") + strerror(-data->res));
-        }
-        outer_loop_data = NULL;
-        if (stopped)
-        {
-            return;
-        }
-        add_to_ringloop(this->outer_loop);
-        ring.loop();
-    };
-}
-
-void msgr_iothread_t::run()
-{
-    while (true)
-    {
-        {
-            std::unique_lock<std::mutex> lk(mu);
-            while (!stopped && !queue.size())
-                cond.wait(lk);
-            if (stopped)
-                return;
-            int i = 0;
-            for (; i < queue.size(); i++)
-            {
-                io_uring_sqe *sqe = ring.get_sqe();
-                if (!sqe)
-                    break;
-                ring_data_t *data = ((ring_data_t*)sqe->user_data);
-                *data = std::move(queue[i].data);
-                *sqe = queue[i].sqe;
-                sqe->user_data = (uint64_t)data;
-            }
-            queue.erase(queue.begin(), queue.begin()+i);
-        }
-        // We only want to offload sendmsg/recvmsg. Callbacks will be called in main thread
-        ring.submit();
-    }
-}
-
 void osd_messenger_t::init()
 {
 #ifdef WITH_RDMACM
@@ -173,12 +73,7 @@ void osd_messenger_t::init()
     }
     if (ringloop && iothread_count > 0)
     {
-        for (int i = 0; i < iothread_count; i++)
-        {
-            auto iot = new msgr_iothread_t();
-            iothreads.push_back(iot);
-            iot->add_to_ringloop(ringloop);
-        }
+        init_iothreads();
     }
     keepalive_timer_id = tfd->set_timer(1000, true, [this](int)
     {
@@ -220,7 +115,7 @@ void osd_messenger_t::init()
                             .opcode = OSD_OP_PING,
                         },
                     };
-                    op->callback = [this, cl](osd_op_t *op)
+                    op->callback = [this](osd_op_t *op)
                     {
                         auto cl_it = clients.find(op->client_id);
                         if (cl_it == clients.end())
@@ -229,6 +124,7 @@ void osd_messenger_t::init()
                             delete op;
                             return;
                         }
+                        auto cl = cl_it->second;
                         uint64_t fail_client_id = (op->reply.hdr.retval != 0 ? op->client_id : 0);
                         auto fail_osd_num = cl->in_osd_num ? cl->in_osd_num : cl->osd_num;
                         cl->ping_time_remaining = 0;
@@ -271,14 +167,7 @@ osd_messenger_t::~osd_messenger_t()
     {
         stop_client(clients.begin()->first, true);
     }
-    if (iothreads.size())
-    {
-        for (auto iot: iothreads)
-        {
-            delete iot;
-        }
-        iothreads.clear();
-    }
+    destroy_iothreads();
 #ifdef WITH_RDMA
     for (auto rdma_context: rdma_contexts)
     {

src/client/messenger.h

@@ -38,6 +38,8 @@
 #define MSGR_SENDP_HDR 1
 #define MSGR_SENDP_FREE 2
 
+#define MAX_SIMPLE_PAYLOAD_SIZE 1048576
+
 struct msgr_sendp_t
 {
     osd_op_t *op;
@@ -129,43 +131,7 @@ struct osd_op_stats_t
     uint64_t subop_stat_count[OSD_OP_MAX+1] = { 0 };
 };
 
-#include <mutex>
-#include <condition_variable>
-#include <thread>
-
-#ifdef __MOCK__
 class msgr_iothread_t;
-#else
-struct iothread_sqe_t
-{
-    io_uring_sqe sqe;
-    ring_data_t data;
-};
-
-class msgr_iothread_t
-{
-protected:
-    ring_loop_t ring;
-    ring_loop_t *outer_loop = NULL;
-    ring_data_t *outer_loop_data = NULL;
-    int eventfd = -1;
-    bool stopped = false;
-    std::mutex mu;
-    std::condition_variable cond;
-    std::vector<iothread_sqe_t> queue;
-    std::thread thread;
-
-    void run();
-public:
-
-    msgr_iothread_t();
-    ~msgr_iothread_t();
-
-    void add_sqe(io_uring_sqe & sqe);
-    void stop();
-    void add_to_ringloop(ring_loop_t *outer_loop);
-};
-#endif
 
 #ifdef WITH_RDMA
 struct rdma_event_channel;
@@ -215,11 +181,14 @@ protected:
 
 public:
     timerfd_manager_t *tfd = NULL;
-    ring_loop_t *ringloop = NULL;
+    ring_loop_i *ringloop = NULL;
     bool has_sendmsg_zc = false;
-    // osd_num_t is only for logging and asserts
     uint64_t next_client_id = 1;
-    osd_num_t osd_num;
+    // osd_num = 0 for client messenger, osd_num > 0 for OSD messenger
+    osd_num_t osd_num = 0;
+    uint32_t clean_entry_bitmap_size = 0;
+    uint32_t bs_block_size = 0;
+    uint32_t max_write_request_size = 0;
     robin_hood::unordered_flat_map<uint64_t, osd_client_t*> clients;
     robin_hood::unordered_flat_map<uint64_t, osd_client_t*> osd_peers;
     robin_hood::unordered_flat_map<int, osd_client_t*> clients_by_fd;
@@ -234,6 +203,7 @@ public:
     osd_op_stats_t stats, recovery_stats;
 
     void init();
+    void init_iothreads();
     void parse_config(const json11::Json & config);
     void connect_peer(uint64_t osd_num, json11::Json peer_state);
     void stop_client(uint64_t client_id, bool force_delete = false);
@@ -246,6 +216,7 @@ public:
     void read_requests();
     void send_replies();
     void accept_connections(int listen_fd);
+    void destroy_iothreads();
     ~osd_messenger_t();
 
     static json11::Json::object read_config(const json11::Json & config);
@@ -256,7 +227,7 @@ public:
 
 #ifdef WITH_RDMA
     bool is_rdma_enabled();
-    bool connect_rdma(uint64_t client_id, std::string rdma_address, uint64_t client_max_msg);
+    json11::Json connect_rdma(uint64_t client_id, std::string rdma_address, uint64_t client_max_msg);
 #endif
 #ifdef WITH_RDMACM
     bool is_use_rdmacm();
@@ -283,7 +254,7 @@ protected:
     bool handle_read(int result, osd_client_t *cl);
     bool handle_read_buffer(osd_client_t *cl, void *curbuf, int remain);
     bool handle_finished_read(osd_client_t *cl);
-    void handle_op_hdr(osd_client_t *cl);
+    bool handle_op_hdr(osd_client_t *cl);
     bool handle_reply_hdr(osd_client_t *cl);
     void handle_reply_ready(osd_op_t *op);
     void handle_immediate_ops();
@@ -293,6 +264,7 @@ protected:
     bool init_recv_rdma(osd_client_t *cl);
     void handle_rdma_events(msgr_rdma_context_t *rdma_context);
     msgr_rdma_context_t* choose_rdma_context(osd_client_t *cl);
+    void destroy_rdma_conn(msgr_rdma_connection_t *rdma_conn);
 #endif
 #ifdef WITH_RDMACM
     void handle_rdmacm_events();

src/client/msgr_iothread.cpp

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

src/client/msgr_iothread.h

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

src/client/msgr_op.cpp

@@ -3,6 +3,7 @@
 
 #include <assert.h>
 
+#include "messenger.h"
 #include "msgr_op.h"
 
 osd_op_t::~osd_op_t()
@@ -38,3 +39,52 @@ bool osd_op_t::is_recovery_related()
         req.hdr.opcode == OSD_OP_SEC_SYNC &&
         (req.sec_sync.flags & OSD_OP_RECOVERY_RELATED);
 }
+
+void osd_messenger_t::measure_exec(osd_op_t *cur_op)
+{
+    // Measure execution latency
+    if (cur_op->req.hdr.opcode > OSD_OP_MAX)
+    {
+        return;
+    }
+    if (!cur_op->tv_end.tv_sec)
+    {
+        clock_gettime(CLOCK_REALTIME, &cur_op->tv_end);
+    }
+    uint64_t len = 0;
+    if (cur_op->req.hdr.opcode == OSD_OP_READ ||
+        cur_op->req.hdr.opcode == OSD_OP_WRITE ||
+        cur_op->req.hdr.opcode == OSD_OP_SCRUB)
+    {
+        // req.rw.len is internally set to the full object size for scrubs
+        len = cur_op->req.rw.len;
+    }
+    else if (cur_op->req.hdr.opcode == OSD_OP_SEC_READ ||
+        cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE ||
+        cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE)
+    {
+        len = cur_op->req.sec_rw.len;
+    }
+    inc_op_stats(stats, cur_op->req.hdr.opcode, cur_op->tv_begin, cur_op->tv_end, len);
+    if (cur_op->is_recovery_related())
+    {
+        inc_op_stats(recovery_stats, cur_op->req.hdr.opcode, cur_op->tv_begin, cur_op->tv_end, len);
+    }
+}
+
+void osd_messenger_t::inc_op_stats(osd_op_stats_t & stats, uint64_t opcode, timespec & tv_begin, timespec & tv_end, uint64_t len)
+{
+    uint64_t usecs = (
+        (tv_end.tv_sec - tv_begin.tv_sec)*1000000 +
+        (tv_end.tv_nsec - tv_begin.tv_nsec)/1000
+    );
+    stats.op_stat_count[opcode]++;
+    if (!stats.op_stat_count[opcode])
+    {
+        stats.op_stat_count[opcode] = 1;
+        stats.op_stat_sum[opcode] = 0;
+        stats.op_stat_bytes[opcode] = 0;
+    }
+    stats.op_stat_sum[opcode] += usecs;
+    stats.op_stat_bytes[opcode] += len;
+}

src/client/msgr_op.h

@@ -157,6 +157,7 @@ struct __attribute__((visibility("default"))) osd_op_t
     timespec tv_begin = { 0 }, tv_end = { 0 };
     uint64_t op_type = OSD_OP_IN;
     uint64_t client_id = 0;
+    osd_num_t osd_num = 0;
     osd_any_op_t req;
     osd_any_reply_t reply;
     blockstore_op_t *bs_op = NULL;
@@ -164,7 +165,7 @@ struct __attribute__((visibility("default"))) osd_op_t
     // bitmap, bitmap_len, bmp_data are only meaningful for reads
     void *bitmap = NULL;
     unsigned bitmap_len = 0;
-    unsigned bmp_data = 0;
+    size_t bmp_data = 0;
     void *bitmap_buf = NULL;
     void *rmw_buf = NULL;
     osd_primary_op_data_t* op_data = NULL;

src/client/msgr_rdma.cpp

@@ -507,7 +507,7 @@ int msgr_rdma_connection_t::connect(msgr_rdma_address_t *dest)
     return 0;
 }
 
-bool osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address, uint64_t client_max_msg)
+json11::Json osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address, uint64_t client_max_msg)
 {
     // Try to connect to the peer using RDMA
     msgr_rdma_address_t addr;
@@ -523,7 +523,7 @@ bool osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address,
         {
             if (log_level > 0)
                 fprintf(stderr, "No RDMA context for peer %ju, using only TCP\n", client_id);
-            return false;
+            return json11::Json();
         }
         msgr_rdma_connection_t *rdma_conn = msgr_rdma_connection_t::create(selected_ctx, rdma_max_send, rdma_max_recv, rdma_max_sge, client_max_msg);
         if (rdma_conn)
@@ -542,11 +542,14 @@ bool osd_messenger_t::connect_rdma(uint64_t client_id, std::string rdma_address,
                 // Remember connection, but switch to RDMA only after sending the configuration response
                 cl->rdma_conn = rdma_conn;
                 cl->peer_state = PEER_RDMA_CONNECTING;
-                return true;
+                return json11::Json::object{
+                    {"rdma_address", rdma_conn->addr.to_string()},
+                    {"rdma_max_msg", rdma_conn->max_msg},
+                };
             }
         }
     }
-    return false;
+    return json11::Json();
 }
 
 static void try_send_rdma_wr(osd_client_t *cl, ibv_sge *sge, int op_sge)
@@ -612,7 +615,9 @@ void osd_messenger_t::try_send_rdma(osd_client_t *cl)
     while (!rc->send_out_full && copied > 0 && rc->cur_send < rc->max_send)
     {
         dst = (uint8_t*)rc->send_out.buf + rc->send_out_pos;
-        dst_len = (rc->send_out_pos < rc->send_out_size ? rc->send_out_size-rc->send_out_pos : rc->send_done_pos-rc->send_out_pos);
+        dst_len = (rc->send_out_pos >= rc->send_done_pos
+            ? rc->send_out_size-rc->send_out_pos
+            : rc->send_done_pos-rc->send_out_pos);
         if (dst_len > rc->max_msg)
             dst_len = rc->max_msg;
         copied = try_send_rdma_copy(cl, dst, dst_len);
@@ -622,7 +627,7 @@ void osd_messenger_t::try_send_rdma(osd_client_t *cl)
             if (rc->send_out_pos == rc->send_out_size)
                 rc->send_out_pos = 0;
             assert(rc->send_out_pos < rc->send_out_size);
-            if (rc->send_out_pos >= rc->send_done_pos)
+            if (rc->send_out_pos == rc->send_done_pos)
                 rc->send_out_full = true;
             ibv_sge sge = {
                 .addr = (uintptr_t)dst,
@@ -792,3 +797,16 @@ void osd_messenger_t::handle_rdma_events(msgr_rdma_context_t *rdma_context)
     } while (event_count > 0);
     handle_immediate_ops();
 }
+
+void osd_messenger_t::destroy_rdma_conn(msgr_rdma_connection_t *rdma_conn)
+{
+    if (rdma_conn->cmid)
+    {
+        auto rdma_it = rdmacm_connections.find(rdma_conn->cmid);
+        if (rdma_it != rdmacm_connections.end() && rdma_it->second->rdma_conn == rdma_conn)
+        {
+            rdmacm_connections.erase(rdma_it);
+        }
+    }
+    delete rdma_conn;
+}

src/client/msgr_receive.cpp

@@ -2,6 +2,7 @@
 // License: VNPL-1.1 or GNU GPL-2.0+ (see README.md for details)
 
 #include "messenger.h"
+#include "msgr_iothread.h"
 
 void osd_messenger_t::read_requests()
 {
@@ -230,7 +231,11 @@ bool osd_messenger_t::handle_finished_read(osd_client_t *cl)
                 }
                 cl->read_op_id++;
             }
-            handle_op_hdr(cl);
+            if (!handle_op_hdr(cl))
+            {
+                stop_client(cl->client_id);
+                return false;
+            }
         }
         else
         {
@@ -261,7 +266,7 @@ bool osd_messenger_t::handle_finished_read(osd_client_t *cl)
     return true;
 }
 
-void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
+bool osd_messenger_t::handle_op_hdr(osd_client_t *cl)
 {
     osd_op_t *cur_op = cl->read_op;
     if (cur_op->req.hdr.opcode == OSD_OP_SEC_READ)
@@ -273,7 +278,16 @@ void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
     {
         if (cur_op->req.sec_rw.attr_len > 0)
         {
-            if (cur_op->req.sec_rw.attr_len > sizeof(unsigned))
+            if (cur_op->req.sec_rw.attr_len > clean_entry_bitmap_size)
+            {
+                if (log_level > 1)
+                {
+                    fprintf(stderr, "Error: peer %ju secondary write request attr_len too large (%u > %u bytes), stopping\n", cl->client_id,
+                        cur_op->req.sec_rw.attr_len, clean_entry_bitmap_size);
+                }
+                return false;
+            }
+            else if (cur_op->req.sec_rw.attr_len > sizeof(cur_op->bmp_data))
                 cur_op->bitmap = cur_op->rmw_buf = malloc_or_die(cur_op->req.sec_rw.attr_len);
             else
                 cur_op->bitmap = &cur_op->bmp_data;
@@ -281,6 +295,15 @@ void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
         }
         if (cur_op->req.sec_rw.len > 0)
         {
+            if (cur_op->req.sec_rw.len > bs_block_size)
+            {
+                if (log_level > 1)
+                {
+                    fprintf(stderr, "Error: peer %ju secondary write request size too large (%u > %u bytes), stopping\n", cl->client_id,
+                        cur_op->req.sec_rw.len, bs_block_size);
+                }
+                return false;
+            }
             cur_op->buf = memalign_or_die(MEM_ALIGNMENT, cur_op->req.sec_rw.len);
             cl->recv_list.push_back(cur_op->buf, cur_op->req.sec_rw.len);
         }
@@ -291,6 +314,15 @@ void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
     {
         if (cur_op->req.sec_stab.len > 0)
         {
+            if (cur_op->req.sec_stab.len > MAX_SIMPLE_PAYLOAD_SIZE)
+            {
+                if (log_level > 1)
+                {
+                    fprintf(stderr, "Error: peer %ju stabilize request size too large (%lu > %u bytes), stopping\n", cl->client_id,
+                        cur_op->req.sec_stab.len, MAX_SIMPLE_PAYLOAD_SIZE);
+                }
+                return false;
+            }
             cur_op->buf = memalign_or_die(MEM_ALIGNMENT, cur_op->req.sec_stab.len);
             cl->recv_list.push_back(cur_op->buf, cur_op->req.sec_stab.len);
         }
@@ -300,6 +332,15 @@ void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
     {
         if (cur_op->req.sec_read_bmp.len > 0)
         {
+            if (cur_op->req.sec_read_bmp.len > MAX_SIMPLE_PAYLOAD_SIZE)
+            {
+                if (log_level > 1)
+                {
+                    fprintf(stderr, "Error: peer %ju sec_read_bmp request size too large (%lu > %u bytes), stopping\n", cl->client_id,
+                        cur_op->req.sec_read_bmp.len, MAX_SIMPLE_PAYLOAD_SIZE);
+                }
+                return false;
+            }
             cur_op->buf = memalign_or_die(MEM_ALIGNMENT, cur_op->req.sec_read_bmp.len);
             cl->recv_list.push_back(cur_op->buf, cur_op->req.sec_read_bmp.len);
         }
@@ -309,6 +350,15 @@ void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
     {
         if (cur_op->req.rw.len > 0)
         {
+            if (cur_op->req.rw.len > max_write_request_size)
+            {
+                if (log_level > 1)
+                {
+                    fprintf(stderr, "Error: peer %ju write request size too large (%u > %u bytes), stopping\n", cl->client_id,
+                        cur_op->req.rw.len, max_write_request_size);
+                }
+                return false;
+            }
             cur_op->buf = memalign_or_die(MEM_ALIGNMENT, cur_op->req.rw.len);
             cl->recv_list.push_back(cur_op->buf, cur_op->req.rw.len);
         }
@@ -318,6 +368,15 @@ void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
     {
         if (cur_op->req.show_conf.json_len > 0)
         {
+            if (cur_op->req.show_conf.json_len > MAX_SIMPLE_PAYLOAD_SIZE)
+            {
+                if (log_level > 1)
+                {
+                    fprintf(stderr, "Error: peer %ju show_config request length too large (%lu > %u bytes), stopping\n", cl->client_id,
+                        cur_op->req.show_conf.json_len, MAX_SIMPLE_PAYLOAD_SIZE);
+                }
+                return false;
+            }
             cur_op->buf = malloc_or_die(cur_op->req.show_conf.json_len+1);
             ((uint8_t*)cur_op->buf)[cur_op->req.show_conf.json_len] = 0;
             cl->recv_list.push_back(cur_op->buf, cur_op->req.show_conf.json_len);
@@ -343,12 +402,13 @@ void osd_messenger_t::handle_op_hdr(osd_client_t *cl)
         cl->read_op = NULL;
         cl->read_state = 0;
     }
+    return true;
 }
 
 bool osd_messenger_t::handle_reply_hdr(osd_client_t *cl)
 {
     auto req_it = cl->sent_ops.find(cl->read_op->req.hdr.id);
-    if (req_it == cl->sent_ops.end())
+    if (req_it == cl->sent_ops.end() || req_it->second->req.hdr.opcode != cl->read_op->req.hdr.opcode)
     {
         // Command out of sync. Drop connection
         fprintf(stderr, "Client %ju command out of sync: id %ju\n", cl->client_id, cl->read_op->req.hdr.id);
@@ -372,7 +432,7 @@ bool osd_messenger_t::handle_reply_hdr(osd_client_t *cl)
             stop_client(cl->client_id);
             return false;
         }
-        if (bmp_len > 0)
+        if (op->reply.hdr.retval >= 0 && bmp_len > 0)
         {
             assert(op->bitmap);
             cl->recv_list.push_back(op->bitmap, bmp_len);

src/client/msgr_send.cpp

@@ -6,6 +6,7 @@
 #include <sys/epoll.h>
 
 #include "messenger.h"
+#include "msgr_iothread.h"
 
 void osd_messenger_t::outbox_push(osd_op_t *cur_op)
 {
@@ -99,10 +100,15 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
     if (cur_op->req.hdr.opcode == OSD_OP_SEC_READ_BMP)
     {
         if (cur_op->op_type == OSD_OP_IN && cur_op->reply.hdr.retval > 0)
+        {
             to_send_list.push_back((iovec){ .iov_base = cur_op->buf, .iov_len = (size_t)cur_op->reply.hdr.retval });
+            to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = 0 });
+        }
         else if (cur_op->op_type == OSD_OP_OUT && cur_op->req.sec_read_bmp.len > 0)
+        {
             to_send_list.push_back((iovec){ .iov_base = cur_op->buf, .iov_len = (size_t)cur_op->req.sec_read_bmp.len });
-        to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = 0 });
+            to_outbox.push_back((msgr_sendp_t){ .op = cur_op, .flags = 0 });
+        }
     }
     if (cur_op->op_type == OSD_OP_IN)
     {
@@ -134,55 +140,6 @@ void osd_messenger_t::outbox_push(osd_op_t *cur_op)
     }
 }
 
-void osd_messenger_t::inc_op_stats(osd_op_stats_t & stats, uint64_t opcode, timespec & tv_begin, timespec & tv_end, uint64_t len)
-{
-    uint64_t usecs = (
-        (tv_end.tv_sec - tv_begin.tv_sec)*1000000 +
-        (tv_end.tv_nsec - tv_begin.tv_nsec)/1000
-    );
-    stats.op_stat_count[opcode]++;
-    if (!stats.op_stat_count[opcode])
-    {
-        stats.op_stat_count[opcode] = 1;
-        stats.op_stat_sum[opcode] = 0;
-        stats.op_stat_bytes[opcode] = 0;
-    }
-    stats.op_stat_sum[opcode] += usecs;
-    stats.op_stat_bytes[opcode] += len;
-}
-
-void osd_messenger_t::measure_exec(osd_op_t *cur_op)
-{
-    // Measure execution latency
-    if (cur_op->req.hdr.opcode > OSD_OP_MAX)
-    {
-        return;
-    }
-    if (!cur_op->tv_end.tv_sec)
-    {
-        clock_gettime(CLOCK_REALTIME, &cur_op->tv_end);
-    }
-    uint64_t len = 0;
-    if (cur_op->req.hdr.opcode == OSD_OP_READ ||
-        cur_op->req.hdr.opcode == OSD_OP_WRITE ||
-        cur_op->req.hdr.opcode == OSD_OP_SCRUB)
-    {
-        // req.rw.len is internally set to the full object size for scrubs
-        len = cur_op->req.rw.len;
-    }
-    else if (cur_op->req.hdr.opcode == OSD_OP_SEC_READ ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE ||
-        cur_op->req.hdr.opcode == OSD_OP_SEC_WRITE_STABLE)
-    {
-        len = cur_op->req.sec_rw.len;
-    }
-    inc_op_stats(stats, cur_op->req.hdr.opcode, cur_op->tv_begin, cur_op->tv_end, len);
-    if (cur_op->is_recovery_related())
-    {
-        inc_op_stats(recovery_stats, cur_op->req.hdr.opcode, cur_op->tv_begin, cur_op->tv_end, len);
-    }
-}
-
 bool osd_messenger_t::try_send(osd_client_t *cl)
 {
     if (!cl->send_list.size() || cl->write_msg.msg_iovlen > 0 || cl->peer_state == PEER_STOPPED || cl->peer_fd < 0)

src/client/msgr_stop.cpp

@@ -5,9 +5,6 @@
 #include <assert.h>
 
 #include "messenger.h"
-#ifdef WITH_RDMA
-#include "msgr_rdma.h"
-#endif
 
 void osd_client_t::cancel_ops()
 {
@@ -92,23 +89,11 @@ void osd_messenger_t::stop_client(uint64_t client_id, bool force_delete)
             osd_peers.erase(osd_it);
         }
     }
-#ifdef WITH_RDMA
-    if (cl->rdma_conn && cl->rdma_conn->cmid)
-    {
-        auto rdma_it = rdmacm_connections.find(cl->rdma_conn->cmid);
-        if (rdma_it != rdmacm_connections.end() && rdma_it->second == cl)
-        {
-            rdmacm_connections.erase(rdma_it);
-        }
-    }
-#endif
-#ifndef __MOCK__
     if (cl->connect_timeout_id >= 0)
     {
         tfd->clear_timer(cl->connect_timeout_id);
         cl->connect_timeout_id = -1;
     }
-#endif
     if (cl->in_osd_num && break_pg_locks)
     {
         // Break PG locks
@@ -143,9 +128,7 @@ void osd_messenger_t::destroy_client(osd_client_t *cl)
     clients.erase(cl->client_id);
     if (cl->peer_fd >= 0)
     {
-#ifndef __MOCK__
         tfd->set_fd_handler(cl->peer_fd, false, NULL);
-#endif
         for (auto rit = read_ready_clients.begin(); rit != read_ready_clients.end(); rit++)
         {
             if (*rit == cl->client_id)
@@ -164,6 +147,13 @@ void osd_messenger_t::destroy_client(osd_client_t *cl)
         }
         clients_by_fd.erase(cl->peer_fd);
     }
+#ifdef WITH_RDMA
+    if (cl->rdma_conn)
+    {
+        destroy_rdma_conn(cl->rdma_conn);
+        cl->rdma_conn = NULL;
+    }
+#endif
     delete cl;
 }
 
@@ -196,13 +186,4 @@ osd_client_t::~osd_client_t()
             delete op;
         }
     }
-#ifndef __MOCK__
-#ifdef WITH_RDMA
-    if (rdma_conn)
-    {
-        delete rdma_conn;
-        rdma_conn = NULL;
-    }
-#endif
-#endif
 }

src/client/nbd_proxy.cpp

@@ -301,10 +301,9 @@ const char *help_text =
     "     --nbd_disconnect_on_close 1\n"
     "       Disconnect the nbd device on close by last opener.\n"
 #endif
-#ifdef NBD_FLAG_READ_ONLY
+    "     --readonly\n"
     "     --nbd_ro 1\n"
     "       Set device into read only mode.\n"
-#endif
     "\n"
     "vitastor-nbd netlink-unmap /dev/nbdN\n"
     "  Unmap a device using netlink interface. Works with both netlink and ioctl mapped devices.\n"
@@ -348,6 +347,7 @@ protected:
     int read_ready = 0;
     msghdr read_msg = { 0 }, send_msg = { 0 };
     iovec read_iov = { 0 };
+    bool stop = false;
 
     std::string logfile = "/dev/null";
 
@@ -514,7 +514,7 @@ help:
         // Create client
         ringloop = new ring_loop_t(RINGLOOP_DEFAULT_SIZE);
         epmgr = new epoll_manager_t(ringloop);
-        cli = new cluster_client_t(ringloop, epmgr->tfd, cfg);
+        cli = cluster_client_t::create(ringloop, epmgr->tfd, cfg);
         if (!inode)
         {
             // Load image metadata
@@ -525,7 +525,7 @@ help:
                     break;
                 ringloop->wait();
             }
-            watch = cli->st_cli.watch_inode(image_name);
+            watch = cli->st_cli->watch_inode(image_name);
             device_size = watch->cfg.size;
             if (!watch->cfg.num || !device_size)
             {
@@ -581,10 +581,8 @@ help:
             }
             uint64_t flags = NBD_FLAG_SEND_FLUSH;
             uint64_t cflags = 0;
-#ifdef NBD_FLAG_READ_ONLY
-            if (!cfg["nbd_ro"].is_null())
+            if (!cfg["readonly"].is_null() || !cfg["nbd_ro"].is_null())
                 flags |= NBD_FLAG_READ_ONLY;
-#endif
 #ifdef NBD_CFLAG_DESTROY_ON_DISCONNECT
             if (!cfg["nbd_destroy_on_disconnect"].is_null())
                 cflags |= NBD_CFLAG_DESTROY_ON_DISCONNECT;
@@ -620,7 +618,10 @@ help:
             if (!cfg["dev_num"].is_null())
             {
                 int r;
-                if ((r = run_nbd(sockfd, cfg["dev_num"].int64_value(), device_size, NBD_FLAG_SEND_FLUSH, nbd_timeout, bg)) != 0)
+                uint64_t flags = NBD_FLAG_SEND_FLUSH;
+                if (!cfg["readonly"].is_null())
+                    flags |= NBD_FLAG_READ_ONLY;
+                if ((r = run_nbd(sockfd, cfg["dev_num"].int64_value(), device_size, flags, nbd_timeout, bg)) != 0)
                 {
                     fprintf(stderr, "run_nbd: %s\n", strerror(-r));
                     exit(1);
@@ -678,8 +679,7 @@ help:
         };
         ringloop->register_consumer(&consumer);
         // Add FD to epoll
-        bool stop = false;
-        epmgr->tfd->set_fd_handler(sockfd[0], false, [this, &stop](int peer_fd, int epoll_events)
+        epmgr->tfd->set_fd_handler(sockfd[0], false, [this](int peer_fd, int epoll_events)
         {
             if (epoll_events & EPOLLRDHUP)
             {
@@ -1118,7 +1118,8 @@ protected:
             {
                 // Disconnect
                 close(nbd_fd);
-                exit(0);
+                stop = true;
+                return;
             }
             if (be32toh(cur_req.magic) != NBD_REQUEST_MAGIC ||
                 req_type != NBD_CMD_READ && req_type != NBD_CMD_WRITE && req_type != NBD_CMD_FLUSH)

src/client/qemu_driver.c

@@ -705,6 +705,54 @@ static void vitastor_close(BlockDriverState *bs)
     client->last_bitmap = NULL;
 }
 
+// Unregister all event sources from the current AioContext. Called by the
+// block layer before bs is moved to a different AioContext (e.g. during live
+// migration, drain, dataplane switching). The block layer guarantees that no
+// requests are in flight at this point.
+static void vitastor_detach_aio_context(BlockDriverState *bs)
+{
+    VitastorClient *client = bs->opaque;
+    int i;
+#if defined VITASTOR_C_API_VERSION && VITASTOR_C_API_VERSION >= 2
+    if (client->uring_eventfd >= 0)
+    {
+        universal_aio_set_fd_handler(client->ctx, client->uring_eventfd, NULL, NULL, NULL);
+        // Wait until any scheduled B/H is processed before switching contexts:
+        // it would otherwise fire on the old context with stale state.
+        if (client->bh_uring_scheduled)
+        {
+            BDRV_POLL_WHILE(bs, client->bh_uring_scheduled);
+        }
+    }
+#endif
+    for (i = 0; i < client->fd_count; i++)
+    {
+        universal_aio_set_fd_handler(client->ctx, client->fds[i]->fd, NULL, NULL, NULL);
+    }
+}
+
+// (Re-)register all event sources on the new AioContext.
+static void vitastor_attach_aio_context(BlockDriverState *bs, AioContext *new_ctx)
+{
+    VitastorClient *client = bs->opaque;
+    int i;
+    client->ctx = new_ctx;
+#if defined VITASTOR_C_API_VERSION && VITASTOR_C_API_VERSION >= 2
+    if (client->uring_eventfd >= 0)
+    {
+        universal_aio_set_fd_handler(new_ctx, client->uring_eventfd, vitastor_uring_handler, NULL, client);
+    }
+#endif
+    for (i = 0; i < client->fd_count; i++)
+    {
+        VitastorFdData *fdd = client->fds[i];
+        universal_aio_set_fd_handler(new_ctx, fdd->fd,
+            fdd->fd_read ? vitastor_aio_fd_read : NULL,
+            fdd->fd_write ? vitastor_aio_fd_write : NULL,
+            fdd);
+    }
+}
+
 #if QEMU_VERSION_MAJOR >= 3 || QEMU_VERSION_MAJOR == 2 && QEMU_VERSION_MINOR >= 2
 static void vitastor_refresh_filename(BlockDriverState *bs)
 {
@@ -832,6 +880,25 @@ static int vitastor_refresh_limits(BlockDriverState *bs)
 //    return 0;
 //}
 
+// Move the running coroutine to the BlockDriverState's home AioContext.
+//
+// The block-coroutine-wrapper generator sets poll_state.ctx to
+// qemu_get_current_aio_context() in the sync wrappers (bdrv_flush(),
+// bdrv_pread() etc.). When bdrv_flush_all() runs under BQL from outside the
+// bs's iothread (e.g. on the migration thread inside do_vm_stop()), that is
+// the main AioContext, not the iothread that actually owns the bs. The
+// coroutine then runs on the wrong context while completions are delivered on
+// the iothread, and racing aio_co_schedule() vs. qemu_aio_coroutine_enter()
+// on the same coroutine triggers "Co-routine was already scheduled in
+// aio_co_schedule" and aborts the process (observed during live migration).
+//
+// aio_co_reschedule_self() is a no-op when we are already on the target ctx.
+#if QEMU_VERSION_MAJOR > 5 || QEMU_VERSION_MAJOR == 5 && QEMU_VERSION_MINOR >= 2
+#define vitastor_co_pin_to_bs_ctx(bs) aio_co_reschedule_self(bdrv_get_aio_context(bs))
+#else
+#define vitastor_co_pin_to_bs_ctx(bs) ((void)0)
+#endif
+
 static void vitastor_co_init_task(BlockDriverState *bs, VitastorRPC *task)
 {
     *task = (VitastorRPC) {
@@ -890,6 +957,7 @@ static int coroutine_fn vitastor_co_preadv(BlockDriverState *bs,
 {
     VitastorClient *client = bs->opaque;
     VitastorRPC task;
+    vitastor_co_pin_to_bs_ctx(bs);
     vitastor_co_init_task(bs, &task);
     task.iov = iov;
 
@@ -918,6 +986,7 @@ static int coroutine_fn vitastor_co_pwritev(BlockDriverState *bs,
 {
     VitastorClient *client = bs->opaque;
     VitastorRPC task;
+    vitastor_co_pin_to_bs_ctx(bs);
     vitastor_co_init_task(bs, &task);
     task.iov = iov;
 
@@ -991,6 +1060,7 @@ static int coroutine_fn vitastor_co_block_status(BlockDriverState *bs,
 #endif
     VitastorRPC task;
     VitastorClient *client = bs->opaque;
+    vitastor_co_pin_to_bs_ctx(bs);
     uint64_t inode = client->watch ? vitastor_c_inode_get_num(client->watch) : client->inode;
     uint8_t bit = 0;
     if (client->last_bitmap && client->last_bitmap_inode == inode &&
@@ -1049,7 +1119,7 @@ static int coroutine_fn vitastor_co_block_status(BlockDriverState *bs,
     {
         // Get larger allocated extents, possibly with false positives
         uint64_t bmp_pos = (offset-task.offset) / task.bitmap_granularity;
-        uint64_t bmp_end = (offset+bytes-task.offset) / task.bitmap_granularity - bmp_pos;
+        uint64_t bmp_end = (offset+bytes-task.offset) / task.bitmap_granularity;
         while (bmp_pos < bmp_end)
         {
             if (!(bmp_pos & 7) && bmp_end >= bmp_pos+8)
@@ -1103,6 +1173,7 @@ static int coroutine_fn vitastor_co_flush(BlockDriverState *bs)
 {
     VitastorClient *client = bs->opaque;
     VitastorRPC task;
+    vitastor_co_pin_to_bs_ctx(bs);
     vitastor_co_init_task(bs, &task);
 
     qemu_mutex_lock(&client->mutex);
@@ -1188,6 +1259,11 @@ static BlockDriver bdrv_vitastor = {
 #endif
     .bdrv_close                     = vitastor_close,
 
+    // Re-register fd handlers when the bs is moved to a different AioContext
+    // (live migration, drain, iothread reassignment).
+    .bdrv_detach_aio_context        = vitastor_detach_aio_context,
+    .bdrv_attach_aio_context        = vitastor_attach_aio_context,
+
     // Option list for the create operation
 #if QEMU_VERSION_MAJOR >= 3 || QEMU_VERSION_MAJOR == 2 && QEMU_VERSION_MINOR > 0
     .create_opts                    = &vitastor_create_opts,

src/client/ublk_server.cpp

@@ -62,6 +62,13 @@ const char *help_text =
     "All usual Vitastor config options like --config_path <path_to_config> may also be specified in CLI.\n"
 ;
 
+struct ublk_request
+{
+    uint64_t ublk_cmd;
+    int index;
+    int result;
+};
+
 class ublk_server
 {
 protected:
@@ -241,7 +248,7 @@ help:
 
         // Create client
         epmgr = new epoll_manager_t(ringloop);
-        cli = new cluster_client_t(ringloop, epmgr->tfd, cfg);
+        cli = cluster_client_t::create(ringloop, epmgr->tfd, cfg);
 
         // cli->config contains merged config
         if (!cfg["queue_depth"].is_null())
@@ -273,7 +280,7 @@ help:
         }
         if (!inode)
         {
-            watch = cli->st_cli.watch_inode(image_name);
+            watch = cli->st_cli->watch_inode(image_name);
             device_size = watch->cfg.size;
             if (!watch->cfg.num || !device_size)
             {
@@ -282,9 +289,9 @@ help:
                 exit(1);
             }
         }
-        const bool writeback = cli->get_immediate_commit(inode);
-        auto pool_it = cli->st_cli.pool_config.find(INODE_POOL(inode ? inode : watch->cfg.num));
-        if (pool_it == cli->st_cli.pool_config.end())
+        const bool writeback = !cli->get_immediate_commit(inode ? inode : watch->cfg.num);
+        auto pool_it = cli->st_cli->pool_config.find(INODE_POOL(inode ? inode : watch->cfg.num));
+        if (pool_it == cli->st_cli->pool_config.end())
         {
             fprintf(stderr, "Pool %u does not exist\n", INODE_POOL(inode ? inode : watch->cfg.num));
             exit(1);
@@ -331,6 +338,11 @@ help:
             daemonize_fork(notifyfd);
             close(notifyfd[0]);
         }
+        consumer.loop = [this]()
+        {
+            submit_postponed();
+        };
+        ringloop->register_consumer(&consumer);
         start_device(recover);
         if (pidfile != "")
             write_pid();
@@ -350,6 +362,7 @@ help:
             ringloop->wait();
         }
         cli->flush();
+        ringloop->unregister_consumer(&consumer);
         delete cli;
         delete epmgr;
         cli = NULL;
@@ -553,6 +566,8 @@ protected:
     ublksrv_ctrl_dev_info ublk_dev = {};
     ublksrv_io_desc *ublk_queue = NULL;
     std::vector<uint8_t*> buffers;
+    ring_consumer_t consumer;
+    std::vector<ublk_request> postponed_requests;
 
     void open_control()
     {
@@ -734,9 +749,19 @@ protected:
         ctrl_fd = -1;
     }
 
-    void submit_request(uint64_t ublk_cmd, int i, int res)
+    bool submit_request(uint64_t ublk_cmd, int i, int res)
     {
         io_uring_sqe *sqe = ringloop->get_sqe();
+        if (!sqe)
+        {
+            // Handle full io_uring by postponing the request
+            postponed_requests.push_back((ublk_request){
+                .ublk_cmd = ublk_cmd,
+                .index = i,
+                .result = res,
+            });
+            return false;
+        }
         ring_data_t* data = ((ring_data_t*)sqe->user_data);
         sqe->fd = cdev_fd;
         sqe->opcode = IORING_OP_URING_CMD;
@@ -750,6 +775,22 @@ protected:
         cmd->addr = (uint64_t)buffers[i];
         cmd->result = res;
         data->callback = [this, i](ring_data_t *data) { exec_request(data->res, i); };
+        return true;
+    }
+
+    void submit_postponed()
+    {
+        int sent = 0;
+        while (postponed_requests.size())
+        {
+            ublk_request r = postponed_requests.back();
+            postponed_requests.pop_back();
+            if (!submit_request(r.ublk_cmd, r.index, r.result))
+                break;
+            sent++;
+        }
+        if (sent)
+            ringloop->submit();
     }
 
     void exec_request(int res, int i)
@@ -864,6 +905,11 @@ protected:
     int sync_ublk_cmd(uint32_t cmd_op, void *addr, uint32_t len, uint16_t dev_path_len = 0, uint64_t data0 = 0)
     {
         io_uring_sqe *sqe = ringloop->get_sqe();
+        if (!sqe)
+        {
+            fprintf(stderr, "Error: io_uring is full when trying to execute a control command\n");
+            exit(1);
+        }
         sqe->fd = ctrl_fd;
         sqe->opcode = IORING_OP_URING_CMD;
         sqe->ioprio = 0;

src/client/vitastor.pc.in

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

src/client/vitastor_c.cpp

@@ -103,7 +103,7 @@ vitastor_c *vitastor_c_create_qemu(QEMUSetFDHandler *aio_set_fd_handler, void *a
         rdma_device, rdma_port_num, rdma_gid_index, rdma_mtu, log_level
     );
     auto self = vitastor_c_create_qemu_common(aio_set_fd_handler, aio_context);
-    self->cli = new cluster_client_t(NULL, self->tfd, cfg_json);
+    self->cli = cluster_client_t::create(NULL, self->tfd, cfg_json);
     return self;
 }
 
@@ -126,7 +126,7 @@ vitastor_c *vitastor_c_create_qemu_uring(QEMUSetFDHandler *aio_set_fd_handler, v
     );
     auto self = vitastor_c_create_qemu_common(aio_set_fd_handler, aio_context);
     self->ringloop = ringloop;
-    self->cli = new cluster_client_t(self->ringloop, self->tfd, cfg_json);
+    self->cli = cluster_client_t::create(self->ringloop, self->tfd, cfg_json);
     ringloop->loop();
     return self;
 }
@@ -150,7 +150,7 @@ vitastor_c *vitastor_c_create_uring(const char *config_path, const char *etcd_ho
     vitastor_c *self = new vitastor_c;
     self->ringloop = ringloop;
     self->epmgr = new epoll_manager_t(self->ringloop);
-    self->cli = new cluster_client_t(self->ringloop, self->epmgr->tfd, cfg_json);
+    self->cli = cluster_client_t::create(self->ringloop, self->epmgr->tfd, cfg_json);
     ringloop->loop();
     return self;
 }
@@ -191,7 +191,7 @@ vitastor_c *vitastor_c_create_uring_json(const char **options, int options_len)
     vitastor_c *self = new vitastor_c;
     self->ringloop = ringloop;
     self->epmgr = new epoll_manager_t(self->ringloop);
-    self->cli = new cluster_client_t(self->ringloop, self->epmgr->tfd, cfg_json);
+    self->cli = cluster_client_t::create(self->ringloop, self->epmgr->tfd, cfg_json);
     ringloop->loop();
     return self;
 }
@@ -206,7 +206,7 @@ vitastor_c *vitastor_c_create_epoll_json(const char **options, int options_len)
     json11::Json cfg_json(cfg);
     vitastor_c *self = new vitastor_c;
     self->epmgr = new epoll_manager_t(NULL);
-    self->cli = new cluster_client_t(NULL, self->epmgr->tfd, cfg_json);
+    self->cli = cluster_client_t::create(NULL, self->epmgr->tfd, cfg_json);
     return self;
 }
 
@@ -396,7 +396,7 @@ void vitastor_c_watch_inode(vitastor_c *client, char *image, VitastorIOHandler c
 {
     client->cli->on_ready([=]()
     {
-        auto watch = client->cli->st_cli.watch_inode(std::string(image));
+        auto watch = client->cli->st_cli->watch_inode(std::string(image));
         cb(opaque, (long)watch);
     });
     if (client->ringloop)
@@ -407,7 +407,7 @@ void vitastor_c_watch_inode(vitastor_c *client, char *image, VitastorIOHandler c
 
 void vitastor_c_close_watch(vitastor_c *client, void *handle)
 {
-    client->cli->st_cli.close_watch((inode_watch_t*)handle);
+    client->cli->st_cli->close_watch((inode_watch_t*)handle);
 }
 
 uint64_t vitastor_c_inode_get_size(void *handle)
@@ -424,8 +424,8 @@ uint64_t vitastor_c_inode_get_num(void *handle)
 
 uint32_t vitastor_c_inode_get_block_size(vitastor_c *client, uint64_t inode_num)
 {
-    auto pool_it = client->cli->st_cli.pool_config.find(INODE_POOL(inode_num));
-    if (pool_it == client->cli->st_cli.pool_config.end())
+    auto pool_it = client->cli->st_cli->pool_config.find(INODE_POOL(inode_num));
+    if (pool_it == client->cli->st_cli->pool_config.end())
         return 0;
     auto & pool_cfg = pool_it->second;
     uint32_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
@@ -434,8 +434,8 @@ uint32_t vitastor_c_inode_get_block_size(vitastor_c *client, uint64_t inode_num)
 
 uint32_t vitastor_c_inode_get_bitmap_granularity(vitastor_c *client, uint64_t inode_num)
 {
-    auto pool_it = client->cli->st_cli.pool_config.find(INODE_POOL(inode_num));
-    if (pool_it == client->cli->st_cli.pool_config.end())
+    auto pool_it = client->cli->st_cli->pool_config.find(INODE_POOL(inode_num));
+    if (pool_it == client->cli->st_cli->pool_config.end())
         return 0;
     // FIXME: READ_BITMAP may fails if parent bitmap granularity differs from inode bitmap granularity
     return pool_it->second.bitmap_granularity;
@@ -471,8 +471,8 @@ uint64_t vitastor_c_inode_get_mod_revision(void *handle)
 
 uint32_t vitastor_c_inode_get_immediate_commit(vitastor_c *client, uint64_t inode_num)
 {
-    auto pool_it = client->cli->st_cli.pool_config.find(INODE_POOL(inode_num));
-    if (pool_it == client->cli->st_cli.pool_config.end())
+    auto pool_it = client->cli->st_cli->pool_config.find(INODE_POOL(inode_num));
+    if (pool_it == client->cli->st_cli->pool_config.end())
         return 0;
     return pool_it->second.immediate_commit;
 }

src/cmd/CMakeLists.txt

@@ -27,6 +27,7 @@ add_library(vitastor_cli STATIC
 	cli_pool_ls.cpp
 	cli_pool_modify.cpp
 	cli_pool_rm.cpp
+	cli_raw_ls.cpp
 )
 target_compile_options(vitastor_cli PUBLIC -fPIC)
 

src/cmd/cli.cpp

@@ -126,6 +126,11 @@ static const char* help_text =
     "  --min-offset, --max-offset\n"
     "      Restrict listing to specific offsets inside inodes.\n"
     "\n"
+    "vitastor-cli raw-ls [OPTIONS]\n"
+    "  Find object(s) in the cluster using raw secondary listing operations. Options:\n"
+    "  [--min_inode NUM] [--max_inode NUM] [--offset NUM] [--pg_num NUM] [--pg_count COUNT]\n"
+    "  [--pg_stripe_size NUM] [--osds 1,2,3,...]\n"
+    "\n"
     "vitastor-cli fix [--objects <objects>] [--bad-osds <osds>] [--part <part>] [--check no]\n"
     "  Fix inconsistent objects in the cluster by deleting some copies.\n"
     "  --objects <objects>\n"
@@ -459,6 +464,11 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
         // Describe unclean objects
         action_cb = p->start_describe(cfg);
     }
+    else if (cmd[0] == "raw-ls")
+    {
+        // Run raw listings
+        action_cb = p->start_raw_ls(cfg);
+    }
     else if (cmd[0] == "fix")
     {
         // Fix inconsistent objects (by deleting some copies)
@@ -545,7 +555,7 @@ static int run(cli_tool_t *p, json11::Json::object cfg)
         json11::Json cfg_j = cfg;
         p->ringloop = new ring_loop_t(RINGLOOP_DEFAULT_SIZE);
         p->epmgr = new epoll_manager_t(p->ringloop);
-        p->cli = new cluster_client_t(p->ringloop, p->epmgr->tfd, cfg_j);
+        p->cli = cluster_client_t::create(p->ringloop, p->epmgr->tfd, cfg_j);
         p->loop_and_wait(action_cb, [&](const cli_result_t & r)
         {
             result = r;

src/cmd/cli.h

@@ -62,6 +62,7 @@ public:
     std::function<bool(cli_result_t &)> start_fix(json11::Json);
     std::function<bool(cli_result_t &)> start_flatten(json11::Json);
     std::function<bool(cli_result_t &)> start_ls(json11::Json);
+    std::function<bool(cli_result_t &)> start_raw_ls(json11::Json cfg);
     std::function<bool(cli_result_t &)> start_merge(json11::Json);
     std::function<bool(cli_result_t &)> start_modify(json11::Json);
     std::function<bool(cli_result_t &)> start_modify_osd(json11::Json);

src/cmd/cli_alloc_osd.cpp

@@ -35,7 +35,7 @@ struct alloc_osd_t
                         { "target", "VERSION" },
                         { "version", 0 },
                         { "key", base64_encode(
-                            parent->cli->st_cli.etcd_prefix+"/osd/stats/"+std::to_string(new_id)
+                            parent->cli->st_cli->etcd_prefix+"/osd/stats/"+std::to_string(new_id)
                         ) },
                     },
                 } },
@@ -43,7 +43,7 @@ struct alloc_osd_t
                     json11::Json::object {
                         { "request_put", json11::Json::object {
                             { "key", base64_encode(
-                                parent->cli->st_cli.etcd_prefix+"/osd/stats/"+std::to_string(new_id)
+                                parent->cli->st_cli->etcd_prefix+"/osd/stats/"+std::to_string(new_id)
                             ) },
                             { "value", base64_encode("{}") },
                         } },
@@ -52,8 +52,8 @@ struct alloc_osd_t
                 { "failure", json11::Json::array {
                     json11::Json::object {
                         { "request_range", json11::Json::object {
-                            { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/osd/stats/") },
-                            { "range_end", base64_encode(parent->cli->st_cli.etcd_prefix+"/osd/stats0") },
+                            { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/osd/stats/") },
+                            { "range_end", base64_encode(parent->cli->st_cli->etcd_prefix+"/osd/stats0") },
                             { "keys_only", true },
                         } },
                     },

src/cmd/cli_common.cpp

@@ -8,8 +8,8 @@
 
 void cli_tool_t::change_parent(inode_t cur, inode_t new_parent, cli_result_t *result)
 {
-    auto cur_cfg_it = cli->st_cli.inode_config.find(cur);
-    if (cur_cfg_it == cli->st_cli.inode_config.end())
+    auto cur_cfg_it = cli->st_cli->inode_config.find(cur);
+    if (cur_cfg_it == cli->st_cli->inode_config.end())
     {
         char buf[128];
         snprintf(buf, 128, "Inode 0x%jx disappeared", cur);
@@ -18,13 +18,13 @@ void cli_tool_t::change_parent(inode_t cur, inode_t new_parent, cli_result_t *re
     }
     inode_config_t new_cfg = cur_cfg_it->second;
     std::string cur_name = new_cfg.name;
-    std::string cur_cfg_key = base64_encode(cli->st_cli.etcd_prefix+
+    std::string cur_cfg_key = base64_encode(cli->st_cli->etcd_prefix+
         "/config/inode/"+std::to_string(INODE_POOL(cur))+
         "/"+std::to_string(INODE_NO_POOL(cur)));
     new_cfg.parent_id = new_parent;
-    json11::Json::object cur_cfg_json = cli->st_cli.serialize_inode_cfg(&new_cfg);
+    json11::Json::object cur_cfg_json = cli->st_cli->serialize_inode_cfg(&new_cfg);
     waiting++;
-    cli->st_cli.etcd_txn_slow(json11::Json::object {
+    cli->st_cli->etcd_txn_slow(json11::Json::object {
         { "compare", json11::Json::array {
             json11::Json::object {
                 { "target", "MOD" },
@@ -53,8 +53,8 @@ void cli_tool_t::change_parent(inode_t cur, inode_t new_parent, cli_result_t *re
         }
         else if (new_parent)
         {
-            auto new_parent_it = cli->st_cli.inode_config.find(new_parent);
-            std::string new_parent_name = new_parent_it != cli->st_cli.inode_config.end()
+            auto new_parent_it = cli->st_cli->inode_config.find(new_parent);
+            std::string new_parent_name = new_parent_it != cli->st_cli->inode_config.end()
                 ? new_parent_it->second.name : "<unknown>";
             *result = (cli_result_t){
                 .text = "Parent of layer "+cur_name+" (inode "+std::to_string(INODE_NO_POOL(cur))+
@@ -77,7 +77,7 @@ void cli_tool_t::change_parent(inode_t cur, inode_t new_parent, cli_result_t *re
 void cli_tool_t::etcd_txn(json11::Json txn)
 {
     waiting++;
-    cli->st_cli.etcd_txn_slow(txn, [this](std::string err, json11::Json res)
+    cli->st_cli->etcd_txn_slow(txn, [this](std::string err, json11::Json res)
     {
         waiting--;
         if (err != "")
@@ -91,7 +91,7 @@ void cli_tool_t::etcd_txn(json11::Json txn)
 
 inode_config_t* cli_tool_t::get_inode_cfg(const std::string & name)
 {
-    for (auto & ic: cli->st_cli.inode_config)
+    for (auto & ic: cli->st_cli->inode_config)
     {
         if (ic.second.name == name)
         {
@@ -171,11 +171,11 @@ void cli_tool_t::iterate_kvs_1(json11::Json kvs, const std::string & prefix, std
     bool is_pool = prefix == "/pool/stats/";
     for (auto & kv_item: kvs.array_items())
     {
-        auto kv = cli->st_cli.parse_etcd_kv(kv_item);
+        auto kv = cli->st_cli->parse_etcd_kv(kv_item);
         uint64_t num = 0;
         char null_byte = 0;
         // OSD or pool number
-        int scanned = sscanf(kv.key.substr(cli->st_cli.etcd_prefix.size() + prefix.size()).c_str(), "%ju%c", &num, &null_byte);
+        int scanned = sscanf(kv.key.substr(cli->st_cli->etcd_prefix.size() + prefix.size()).c_str(), "%ju%c", &num, &null_byte);
         if (scanned != 1 || !num || is_pool && num >= POOL_ID_MAX)
         {
             fprintf(stderr, "Invalid key in etcd: %s\n", kv.key.c_str());
@@ -190,12 +190,12 @@ void cli_tool_t::iterate_kvs_2(json11::Json kvs, const std::string & prefix, std
     bool is_inode = prefix == "/config/inode/" || prefix == "/inode/stats/";
     for (auto & kv_item: kvs.array_items())
     {
-        auto kv = cli->st_cli.parse_etcd_kv(kv_item);
+        auto kv = cli->st_cli->parse_etcd_kv(kv_item);
         pool_id_t pool_id = 0;
         uint64_t num = 0;
         char null_byte = 0;
         // pool+pg or pool+inode
-        int scanned = sscanf(kv.key.substr(cli->st_cli.etcd_prefix.size() + prefix.size()).c_str(),
+        int scanned = sscanf(kv.key.substr(cli->st_cli->etcd_prefix.size() + prefix.size()).c_str(),
             "%u/%ju%c", &pool_id, &num, &null_byte);
         if (scanned != 2 || !pool_id || is_inode && INODE_POOL(num) || !is_inode && num >= UINT32_MAX)
         {

src/cmd/cli_create.cpp

@@ -46,7 +46,7 @@ struct image_creator_t
 
     void loop()
     {
-        auto & pools = parent->cli->st_cli.pool_config;
+        auto & pools = parent->cli->st_cli->pool_config;
         if (state >= 1)
             goto resume_1;
         if (image_name == "")
@@ -117,7 +117,7 @@ struct image_creator_t
             goto resume_2;
         else if (state == 3)
             goto resume_3;
-        for (auto & ic: parent->cli->st_cli.inode_config)
+        for (auto & ic: parent->cli->st_cli->inode_config)
         {
             if (ic.second.name == image_name)
             {
@@ -193,7 +193,7 @@ resume_3:
         } while (!parent->etcd_result["succeeded"].bool_value());
         // Save into inode_config for library users to be able to take it from there immediately
         new_cfg.mod_revision = parent->etcd_result["header"]["revision"].uint64_value();
-        parent->cli->st_cli.insert_inode_config(new_cfg);
+        parent->cli->st_cli->insert_inode_config(new_cfg);
         result = (cli_result_t){
             .err = 0,
             .text = "Image "+image_name+" created",
@@ -215,8 +215,8 @@ resume_3:
             goto resume_3;
         else if (state == 4)
             goto resume_4;
-        // FIXME: take all info from etcd requests, not mixed with st_cli.inode_config
-        for (auto & ic: parent->cli->st_cli.inode_config)
+        // FIXME: take all info from etcd requests, not mixed with st_cli->inode_config
+        for (auto & ic: parent->cli->st_cli->inode_config)
         {
             if (ic.second.name == image_name+"@"+new_snap)
             {
@@ -271,7 +271,7 @@ resume_4:
         } while (!parent->etcd_result["succeeded"].bool_value());
         // Save into inode_config for library users to be able to take it from there immediately
         new_cfg.mod_revision = parent->etcd_result["header"]["revision"].uint64_value();
-        parent->cli->st_cli.insert_inode_config(new_cfg);
+        parent->cli->st_cli->insert_inode_config(new_cfg);
         result = (cli_result_t){
             .err = 0,
             .text = "Snapshot "+image_name+"@"+new_snap+" created",
@@ -291,7 +291,7 @@ resume_4:
         return json11::Json::object {
             { "request_range", json11::Json::object {
                 { "key", base64_encode(
-                    parent->cli->st_cli.etcd_prefix+"/index/maxid/"+std::to_string(new_pool_id)
+                    parent->cli->st_cli->etcd_prefix+"/index/maxid/"+std::to_string(new_pool_id)
                 ) },
             } },
         };
@@ -303,13 +303,13 @@ resume_4:
         max_id_mod_rev = 0;
         if (response["response_range"]["kvs"].array_items().size() > 0)
         {
-            auto kv = parent->cli->st_cli.parse_etcd_kv(response["response_range"]["kvs"][0]);
+            auto kv = parent->cli->st_cli->parse_etcd_kv(response["response_range"]["kvs"][0]);
             new_id = 1+INODE_NO_POOL(kv.value.uint64_value());
             max_id_mod_rev = kv.mod_revision;
         }
         // Also check existing inodes - for the case when some inodes are created without changing /index/maxid
-        auto ino_it = parent->cli->st_cli.inode_config.lower_bound(INODE_WITH_POOL(new_pool_id+1, 0));
-        if (ino_it != parent->cli->st_cli.inode_config.begin())
+        auto ino_it = parent->cli->st_cli->inode_config.lower_bound(INODE_WITH_POOL(new_pool_id+1, 0));
+        if (ino_it != parent->cli->st_cli->inode_config.begin())
         {
             ino_it--;
             if (INODE_POOL(ino_it->first) == new_pool_id && new_id < 1+INODE_NO_POOL(ino_it->first))
@@ -325,7 +325,7 @@ resume_4:
             goto resume_3;
         if (!new_pool_id)
         {
-            for (auto & ic: parent->cli->st_cli.inode_config)
+            for (auto & ic: parent->cli->st_cli->inode_config)
             {
                 if (ic.second.name == image_name)
                 {
@@ -339,7 +339,7 @@ resume_4:
             json11::Json::object {
                 { "request_range", json11::Json::object {
                     { "key", base64_encode(
-                        parent->cli->st_cli.etcd_prefix+"/index/image/"+image_name
+                        parent->cli->st_cli->etcd_prefix+"/index/image/"+image_name
                     ) },
                 } },
             },
@@ -360,7 +360,7 @@ resume_2:
         cfg_mod_rev = idx_mod_rev = 0;
         if (parent->etcd_result["responses"][1]["response_range"]["kvs"].array_items().size() == 0)
         {
-            for (auto & ic: parent->cli->st_cli.inode_config)
+            for (auto & ic: parent->cli->st_cli->inode_config)
             {
                 if (ic.second.name == image_name)
                 {
@@ -377,7 +377,7 @@ resume_2:
         {
             // FIXME: Parse kvs in etcd_state_client automatically
             {
-                auto kv = parent->cli->st_cli.parse_etcd_kv(parent->etcd_result["responses"][1]["response_range"]["kvs"][0]);
+                auto kv = parent->cli->st_cli->parse_etcd_kv(parent->etcd_result["responses"][1]["response_range"]["kvs"][0]);
                 old_id = INODE_NO_POOL(kv.value["id"].uint64_value());
                 old_pool_id = (pool_id_t)kv.value["pool_id"].uint64_value();
                 idx_mod_rev = kv.mod_revision;
@@ -393,7 +393,7 @@ resume_2:
                     json11::Json::object {
                         { "request_range", json11::Json::object {
                             { "key", base64_encode(
-                                parent->cli->st_cli.etcd_prefix+"/config/inode/"+
+                                parent->cli->st_cli->etcd_prefix+"/config/inode/"+
                                 std::to_string(old_pool_id)+"/"+std::to_string(old_id)
                             ) },
                         } },
@@ -411,7 +411,7 @@ resume_3:
                 return;
             }
             {
-                auto kv = parent->cli->st_cli.parse_etcd_kv(parent->etcd_result["responses"][0]["response_range"]["kvs"][0]);
+                auto kv = parent->cli->st_cli->parse_etcd_kv(parent->etcd_result["responses"][0]["response_range"]["kvs"][0]);
                 size = kv.value["size"].uint64_value();
                 new_parent_id = kv.value["parent_id"].uint64_value();
                 uint64_t parent_pool_id = kv.value["parent_pool"].uint64_value();
@@ -439,7 +439,7 @@ resume_3:
                 { "target", "VERSION" },
                 { "version", 0 },
                 { "key", base64_encode(
-                    parent->cli->st_cli.etcd_prefix+"/config/inode/"+
+                    parent->cli->st_cli->etcd_prefix+"/config/inode/"+
                     std::to_string(new_pool_id)+"/"+std::to_string(new_id)
                 ) },
             },
@@ -447,31 +447,31 @@ resume_3:
                 { "target", "VERSION" },
                 { "version", 0 },
                 { "key", base64_encode(
-                    parent->cli->st_cli.etcd_prefix+"/index/image/"+image_name+
+                    parent->cli->st_cli->etcd_prefix+"/index/image/"+image_name+
                     (new_snap != "" ? "@"+new_snap : "")
                 ) },
             },
             json11::Json::object {
                 { "target", "MOD" },
                 { "mod_revision", max_id_mod_rev },
-                { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/index/maxid/"+std::to_string(new_pool_id)) },
+                { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/index/maxid/"+std::to_string(new_pool_id)) },
             },
         };
         json11::Json::array success = json11::Json::array {
             json11::Json::object {
                 { "request_put", json11::Json::object {
                     { "key", base64_encode(
-                        parent->cli->st_cli.etcd_prefix+"/config/inode/"+
+                        parent->cli->st_cli->etcd_prefix+"/config/inode/"+
                         std::to_string(new_pool_id)+"/"+std::to_string(new_id)
                     ) },
                     { "value", base64_encode(
-                        json11::Json(parent->cli->st_cli.serialize_inode_cfg(&new_cfg)).dump()
+                        json11::Json(parent->cli->st_cli->serialize_inode_cfg(&new_cfg)).dump()
                     ) },
                 } },
             },
             json11::Json::object {
                 { "request_put", json11::Json::object {
-                    { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/index/image/"+image_name) },
+                    { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/index/image/"+image_name) },
                     { "value", base64_encode(json11::Json(json11::Json::object{
                         { "id", new_id },
                         { "pool_id", (uint64_t)new_pool_id },
@@ -481,7 +481,7 @@ resume_3:
             json11::Json::object {
                 { "request_put", json11::Json::object {
                     { "key", base64_encode(
-                        parent->cli->st_cli.etcd_prefix+"/index/maxid/"+
+                        parent->cli->st_cli->etcd_prefix+"/index/maxid/"+
                         std::to_string(new_pool_id)
                     ) },
                     { "value", base64_encode(std::to_string(new_id)) }
@@ -492,7 +492,7 @@ resume_3:
             json11::Json::object {
                 { "request_range", json11::Json::object {
                     { "key", base64_encode(
-                        parent->cli->st_cli.etcd_prefix+"/index/image/"+
+                        parent->cli->st_cli->etcd_prefix+"/index/image/"+
                         image_name+(new_snap != "" ? "@"+new_snap : "")
                     ) },
                 } },
@@ -511,29 +511,29 @@ resume_3:
                 { "target", "MOD" },
                 { "mod_revision", cfg_mod_rev },
                 { "key", base64_encode(
-                    parent->cli->st_cli.etcd_prefix+"/config/inode/"+
+                    parent->cli->st_cli->etcd_prefix+"/config/inode/"+
                     std::to_string(old_pool_id)+"/"+std::to_string(old_id)
                 ) },
             });
             checks.push_back(json11::Json::object {
                 { "target", "MOD" },
                 { "mod_revision", idx_mod_rev },
-                { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/index/image/"+image_name) }
+                { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/index/image/"+image_name) }
             });
             success.push_back(json11::Json::object {
                 { "request_put", json11::Json::object {
                     { "key", base64_encode(
-                        parent->cli->st_cli.etcd_prefix+"/config/inode/"+
+                        parent->cli->st_cli->etcd_prefix+"/config/inode/"+
                         std::to_string(old_pool_id)+"/"+std::to_string(old_id)
                     ) },
                     { "value", base64_encode(
-                        json11::Json(parent->cli->st_cli.serialize_inode_cfg(&snap_cfg)).dump()
+                        json11::Json(parent->cli->st_cli->serialize_inode_cfg(&snap_cfg)).dump()
                     ) },
                 } },
             });
             success.push_back(json11::Json::object {
                 { "request_put", json11::Json::object {
-                    { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/index/image/"+image_name+"@"+new_snap) },
+                    { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/index/image/"+image_name+"@"+new_snap) },
                     { "value", base64_encode(json11::Json(json11::Json::object{
                         { "id", old_id },
                         { "pool_id", (uint64_t)old_pool_id },

src/cmd/cli_dd.cpp

@@ -52,19 +52,19 @@ struct dd_in_info_t
         in_seekable = true;
         if (iimg != "")
         {
-            iwatch = parent->cli->st_cli.watch_inode(iimg);
+            iwatch = parent->cli->st_cli->watch_inode(iimg);
             if (!iwatch->cfg.num)
             {
                 result = (cli_result_t){ .err = ENOENT, .text = "Image "+iimg+" does not exist" };
-                parent->cli->st_cli.close_watch(iwatch);
+                parent->cli->st_cli->close_watch(iwatch);
                 iwatch = NULL;
                 return;
             }
-            auto pool_it = parent->cli->st_cli.pool_config.find(INODE_POOL(iwatch->cfg.num));
-            if (pool_it == parent->cli->st_cli.pool_config.end())
+            auto pool_it = parent->cli->st_cli->pool_config.find(INODE_POOL(iwatch->cfg.num));
+            if (pool_it == parent->cli->st_cli->pool_config.end())
             {
                 result = (cli_result_t){ .err = ENOENT, .text = "Pool of image "+iimg+" does not exist" };
-                parent->cli->st_cli.close_watch(iwatch);
+                parent->cli->st_cli->close_watch(iwatch);
                 iwatch = NULL;
                 return;
             }
@@ -131,7 +131,7 @@ struct dd_in_info_t
     {
         if (iimg != "")
         {
-            parent->cli->st_cli.close_watch(iwatch);
+            parent->cli->st_cli->close_watch(iwatch);
             iwatch = NULL;
         }
         else if (ifile != "")
@@ -163,11 +163,11 @@ struct dd_out_info_t
 
     pool_config_t *find_pool(cli_tool_t *parent, const std::string & name)
     {
-        if (name == "" && parent->cli->st_cli.pool_config.size() == 1)
+        if (name == "" && parent->cli->st_cli->pool_config.size() == 1)
         {
-            return &parent->cli->st_cli.pool_config.begin()->second;
+            return &parent->cli->st_cli->pool_config.begin()->second;
         }
-        for (auto & pp: parent->cli->st_cli.pool_config)
+        for (auto & pp: parent->cli->st_cli->pool_config)
         {
             if (pp.second.name == name)
             {
@@ -186,14 +186,14 @@ struct dd_out_info_t
         if (oimg != "")
         {
             out_seekable = true;
-            owatch = parent->cli->st_cli.watch_inode(oimg);
+            owatch = parent->cli->st_cli->watch_inode(oimg);
             if (owatch->cfg.num)
             {
-                auto pool_it = parent->cli->st_cli.pool_config.find(INODE_POOL(owatch->cfg.num));
-                if (pool_it == parent->cli->st_cli.pool_config.end())
+                auto pool_it = parent->cli->st_cli->pool_config.find(INODE_POOL(owatch->cfg.num));
+                if (pool_it == parent->cli->st_cli->pool_config.end())
                 {
                     result = (cli_result_t){ .err = ENOENT, .text = "Pool of image "+oimg+" does not exist" };
-                    parent->cli->st_cli.close_watch(owatch);
+                    parent->cli->st_cli->close_watch(owatch);
                     owatch = NULL;
                     return true;
                 }
@@ -209,7 +209,7 @@ struct dd_out_info_t
                 else
                 {
                     result = (cli_result_t){ .err = ENOENT, .text = "Pool to create output image "+oimg+" is not specified" };
-                    parent->cli->st_cli.close_watch(owatch);
+                    parent->cli->st_cli->close_watch(owatch);
                     owatch = NULL;
                     return true;
                 }
@@ -224,14 +224,14 @@ struct dd_out_info_t
                 if (!out_create)
                 {
                     result = (cli_result_t){ .err = ENOENT, .text = "Image "+oimg+" does not exist" };
-                    parent->cli->st_cli.close_watch(owatch);
+                    parent->cli->st_cli->close_watch(owatch);
                     owatch = NULL;
                     return true;
                 }
                 if (!out_size)
                 {
                     result = (cli_result_t){ .err = ENOENT, .text = "Input size is unknown, specify size to create output image "+oimg };
-                    parent->cli->st_cli.close_watch(owatch);
+                    parent->cli->st_cli->close_watch(owatch);
                     owatch = NULL;
                     return true;
                 }
@@ -247,7 +247,7 @@ struct dd_out_info_t
                 if (!out_size)
                 {
                     result = (cli_result_t){ .err = ENOENT, .text = "Input size is unknown, specify size to truncate output image" };
-                    parent->cli->st_cli.close_watch(owatch);
+                    parent->cli->st_cli->close_watch(owatch);
                     owatch = NULL;
                     return true;
                 }
@@ -275,7 +275,7 @@ resume_1:
             sub_cb = NULL;
             if (result.err)
             {
-                parent->cli->st_cli.close_watch(owatch);
+                parent->cli->st_cli->close_watch(owatch);
                 owatch = NULL;
                 return true;
             }
@@ -324,8 +324,14 @@ resume_2:
                 cluster_op_t *sync_op = new cluster_op_t;
                 sync_op->opcode = OSD_OP_SYNC;
                 parent->waiting++;
-                sync_op->callback = [parent](cluster_op_t *sync_op)
+                sync_op->callback = [this, parent](cluster_op_t *sync_op)
                 {
+                    if (sync_op->retval != 0 && !result.err)
+                    {
+                        // Just in case, actually OP_SYNC can't fail
+                        result.err = -sync_op->retval;
+                        result.text = "Failed to sync "+oimg+": "+std::string(strerror(result.err));
+                    }
                     parent->waiting--;
                     delete sync_op;
                     parent->ringloop->wakeup();
@@ -354,7 +360,7 @@ resume_2:
     {
         if (oimg != "")
         {
-            parent->cli->st_cli.close_watch(owatch);
+            parent->cli->st_cli->close_watch(owatch);
             owatch = NULL;
         }
         else

src/cmd/cli_describe.cpp

@@ -60,7 +60,7 @@ struct cli_describe_t
         only_pool = cfg["pool"].uint64_value();
         if (!only_pool && cfg["pool"].is_string())
         {
-            for (auto & pp: parent->cli->st_cli.pool_config)
+            for (auto & pp: parent->cli->st_cli->pool_config)
             {
                 if (pp.second.name == cfg["pool"].string_value())
                 {
@@ -125,7 +125,7 @@ struct cli_describe_t
         {
             uint64_t min_pool = min_inode >> (64-POOL_ID_BITS);
             uint64_t max_pool = max_inode >> (64-POOL_ID_BITS);
-            for (auto & pp: parent->cli->st_cli.pool_config)
+            for (auto & pp: parent->cli->st_cli->pool_config)
             {
                 if (pp.first >= min_pool && (!max_pool || pp.first <= max_pool))
                 {

src/cmd/cli_fix.cpp

@@ -134,8 +134,8 @@ struct cli_fix_t
                 return;
             }
             auto & obj = objects[processed_count++];
-            auto pool_cfg_it = parent->cli->st_cli.pool_config.find(INODE_POOL(obj.inode));
-            if (pool_cfg_it == parent->cli->st_cli.pool_config.end())
+            auto pool_cfg_it = parent->cli->st_cli->pool_config.find(INODE_POOL(obj.inode));
+            if (pool_cfg_it == parent->cli->st_cli->pool_config.end())
             {
                 fprintf(stderr, "Object %jx:%jx is from unknown pool\n", obj.inode, obj.stripe);
                 continue;

src/cmd/cli_flatten.cpp

@@ -41,8 +41,8 @@ struct snap_flattener_t
         chain_list.push_back(cur->num);
         while (cur->parent_id != 0 && cur->parent_id != target_cfg->num)
         {
-            auto it = parent->cli->st_cli.inode_config.find(cur->parent_id);
-            if (it == parent->cli->st_cli.inode_config.end())
+            auto it = parent->cli->st_cli->inode_config.find(cur->parent_id);
+            if (it == parent->cli->st_cli->inode_config.end())
             {
                 result = (cli_result_t){
                     .err = ENOENT,
@@ -97,9 +97,9 @@ struct snap_flattener_t
             { "from", top_parent_name },
             { "to", target_name },
             { "target", target_name },
-            { "delete-source", false },
+            { "delete_source", false },
             { "cas", use_cas },
-            { "fsync-interval", fsync_interval },
+            { "fsync_interval", fsync_interval },
         });
         // Wait for it
 resume_1:

src/cmd/cli_ls.cpp

@@ -37,7 +37,7 @@ struct image_lister_t
     {
         if (list_pool_name != "")
         {
-            for (auto & ic: parent->cli->st_cli.pool_config)
+            for (auto & ic: parent->cli->st_cli->pool_config)
             {
                 if (ic.second.name == list_pool_name)
                 {
@@ -52,14 +52,14 @@ struct image_lister_t
                 return;
             }
         }
-        for (auto & ic: parent->cli->st_cli.inode_config)
+        for (auto & ic: parent->cli->st_cli->inode_config)
         {
             if (list_pool_id && INODE_POOL(ic.second.num) != list_pool_id)
             {
                 continue;
             }
-            auto pool_it = parent->cli->st_cli.pool_config.find(INODE_POOL(ic.second.num));
-            bool good_pool = pool_it != parent->cli->st_cli.pool_config.end();
+            auto pool_it = parent->cli->st_cli->pool_config.find(INODE_POOL(ic.second.num));
+            bool good_pool = pool_it != parent->cli->st_cli->pool_config.end();
             auto item = json11::Json::object {
                 { "name", ic.second.name },
                 { "size", ic.second.size },
@@ -73,8 +73,8 @@ struct image_lister_t
             };
             if (ic.second.parent_id)
             {
-                auto p_it = parent->cli->st_cli.inode_config.find(ic.second.parent_id);
-                item["parent_name"] = p_it != parent->cli->st_cli.inode_config.end()
+                auto p_it = parent->cli->st_cli->inode_config.find(ic.second.parent_id);
+                item["parent_name"] = p_it != parent->cli->st_cli->inode_config.end()
                     ? p_it->second.name : "";
                 item["parent_pool_id"] = (uint64_t)INODE_POOL(ic.second.parent_id);
                 item["parent_inode_num"] = INODE_NO_POOL(ic.second.parent_id);
@@ -96,21 +96,21 @@ struct image_lister_t
                 json11::Json::object {
                     { "request_range", (list_pool_id
                         ? json11::Json::object {
-                            { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/pool/stats/"+std::to_string(list_pool_id)) },
+                            { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/pool/stats/"+std::to_string(list_pool_id)) },
                         }
                         : json11::Json::object {
-                            { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/pool/stats/") },
-                            { "range_end", base64_encode(parent->cli->st_cli.etcd_prefix+"/pool/stats0") },
+                            { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/pool/stats/") },
+                            { "range_end", base64_encode(parent->cli->st_cli->etcd_prefix+"/pool/stats0") },
                         }) },
                 },
                 json11::Json::object {
                     { "request_range", json11::Json::object {
                         { "key", base64_encode(
-                            parent->cli->st_cli.etcd_prefix+"/inode/stats"+
+                            parent->cli->st_cli->etcd_prefix+"/inode/stats"+
                             (list_pool_id ? "/"+std::to_string(list_pool_id) : "")+"/"
                         ) },
                         { "range_end", base64_encode(
-                            parent->cli->st_cli.etcd_prefix+"/inode/stats"+
+                            parent->cli->st_cli->etcd_prefix+"/inode/stats"+
                             (list_pool_id ? "/"+std::to_string(list_pool_id) : "")+"0"
                         ) },
                     } },
@@ -131,11 +131,11 @@ resume_1:
         std::map<pool_id_t, uint64_t> pool_pg_real_size;
         for (auto & kv_item: space_info["responses"][0]["response_range"]["kvs"].array_items())
         {
-            auto kv = parent->cli->st_cli.parse_etcd_kv(kv_item);
+            auto kv = parent->cli->st_cli->parse_etcd_kv(kv_item);
             // pool ID
             pool_id_t pool_id;
             char null_byte = 0;
-            int scanned = sscanf(kv.key.substr(parent->cli->st_cli.etcd_prefix.length()).c_str(), "/pool/stats/%u%c", &pool_id, &null_byte);
+            int scanned = sscanf(kv.key.substr(parent->cli->st_cli->etcd_prefix.length()).c_str(), "/pool/stats/%u%c", &pool_id, &null_byte);
             if (scanned != 1 || !pool_id || pool_id >= POOL_ID_MAX)
             {
                 fprintf(stderr, "Invalid key in etcd: %s\n", kv.key.c_str());
@@ -146,12 +146,12 @@ resume_1:
         }
         for (auto & kv_item: space_info["responses"][1]["response_range"]["kvs"].array_items())
         {
-            auto kv = parent->cli->st_cli.parse_etcd_kv(kv_item);
+            auto kv = parent->cli->st_cli->parse_etcd_kv(kv_item);
             // pool ID & inode number
             pool_id_t pool_id;
             inode_t only_inode_num;
             char null_byte = 0;
-            int scanned = sscanf(kv.key.substr(parent->cli->st_cli.etcd_prefix.length()).c_str(),
+            int scanned = sscanf(kv.key.substr(parent->cli->st_cli->etcd_prefix.length()).c_str(),
                 "/inode/stats/%u/%ju%c", &pool_id, &only_inode_num, &null_byte);
             if (scanned != 2 || !pool_id || pool_id >= POOL_ID_MAX || INODE_POOL(only_inode_num) != 0)
             {
@@ -161,8 +161,8 @@ resume_1:
             inode_t inode_num = INODE_WITH_POOL(pool_id, only_inode_num);
             uint64_t used_size = kv.value["raw_used"].uint64_value();
             // save stats
-            auto pool_it = parent->cli->st_cli.pool_config.find(pool_id);
-            if (pool_it != parent->cli->st_cli.pool_config.end())
+            auto pool_it = parent->cli->st_cli->pool_config.find(pool_id);
+            if (pool_it != parent->cli->st_cli->pool_config.end())
             {
                 auto & pool_cfg = pool_it->second;
                 used_size = used_size / (pool_pg_real_size[pool_id] ? pool_pg_real_size[pool_id] : 1)
@@ -176,7 +176,7 @@ resume_1:
                     { "size", 0 },
                     { "readonly", false },
                     { "pool_id", (uint64_t)INODE_POOL(inode_num) },
-                    { "pool_name", pool_it != parent->cli->st_cli.pool_config.end()
+                    { "pool_name", pool_it != parent->cli->st_cli->pool_config.end()
                         ? (pool_it->second.name == "" ? "<Unnamed>" : pool_it->second.name) : "?" },
                     { "inode_num", INODE_NO_POOL(inode_num) },
                     { "inode_id", inode_num },

src/cmd/cli_merge.cpp

@@ -110,8 +110,8 @@ struct snap_merger_t
             cur->parent_id != to_cfg->num &&
             cur->parent_id != 0)
         {
-            auto it = parent->cli->st_cli.inode_config.find(cur->parent_id);
-            if (it == parent->cli->st_cli.inode_config.end())
+            auto it = parent->cli->st_cli->inode_config.find(cur->parent_id);
+            if (it == parent->cli->st_cli->inode_config.end())
             {
                 result = (cli_result_t){
                     .err = ENOENT,
@@ -166,7 +166,7 @@ struct snap_merger_t
         //
         //    <from> - <layer 1> - <target> - <to>
         //          \- <layer 2> <---------X-------- NOT ALLOWED
-        for (auto & ic: parent->cli->st_cli.inode_config)
+        for (auto & ic: parent->cli->st_cli->inode_config)
         {
             auto it = sources.find(ic.second.num);
             if (it == sources.end() && ic.second.parent_id != 0)
@@ -182,7 +182,7 @@ struct snap_merger_t
                             .text = "Layers at or above "+(check_delete_source ? from_name : target_name)+
                                 ", but below "+to_name+" are not allowed to have other children, but "+
                                 ic.second.name+" is a child of "+
-                                parent->cli->st_cli.inode_config.at(ic.second.parent_id).name,
+                                parent->cli->st_cli->inode_config.at(ic.second.parent_id).name,
                         };
                         state = 100;
                         return;
@@ -213,7 +213,7 @@ struct snap_merger_t
 
     uint64_t get_block_size(inode_t inode, uint32_t *bitmap_granularity)
     {
-        auto & pool_cfg = parent->cli->st_cli.pool_config.at(INODE_POOL(inode));
+        auto & pool_cfg = parent->cli->st_cli->pool_config.at(INODE_POOL(inode));
         uint64_t pg_data_size = (pool_cfg.scheme == POOL_SCHEME_REPLICATED ? 1 : pool_cfg.pg_size-pool_cfg.parity_chunks);
         if (bitmap_granularity)
             *bitmap_granularity = pool_cfg.bitmap_granularity;
@@ -251,6 +251,8 @@ struct snap_merger_t
             goto resume_100;
         // Get parents and so on
         start_merge();
+        if (state == 100)
+            return;
         // First list lower layers
         list_errcode.clear();
         list_layers(true);
@@ -418,7 +420,7 @@ struct snap_merger_t
                     }
                     if (!pgs_left)
                     {
-                        auto & name = parent->cli->st_cli.inode_config.at(src).name;
+                        auto & name = parent->cli->st_cli->inode_config.at(src).name;
                         if (list_errcode.find(src) != list_errcode.end())
                         {
                             fprintf(stderr, "Failed to get listing of layer %s (inode %ju in pool %u): %s (code %d)\n",
@@ -612,8 +614,10 @@ struct snap_merger_t
         subop->offset = offset;
         subop->len = 0;
         subop->flags = OSD_OP_IGNORE_READONLY | OSD_OP_WAIT_UP_TIMEOUT;
-        subop->callback = [](cluster_op_t *subop)
+        in_flight++;
+        subop->callback = [this](cluster_op_t *subop)
         {
+            in_flight--;
             if (subop->retval != 0)
             {
                 fprintf(stderr, "error deleting from layer 0x%jx at offset %jx: %s", subop->inode, subop->offset, strerror(-subop->retval));
@@ -640,8 +644,10 @@ struct snap_merger_t
                     uint64_t to = last_written_offset;
                     cluster_op_t *subop = new cluster_op_t;
                     subop->opcode = OSD_OP_SYNC;
+                    in_flight++;
                     subop->callback = [this, to](cluster_op_t *subop)
                     {
+                        in_flight--;
                         delete subop;
                         // We can now delete source data between <from> and <to>
                         // But to do this we have to keep all object lists in memory :-(

src/cmd/cli_modify.cpp

@@ -53,7 +53,7 @@ struct image_changer_t
             state = 100;
             return;
         }
-        for (auto & ic: parent->cli->st_cli.inode_config)
+        for (auto & ic: parent->cli->st_cli->inode_config)
         {
             if (ic.second.name == image_name)
             {
@@ -74,7 +74,7 @@ struct image_changer_t
             state = 100;
             return;
         }
-        for (auto & ic: parent->cli->st_cli.inode_config)
+        for (auto & ic: parent->cli->st_cli->inode_config)
         {
             if (ic.second.parent_id == inode_num)
             {
@@ -110,9 +110,9 @@ struct image_changer_t
                 cb = parent->start_rm_data(json11::Json::object {
                     { "inode", INODE_NO_POOL(inode_num) },
                     { "pool", (uint64_t)INODE_POOL(inode_num) },
-                    { "fsync-interval", fsync_interval },
-                    { "min-offset", ((new_size+4095)/4096)*4096 },
-                    { "down-ok", down_ok },
+                    { "fsync_interval", fsync_interval },
+                    { "min_offset", ((new_size+4095)/4096)*4096 },
+                    { "down_ok", down_ok },
                 });
 resume_1:
                 while (!cb(result))
@@ -153,7 +153,7 @@ resume_1:
             cfg.name = new_name;
         }
         {
-            std::string cur_cfg_key = base64_encode(parent->cli->st_cli.etcd_prefix+
+            std::string cur_cfg_key = base64_encode(parent->cli->st_cli->etcd_prefix+
                 "/config/inode/"+std::to_string(INODE_POOL(inode_num))+
                 "/"+std::to_string(INODE_NO_POOL(inode_num)));
             checks.push_back(json11::Json::object {
@@ -166,7 +166,7 @@ resume_1:
                 { "request_put", json11::Json::object {
                     { "key", cur_cfg_key },
                     { "value", base64_encode(json11::Json(
-                        parent->cli->st_cli.serialize_inode_cfg(&cfg)
+                        parent->cli->st_cli->serialize_inode_cfg(&cfg)
                     ).dump()) },
                 } }
             });
@@ -174,10 +174,10 @@ resume_1:
         if (new_name != "")
         {
             std::string old_idx_key = base64_encode(
-                parent->cli->st_cli.etcd_prefix+"/index/image/"+image_name
+                parent->cli->st_cli->etcd_prefix+"/index/image/"+image_name
             );
             std::string new_idx_key = base64_encode(
-                parent->cli->st_cli.etcd_prefix+"/index/image/"+new_name
+                parent->cli->st_cli->etcd_prefix+"/index/image/"+new_name
             );
             checks.push_back(json11::Json::object {
                 { "target", "MOD" },
@@ -229,9 +229,9 @@ resume_2:
         cfg.mod_revision = parent->etcd_result["header"]["revision"].uint64_value();
         if (new_name != "")
         {
-            parent->cli->st_cli.inode_by_name.erase(image_name);
+            parent->cli->st_cli->inode_by_name.erase(image_name);
         }
-        parent->cli->st_cli.insert_inode_config(cfg);
+        parent->cli->st_cli->insert_inode_config(cfg);
         result = (cli_result_t){
             .err = 0,
             .text = "Image "+image_name+" modified",

src/cmd/cli_modify_osd.cpp

@@ -68,12 +68,12 @@ struct osd_changer_t
             { "success", json11::Json::array {
                 json11::Json::object {
                     { "request_range", json11::Json::object {
-                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/osd/stats/"+std::to_string(osd_num)) },
+                        { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/osd/stats/"+std::to_string(osd_num)) },
                     } },
                 },
                 json11::Json::object {
                     { "request_range", json11::Json::object {
-                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
+                        { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
                     } },
                 },
             } },
@@ -89,14 +89,14 @@ resume_1:
             return;
         }
         {
-            auto osd_stats = parent->cli->st_cli.parse_etcd_kv(parent->etcd_result["responses"][0]["response_range"]["kvs"][0]).value;
+            auto osd_stats = parent->cli->st_cli->parse_etcd_kv(parent->etcd_result["responses"][0]["response_range"]["kvs"][0]).value;
             if (!osd_stats.is_object() && !force)
             {
                 result = (cli_result_t){ .err = ENOENT, .text = "OSD "+std::to_string(osd_num)+" does not exist. Use --force to set configuration anyway" };
                 state = 100;
                 return;
             }
-            auto kv = parent->cli->st_cli.parse_etcd_kv(parent->etcd_result["responses"][1]["response_range"]["kvs"][0]);
+            auto kv = parent->cli->st_cli->parse_etcd_kv(parent->etcd_result["responses"][1]["response_range"]["kvs"][0]);
             osd_cfg_mod_rev = kv.mod_revision;
             osd_cfg = kv.value.object_items();
             if (set_reweight)
@@ -124,7 +124,7 @@ resume_1:
             {
                 compare.push_back(json11::Json::object {
                     { "target", "MOD" },
-                    { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
+                    { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
                     { "result", "LESS" },
                     { "mod_revision", osd_cfg_mod_rev+1 },
                 });
@@ -133,7 +133,7 @@ resume_1:
             {
                 compare.push_back(json11::Json::object {
                     { "target", "VERSION" },
-                    { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
+                    { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
                     { "version", 0 },
                 });
             }
@@ -141,7 +141,7 @@ resume_1:
             {
                 success.push_back(json11::Json::object {
                     { "request_delete_range", json11::Json::object {
-                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
+                        { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
                     } },
                 });
             }
@@ -149,7 +149,7 @@ resume_1:
             {
                 success.push_back(json11::Json::object {
                     { "request_put", json11::Json::object {
-                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
+                        { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/osd/"+std::to_string(osd_num)) },
                         { "value", base64_encode(json11::Json(osd_cfg).dump()) },
                     } },
                 });

src/cmd/cli_osd_tree.cpp

@@ -62,19 +62,19 @@ struct osd_tree_printer_t
             { "success", json11::Json::array {
                 json11::Json::object {
                     { "request_range", json11::Json::object {
-                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/node_placement") },
+                        { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/node_placement") },
                     } },
                 },
                 json11::Json::object {
                     { "request_range", json11::Json::object {
-                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/osd/") },
-                        { "range_end", base64_encode(parent->cli->st_cli.etcd_prefix+"/config/osd0") },
+                        { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/osd/") },
+                        { "range_end", base64_encode(parent->cli->st_cli->etcd_prefix+"/config/osd0") },
                     } },
                 },
                 json11::Json::object {
                     { "request_range", json11::Json::object {
-                        { "key", base64_encode(parent->cli->st_cli.etcd_prefix+"/osd/stats/") },
-                        { "range_end", base64_encode(parent->cli->st_cli.etcd_prefix+"/osd/stats0") },
+                        { "key", base64_encode(parent->cli->st_cli->etcd_prefix+"/osd/stats/") },
+                        { "range_end", base64_encode(parent->cli->st_cli->etcd_prefix+"/osd/stats0") },
                     } },
                 },
             } },
@@ -91,7 +91,7 @@ resume_1:
         }
         for (auto & item: parent->etcd_result["responses"][0]["response_range"]["kvs"].array_items())
         {
-            node_placement = parent->cli->st_cli.parse_etcd_kv(item).value;
+            node_placement = parent->cli->st_cli->parse_etcd_kv(item).value;
         }
         parent->iterate_kvs_1(parent->etcd_result["responses"][1]["response_range"]["kvs"], "/config/osd/", [&](uint64_t cur_osd, json11::Json value)
         {
@@ -132,7 +132,7 @@ resume_1:
                 .parent = kv.second["host"].string_value(),
                 .size = kv.second["size"].uint64_value(),
                 .free = kv.second["free"].uint64_value(),
-                .up = parent->cli->st_cli.peer_states.find(kv.first) != parent->cli->st_cli.peer_states.end(),
+                .up = parent->cli->st_cli->peer_states.find(kv.first) != parent->cli->st_cli->peer_states.end(),
                 .reweight = 1,
                 .noout = false,
                 .block_size = (uint32_t)kv.second["data_block_size"].uint64_value(),