# 创建 ext4 文件系统并查看超级块信息
mkfs.ext4 -L datapool /dev/sdb1
tune2fs -l /dev/sdb1 | grep -E 'Block size|Inode size|Journal size|Filesystem features'

# 生产环境推荐挂载选项
mount -t ext4 -o noatime,nodiratime,data=ordered,barrier=1,discard /dev/sdb1 /data

# 高性能场景（牺牲部分安全性）
mount -t ext4 -o noatime,data=writeback,barrier=0,nobh /dev/sdb1 /data

# 创建 XFS 文件系统
mkfs.xfs -f -L datapool -d agcount=32 /dev/sdb1

# 查看 XFS 文件系统信息
xfs_info /dev/sdb1

# 生产环境推荐挂载选项
mount -t xfs -o noatime,nodiratime,logbufs=8,logbsize=256k,allocsize=64m /dev/sdb1 /data

# 查看分配组分布
xfs_db -r /dev/sdb1 -c "sb 0" -c "p agcount"

# 在线碎片整理
xfs_fsr /data

# 创建 Btrfs 文件系统
mkfs.btrfs -L datapool -d raid1 -m raid1 /dev/sdb1 /dev/sdc1

# 创建子卷
btrfs subvolume create /mnt/datapool/home
btrfs subvolume create /mnt/datapool/snapshots

# 创建快照
btrfs subvolume snapshot -r /mnt/datapool/home /mnt/datapool/snapshots/home-20250827

# 启用透明压缩
mount -t btrfs -o noatime,compress=zstd:3,space_cache=v2,autodefrag /dev/sdb1 /data

# 创建 ZFS 存储池
zpool create -o ashift=12 datapool mirror /dev/sdb /dev/sdc

# 创建数据集
zfs create -o compression=lz4 -o atime=off -o recordsize=128k datapool/data

# 查看存储池状态
zpool status datapool
zpool iostat -v datapool 1

# 执行数据清洗
zpool scrub datapool

# 限制 ARC 最大内存使用
echo 4294967296 > /sys/module/zfs/parameters/zfs_arc_max

# 持久化配置
echo "options zfs zfs_arc_max=4294967296" > /etc/modprobe.d/zfs.conf

#!/bin/bash
# metadata_create_bench.sh - 文件创建性能测试
FS_TYPE=$1
MOUNT_POINT=/mnt/bench
COUNTS=(1000 10000 100000 1000000)

for count in "${COUNTS[@]}"; do
    # 清理并重新挂载
    umount $MOUNT_POINT 2>/dev/null
    mkfs.$FS_TYPE -f /dev/nvme1n1p1 2>/dev/null
    mount /dev/nvme1n1p1 $MOUNT_POINT

    # 丢弃缓存
    sync && echo 3 > /proc/sys/vm/drop_caches

    # 创建测试目录
    mkdir -p $MOUNT_POINT/testdir

    # 计时批量创建
    start_time=$(date +%s%N)
    for i in $(seq 1 $count); do
        touch "$MOUNT_POINT/testdir/file_$i"
    done
    end_time=$(date +%s%N)

    elapsed=$(( (end_time - start_time) / 1000000 ))
    rate=$(( count * 1000 / elapsed ))
    echo "$FS_TYPE,$count,$elapsed ms,$rate files/s"

    # 清理
    umount $MOUNT_POINT
done

#!/bin/bash
# metadata_delete_bench.sh - 文件删除性能测试
FS_TYPE=$1
MOUNT_POINT=/mnt/bench
COUNT=100000

# 准备测试文件
umount $MOUNT_POINT 2>/dev/null
mkfs.$FS_TYPE -f /dev/nvme1n1p1 2>/dev/null
mount /dev/nvme1n1p1 $MOUNT_POINT
mkdir -p $MOUNT_POINT/testdir

for i in $(seq 1 $COUNT); do
    touch "$MOUNT_POINT/testdir/file_$i"
done
sync && echo 3 > /proc/sys/vm/drop_caches

# 计时批量删除
start_time=$(date +%s%N)
rm -rf $MOUNT_POINT/testdir
end_time=$(date +%s%N)

elapsed=$(( (end_time - start_time) / 1000000 ))
rate=$(( COUNT * 1000 / elapsed ))
echo "$FS_TYPE: $elapsed ms, $rate files/s"

