【存储工程】存储快照与精简配置

# 物理副本：逐块复制整个卷
dd if=/dev/sda1 of=/dev/sdb1 bs=4M status=progress

# 冻结文件系统，确保所有脏页刷盘
fsfreeze --freeze /mnt/data

# 创建快照（具体命令因实现而异）
lvcreate --snapshot --name snap_data --size 10G /dev/vg0/lv_data

# 解冻文件系统
fsfreeze --unfreeze /mnt/data

# 查看现有卷组和逻辑卷
vgs
lvs

# 确认卷组有足够的空闲空间用于 COW 设备
vgs -o +vg_free

# 创建快照（-L 指定 COW 设备大小，-s 表示快照）
lvcreate --snapshot --name snap_data --size 5G /dev/vg0/lv_data

# 查看快照状态
lvs -o +snap_percent

# 查看快照空间使用率
lvs -o lv_name,data_percent,snap_percent /dev/vg0/snap_data

# 挂载快照卷（只读方式）
mount -o ro /dev/vg0/snap_data /mnt/snapshot

# 从快照中恢复特定文件
cp /mnt/snapshot/important_file /mnt/data/important_file

# 卸载快照
umount /mnt/snapshot

# 挂载可写快照
mount /dev/vg0/snap_data /mnt/snapshot_rw

# 在快照上做实验性修改，不影响原始卷
# ...

# 完成后卸载并删除快照
umount /mnt/snapshot_rw
lvremove /dev/vg0/snap_data

# 卸载原始卷和快照卷
umount /mnt/data
umount /mnt/snapshot

# 执行合并（将快照的数据恢复到原始卷）
lvconvert --merge /dev/vg0/snap_data

# 重新激活原始卷
lvchange -an /dev/vg0/lv_data
lvchange -ay /dev/vg0/lv_data

# 挂载原始卷（现在数据已回滚到快照时刻）
mount /dev/vg0/lv_data /mnt/data

# 对根卷执行合并（需要重启生效）
lvconvert --merge /dev/vg0/snap_root
reboot

# 无快照基准
fio --name=baseline --filename=/dev/vg0/lv_data \
    --rw=randwrite --bs=4k --iodepth=32 --runtime=60 \
    --time_based --group_reporting --direct=1

# 创建快照后再次测试
lvcreate -s -n snap_bench -L 5G /dev/vg0/lv_data
fio --name=with_snapshot --filename=/dev/vg0/lv_data \
    --rw=randwrite --bs=4k --iodepth=32 --runtime=60 \
    --time_based --group_reporting --direct=1

# 使用 64 KB 块大小创建快照
lvcreate -s -n snap_data -L 5G -c 64k /dev/vg0/lv_data

# 创建子卷
btrfs subvolume create /mnt/btrfs_pool/data

# 向子卷写入数据
echo "important data" > /mnt/btrfs_pool/data/file.txt

# 创建只读快照
btrfs subvolume snapshot -r /mnt/btrfs_pool/data /mnt/btrfs_pool/snap_data_readonly

# 创建可写快照
btrfs subvolume snapshot /mnt/btrfs_pool/data /mnt/btrfs_pool/snap_data_writable

# 测量快照创建时间（即使子卷有 1 TB 数据，也是毫秒级）
time btrfs subvolume snapshot -r /mnt/btrfs_pool/data /mnt/btrfs_pool/snap_$(date +%Y%m%d_%H%M%S)

# 创建可写快照用于测试
btrfs subvolume snapshot /mnt/btrfs_pool/production /mnt/btrfs_pool/test_env

# 在测试环境中修改数据（不影响生产环境）
echo "test modification" >> /mnt/btrfs_pool/test_env/config.txt

# 测试完毕后删除
btrfs subvolume delete /mnt/btrfs_pool/test_env

