diff --git a/.github/scripts/summarize-tcmu-performance.py b/.github/scripts/summarize-tcmu-performance.py
new file mode 100644
index 00000000..ca757f7a
--- /dev/null
+++ b/.github/scripts/summarize-tcmu-performance.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+
+import csv
+import json
+import os
+import re
+import statistics
+import sys
+from pathlib import Path
+
+
+def load_runs(result_dir: Path):
+    rows = []
+    for path in sorted(result_dir.glob("*.json")):
+        match = re.fullmatch(r"(baseline|current)-(.+)-(\d+)", path.stem)
+        if not match:
+            continue
+        label, profile, run = match.groups()
+        with path.open() as file:
+            job = json.load(file)["jobs"][0]["read"]
+        rows.append(
+            {
+                "label": label,
+                "profile": profile,
+                "run": int(run),
+                "iops": float(job["iops"]),
+                "bw_bytes": float(job["bw_bytes"]),
+                "clat_us": float(job["clat_ns"]["mean"]) / 1000,
+            }
+        )
+    return rows
+
+
+def median(rows, label, profile, metric):
+    return statistics.median(
+        row[metric]
+        for row in rows
+        if row["label"] == label and row["profile"] == profile
+    )
+
+
+def delta(current, baseline):
+    return (current / baseline - 1) * 100
+
+
+result_dir = Path(sys.argv[1])
+result_dir.mkdir(parents=True, exist_ok=True)
+rows = load_runs(result_dir)
+profiles = ("qd1-j1", "qd4-j2", "qd8-j4", "qd16-j4", "qd32-j4", "qd64-j4")
+total_concurrency = {
+    "qd1-j1": 1,
+    "qd4-j2": 8,
+    "qd8-j4": 32,
+    "qd16-j4": 64,
+    "qd32-j4": 128,
+    "qd64-j4": 256,
+}
+minimum_baseline_ratio = {
+    "qd1-j1": 0.90,
+    "qd4-j2": 0.90,
+    "qd8-j4": 0.90,
+    "qd16-j4": 0.90,
+    "qd32-j4": 0.90,
+    "qd64-j4": 1.00,
+}
+failures = []
+# Check-run annotations are public; job logs and artifacts are not.
+highlights = []
+
+if rows:
+    with (result_dir / "raw-results.csv").open("w", newline="") as file:
+        writer = csv.DictWriter(file, fieldnames=rows[0].keys())
+        writer.writeheader()
+        writer.writerows(rows)
+
+lines = [
+    "# OverlayBD TCMU performance comparison",
+    "",
+    f"- Baseline: `{os.getenv('BASELINE_SHA', 'unknown')}` with its checked-in configuration",
+    f"- Current: `{os.getenv('GITHUB_SHA', 'working tree')}` with "
+    f"`workpoolSize={os.getenv('WORKPOOL_SIZE', 'nproc')}`, per-vCPU command queues and in-place completions",
+    f"- Build type: `{os.getenv('BUILD_TYPE', 'unknown')}` for both versions",
+    "- I/O: 4 KiB random reads from the image's largest allocated data extent, `libaio`, `O_DIRECT`; profile names encode queue depth and job count",
+    "- Required current/baseline IOPS: `>= 90%` through 128 total concurrency; `qd64-j4 >= 100%`",
+    "",
+    "Both versions ran sequentially on the same GitHub runner. Values are the median of three 15-second fio runs after a 45-second cache warmup.",
+    "",
+    "| fio profile | total concurrency | baseline IOPS | current IOPS | baseline ratio | IOPS change | baseline latency | current latency | latency change |",
+    "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+]
+for profile in profiles:
+    baseline_runs = [row for row in rows if row["label"] == "baseline" and row["profile"] == profile]
+    current_runs = [row for row in rows if row["label"] == "current" and row["profile"] == profile]
+    if baseline_runs and current_runs:
+        baseline_iops = median(rows, "baseline", profile, "iops")
+        current_iops = median(rows, "current", profile, "iops")
+        baseline_lat = median(rows, "baseline", profile, "clat_us")
+        current_lat = median(rows, "current", profile, "clat_us")
+        iops_ratio = current_iops / baseline_iops
+        lines.append(
+            f"| `{profile}` | {total_concurrency[profile]} | "
+            f"{baseline_iops:,.0f} | {current_iops:,.0f} | "
+            f"{iops_ratio:.1%} | {delta(current_iops, baseline_iops):+.1f}% | "
+            f"{baseline_lat:,.1f} us | "
+            f"{current_lat:,.1f} us | {delta(current_lat, baseline_lat):+.1f}% |"
+        )
+        highlights.append(
+            f"{profile} iops {baseline_iops:,.0f} -> {current_iops:,.0f} "
+            f"baseline ratio {iops_ratio:.2f}, "
+            f"latency {baseline_lat:,.0f} us -> {current_lat:,.0f} us"
+        )
+        if profile in minimum_baseline_ratio and iops_ratio < minimum_baseline_ratio[profile]:
+            failures.append(
+                f"{profile} current/baseline IOPS is {iops_ratio:.1%}; "
+                f"required >= {minimum_baseline_ratio[profile]:.0%}"
+            )
+    else:
+        baseline_iops = f"{median(rows, 'baseline', profile, 'iops'):,.0f}" if baseline_runs else "timeout/no data"
+        current_iops = f"{median(rows, 'current', profile, 'iops'):,.0f}" if current_runs else "timeout/no data"
+        baseline_lat = f"{median(rows, 'baseline', profile, 'clat_us'):,.1f} us" if baseline_runs else "—"
+        current_lat = f"{median(rows, 'current', profile, 'clat_us'):,.1f} us" if current_runs else "—"
+        lines.append(
+            f"| `{profile}` | {total_concurrency[profile]} | "
+            f"{baseline_iops} | {current_iops} | — | — | "
+            f"{baseline_lat} | {current_lat} | — |"
+        )
+        failures.append(f"{profile} has incomplete benchmark data")
+
+summary = "\n".join(lines) + "\n"
+(result_dir / "summary.md").write_text(summary)
+print(summary)
+
+if highlights:
+    # A plain factor, since '%' must be percent-escaped in workflow commands.
+    print("::notice title=TCMU performance summary::" + "; ".join(highlights))
+
+if failures:
+    for failure in failures:
+        print(f"::error title=TCMU performance regression::{failure}")
+    sys.exit(1)
diff --git a/.github/scripts/tcmu-performance.sh b/.github/scripts/tcmu-performance.sh
new file mode 100644
index 00000000..94116721
--- /dev/null
+++ b/.github/scripts/tcmu-performance.sh
@@ -0,0 +1,292 @@
+#!/usr/bin/env bash
+
+set -Eeuo pipefail
+
+if [[ $# -ne 5 ]]; then
+    echo "usage: $0 <label> <service-config> <image-config> <result-dir> <wwn>" >&2
+    exit 2
+fi
+
+label=$1
+service_config=$2
+image_config=$3
+result_dir=$4
+wwn=$5
+mkdir -p "$result_dir"
+cpu_flags=$(awk -F: '/^flags[[:space:]]*:/ {sub(/^[[:space:]]+/, "", $2); print $2; exit}' /proc/cpuinfo)
+{
+    echo "${label}: CPU flags: ${cpu_flags}"
+    if grep -qw avx512f <<<"$cpu_flags"; then
+        echo "${label}: AVX-512F is exposed to the runner"
+    else
+        echo "${label}: AVX-512F is not exposed to the runner"
+    fi
+} | tee "${result_dir}/${label}-cpu-features.txt"
+if [[ "$label" == "baseline" ]]; then
+    device_name=vol1
+else
+    device_name=vol2
+fi
+core_dir="/sys/kernel/config/target/core/user_1/${device_name}"
+fabric_dir="/sys/kernel/config/target/loopback/${wwn}/tpgt_1"
+lun_dir="${fabric_dir}/lun/lun_0"
+lun_link="${lun_dir}/${device_name}"
+mount_dir="${RUNNER_TEMP}/overlaybd-perf-mount-${label}"
+ipv4_blocked=0
+ipv6_blocked=0
+
+on_error() {
+    local rc=$1
+    local line=$2
+    local command=$3
+    trap - ERR
+    set +e
+    echo "::error title=TCMU benchmark failed::${label}: line ${line}: ${command} (exit ${rc})"
+    {
+        echo "label: $label"
+        echo "line: $line"
+        echo "command: $command"
+        echo "exit_code: $rc"
+        echo
+        sudo systemctl status overlaybd-tcmu --no-pager --full
+        echo
+        sudo tail -n 200 /var/log/overlaybd.log
+    } 2>&1 | tee "${result_dir}/${label}-diagnostics.log"
+    # That file only reaches the artifact, which needs repository
+    # authentication to download. Repeat the daemon's own tail as an annotation
+    # so a failure is diagnosable without it - this is what separates a
+    # registry or network error from a bug in the backend.
+    local state escaped_tail
+    state=$(sudo systemctl is-active overlaybd-tcmu 2>/dev/null || true)
+    escaped_tail=$(sudo tail -n 25 /var/log/overlaybd.log 2>/dev/null |
+        sed -e 's/%/%25/g' -e 's/\r/%0D/g' -e 's/$/%0A/' | tr -d '\n')
+    echo "::error title=${label} daemon diagnostics::overlaybd-tcmu=${state}; /var/log/overlaybd.log tail: ${escaped_tail}"
+    exit "$rc"
+}
+trap 'on_error "$?" "$LINENO" "$BASH_COMMAND"' ERR
+
+cleanup() {
+    set +e
+    if [[ "$ipv6_blocked" -eq 1 ]]; then
+        sudo ip6tables -D OUTPUT ! -o lo -m owner --uid-owner 0 -j REJECT || true
+        ipv6_blocked=0
+    fi
+    if [[ "$ipv4_blocked" -eq 1 ]]; then
+        sudo iptables -D OUTPUT ! -o lo -m owner --uid-owner 0 -j REJECT || true
+        ipv4_blocked=0
+    fi
+    if mountpoint -q "$mount_dir"; then
+        sudo timeout 15 umount "$mount_dir" || true
+    fi
+    if [[ -L "$lun_link" ]]; then
+        sudo unlink "$lun_link" || true
+    fi
+    if [[ -e "${core_dir}/enable" ]]; then
+        echo -n 0 | sudo tee "${core_dir}/enable" >/dev/null || true
+    fi
+    sudo timeout 15 systemctl stop overlaybd-tcmu >/dev/null 2>&1 || true
+    sudo udevadm settle --timeout=10 || true
+}
+trap cleanup EXIT
+
+cleanup
+sudo install -d -m 0755 \
+    /etc/overlaybd \
+    /opt/overlaybd/registry_cache \
+    /var/lib/overlaybd/test \
+    "$result_dir" \
+    "$mount_dir"
+sudo cp "$service_config" /etc/overlaybd/overlaybd.json
+sudo find /opt/overlaybd/registry_cache -mindepth 1 -delete
+sudo truncate -s 0 /var/log/overlaybd.log
+sudo systemctl enable /opt/overlaybd/overlaybd-tcmu.service
+sudo systemctl daemon-reload
+sudo systemctl start overlaybd-tcmu
+sudo systemctl is-active --quiet overlaybd-tcmu
+
+sudo mkdir -p "$core_dir"
+echo -n "dev_config=overlaybd/${image_config}" | sudo tee "${core_dir}/control" >/dev/null
+echo -n 1 | sudo tee "${core_dir}/enable" >/dev/null
+sudo mkdir -p "$lun_dir"
+echo -n "$wwn" | sudo tee "${fabric_dir}/nexus" >/dev/null
+
+# Record the runner's existing block devices. The legacy and current TCMU
+# implementations do not always expose the same vendor/model text to lsscsi,
+# so identify the benchmark disk by the new whole-block device instead.
+declare -A blocks_before=()
+for block_path in /sys/class/block/*; do
+    blocks_before["$(basename "$block_path")"]=1
+done
+sudo ln -s "$core_dir" "$lun_link"
+sudo udevadm settle
+
+dev=""
+for _ in $(seq 1 30); do
+    for block_path in /sys/class/block/*; do
+        block_name=$(basename "$block_path")
+        if [[ -z "${blocks_before[$block_name]+present}" &&
+              ! -e "${block_path}/partition" &&
+              -b "/dev/${block_name}" ]]; then
+            dev="/dev/${block_name}"
+            break
+        fi
+    done
+    if [[ -n "$dev" && -b "$dev" ]]; then
+        break
+    fi
+    sleep 1
+done
+lsblk
+lsscsi
+test -n "$dev"
+test -b "$dev"
+echo "${label}: benchmarking ${dev}"
+
+echo "${label}: LSMT linearized B+tree selection:"
+sudo grep -iE 'linearized b\+tree|linearized bptree' /var/log/overlaybd.log \
+    | tee "${result_dir}/${label}-lsmt-index.log" || true
+if sudo grep -qi 'using accelerated search for linearized b+tree' /var/log/overlaybd.log; then
+    echo "::notice title=${label} LSMT index::AVX-512 accelerated linearized B+tree search enabled"
+else
+    echo "::notice title=${label} LSMT index::AVX-512 accelerated linearized B+tree search not observed"
+fi
+
+# Keep the filesystem mounted as it is in production and select the regular
+# file with the most allocated blocks. Use its largest allocated physical
+# extent as the raw-device benchmark range: this avoids both the virtual disk's
+# unmapped zero ranges and filesystem-level contention between fio jobs.
+sudo mount -o ro "$dev" "$mount_dir"
+benchmark_file=$(sudo find "$mount_dir" -xdev -type f -size +1M -printf '%b\t%p\n' |
+    sort -nr | sed -n '1s/^[^\t]*\t//p')
+test -n "$benchmark_file"
+filesystem_block_size=$(sudo stat -f -c %S "$mount_dir")
+extent_output=$(sudo filefrag -e -b"$filesystem_block_size" "$benchmark_file")
+printf '%s\n' "$extent_output" \
+    | tee "${result_dir}/${label}-benchmark-file-extents.txt"
+read -r extent_start extent_blocks < <(
+    printf '%s\n' "$extent_output" | awk '
+        /^[[:space:]]*[0-9]+:/ && $0 !~ /unwritten/ {
+            start = $4
+            end = $5
+            sub(/\.\.$/, "", start)
+            sub(/:$/, "", end)
+            blocks = end - start + 1
+            if (blocks > largest) {
+                selected = start
+                largest = blocks
+            }
+        }
+        END { if (largest > 0) print selected, largest }
+    '
+)
+test -n "${extent_start:-}"
+test "${extent_blocks:-0}" -gt 0
+benchmark_offset=$((extent_start * filesystem_block_size))
+benchmark_size=$((extent_blocks * filesystem_block_size))
+test "$benchmark_size" -ge 1048576
+echo "${label}: fio data extent: ${benchmark_file}, offset=${benchmark_offset}, size=${benchmark_size}"
+printf '%s\n' "$benchmark_file" > "${result_dir}/${label}-benchmark-file.txt"
+
+cache_blocks_before=$(sudo find /opt/overlaybd/registry_cache -type f -printf '%b\n' |
+    awk '{blocks += $1} END {print blocks + 0}')
+echo "${label}: prewarming ${benchmark_size} data bytes into OverlayBD file cache"
+# Use a single outstanding request so this phase measures neither WorkPool
+# concurrency nor concurrent cache population; it only establishes identical,
+# complete local-cache state for both implementations.
+sudo timeout --signal=TERM --kill-after=15s 15m fio \
+    --name="${label}-prewarm" \
+    --filename="$dev" \
+    --offset="$benchmark_offset" \
+    --readonly \
+    --direct=1 \
+    --ioengine=libaio \
+    --rw=read \
+    --bs=1m \
+    --iodepth=1 \
+    --numjobs=1 \
+    --size="$benchmark_size" \
+    --group_reporting=1 \
+    --eta=never
+cache_blocks_after=$(sudo find /opt/overlaybd/registry_cache -type f -printf '%b\n' |
+    awk '{blocks += $1} END {print blocks + 0}')
+if [[ "$cache_blocks_after" -le "$cache_blocks_before" ]]; then
+    echo "::error title=TCMU cache prewarm failed::${label}: file cache did not grow"
+    exit 1
+fi
+
+# From this point until cleanup, root processes (including overlaybd-tcmu) have
+# no outbound network. fio itself also runs as root, but only accesses the
+# selected data extent. A second full read therefore proves every block needed
+# by the benchmark can be served from OverlayBD's local file cache.
+sudo iptables -I OUTPUT 1 ! -o lo -m owner --uid-owner 0 -j REJECT
+ipv4_blocked=1
+if command -v ip6tables >/dev/null &&
+    sudo ip6tables -I OUTPUT 1 ! -o lo -m owner --uid-owner 0 -j REJECT; then
+    ipv6_blocked=1
+fi
+echo "${label}: verifying the data extent with OverlayBD network access blocked"
+sudo timeout --signal=TERM --kill-after=15s 15m fio \
+    --name="${label}-offline-cache-verification" \
+    --filename="$dev" \
+    --offset="$benchmark_offset" \
+    --readonly \
+    --direct=1 \
+    --ioengine=libaio \
+    --rw=read \
+    --bs=1m \
+    --iodepth=1 \
+    --numjobs=1 \
+    --size="$benchmark_size" \
+    --group_reporting=1 \
+    --eta=never
+echo verified > "${result_dir}/${label}-prewarm-status.txt"
+
+fio_worker_limit=$(nproc)
+echo "${label}: fio worker limit: ${fio_worker_limit}"
+
+run_profile() {
+    local profile=$1
+    local jobs=$2
+    local depth=$3
+    local run
+    test "$jobs" -le "$fio_worker_limit"
+    for run in 1 2 3; do
+        local output="${result_dir}/${label}-${profile}-${run}.json"
+        if ! sudo timeout --signal=TERM --kill-after=10s 40s fio \
+            --name="${label}-${profile}" \
+            --filename="$dev" \
+            --offset="$benchmark_offset" \
+            --size="$benchmark_size" \
+            --readonly \
+            --direct=1 \
+            --ioengine=libaio \
+            --rw=randread \
+            --bs=4k \
+            --iodepth="$depth" \
+            --numjobs="$jobs" \
+            --time_based=1 \
+            --runtime=15 \
+            --ramp_time=3 \
+            --randrepeat=1 \
+            --randseed=20260825 \
+            --group_reporting=1 \
+            --eta=never \
+            --output-format=json \
+            --output="$output"; then
+            sudo unlink "$output" 2>/dev/null || true
+            echo timeout > "${result_dir}/${label}-${profile}-${run}-status.txt"
+            echo "::error title=TCMU fio timeout::${label}: ${profile} run ${run} did not finish"
+            return 1
+        fi
+    done
+}
+
+run_profile qd1-j1 1 1
+run_profile qd4-j2 2 4
+run_profile qd8-j4 4 8
+run_profile qd16-j4 4 16
+run_profile qd32-j4 4 32
+run_profile qd64-j4 4 64
+sudo chown -R "$(id -u):$(id -g)" "$result_dir"
+sudo systemctl is-active --quiet overlaybd-tcmu ||
+    echo "::warning title=OverlayBD service stopped::${label}: service exited during benchmark"
diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index 30952be7..d844d118 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -26,8 +26,8 @@ jobs:
       run: |
         sudo apt-get update -y
         sudo apt-get install -y libgflags-dev libcurl4-openssl-dev libssl-dev libaio-dev libnl-3-dev libnl-genl-3-dev libzstd-dev
-        sudo apt-get install -y uuid-dev libjson-c-dev libkmod-dev libsystemd-dev autoconf automake libtool libpci-dev nasm
-        sudo apt-get install -y libext2fs-dev
+        sudo apt-get install -y uuid-dev libjson-c-dev libkmod-dev libsystemd-dev autoconf automake libtool libpci-dev nasm pkg-config help2man
+        sudo apt-get install -y libext2fs-dev fio jq lsscsi
         wget https://github.com/google/googletest/archive/refs/tags/release-1.11.0.tar.gz
         tar -zxvf release-1.11.0.tar.gz
         cd googletest-release-1.11.0/
@@ -61,6 +61,9 @@ jobs:
         lscpu
         sudo make install
         sudo cp ${{github.workspace}}/src/example_config/overlaybd-registryv2.json /etc/overlaybd/overlaybd.json
+        grep -Eq '"cacheType"[[:space:]]*:[[:space:]]*"file"' /etc/overlaybd/overlaybd.json
+        sudo install -d -m 0755 /opt/overlaybd/registry_cache
+        sudo find /opt/overlaybd/registry_cache -mindepth 1 -delete
         sudo systemctl enable /opt/overlaybd/overlaybd-tcmu.service
         sudo systemctl start overlaybd-tcmu
         sudo systemctl status overlaybd-tcmu
@@ -72,12 +75,67 @@ jobs:
         echo -n "naa.123456789abcdef" | sudo tee /sys/kernel/config/target/loopback/naa.123456789abcdef/tpgt_1/nexus
         sudo ln -s /sys/kernel/config/target/core/user_1/vol1 /sys/kernel/config/target/loopback/naa.123456789abcdef/tpgt_1/lun/lun_0/vol1
         lsblk
-        sudo apt-get install -y lsscsi
-        dev=`lsscsi | grep TCMU | awk '{print $7}'`
-        echo $dev
+        dev=$(lsscsi | awk '/TCMU/ {print $7; exit}')
+        test -b "$dev"
+        echo "$dev"
         mkdir obd_mp
-        sudo mount -o ro $dev obd_mp
+        sudo mount -o ro "$dev" obd_mp
         ls obd_mp
+
+        # Exercise OverlayBD while the filesystem is mounted. direct=1 opens the
+        # raw block device with O_DIRECT, so Linux's block/page cache cannot
+        # satisfy these reads before they reach OverlayBD.
+        cache_blocks_before=$(sudo find /opt/overlaybd/registry_cache -type f -printf '%b\n' | awk '{blocks += $1} END {print blocks + 0}')
+        sudo fio \
+          --name=overlaybd-file-cache-fill \
+          --filename="$dev" \
+          --readonly \
+          --direct=1 \
+          --ioengine=libaio \
+          --rw=randread \
+          --bs=4k \
+          --iodepth=32 \
+          --numjobs=8 \
+          --time_based=1 \
+          --runtime=20 \
+          --randrepeat=1 \
+          --randseed=20260821 \
+          --group_reporting=1
+        cache_blocks_after=$(sudo find /opt/overlaybd/registry_cache -type f -printf '%b\n' | awk '{blocks += $1} END {print blocks + 0}')
+        test "$cache_blocks_after" -gt "$cache_blocks_before"
+
+        # Repeat the same high-concurrency direct-I/O workload so the requests
+        # traverse OverlayBD again and hit the file cache populated above.
+        fio_result="$RUNNER_TEMP/overlaybd-file-cache-hit.json"
+        sudo fio \
+          --name=overlaybd-file-cache-hit \
+          --filename="$dev" \
+          --readonly \
+          --direct=1 \
+          --ioengine=libaio \
+          --rw=randread \
+          --bs=4k \
+          --iodepth=32 \
+          --numjobs=8 \
+          --time_based=1 \
+          --runtime=20 \
+          --randrepeat=1 \
+          --randseed=20260821 \
+          --group_reporting=1 \
+          --output-format=json \
+          --output="$fio_result"
+        iops=$(jq -r '.jobs[0].read.iops | floor' "$fio_result")
+        echo "OverlayBD file-cache random-read IOPS: $iops"
+        echo "::notice title=OverlayBD file-cache IOPS::$iops (4k randread, iodepth=32, numjobs=8)"
+        # Not a performance gate - runners vary ~1.5x (90k-135k for this profile
+        # across three runs of identical code). 60k sits above the single-vCPU
+        # range (22k-41k), so it only catches multi-vCPU failing to engage;
+        # tcmu-performance.yml is the actual performance gate.
+        if ((iops < 60000)); then
+          echo "::error title=OverlayBD IOPS regression::Expected at least 60000 IOPS, got $iops"
+          exit 1
+        fi
+        sudo systemctl is-active --quiet overlaybd-tcmu
         sudo umount obd_mp
         ls -l /sys/kernel/config/target/loopback/naa.123456789abcdef/tpgt_1/lun/lun_0/vol1
         sudo unlink /sys/kernel/config/target/loopback/naa.123456789abcdef/tpgt_1/lun/lun_0/vol1
@@ -115,11 +173,11 @@ jobs:
         echo -n "naa.987654321abcdef" | sudo tee /sys/kernel/config/target/loopback/naa.987654321abcdef/tpgt_1/nexus
         sudo ln -s /sys/kernel/config/target/core/user_1/vol2 /sys/kernel/config/target/loopback/naa.987654321abcdef/tpgt_1/lun/lun_0/vol2
         lsblk
-        sudo apt-get install -y lsscsi
-        dev=`lsscsi | grep TCMU | awk '{print $7}'`
-        echo $dev
+        dev=$(lsscsi | awk '/TCMU/ {print $7; exit}')
+        test -b "$dev"
+        echo "$dev"
         sudo mkdir foci_mp
-        sudo mount -o ro $dev foci_mp
+        sudo mount -o ro "$dev" foci_mp
         ls foci_mp
         sudo umount foci_mp
         sudo unlink /sys/kernel/config/target/loopback/naa.987654321abcdef/tpgt_1/lun/lun_0/vol2
diff --git a/.github/workflows/tcmu-performance.yml b/.github/workflows/tcmu-performance.yml
new file mode 100644
index 00000000..327ae8b7
--- /dev/null
+++ b/.github/workflows/tcmu-performance.yml
@@ -0,0 +1,145 @@
+name: TCMU Performance Comparison
+
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+    branches:
+    - main
+
+env:
+  BASELINE_SHA: 838a95ecfc9af33cb9e3d7908a79f35cfc762d7f
+  BUILD_TYPE: Release
+
+permissions:
+  contents: read
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 90
+
+    steps:
+    - uses: actions/checkout@v7
+
+    - name: Install dependencies
+      shell: bash
+      run: |
+        sudo apt-get update -y
+        sudo apt-get install -y \
+          autoconf automake fio help2man jq libaio-dev libcurl4-openssl-dev \
+          libext2fs-dev libgflags-dev libjson-c-dev libkmod-dev libnl-3-dev \
+          libnl-genl-3-dev libpci-dev libssl-dev libsystemd-dev libtool \
+          libzstd-dev lsscsi nasm pkg-config uuid-dev
+
+    - name: Record runner information
+      run: |
+        lscpu
+        free -h
+        uname -a
+        fio --version
+
+    - name: Build native Photon WorkPool implementation
+      shell: bash
+      run: |
+        current_build="$GITHUB_WORKSPACE/build"
+        result_dir="$RUNNER_TEMP/tcmu-performance-results"
+        mkdir -p "$result_dir"
+        # Match the regular CMake workflow. actions/checkout's recursive,
+        # shallow submodule mode can leave DML tag refs without their trees.
+        git submodule update --init
+        # Build production binaries only; unit tests and their GoogleTest
+        # dependency are covered by the regular CMake workflow.
+        # DSA and ISA-L only change zfile CRC acceleration. Keep them disabled
+        # in both builds so this benchmark measures the TCMU implementation;
+        # older baselines also leaked ISA-L's -mavx512f into every consumer.
+        cmake -S "$GITHUB_WORKSPACE" -B "$current_build" \
+          -DCMAKE_BUILD_TYPE="$BUILD_TYPE" \
+          -DBUILD_TESTING=0 \
+          -DENABLE_DSA=0 \
+          -DENABLE_ISAL=0
+        if ! cmake --build "$current_build" --parallel "$(nproc)" \
+            2>&1 | tee "$result_dir/current-build.log"; then
+          first_error=$(grep -Eim1 'error:|fatal:|undefined reference|No space left' \
+            "$result_dir/current-build.log" || true)
+          echo "::error title=Current build failed::${first_error:-see current-build.log artifact}"
+          exit 1
+        fi
+
+    - name: Build baseline
+      shell: bash
+      run: |
+        baseline_src="$RUNNER_TEMP/overlaybd-baseline"
+        baseline_build="$RUNNER_TEMP/overlaybd-baseline-build"
+        git clone --filter=blob:none https://github.com/containerd/overlaybd.git "$baseline_src"
+        git -C "$baseline_src" checkout "$BASELINE_SHA"
+        git -C "$baseline_src" submodule update --init --recursive
+        cmake -S "$baseline_src" -B "$baseline_build" \
+          -DCMAKE_BUILD_TYPE="$BUILD_TYPE" \
+          -DBUILD_TESTING=0 \
+          -DENABLE_DSA=0 \
+          -DENABLE_ISAL=0
+        cmake --build "$baseline_build" --parallel "$(nproc)"
+        sudo cmake --install "$baseline_build"
+
+    - name: Benchmark baseline implementation
+      shell: bash
+      run: |
+        bash .github/scripts/tcmu-performance.sh \
+          baseline \
+          "$RUNNER_TEMP/overlaybd-baseline/src/example_config/overlaybd-registryv2.json" \
+          "$RUNNER_TEMP/overlaybd-baseline/src/example_config/redis.obd.config.json" \
+          "$RUNNER_TEMP/tcmu-performance-results" \
+          naa.123456789abcdef
+
+    - name: Remove baseline build
+      shell: bash
+      run: |
+        test "$RUNNER_TEMP/overlaybd-baseline" != "/"
+        test "$RUNNER_TEMP/overlaybd-baseline-build" != "/"
+        rm -rf \
+          "$RUNNER_TEMP/overlaybd-baseline" \
+          "$RUNNER_TEMP/overlaybd-baseline-build"
+        # The baseline workload intentionally fills OverlayBD's file cache.
+        # Reclaim it before compiling the current revision on the small hosted
+        # runner disk; each benchmark repopulates an empty cache itself.
+        sudo find /opt/overlaybd/registry_cache -mindepth 1 -delete
+        df -h
+
+    - name: Install native Photon WorkPool implementation
+      shell: bash
+      run: |
+        current_build="$GITHUB_WORKSPACE/build"
+        sudo cmake --install "$current_build"
+        workpool_size=$(nproc)
+        jq --argjson workpool_size "$workpool_size" \
+          '.workpoolSize = $workpool_size | del(.enableThread)' \
+          "$GITHUB_WORKSPACE/src/example_config/overlaybd-registryv2.json" \
+          > "$RUNNER_TEMP/current-overlaybd.json"
+        echo "WORKPOOL_SIZE=$workpool_size" >> "$GITHUB_ENV"
+
+    - name: Benchmark native Photon WorkPool implementation
+      shell: bash
+      run: |
+        bash .github/scripts/tcmu-performance.sh \
+          current \
+          "$RUNNER_TEMP/current-overlaybd.json" \
+          "$GITHUB_WORKSPACE/src/example_config/redis.obd.config.json" \
+          "$RUNNER_TEMP/tcmu-performance-results" \
+          naa.987654321abcdef
+
+    - name: Summarize comparison
+      if: always()
+      shell: bash
+      run: |
+        python3 .github/scripts/summarize-tcmu-performance.py \
+          "$RUNNER_TEMP/tcmu-performance-results" | tee -a "$GITHUB_STEP_SUMMARY"
+
+    - name: Upload fio results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: tcmu-performance-${{ github.sha }}
+        path: ${{ runner.temp }}/tcmu-performance-results
+        if-no-files-found: warn
diff --git a/README.md b/README.md
index 9931e50d..037f83fc 100644
--- a/README.md
+++ b/README.md
@@ -173,6 +173,7 @@ Default configure file `overlaybd.json` is installed to `/etc/overlaybd/`.
         "path": "/opt/overlaybd/cred.json"
     },
     "ioEngine": 0,
+    "workpoolSize": 8,
     "download": {
         "enable": true,
         "delay": 600,
@@ -231,7 +232,7 @@ Default configure file `overlaybd.json` is installed to `/etc/overlaybd/`.
 | exporterConfig.port           | port for http server to show metrics.                                                       |
 | exporterConfig.updateInterval | Time interval to update metrics in microseconds.                                            |
 | enableAudit         | Enable audit or not.                                                                                  |
-| enableThread        | Enable overlaybd device run in seprate thread or not. Note `cacheType` should be `ocf`. `false` is default. |
+| workpoolSize        | Number of Photon vCPUs (OS threads) in the shared device work pool. `8` is default.                   |
 | auditPath           | The path for audit file, `/var/log/overlaybd-audit.log` is the default value.                         |
 | registryFsVersion   | registry client version, 'v1' libcurl based, 'v2' is photon http based. 'v2' is the default value.    |
 | prefetchConfig.concurrency    | Prefetch concurrency for reloading trace, `16` is default                                   |
diff --git a/src/config.h b/src/config.h
index d89a210a..b19375ed 100644
--- a/src/config.h
+++ b/src/config.h
@@ -153,7 +153,7 @@ struct GlobalConfig : public ConfigUtils::Config {
     APPCFG_PARA(logPath, std::string, "/var/log/overlaybd.log");
     APPCFG_PARA(download, DownloadConfig);
     APPCFG_PARA(enableAudit, bool, true);
-    APPCFG_PARA(enableThread, bool, false);
+    APPCFG_PARA(workpoolSize, uint32_t, 8);
     APPCFG_PARA(p2pConfig, P2PConfig);
     APPCFG_PARA(exporterConfig, ExporterConfig);
     APPCFG_PARA(auditPath, std::string, "/var/log/overlaybd-audit.log");
diff --git a/src/example_config/overlaybd-registryv2.json b/src/example_config/overlaybd-registryv2.json
index 5228416a..990df9b0 100644
--- a/src/example_config/overlaybd-registryv2.json
+++ b/src/example_config/overlaybd-registryv2.json
@@ -13,6 +13,7 @@
         "path": "/opt/overlaybd/cred.json"
     },
     "ioEngine": 0,
+    "workpoolSize": 8,
     "download": {
         "enable": true,
         "delay": 600,
diff --git a/src/example_config/overlaybd.json b/src/example_config/overlaybd.json
index 2fe5cd26..cc274fe2 100644
--- a/src/example_config/overlaybd.json
+++ b/src/example_config/overlaybd.json
@@ -18,6 +18,7 @@
         "path": "/opt/overlaybd/cred.json"
     },
     "ioEngine": 0,
+    "workpoolSize": 8,
     "download": {
         "enable": true,
         "delay": 600,
diff --git a/src/image_service.cpp b/src/image_service.cpp
index 5b63937d..97c4cb75 100644
--- a/src/image_service.cpp
+++ b/src/image_service.cpp
@@ -459,10 +459,6 @@ int ImageService::init() {
             global_fs.srcfs = global_fs.underlay_registryfs;
         }
 
-        if (global_conf.enableThread() == true && cache_type == "file") {
-            LOG_ERROR_RETURN(0, -1, "multi-thread has not been valid for file cache");
-        }
-
         global_fs.io_alloc = new IOAlloc;
 
         if (cache_type == "file") {
diff --git a/src/main.cpp b/src/main.cpp
index e151dd38..91c92359 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -17,6 +17,9 @@
 #include "image_file.h"
 #include "image_service.h"
 #include "tools/comm_func.h"
+#include <libtcmu.h>
+#include <libtcmu_common.h>
+
 #include <photon/common/alog.h>
 #include <photon/common/event-loop.h>
 #include <photon/fs/filesystem.h>
@@ -25,10 +28,9 @@
 #include <photon/io/signal.h>
 #include <photon/photon.h>
 #include <photon/thread/thread.h>
-#include <photon/thread/thread-pool.h>
+#include <photon/thread/thread11.h>
+#include <photon/thread/workerpool.h>
 
-#include <libtcmu.h>
-#include <libtcmu_common.h>
 #include <scsi.h>
 #include <scsi_defs.h>
 #include <fcntl.h>
@@ -36,30 +38,39 @@
 #include <sys/resource.h>
 #include <sys/prctl.h>
 #include <linux/netlink.h>
+#include <atomic>
+#include <cstring>
+#include <cstdint>
+#include <memory>
 #include <string>
+#include <vector>
 
 class TCMUDevLoop;
+class TCMUWorkPool;
+
+static constexpr uint32_t MAX_HANDLERS_PER_VCPU = 48;
+static thread_local photon::semaphore tlu_handler_slots{MAX_HANDLERS_PER_VCPU};
+static thread_local uint32_t tlu_active_handlers = 0;
 
 #define MAX_OPEN_FD 1048576
 
 struct obd_dev {
     ImageFile *file;
     TCMUDevLoop *loop;
-    uint32_t aio_pending_wakeups;
-    uint32_t inflight;
-    std::thread *work;
-    photon::semaphore start, end;
+    std::atomic<uint64_t> inflight{0};
+    // Serialises response-ring updates. The kernel matches responses by
+    // cmd_id, so any vCPU may publish one, but never two at once.
+    photon::spinlock ring_lock;
+    // Coalesces the uio notification: whoever finds it zero owns the notify
+    // loop, the rest only bump it.
+    std::atomic<uint32_t> pending_wakeups{0};
     std::string dev_id;
 };
 
-struct handle_args {
-    struct tcmu_device *dev;
-    struct tcmulib_cmd *cmd;
-};
-
 class TCMULoop;
 TCMULoop *main_loop = nullptr;
 ImageService *imgservice = nullptr;
+TCMUWorkPool *io_work_pool = nullptr;
 
 class TCMULoop {
 protected:
@@ -149,6 +160,35 @@ ssize_t sure(SureIODelegate io, const struct iovec *iov, int iovcnt, off_t offse
     goto again;
 }
 
+// Completes on the vCPU that did the work; forwarding completions to a home
+// vCPU would cost one cross-vCPU wakeup per command.
+void complete_command(struct tcmu_device *dev, struct tcmulib_cmd *cmd,
+                      int result) {
+    obd_dev *odev = (obd_dev *)tcmu_dev_get_private(dev);
+    bool notify;
+    {
+        SCOPED_LOCK(odev->ring_lock);
+        tcmulib_command_complete(dev, cmd, result);
+        notify = odev->pending_wakeups.fetch_add(1, std::memory_order_acq_rel) == 0;
+    }
+
+    if (notify) {
+        for (;;) {
+            tcmulib_processing_complete(dev);
+            photon::thread_yield();
+            uint32_t expected = 1;
+            if (odev->pending_wakeups.compare_exchange_strong(
+                    expected, 0, std::memory_order_acq_rel))
+                break;
+            // Completed while we were notifying; collapse and notify again.
+            odev->pending_wakeups.store(1, std::memory_order_release);
+        }
+    }
+
+    // Last access to the device: ~TCMUDevLoop() frees odev once this hits 0.
+    odev->inflight.fetch_sub(1, std::memory_order_release);
+}
+
 void cmd_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd) {
     obd_dev *odev = (obd_dev *)tcmu_dev_get_private(dev);
     ImageFile *file = odev->file;
@@ -159,13 +199,13 @@ void cmd_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd) {
     case INQUIRY:
         photon::thread_yield();
         ret = tcmu_emulate_inquiry(dev, NULL, cmd->cdb, cmd->iovec, cmd->iov_cnt);
-        tcmulib_command_complete(dev, cmd, ret);
+        complete_command(dev, cmd, ret);
         break;
 
     case TEST_UNIT_READY:
         photon::thread_yield();
         ret = tcmu_emulate_test_unit_ready(cmd->cdb, cmd->iovec, cmd->iov_cnt);
-        tcmulib_command_complete(dev, cmd, ret);
+        complete_command(dev, cmd, ret);
         break;
 
     case SERVICE_ACTION_IN_16:
@@ -175,21 +215,21 @@ void cmd_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd) {
                                                 cmd->iovec, cmd->iov_cnt);
         else
             ret = TCMU_STS_NOT_HANDLED;
-        tcmulib_command_complete(dev, cmd, ret);
+        complete_command(dev, cmd, ret);
         break;
 
     case MODE_SENSE:
     case MODE_SENSE_10:
         photon::thread_yield();
         ret = tcmu_emulate_mode_sense(dev, cmd->cdb, cmd->iovec, cmd->iov_cnt);
-        tcmulib_command_complete(dev, cmd, ret);
+        complete_command(dev, cmd, ret);
         break;
 
     case MODE_SELECT:
     case MODE_SELECT_10:
         photon::thread_yield();
         ret = tcmu_emulate_mode_select(dev, cmd->cdb, cmd->iovec, cmd->iov_cnt);
-        tcmulib_command_complete(dev, cmd, ret);
+        complete_command(dev, cmd, ret);
         break;
 
     case READ_6:
@@ -200,9 +240,9 @@ void cmd_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd) {
         ret = sure({file, &ImageFile::preadv}, cmd->iovec, cmd->iov_cnt,
                    tcmu_cdb_to_byte(dev, cmd->cdb));
         if (ret == length) {
-            tcmulib_command_complete(dev, cmd, TCMU_STS_OK);
+            complete_command(dev, cmd, TCMU_STS_OK);
         } else {
-            tcmulib_command_complete(dev, cmd, TCMU_STS_RD_ERR);
+            complete_command(dev, cmd, TCMU_STS_RD_ERR);
         }
         break;
 
@@ -213,12 +253,12 @@ void cmd_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd) {
         length = tcmu_iovec_length(cmd->iovec, cmd->iov_cnt);
         ret = file->pwritev(cmd->iovec, cmd->iov_cnt, tcmu_cdb_to_byte(dev, cmd->cdb));
         if (ret == length) {
-            tcmulib_command_complete(dev, cmd, TCMU_STS_OK);
+            complete_command(dev, cmd, TCMU_STS_OK);
         } else {
             if (errno == EROFS) {
-                tcmulib_command_complete(dev, cmd, TCMU_STS_WR_ERR_INCOMPAT_FRMT);
+                complete_command(dev, cmd, TCMU_STS_WR_ERR_INCOMPAT_FRMT);
             } else {
-                tcmulib_command_complete(dev, cmd, TCMU_STS_WR_ERR);
+                complete_command(dev, cmd, TCMU_STS_WR_ERR);
             }
         }
         break;
@@ -227,9 +267,9 @@ void cmd_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd) {
     case SYNCHRONIZE_CACHE_16:
         ret = file->fdatasync();
         if (ret == 0) {
-            tcmulib_command_complete(dev, cmd, TCMU_STS_OK);
+            complete_command(dev, cmd, TCMU_STS_OK);
         } else {
-            tcmulib_command_complete(dev, cmd, TCMU_STS_WR_ERR);
+            complete_command(dev, cmd, TCMU_STS_WR_ERR);
         }
         break;
 
@@ -239,59 +279,77 @@ void cmd_handler(struct tcmu_device *dev, struct tcmulib_cmd *cmd) {
             length = tcmu_lba_to_byte(dev, tcmu_cdb_get_xfer_length(cmd->cdb));
             ret = file->fallocate(3, tcmu_cdb_to_byte(dev, cmd->cdb), length);
             if (ret == 0) {
-                tcmulib_command_complete(dev, cmd, TCMU_STS_OK);
+                complete_command(dev, cmd, TCMU_STS_OK);
             } else {
-                tcmulib_command_complete(dev, cmd, TCMU_STS_WR_ERR);
+                complete_command(dev, cmd, TCMU_STS_WR_ERR);
             }
         } else {
             LOG_ERROR("unknown write_same command `", cmd->cdb[0]);
-            tcmulib_command_complete(dev, cmd, TCMU_STS_NOT_HANDLED);
+            complete_command(dev, cmd, TCMU_STS_NOT_HANDLED);
         }
         break;
 
     case MAINTENANCE_IN:
     case MAINTENANCE_OUT:
-        tcmulib_command_complete(dev, cmd, TCMU_STS_NOT_HANDLED);
+        complete_command(dev, cmd, TCMU_STS_NOT_HANDLED);
         break;
 
     default:
         LOG_ERROR("unknown command `", cmd->cdb[0]);
-        tcmulib_command_complete(dev, cmd, TCMU_STS_NOT_HANDLED);
+        complete_command(dev, cmd, TCMU_STS_NOT_HANDLED);
         break;
     }
+    --tlu_active_handlers;
+    tlu_handler_slots.signal(1);
+}
 
-    // call tcmulib_processing_complete(dev) if needed
-    ++odev->aio_pending_wakeups;
-    int wake_up = (odev->aio_pending_wakeups == 1) ? 1 : 0;
-    while (wake_up) {
-        tcmulib_processing_complete(dev);
-        photon::thread_yield();
-
-        if (odev->aio_pending_wakeups > 1) {
-            odev->aio_pending_wakeups = 1;
-            wake_up = 1;
-        } else {
-            odev->aio_pending_wakeups = 0;
-            wake_up = 0;
+class TCMUWorkPool : public photon::WorkPool {
+public:
+    // Fill idle handler slots on the current vCPU before paying for a ring push
+    // and moving the command's cache lines to another core.
+    // thread_mod -1: the pool runs tasks inline, so a task must only spawn
+    // work and return.
+    TCMUWorkPool(size_t vcpu_num, int event_engine, int io_engine)
+        : photon::WorkPool(vcpu_num, event_engine, io_engine, -1) {}
+
+    void dispatch_commands(struct tcmu_device *dev,
+                           const std::vector<struct tcmulib_cmd *> &commands) {
+        auto local_commands = std::min(
+            commands.size(),
+            static_cast<size_t>(MAX_HANDLERS_PER_VCPU - tlu_active_handlers));
+        size_t command_index = 0;
+        for (; command_index < local_commands; ++command_index)
+            start_command(dev, commands[command_index]);
+
+        // The pool's ring spreads the batch over free vCPUs and only pays for
+        // a wakeup when a worker is parked. The task must create the handler
+        // thread on the vCPU that runs it: Photon's pooled stack allocator is
+        // thread-local, so a stack allocated here and freed on a worker is
+        // never reused, and every command pays a fresh 8 MiB mmap.
+        for (; command_index < commands.size(); ++command_index) {
+            auto cmd = commands[command_index];
+            async_call(new auto([dev, cmd] { start_command(dev, cmd); }));
         }
     }
 
-    odev->inflight--;
-}
-
-void *handle(void *args) {
-    handle_args *obj = (handle_args *)args;
-    cmd_handler(obj->dev, obj->cmd);
-    delete obj;
-    return nullptr;
-}
+private:
+    static void start_command(struct tcmu_device *dev,
+                              struct tcmulib_cmd *cmd) {
+        tlu_handler_slots.wait(1);
+        ++tlu_active_handlers;
+        if (!photon::thread_create11(&cmd_handler, dev, cmd)) {
+            LOG_WARN("failed to create Photon thread for TCMU command");
+            cmd_handler(dev, cmd);
+        }
+    }
+};
 
 class TCMUDevLoop {
 protected:
     struct tcmu_device *dev;
     EventLoop *loop;
+    std::vector<struct tcmulib_cmd *> pending_commands;
     int fd;
-    photon::ThreadPool<32> threadpool;
 
     int wait_for_readable(EventLoop *) {
         auto ret = photon::wait_for_fd_readable(fd);
@@ -307,11 +365,13 @@ class TCMUDevLoop {
     int on_accept(EventLoop *) {
         struct tcmulib_cmd *cmd;
         obd_dev *odev = (obd_dev *)tcmu_dev_get_private(dev);
+        pending_commands.clear();
         tcmulib_processing_start(dev);
         while ((cmd = tcmulib_get_next_command(dev, 0)) != NULL) {
-            odev->inflight++;
-            threadpool.thread_create(&handle, new handle_args{dev, cmd});
+            odev->inflight.fetch_add(1, std::memory_order_relaxed);
+            pending_commands.push_back(cmd);
         }
+        io_work_pool->dispatch_commands(dev, pending_commands);
         return 0;
     }
 
@@ -325,10 +385,18 @@ class TCMUDevLoop {
     ~TCMUDevLoop() {
         loop->stop();
         delete loop;
+        obd_dev *odev = (obd_dev *)tcmu_dev_get_private(dev);
+        while (odev->inflight.load(std::memory_order_acquire) != 0) {
+            photon::thread_usleep(1000);
+        }
     }
 
     void run() {
         loop->async_run();
+        if (io_work_pool->thread_migrate(loop->loop_thread()) != 0)
+            LOG_WARN("failed to migrate the accept loop of device ` into the "
+                     "WorkPool, it stays on the vCPU that opened it",
+                     tcmu_dev_get_uio_name(dev));
     }
 };
 
@@ -361,8 +429,6 @@ static int dev_open(struct tcmu_device *dev) {
     }
 
     obd_dev *odev = new obd_dev;
-    odev->aio_pending_wakeups = 0;
-    odev->inflight = 0;
     odev->file = file;
     odev->dev_id = dev_id;
 
@@ -373,27 +439,9 @@ static int dev_open(struct tcmu_device *dev) {
     tcmu_dev_set_write_cache_enabled(dev, false);
     tcmu_dev_set_write_protect_enabled(dev, file->read_only);
 
-    if (imgservice->global_conf.enableThread()) {
-        auto obd_th = [](obd_dev *odev, struct tcmu_device *dev) {
-            photon::init(photon::INIT_EVENT_EPOLL, photon::INIT_IO_LIBCURL);
-            DEFER(photon::fini());
-
-            odev->loop = new TCMUDevLoop(dev);
-            odev->loop->run();
-            LOG_INFO("obd device running");
-            odev->start.signal(1);
-
-            odev->end.wait(1);
-            delete odev->loop;
-            LOG_INFO("obd device exit");
-        };
-
-        odev->work = new std::thread(obd_th, odev, dev);
-        odev->start.wait(1);
-    } else {
-        odev->loop = new TCMUDevLoop(dev);
-        odev->loop->run();
-    }
+    odev->loop = new TCMUDevLoop(dev);
+    odev->loop->run();
+    LOG_INFO("obd device running");
 
     struct timeval end;
     gettimeofday(&end, NULL);
@@ -406,15 +454,7 @@ static int dev_open(struct tcmu_device *dev) {
 static int close_cnt = 0;
 static void dev_close(struct tcmu_device *dev) {
     obd_dev *odev = (obd_dev *)tcmu_dev_get_private(dev);
-    if (imgservice->global_conf.enableThread()) {
-        odev->end.signal(1);
-        if (odev->work->joinable()) {
-            odev->work->join();
-        }
-        delete odev->work;
-    } else {
-        delete odev->loop;
-    }
+    delete odev->loop;
     delete odev->file;
     delete odev;
     LOG_INFO("dev closed `", tcmu_get_path(dev));
@@ -438,7 +478,9 @@ int main(int argc, char **argv) {
     mallopt(M_TRIM_THRESHOLD, 128 * 1024);
     prctl(PR_SET_THP_DISABLE, 1);
 
-    photon::init(photon::INIT_EVENT_DEFAULT, photon::INIT_IO_DEFAULT);
+    photon::PhotonOptions photon_options;
+    photon_options.use_pooled_stack_allocator = true;
+    photon::init(photon::INIT_EVENT_DEFAULT, photon::INIT_IO_DEFAULT, photon_options);
     photon::block_all_signal();
     photon::sync_signal(SIGTERM, &sigint_handler);
     photon::sync_signal(SIGINT, &sigint_handler);
@@ -451,6 +493,17 @@ int main(int argc, char **argv) {
         return -1;
     }
 
+    std::unique_ptr<TCMUWorkPool> work_pool;
+    auto pool_size = imgservice->global_conf.workpoolSize();
+    if (pool_size == 0) {
+        LOG_WARN("workpoolSize is zero, using one worker");
+        pool_size = 1;
+    }
+    work_pool.reset(new TCMUWorkPool(pool_size, photon::INIT_EVENT_EPOLL,
+                                    photon::INIT_IO_LIBCURL));
+    io_work_pool = work_pool.get();
+    LOG_INFO("I/O work pool initialized with ` workers", pool_size);
+
     /*
      * Handings for rlimit and netlink are from tcmu-runner main.c
      */
@@ -524,6 +577,8 @@ int main(int argc, char **argv) {
     tcmulib_close(tcmulib_ctx);
     LOG_INFO("tcmulib closed");
 
+    io_work_pool = nullptr;
+    work_pool.reset();
     delete imgservice;
     return 0;
 }
diff --git a/src/overlaybd/zfile/compressor.cpp b/src/overlaybd/zfile/compressor.cpp
index d1dfee3e..3b83c41b 100644
--- a/src/overlaybd/zfile/compressor.cpp
+++ b/src/overlaybd/zfile/compressor.cpp
@@ -16,6 +16,7 @@
 
 #include "compressor.h"
 #include "lz4/lz4.h"
+#include <array>
 #include <cstddef>
 #include <photon/common/alog.h>
 #include <memory>
@@ -45,13 +46,10 @@ static std::atomic<int> g_qat_state{0};
 #endif
 class BaseCompressor : public ICompressor {
 public:
+    enum : size_t { MAX_BATCH = 256 };
     uint32_t max_dst_size = 0;
     uint32_t src_blk_size = 0;
-    // vector<unsigned char *> raw_data;
-    vector<unsigned char *> compressed_data;
-    vector<unsigned char *> uncompressed_data;
-
-    const int DEFAULT_N_BATCH = 256;
+    enum { DEFAULT_N_BATCH = MAX_BATCH };
 
     virtual int init(const CompressArgs *args) {
         auto opt = &args->opt;
@@ -61,9 +59,6 @@ class BaseCompressor : public ICompressor {
 
         src_blk_size = opt->block_size;
         LOG_DEBUG("create batch buffer, size: `", nbatch());
-        // raw_data.resize(nbatch());
-        compressed_data.resize(nbatch());
-        uncompressed_data.resize(nbatch());
         return 0;
     }
 
@@ -72,11 +67,15 @@ class BaseCompressor : public ICompressor {
     }
 
     virtual int do_compress(size_t *src_chunk_len /* uncompressed length per block */,
-                            size_t *dst_chunk_len, size_t dst_buffer_capacity, size_t nblock) = 0;
+                            size_t *dst_chunk_len, size_t dst_buffer_capacity, size_t nblock,
+                            unsigned char **compressed_data,
+                            unsigned char **uncompressed_data) = 0;
 
     virtual int do_decompress(size_t *src_chunk_len,
                               /* compressed length per block */ size_t *dst_chunk_len,
-                              size_t dst_buffer_capacity, size_t nblock) = 0;
+                              size_t dst_buffer_capacity, size_t nblock,
+                              unsigned char **compressed_data,
+                              unsigned char **uncompressed_data) = 0;
 
     virtual int compress(const unsigned char *src, size_t src_len, unsigned char *dst,
                          size_t dst_len) override {
@@ -91,9 +90,14 @@ class BaseCompressor : public ICompressor {
     int compress_batch(const unsigned char *src, size_t *src_chunk_len, unsigned char *dst,
                        size_t dst_buffer_capacity, size_t *dst_chunk_len, size_t n) override {
 
+        if (n == 0 || n > MAX_BATCH) {
+            LOG_ERROR_RETURN(EINVAL, -1, "invalid batch size (`), maximum is `", n, MAX_BATCH);
+        }
         if (dst_buffer_capacity / n < max_dst_size) {
             LOG_ERROR_RETURN(ENOBUFS, -1, "dst_len should be greater than `", max_dst_size - 1);
         }
+        std::array<unsigned char *, MAX_BATCH> compressed_data;
+        std::array<unsigned char *, MAX_BATCH> uncompressed_data;
         off_t src_offset = 0, dst_offset = 0;
         for (size_t i = 0; i < n; i++) {
             uncompressed_data[i] = ((unsigned char *)src + src_offset);
@@ -101,7 +105,8 @@ class BaseCompressor : public ICompressor {
             src_offset += src_chunk_len[i];
             dst_offset += dst_buffer_capacity / n;
         }
-        return do_compress(src_chunk_len, dst_chunk_len, dst_buffer_capacity, n);
+        return do_compress(src_chunk_len, dst_chunk_len, dst_buffer_capacity, n,
+                           compressed_data.data(), uncompressed_data.data());
     }
 
     virtual int decompress(const unsigned char *src, size_t src_len, unsigned char *dst,
@@ -117,11 +122,16 @@ class BaseCompressor : public ICompressor {
     int decompress_batch(const unsigned char *src, size_t *src_chunk_len, unsigned char *dst,
                          size_t dst_buffer_capacity, size_t *dst_chunk_len, size_t n) override {
 
+        if (n == 0 || n > MAX_BATCH) {
+            LOG_ERROR_RETURN(EINVAL, -1, "invalid batch size (`), maximum is `", n, MAX_BATCH);
+        }
         if (dst_buffer_capacity / n < src_blk_size) {
             LOG_ERROR_RETURN(ENOBUFS, -1,
                              "dst_len (`) should be greater than compressed block size `",
                              dst_buffer_capacity / n, src_blk_size);
         }
+        std::array<unsigned char *, MAX_BATCH> compressed_data;
+        std::array<unsigned char *, MAX_BATCH> uncompressed_data;
         off_t src_offset = 0, dst_offset = 0;
         for (size_t i = 0; i < n; i++) {
             compressed_data[i] = ((unsigned char *)src + src_offset);
@@ -130,7 +140,8 @@ class BaseCompressor : public ICompressor {
             dst_offset += dst_buffer_capacity / n;
         }
 
-        return do_decompress(src_chunk_len, dst_chunk_len, dst_buffer_capacity, n);
+        return do_decompress(src_chunk_len, dst_chunk_len, dst_buffer_capacity, n,
+                             compressed_data.data(), uncompressed_data.data());
     }
 };
 
@@ -195,9 +206,6 @@ class LZ4Compressor : public BaseCompressor {
             if (qat_init(pQat) == 0) {
                 qat_enable = true;
                 g_qat_state.store(1, std::memory_order_release);
-                /* nbatch() now returns DEFAULT_N_BATCH (was 1 when BaseCompressor::init ran). */
-                compressed_data.resize(DEFAULT_N_BATCH);
-                uncompressed_data.resize(DEFAULT_N_BATCH);
             } else {
                 delete pQat;
                 pQat = nullptr;
@@ -213,7 +221,9 @@ class LZ4Compressor : public BaseCompressor {
     }
 
     virtual int do_compress(size_t *src_chunk_len, size_t *dst_chunk_len,
-                            size_t dst_buffer_capacity, size_t nblock) override {
+                            size_t dst_buffer_capacity, size_t nblock,
+                            unsigned char **compressed_data,
+                            unsigned char **uncompressed_data) override {
 
         int ret = 0;
 #ifdef ENABLE_QAT
@@ -245,7 +255,8 @@ class LZ4Compressor : public BaseCompressor {
     }
 
     int do_decompress(size_t *src_chunk_len, size_t *dst_chunk_len, size_t dst_buffer_capacity,
-                      size_t n) override {
+                      size_t n, unsigned char **compressed_data,
+                      unsigned char **uncompressed_data) override {
 
         int ret = 0;
 #ifdef ENABLE_QAT
@@ -310,7 +321,8 @@ class Compressor_zstd : public BaseCompressor {
 
     virtual int do_compress(size_t *src_chunk_len /* uncompressed length per block */,
                             size_t *dst_chunk_len, size_t dst_buffer_capacity,
-                            size_t nblock) override {
+                            size_t nblock, unsigned char **compressed_data,
+                            unsigned char **uncompressed_data) override {
 
         int ret = 0;
         for (size_t i = 0; i < nblock; i++) {
@@ -326,7 +338,9 @@ class Compressor_zstd : public BaseCompressor {
 
     virtual int do_decompress(size_t *src_chunk_len,
                               /* compressed length per block */ size_t *dst_chunk_len,
-                              size_t dst_buffer_capacity, size_t nblock) override {
+                              size_t dst_buffer_capacity, size_t nblock,
+                              unsigned char **compressed_data,
+                              unsigned char **uncompressed_data) override {
 
         int ret = 0;
         for (size_t i = 0; i < nblock; i++) {