#!/bin/bash
# metadata_traverse_bench.sh - 目录遍历性能测试
FS_TYPE=$1
MOUNT_POINT=/mnt/bench

# 准备：创建深层目录结构
# 10 个一级目录，每个包含 100 个二级目录，每个包含 100 个文件
for d1 in $(seq 1 10); do
    for d2 in $(seq 1 100); do
        mkdir -p "$MOUNT_POINT/dir_$d1/sub_$d2"
        for f in $(seq 1 100); do
            dd if=/dev/urandom of="$MOUNT_POINT/dir_$d1/sub_$d2/file_$f" bs=4k count=1 2>/dev/null
        done
    done
done
sync && echo 3 > /proc/sys/vm/drop_caches

# 冷缓存遍历
time find $MOUNT_POINT -type f | wc -l

# 热缓存遍历
time find $MOUNT_POINT -type f | wc -l

#!/bin/bash
# small_file_bench.sh - 小文件综合性能测试
# 创建大量 4KB 小文件并统计总耗时
FS_TYPE=$1
MOUNT_POINT=/mnt/bench
FILE_COUNT=500000
FILE_SIZE=4096

sync && echo 3 > /proc/sys/vm/drop_caches

start_time=$(date +%s%N)
for i in $(seq 1 $FILE_COUNT); do
    dir_idx=$(( i % 1000 ))
    mkdir -p "$MOUNT_POINT/bucket_$dir_idx" 2>/dev/null
    dd if=/dev/urandom of="$MOUNT_POINT/bucket_$dir_idx/file_$i" bs=$FILE_SIZE count=1 2>/dev/null
done
end_time=$(date +%s%N)

elapsed=$(( (end_time - start_time) / 1000000 ))
echo "$FS_TYPE: $FILE_COUNT files ($FILE_SIZE bytes each) in $elapsed ms"

; seq_rw.fio - 顺序读写测试作业文件
[global]
ioengine=libaio
direct=1
bs=1m
iodepth=32
numjobs=4
runtime=60
time_based
group_reporting

[seq-read]
rw=read
filename=/data/testfile
size=10g

[seq-write]
rw=write
filename=/data/testfile
size=10g

# 执行顺序读写测试
fio seq_rw.fio --output-format=json --output=seq_rw_result.json

; rand_rw.fio - 随机读写测试作业文件
[global]
ioengine=libaio
direct=1
bs=4k
iodepth=64
numjobs=8
runtime=60
time_based
group_reporting
randrepeat=0
norandommap

[rand-read]
rw=randread
filename=/data/testfile
size=10g

[rand-write]
rw=randwrite
filename=/data/testfile
size=10g

[rand-readwrite]
rw=randrw
rwmixread=70
filename=/data/testfile
size=10g

; block_size_sweep.fio - 块大小扫描测试
[global]
ioengine=libaio
direct=1
iodepth=32
numjobs=4
runtime=30
time_based
group_reporting
rw=randread
filename=/data/testfile
size=10g

[bs-4k]
bs=4k

[bs-8k]
bs=8k

[bs-16k]
bs=16k

[bs-64k]
bs=64k

[bs-256k]
bs=256k

[bs-1m]
bs=1m

# 大文件创建测试：单文件 100GB
dd if=/dev/zero of=/data/largefile bs=1M count=102400 oflag=direct conv=fdatasync

# 小文件批量创建测试：100 万个 4KB 文件
for i in $(seq 1 1000000); do
    dd if=/dev/urandom of="/data/smallfiles/file_$i" bs=4k count=1 2>/dev/null
done

; fsync_bench.fio - fsync 性能测试
[global]
ioengine=sync
bs=16k
numjobs=1
runtime=60
time_based
group_reporting

[fsync-test]
rw=randwrite
filename=/data/fsync_test
size=1g
fsync=1

# 检查文件系统是否支持 O_DIRECT
# ext4 和 XFS 完整支持 O_DIRECT
# Btrfs 支持 O_DIRECT 但在 CoW 模式下有限制
# ZFS 接受 O_DIRECT 标志但内部仍经过 ARC 缓存

# MySQL InnoDB 推荐配置
cat >> /etc/mysql/mysql.conf.d/innodb.cnf << 'EOF'
[mysqld]
innodb_flush_method = O_DIRECT
innodb_flush_log_at_trx_commit = 1
innodb_doublewrite = 1
innodb_file_per_table = 1
EOF