# 第一次全量传输
btrfs subvolume snapshot -r /mnt/src/data /mnt/src/snap_base
btrfs send /mnt/src/snap_base | btrfs receive /mnt/dst/

# 后续增量传输
btrfs subvolume snapshot -r /mnt/src/data /mnt/src/snap_incr1
btrfs send -p /mnt/src/snap_base /mnt/src/snap_incr1 | btrfs receive /mnt/dst/

# 通过 SSH 远程传输
btrfs send -p /mnt/src/snap_base /mnt/src/snap_incr1 | \
    ssh remote_host btrfs receive /mnt/backup/

# 带压缩的远程传输
btrfs send -p /mnt/src/snap_base /mnt/src/snap_incr1 | \
    zstd -3 | ssh remote_host "zstd -d | btrfs receive /mnt/backup/"

# 查看所有子卷和快照
btrfs subvolume list -t /mnt/btrfs_pool

# 查看子卷的父子关系
btrfs subvolume list -p /mnt/btrfs_pool

# 查看快照的空间使用情况
btrfs subvolume show /mnt/btrfs_pool/snap_data_readonly

# 定期清理过期快照
for snap in $(btrfs subvolume list -r -o /mnt/btrfs_pool | \
    awk '{print $NF}' | grep "snap_" | head -n -5); do
    btrfs subvolume delete "/mnt/btrfs_pool/${snap}"
done

# 检查快照空间占用（需要启用配额）
btrfs quota enable /mnt/btrfs_pool
btrfs qgroup show -reF /mnt/btrfs_pool

# 查看空间使用详情
btrfs filesystem du -s /mnt/btrfs_pool/data
btrfs filesystem du -s /mnt/btrfs_pool/snap_data_readonly

# 示例输出：
#      Total   Exclusive  Set shared  Filename
#   10.00GiB   256.00MiB    9.75GiB   /mnt/btrfs_pool/data
#   10.00GiB    64.00MiB    9.75GiB   /mnt/btrfs_pool/snap_data_readonly

# 创建快照（命名规则：dataset@snapname）
zfs snapshot pool0/data@snap_20250901

# 递归创建快照（包含所有子数据集）
zfs snapshot -r pool0@snap_20250901

# 列出所有快照
zfs list -t snapshot

# 查看特定数据集的快照
zfs list -t snapshot -r pool0/data

# 查看快照的空间使用
zfs list -t snapshot -o name,used,refer pool0/data

# 从快照创建克隆
zfs clone pool0/data@snap_20250901 pool0/data_test

# 克隆是完整的可写数据集
echo "test" > /pool0/data_test/test.txt

# 查看克隆关系
zfs get origin pool0/data_test

# 将克隆提升为独立数据集（断开与源快照的依赖）
zfs promote pool0/data_test

# 从快照创建书签
zfs bookmark pool0/data@snap_20250901 pool0/data#bm_20250901

# 列出书签
zfs list -t bookmark pool0/data

# 使用书签作为增量发送的参考点
zfs send -i pool0/data#bm_20250901 pool0/data@snap_20250902 | \
    zfs receive pool1/data_backup

# 删除原始快照（书签仍然可用于增量发送）
zfs destroy pool0/data@snap_20250901

# 对快照设置 hold（tag 用于标识 hold 的用途）
zfs hold backup_job pool0/data@snap_20250901

# 查看快照的 hold
zfs holds pool0/data@snap_20250901

# 尝试删除被 hold 的快照（会失败）
zfs destroy pool0/data@snap_20250901
# cannot destroy 'pool0/data@snap_20250901': dataset is busy

# 带 -d 选项延迟销毁（hold 释放后自动删除）
zfs destroy -d pool0/data@snap_20250901

# 释放 hold
zfs release backup_job pool0/data@snap_20250901

# 销毁单个快照
zfs destroy pool0/data@snap_20250901

# 批量销毁快照（范围语法）
zfs destroy pool0/data@snap_20250801%snap_20250831