; wal_workload.fio - 模拟 WAL 工作负载
[global]
ioengine=sync
direct=1
numjobs=1
runtime=120
time_based

[wal-writer]
rw=write
bs=8k
filename=/data/wal/wal_test
size=2g
fsync=1
fdatasync=1

# ext4 - 数据库 WAL 目录推荐配置
mkfs.ext4 -O journal_data -b 4096 /dev/nvme0n1p2
mount -t ext4 -o noatime,data=ordered,barrier=1,commit=5 /dev/nvme0n1p2 /data/wal

# XFS - 使用外部日志设备加速 WAL
mkfs.xfs -f -l logdev=/dev/nvme1n1p1,size=512m /dev/nvme0n1p1
mount -t xfs -o noatime,logdev=/dev/nvme1n1p1,logbufs=8 /dev/nvme0n1p1 /data

# PostgreSQL WAL 配置
cat >> /etc/postgresql/16/main/postgresql.conf << 'EOF'
wal_level = replica
fsync = on
synchronous_commit = on
full_page_writes = on
wal_buffers = 64MB
EOF

# Btrfs 上运行数据库时必须禁用 CoW
chattr +C /var/lib/mysql
chattr +C /var/lib/postgresql

# 验证 CoW 是否已禁用
lsattr /var/lib/mysql

; olap_scan.fio - 模拟 OLAP 顺序扫描
[global]
ioengine=libaio
direct=1
bs=1m
iodepth=64
numjobs=8
runtime=60
time_based
group_reporting

[sequential-scan]
rw=read
filename=/data/warehouse/fact_table.dat
size=100g

# Btrfs 压缩配置
mount -t btrfs -o compress=zstd:3 /dev/sdb1 /data

# 查看压缩效果
btrfs filesystem defragment -r -czstd /data/warehouse
compsize /data/warehouse

# ZFS 压缩配置
zfs set compression=lz4 datapool/warehouse
zfs set compression=zstd-3 datapool/warehouse_archive

# 查看压缩比
zfs get compressratio datapool/warehouse

# XFS 预分配大文件空间
xfs_io -f -c "falloc 0 1t" /data/warehouse/large_table.dat

# ext4 预分配
fallocate -l 1T /data/warehouse/large_table.dat

# 检查文件碎片程度
filefrag -v /data/warehouse/large_table.dat

# XFS 在线碎片整理
xfs_fsr /data/warehouse/large_table.dat

# 大文件优化挂载
mount -t xfs -o noatime,allocsize=1g,logbufs=8,logbsize=256k /dev/sdb1 /data

# 查看 Docker 存储驱动配置
docker info | grep -i storage

# Docker 推荐的底层文件系统配置
cat > /etc/docker/daemon.json << 'EOF'
{
    "storage-driver": "overlay2",
    "storage-opts": [
        "overlay2.override_kernel_check=true"
    ]
}
EOF

# 检查 XFS 是否启用 d_type
xfs_info /var/lib/docker | grep ftype

# 创建支持 d_type 的 XFS 文件系统
mkfs.xfs -f -n ftype=1 /dev/sdb1

# Btrfs 快照用于虚拟机模板
btrfs subvolume create /data/vms/template-ubuntu2404
# 安装和配置模板虚拟机...

# 基于模板快照创建新虚拟机（几乎瞬间完成）
btrfs subvolume snapshot /data/vms/template-ubuntu2404 /data/vms/vm-web-01
btrfs subvolume snapshot /data/vms/template-ubuntu2404 /data/vms/vm-web-02

# ZFS 克隆用于虚拟机快速部署
zfs snapshot datapool/vms/template-ubuntu2404@base
zfs clone datapool/vms/template-ubuntu2404@base datapool/vms/vm-web-01
zfs clone datapool/vms/template-ubuntu2404@base datapool/vms/vm-web-02

# Kubernetes StorageClass 示例 - 使用 XFS
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast-xfs
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer
parameters:
  fsType: xfs

# Kubernetes StorageClass 示例 - 使用 ext4
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standard-ext4
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer
parameters:
  fsType: ext4

# Samba 配置优化（以 ext4 为底层）
cat >> /etc/samba/smb.conf << 'EOF'
[shared]
    path = /data/shared
    read only = no
    vfs objects = acl_xattr
    map acl inherit = yes
    store dos attributes = yes
    # 文件系统相关优化
    strict allocate = yes
    allocation roundup size = 1048576