# 查看销毁快照后可释放的空间（dry-run）
zfs destroy -nv pool0/data@snap_20250901

# 查看快照的独占空间（used 字段）
zfs list -t snapshot -o name,used,refer pool0/data

# used = 0 表示该快照没有独占数据块，删除后不释放空间
# used > 0 表示删除该快照可以释放对应空间

# 回滚到最近的快照
zfs rollback pool0/data@snap_20250901

# 回滚到较早的快照（需要 -r 选项删除中间的快照）
zfs rollback -r pool0/data@snap_20250801

# 步骤 1：创建精简池
# --thinpool 指定池名，-L 指定数据卷大小
lvcreate --type thin-pool --thinpool tpool --size 100G vg0

# 查看精简池状态
lvs -a -o +pool_lv,data_percent,metadata_percent vg0

# 步骤 2：在精简池中创建精简逻辑卷
# -V 指定虚拟大小，可以大于精简池的物理大小
lvcreate --virtualsize 200G --thin --name thin_lv1 vg0/tpool
lvcreate --virtualsize 300G --thin --name thin_lv2 vg0/tpool

# 查看精简卷状态
lvs -o lv_name,lv_size,data_percent,pool_lv vg0

# 创建精简快照（不需要指定 --size，空间从精简池自动分配）
lvcreate --snapshot --name snap_thin1 vg0/thin_lv1

# 精简快照默认可写
# 查看精简快照
lvs -o lv_name,lv_size,data_percent,origin,pool_lv vg0

# 精简快照的快照（支持多级快照）
lvcreate --snapshot --name snap_thin1_v2 vg0/snap_thin1

# 查看当前自动扩展配置
grep -E "thin_pool_autoextend" /etc/lvm/lvm.conf

# 编辑 lvm.conf 启用自动扩展
# /etc/lvm/lvm.conf 中的关键参数：

# /etc/lvm/lvm.conf
activation {
    # 当精简池使用率达到此百分比时触发自动扩展
    thin_pool_autoextend_threshold = 80

    # 每次扩展增加的百分比
    thin_pool_autoextend_percent = 20
}

# 手动扩展精简池的数据卷
lvextend -L +50G vg0/tpool

# 手动扩展精简池的元数据卷
lvextend --poolmetadatasize +1G vg0/tpool

# 查看扩展后的状态
lvs -a -o +data_percent,metadata_percent vg0/tpool

# 查看精简池使用率
lvs -o lv_name,lv_size,data_percent,metadata_percent vg0/tpool

# 使用 dmsetup 查看底层 thin-pool 状态
dmsetup status vg0-tpool-tpool

# 输出示例：
# 0 209715200 thin-pool 74 6/2048 1024/65536 - rw no_discard_passdown queue_if_no_space -

# 字段含义：
# 74 = 事务 ID
# 6/2048 = 已用元数据块/总元数据块
# 1024/65536 = 已用数据块/总数据块

# 监控脚本示例
cat << 'EOF'
#!/bin/bash
POOL="vg0/tpool"
DATA_PCT=$(lvs --noheadings -o data_percent "$POOL" | tr -d ' ')
META_PCT=$(lvs --noheadings -o metadata_percent "$POOL" | tr -d ' ')

if (( $(echo "$DATA_PCT > 85" | bc -l) )); then
    echo "WARNING: Thin pool data usage at ${DATA_PCT}%"
fi

if (( $(echo "$META_PCT > 85" | bc -l) )); then
    echo "WARNING: Thin pool metadata usage at ${META_PCT}%"
fi
EOF

# 查看当前模式
dmsetup status vg0-tpool-tpool | grep -o 'queue_if_no_space\|error_if_no_space'

# 设置为 queue 模式（推荐：给管理员时间扩容）
dmsetup message vg0-tpool-tpool 0 set_transaction_id 0 1

# 紧急扩容
lvextend -L +20G vg0/tpool

# 如果卷组也没有空间，先扩展卷组
vgextend vg0 /dev/sdc
lvextend -L +20G vg0/tpool

# 检查设备是否支持 discard
lsblk -D /dev/sda

# 查看 discard 粒度和最大字节数
cat /sys/block/sda/queue/discard_granularity
cat /sys/block/sda/queue/discard_max_bytes

# 非零值表示设备支持 discard

# 挂载时启用实时 discard
mount -o discard /dev/vg0/thin_lv1 /mnt/data

# 或在 fstab 中配置
# /dev/vg0/thin_lv1  /mnt/data  ext4  defaults,discard  0  2

# 手动执行 fstrim
fstrim -v /mnt/data

# 输出示例：
# /mnt/data: 15.3 GiB (16424214528 bytes) trimmed

# 设置定时任务（推荐每周执行一次）
systemctl enable fstrim.timer
systemctl start fstrim.timer

# 查看 fstrim.timer 的配置
systemctl cat fstrim.timer

# 检查精简池是否启用了 discard passdown
dmsetup table vg0-tpool-tpool | grep -o 'no_discard_passdown\|discard_passdown'

# 如果显示 no_discard_passdown，需要在 lvm.conf 中配置
# /etc/lvm/lvm.conf:
# devices {
#     issue_discards = 1
# }

# 重新加载 LVM 配置
lvchange --refresh vg0/tpool

# 验证精简卷的 discard 支持
lsblk -D /dev/vg0/thin_lv1

# QEMU/KVM 配置 virtio-blk 设备支持 discard
# 在虚拟机 XML 配置中：
# <disk type='block' device='disk'>
#   <driver name='qemu' type='raw' discard='unmap'/>
#   <source dev='/dev/vg0/thin_lv_vm1'/>
#   <target dev='vda' bus='virtio'/>
# </disk>

# 虚拟机内部验证
lsblk -D /dev/vda

# 虚拟机内部执行 fstrim
fstrim -v /

# 查看 SSD 的 TRIM 支持信息
hdparm -I /dev/sda | grep -i trim

# 对于 NVMe 设备
nvme id-ctrl /dev/nvme0 -H | grep -i "Dataset Management"

# 获取精简池物理大小
POOL_SIZE=$(lvs --noheadings --nosuffix --units g -o lv_size vg0/tpool | tr -d ' ')

# 获取所有精简卷的虚拟大小之和
VIRTUAL_TOTAL=$(lvs --noheadings --nosuffix --units g -o lv_size \
    -S "pool_lv=tpool" vg0 | awk '{sum+=$1} END{print sum}')

# 计算超额分配比
echo "scale=2; $VIRTUAL_TOTAL / $POOL_SIZE * 100" | bc

# 检查元数据使用率
lvs -o metadata_percent vg0/tpool

# 元数据卷的推荐大小
# 经验公式：每 1 TB 数据空间需要约 64 MB 元数据空间
# 但具体取决于块大小和快照数量

# 修复元数据空间不足
lvextend --poolmetadatasize +512M vg0/tpool

#!/bin/bash
# thin_pool_monitor.sh - 精简池监控脚本

POOL="vg0/tpool"
WARN_THRESHOLD=80
CRIT_THRESHOLD=90

DATA_PCT=$(lvs --noheadings -o data_percent "$POOL" | tr -d ' ')
META_PCT=$(lvs --noheadings -o metadata_percent "$POOL" | tr -d ' ')

# 数据空间检查
if (( $(echo "$DATA_PCT > $CRIT_THRESHOLD" | bc -l) )); then
    echo "CRITICAL: Thin pool data at ${DATA_PCT}% - immediate expansion required"
    exit 2
elif (( $(echo "$DATA_PCT > $WARN_THRESHOLD" | bc -l) )); then
    echo "WARNING: Thin pool data at ${DATA_PCT}% - plan expansion"
    exit 1