EOF

# NFS 导出配置
cat >> /etc/exports << 'EOF'
/data/shared 192.168.1.0/24(rw,sync,no_subtree_check,no_root_squash)
EOF
exportfs -ra

# ext4 索引节点预分配
# 每 4KB 分配一个 inode，适合大量小文件
mkfs.ext4 -i 4096 -N 100000000 /dev/sdb1

# XFS 动态 inode 分配（默认行为）
mkfs.xfs -f /dev/sdb1
# XFS 的 inode 按需分配，不需要预估数量

# 检查 inode 使用情况
df -i /data

#!/bin/bash
# hash_bucket.sh - 哈希分桶存储示例
# 将文件按名称哈希分散到 1024 个子目录中
store_file() {
    local filename=$1
    local hash=$(echo -n "$filename" | md5sum | head -c 3)
    local bucket_dir="/data/files/${hash:0:1}/${hash:1:1}/${hash:2:1}"
    mkdir -p "$bucket_dir"
    mv "$filename" "$bucket_dir/"
}

# 测试目录可扩展性
# 在单个目录中逐步增加文件数量，测量 lookup 时间
for count in 100 1000 10000 100000 1000000; do
    # 创建测试文件
    for i in $(seq 1 $count); do
        touch "/data/scalability_test/file_$i"
    done
    sync && echo 3 > /proc/sys/vm/drop_caches

    # 测量单次 stat 调用的时间
    time stat "/data/scalability_test/file_$((count / 2))" > /dev/null
done

# XFS 项目配额配置
mount -t xfs -o prjquota /dev/sdb1 /data
xfs_quota -x -c "project -s -p /data/user1 100" /data
xfs_quota -x -c "limit -p bhard=100g 100" /data

#!/bin/bash
# fio_bench_framework.sh - fio 文件系统基准测试框架
set -euo pipefail

FILESYSTEMS=("ext4" "xfs" "btrfs" "zfs")
DEVICE="/dev/nvme1n1p1"
MOUNT_POINT="/mnt/bench"
RESULTS_DIR="./results/$(date +%Y%m%d_%H%M%S)"
ROUNDS=3

mkdir -p "$RESULTS_DIR"

for fs in "${FILESYSTEMS[@]}"; do
    echo "=== Testing $fs ==="
    for round in $(seq 1 $ROUNDS); do
        echo "  Round $round/$ROUNDS"

        # 格式化和挂载
        umount "$MOUNT_POINT" 2>/dev/null || true
        case "$fs" in
            ext4) mkfs.ext4 -F "$DEVICE" > /dev/null 2>&1
                  mount -t ext4 -o noatime "$DEVICE" "$MOUNT_POINT" ;;
            xfs)  mkfs.xfs -f "$DEVICE" > /dev/null 2>&1
                  mount -t xfs -o noatime "$DEVICE" "$MOUNT_POINT" ;;
            btrfs) mkfs.btrfs -f "$DEVICE" > /dev/null 2>&1
                   mount -t btrfs -o noatime "$DEVICE" "$MOUNT_POINT" ;;
            zfs)  zpool destroy benchpool 2>/dev/null || true
                  zpool create -o ashift=12 benchpool "$DEVICE"
                  zfs set mountpoint="$MOUNT_POINT" benchpool
                  zfs set atime=off benchpool ;;
        esac

        # 清除缓存
        sync && echo 3 > /proc/sys/vm/drop_caches

        # 预热
        fio --name=warmup --filename="$MOUNT_POINT/testfile" \
            --rw=write --bs=1m --size=10g --direct=1 --runtime=30 \
            --time_based --minimal > /dev/null 2>&1

        # 正式测试
        fio fs_bench.fio \
            --output-format=json \
            --output="$RESULTS_DIR/${fs}_round${round}.json" \
            --directory="$MOUNT_POINT"

        # 清理
        case "$fs" in
            zfs) zpool destroy benchpool ;;
            *)   umount "$MOUNT_POINT" ;;
        esac
    done
done

echo "Results saved to $RESULTS_DIR"

; fs_bench.fio - 文件系统综合基准测试作业文件
[global]
ioengine=libaio
direct=1
time_based
runtime=60
group_reporting
ramp_time=5
filename_format=$jobname.$jobnum.$filenum

; === 顺序读测试 ===
[seq-read-1m]
description=Sequential Read 1M
rw=read
bs=1m
iodepth=32
numjobs=4
size=10g
filename=seq_read_file
stonewall