fi

# 元数据空间检查
if (( $(echo "$META_PCT > $CRIT_THRESHOLD" | bc -l) )); then
    echo "CRITICAL: Thin pool metadata at ${META_PCT}% - immediate expansion required"
    exit 2
elif (( $(echo "$META_PCT > $WARN_THRESHOLD" | bc -l) )); then
    echo "WARNING: Thin pool metadata at ${META_PCT}% - plan expansion"
    exit 1
fi

echo "OK: data=${DATA_PCT}%, metadata=${META_PCT}%"
exit 0

#!/bin/bash
# thin_pool_metrics.sh - 生成 Prometheus 指标

METRICS_DIR="/var/lib/node_exporter/textfile_collector"
METRICS_FILE="${METRICS_DIR}/thin_pool.prom"

# 遍历所有精简池
for pool in $(lvs --noheadings -o lv_name -S "lv_attr=~^t" | tr -d ' '); do
    vg=$(lvs --noheadings -o vg_name -S "lv_name=$pool" | tr -d ' ')
    data_pct=$(lvs --noheadings -o data_percent "${vg}/${pool}" | tr -d ' ')
    meta_pct=$(lvs --noheadings -o metadata_percent "${vg}/${pool}" | tr -d ' ')

    cat >> "${METRICS_FILE}.tmp" << EOF
# HELP thin_pool_data_percent Thin pool data space usage percentage
# TYPE thin_pool_data_percent gauge
thin_pool_data_percent{vg="${vg}",pool="${pool}"} ${data_pct}
# HELP thin_pool_metadata_percent Thin pool metadata space usage percentage
# TYPE thin_pool_metadata_percent gauge
thin_pool_metadata_percent{vg="${vg}",pool="${pool}"} ${meta_pct}
EOF
done

mv "${METRICS_FILE}.tmp" "${METRICS_FILE}"

# prometheus_rules.yml
groups:
  - name: thin_pool_alerts
    rules:
      - alert: ThinPoolDataSpaceWarning
        expr: thin_pool_data_percent > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Thin pool {{ $labels.pool }} data space above 80%"
          description: "Current usage: {{ $value }}%"

      - alert: ThinPoolDataSpaceCritical
        expr: thin_pool_data_percent > 90
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Thin pool {{ $labels.pool }} data space above 90%"
          description: "Immediate expansion required. Current usage: {{ $value }}%"

      - alert: ThinPoolMetadataSpaceWarning
        expr: thin_pool_metadata_percent > 75
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Thin pool {{ $labels.pool }} metadata space above 75%"

      - alert: ThinPoolMetadataSpaceCritical
        expr: thin_pool_metadata_percent > 85
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Thin pool {{ $labels.pool }} metadata space critically high"

#!/bin/bash
# capacity_trend.sh - 记录容量数据用于趋势分析

LOG_FILE="/var/log/thin_pool_capacity.csv"
TIMESTAMP=$(date +%Y-%m-%dT%H:%M:%S)
POOL="vg0/tpool"

DATA_PCT=$(lvs --noheadings -o data_percent "$POOL" | tr -d ' ')
META_PCT=$(lvs --noheadings -o metadata_percent "$POOL" | tr -d ' ')
POOL_SIZE=$(lvs --noheadings --nosuffix --units m -o lv_size "$POOL" | tr -d ' ')

echo "${TIMESTAMP},${DATA_PCT},${META_PCT},${POOL_SIZE}" >> "$LOG_FILE"

#!/bin/bash
# snapshot_backup.sh - 基于快照的一致性备份脚本

set -euo pipefail

SOURCE_LV="/dev/vg0/lv_data"
MOUNT_POINT="/mnt/data"
SNAP_NAME="snap_backup_$(date +%Y%m%d_%H%M%S)"
SNAP_SIZE="10G"
SNAP_MOUNT="/mnt/snap_backup"
BACKUP_DEST="/backup/daily"