; === 顺序写测试 ===
[seq-write-1m]
description=Sequential Write 1M
rw=write
bs=1m
iodepth=32
numjobs=4
size=10g
filename=seq_write_file
stonewall

; === 随机读测试 ===
[rand-read-4k]
description=Random Read 4K
rw=randread
bs=4k
iodepth=64
numjobs=8
size=10g
filename=rand_rw_file
stonewall

; === 随机写测试 ===
[rand-write-4k]
description=Random Write 4K
rw=randwrite
bs=4k
iodepth=64
numjobs=8
size=10g
filename=rand_rw_file
stonewall

; === 混合随机读写 ===
[rand-readwrite-4k]
description=Mixed Random Read/Write 4K (70/30)
rw=randrw
rwmixread=70
bs=4k
iodepth=64
numjobs=8
size=10g
filename=rand_rw_file
stonewall

; === fsync 写测试 ===
[fsync-write]
description=Fsync Write 16K
ioengine=sync
rw=randwrite
bs=16k
numjobs=1
size=2g
filename=fsync_file
fsync=1
stonewall

; === 大块顺序写 ===
[seq-write-large]
description=Sequential Write 4M
rw=write
bs=4m
iodepth=16
numjobs=2
size=20g
filename=large_seq_file
stonewall

#!/usr/bin/env python3
"""parse_fio_results.py - 解析 fio JSON 结果并生成对比报告"""

import json
import sys
import os
from pathlib import Path

def parse_fio_json(filepath):
    """解析单个 fio JSON 结果文件"""
    with open(filepath, 'r') as f:
        data = json.load(f)

    results = {}
    for job in data.get('jobs', []):
        job_name = job['jobname']
        results[job_name] = {
            'read_bw_mib': job['read']['bw'] / 1024,
            'read_iops': job['read']['iops'],
            'read_lat_p99_us': job['read'].get('clat_ns', {}).get('percentile', {}).get('99.000000', 0) / 1000,
            'write_bw_mib': job['write']['bw'] / 1024,
            'write_iops': job['write']['iops'],
            'write_lat_p99_us': job['write'].get('clat_ns', {}).get('percentile', {}).get('99.000000', 0) / 1000,
        }
    return results