echo "[$(date)] Starting backup workflow"

# 步骤 1：冻结文件系统
echo "[$(date)] Freezing filesystem..."
fsfreeze --freeze "$MOUNT_POINT"

# 步骤 2：创建快照
echo "[$(date)] Creating snapshot..."
lvcreate --snapshot --name "$SNAP_NAME" --size "$SNAP_SIZE" "$SOURCE_LV"

# 步骤 3：解冻文件系统（尽快解冻，减少业务影响）
echo "[$(date)] Unfreezing filesystem..."
fsfreeze --unfreeze "$MOUNT_POINT"

# 步骤 4：挂载快照
echo "[$(date)] Mounting snapshot..."
mkdir -p "$SNAP_MOUNT"
mount -o ro "/dev/vg0/$SNAP_NAME" "$SNAP_MOUNT"

# 步骤 5：执行备份（可以用 rsync、tar 或其他工具）
echo "[$(date)] Running backup..."
rsync -a --delete "$SNAP_MOUNT/" "$BACKUP_DEST/"

# 步骤 6：清理
echo "[$(date)] Cleaning up..."
umount "$SNAP_MOUNT"
lvremove -f "/dev/vg0/$SNAP_NAME"
rmdir "$SNAP_MOUNT"

echo "[$(date)] Backup completed successfully"

#!/bin/bash
# btrfs_backup.sh - Btrfs 增量备份脚本

set -euo pipefail

SRC_SUBVOL="/mnt/btrfs/data"
SNAP_DIR="/mnt/btrfs/.snapshots"
REMOTE_HOST="backup-server"
REMOTE_PATH="/mnt/backup/btrfs"

CURRENT_SNAP="snap_$(date +%Y%m%d_%H%M%S)"
PREVIOUS_SNAP=$(ls -1t "$SNAP_DIR" | head -1)

# 创建当前只读快照
btrfs subvolume snapshot -r "$SRC_SUBVOL" "${SNAP_DIR}/${CURRENT_SNAP}"

if [ -n "$PREVIOUS_SNAP" ]; then
    # 增量发送（相对于上一个快照）
    echo "Incremental send from $PREVIOUS_SNAP to $CURRENT_SNAP"
    btrfs send -p "${SNAP_DIR}/${PREVIOUS_SNAP}" "${SNAP_DIR}/${CURRENT_SNAP}" | \
        zstd -3 | ssh "$REMOTE_HOST" "zstd -d | btrfs receive $REMOTE_PATH"
else
    # 首次全量发送
    echo "Full send: $CURRENT_SNAP"
    btrfs send "${SNAP_DIR}/${CURRENT_SNAP}" | \
        zstd -3 | ssh "$REMOTE_HOST" "zstd -d | btrfs receive $REMOTE_PATH"
fi

# 保留最近 7 个快照，清理旧快照
ls -1t "$SNAP_DIR" | tail -n +8 | while read old_snap; do
    btrfs subvolume delete "${SNAP_DIR}/${old_snap}"
done

# 场景：从 500 GB 的生产数据库创建 10 个开发环境
# 传统方式需要 5 TB 空间
# 精简快照方式只需要增量空间（通常 < 50 GB）

# 创建生产数据的基线快照
lvcreate --snapshot --name prod_baseline vg0/thin_prod_db

# 为每个开发者创建独立的可写快照
for dev in alice bob charlie dave eve; do
    lvcreate --snapshot --name "dev_${dev}" "vg0/prod_baseline"
done

# 每个开发者获得独立的完整数据副本
# 写入只影响自己的快照，不影响其他开发者

# 查看实际空间使用
lvs -o lv_name,lv_size,data_percent,origin vg0 | grep dev_

# Btrfs 方式
btrfs subvolume snapshot /mnt/btrfs/prod_db /mnt/btrfs/dev_alice
btrfs subvolume snapshot /mnt/btrfs/prod_db /mnt/btrfs/dev_bob