def generate_report(results_dir):
    """生成文件系统对比报告"""
    all_results = {}
    for filepath in sorted(Path(results_dir).glob('*.json')):
        fs_name = filepath.stem.rsplit('_', 1)[0]
        if fs_name not in all_results:
            all_results[fs_name] = []
        all_results[fs_name].append(parse_fio_json(filepath))

    # 输出 Markdown 格式对比表
    print("| 测试项 | 指标 |", end="")
    for fs in sorted(all_results.keys()):
        print(f" {fs} |", end="")
    print()

    print("|--------|------|", end="")
    for _ in all_results:
        print("------|", end="")
    print()

    # 取中位数
    for job_name in all_results[list(all_results.keys())[0]][0]:
        for metric in ['read_bw_mib', 'write_bw_mib', 'read_iops', 'write_iops']:
            print(f"| {job_name} | {metric} |", end="")
            for fs in sorted(all_results.keys()):
                values = [r[job_name][metric] for r in all_results[fs] if job_name in r]
                median = sorted(values)[len(values) // 2] if values else 0
                print(f" {median:.1f} |", end="")
            print()


if __name__ == '__main__':
    results_dir = sys.argv[1] if len(sys.argv) > 1 else './results'
    generate_report(results_dir)

# 检查和设置 I/O 调度器
cat /sys/block/nvme0n1/queue/scheduler
echo "mq-deadline" > /sys/block/nvme0n1/queue/scheduler

# 检查设备队列深度
cat /sys/block/nvme0n1/queue/nr_requests

# 确认 direct I/O 对齐
blockdev --getss /dev/nvme0n1
blockdev --getpbsz /dev/nvme0n1

# 安装 filebench
apt-get install -y filebench

# 或从源码编译（推荐，获取最新版本）
git clone https://github.com/filebench/filebench.git
cd filebench
libtoolize
aclocal
autoheader
automake --add-missing
autoconf
./configure
make && make install

#!/bin/bash
# fs_migration.sh - 文件系统迁移脚本示例（ext4 -> XFS）
set -euo pipefail

SOURCE_DEV="/dev/sdb1"
TARGET_DEV="/dev/sdc1"
MOUNT_SOURCE="/mnt/source"
MOUNT_TARGET="/mnt/target"

# 第一步：格式化目标设备
mkfs.xfs -f -L migrated "$TARGET_DEV"

# 第二步：挂载源和目标
mkdir -p "$MOUNT_SOURCE" "$MOUNT_TARGET"
mount "$SOURCE_DEV" "$MOUNT_SOURCE"
mount "$TARGET_DEV" "$MOUNT_TARGET"

# 第三步：使用 rsync 迁移数据（保留所有属性）
rsync -aAXHv --progress "$MOUNT_SOURCE/" "$MOUNT_TARGET/"

# 第四步：校验数据完整性
echo "源文件数量: $(find $MOUNT_SOURCE -type f | wc -l)"
echo "目标文件数量: $(find $MOUNT_TARGET -type f | wc -l)"

# 第五步：对比关键文件的校验和
find "$MOUNT_SOURCE" -type f -exec md5sum {} + | sort > /root/source_checksums.txt
find "$MOUNT_TARGET" -type f -exec md5sum {} + | \
    sed "s|$MOUNT_TARGET|$MOUNT_SOURCE|g" | sort > /root/target_checksums.txt
diff /root/source_checksums.txt /root/target_checksums.txt

echo "迁移完成，数据校验通过"

# 更新 fstab
cat >> /etc/fstab << 'EOF'
/dev/sdc1  /data  xfs  noatime,nodiratime,logbufs=8,logbsize=256k  0  2
EOF

# 如使用 SELinux，重新标记
restorecon -Rv /data

# 验证挂载
mount -a
df -Th /data

# 1. 禁用 atime 更新
mount -o remount,noatime /data

# 2. 调整预读大小
blockdev --setra 4096 /dev/sdb

# 3. 调整脏页回写参数
sysctl -w vm.dirty_ratio=20
sysctl -w vm.dirty_background_ratio=5
sysctl -w vm.dirty_expire_centisecs=3000

# 4. 调整虚拟内存交换倾向
sysctl -w vm.swappiness=10

# 5. 持久化内核参数
cat >> /etc/sysctl.d/99-storage.conf << 'EOF'
vm.dirty_ratio = 20
vm.dirty_background_ratio = 5
vm.dirty_expire_centisecs = 3000
vm.swappiness = 10
EOF

# ext4 特定调优
mount -t ext4 -o noatime,data=ordered,barrier=1,commit=5,max_batch_time=15000 /dev/sdb1 /data

# XFS 特定调优
mount -t xfs -o noatime,logbufs=8,logbsize=256k,allocsize=64m,inode64 /dev/sdb1 /data

# Btrfs 特定调优
mount -t btrfs -o noatime,compress=zstd:3,space_cache=v2,autodefrag,ssd /dev/sdb1 /data

# ZFS 特定调优
zfs set atime=off datapool
zfs set primarycache=all datapool
zfs set recordsize=128k datapool/general
zfs set recordsize=8k datapool/database
zfs set logbias=throughput datapool/warehouse
zfs set logbias=latency datapool/database

#!/bin/bash
# fs_monitor.sh - 文件系统健康监控脚本
MOUNT_POINT="/data"

# 磁盘使用率
usage=$(df -h "$MOUNT_POINT" | awk 'NR==2{print $5}' | tr -d '%')
if [ "$usage" -gt 85 ]; then
    echo "WARNING: Disk usage at ${usage}% on $MOUNT_POINT"
fi

# inode 使用率
inode_usage=$(df -i "$MOUNT_POINT" | awk 'NR==2{print $5}' | tr -d '%')
if [ "$inode_usage" -gt 80 ]; then
    echo "WARNING: Inode usage at ${inode_usage}% on $MOUNT_POINT"
fi

# 文件系统错误检查（ext4）
dumpe2fs -h /dev/sdb1 2>/dev/null | grep -i "error"

# XFS 碎片度检查
xfs_db -r /dev/sdb1 -c frag 2>/dev/null

# I/O 延迟监控
iostat -xz 1 3 | grep -E "^sd|^nvme"

# 使用 blktrace 进行深度 I/O 分析
blktrace -d /dev/nvme0n1 -o trace &
sleep 30
kill %1
blkparse -i trace -d trace.bin
btt -i trace.bin -l trace_latency.dat