# ZFS 方式
zfs snapshot pool0/prod_db@baseline
zfs clone pool0/prod_db@baseline pool0/dev_alice
zfs clone pool0/prod_db@baseline pool0/dev_bob

#!/bin/bash
# snapshot_cleanup.sh - 基于时间的快照清理

# 保留策略：
# - 24 小时内的快照：全部保留
# - 7 天内的快照：每天保留一个
# - 30 天内的快照：每周保留一个
# - 超过 30 天的快照：删除

SNAP_DIR="/mnt/btrfs/.snapshots"
NOW=$(date +%s)

for snap in $(ls -1 "$SNAP_DIR"); do
    snap_time=$(stat -c %Y "${SNAP_DIR}/${snap}")
    age_days=$(( (NOW - snap_time) / 86400 ))

    if [ "$age_days" -gt 30 ]; then
        echo "Deleting old snapshot: $snap (age: ${age_days} days)"
        btrfs subvolume delete "${SNAP_DIR}/${snap}"
    fi
done

# 安装 zfs-auto-snapshot（自动快照管理工具）
# 它会按照预设策略自动创建和清理快照

# 手动实现类似策略
# 每小时创建快照，保留 24 个
zfs snapshot pool0/data@hourly_$(date +%Y%m%d_%H)

# 清理超过 24 小时的每小时快照
zfs list -t snapshot -o name -H pool0/data | grep "hourly_" | head -n -24 | \
    xargs -I {} zfs destroy {}

# 每天创建快照，保留 30 个
zfs snapshot pool0/data@daily_$(date +%Y%m%d)

# 清理超过 30 天的每日快照
zfs list -t snapshot -o name -H pool0/data | grep "daily_" | head -n -30 | \
    xargs -I {} zfs destroy {}

# 1. 精简池块大小选择
# 默认 64 KB，对于大 I/O 工作负载可以增大
lvcreate --type thin-pool --thinpool tpool -L 100G \
    --chunksize 512k vg0

# 2. 元数据缓存
# 确保足够的内存用于缓存精简池元数据
# 查看当前元数据大小
lvs -o metadata_percent,lv_metadata_size vg0/tpool

# 3. 使用 SSD 作为精简池
# 精简池的随机 I/O 特征更适合 SSD
# 如果数据在 HDD 上，至少把元数据放在 SSD 上
lvcreate --type thin-pool --thinpool tpool \
    --size 1T --poolmetadatasize 4G \
    --poolmetadataspare y vg0

# 4. 减少快照层数
# LVM 精简快照的多层嵌套会增加元数据查找开销
# 建议快照层数不超过 5 层

# 5. 避免在高 I/O 负载期间创建/删除快照
# 快照操作虽然是 O(1)，但元数据更新可能短暂阻塞 I/O

# 1. 检查精简池整体状态
lvs -a -o +health_status vg0

# 2. 检查精简池空间使用
lvs -o lv_name,data_percent,metadata_percent vg0/tpool

# 3. 检查 dmesg 中的存储相关错误
dmesg | grep -E "thin|device-mapper|dm-" | tail -20

# 4. 检查精简池的 transaction ID 一致性
thin_check /dev/mapper/vg0-tpool_tmeta

# 5. 如果元数据损坏，尝试修复
thin_repair -i /dev/mapper/vg0-tpool_tmeta \
            -o /dev/mapper/vg0-tpool_tmeta_repaired

# 6. 检查快照有效性
lvs -o lv_name,lv_attr,snap_percent vg0 | grep -E "^  snap"

# 7. 快照空间耗尽后的恢复
# 扩展 COW 设备
lvextend -L +5G /dev/vg0/snap_data

# 8. 如果快照已失效（Invalid），只能删除重建
lvremove /dev/vg0/snap_invalid