# 查看當(dāng)前文件系統(tǒng)最大支持大小
sudo xfs_info /dev/sdb1 | grep "data"

data     = bsize=4096 blocks=262144000, imaxpct=25
         = sunit=0 swidth=0 blks

fio --name=randwrite --ioengine=libaio --iodepth=32 \
    --rw=randwrite --bs=4k --direct=1 --size=1G \
    --numjobs=4 --runtime=60 --group_reporting

# 擴(kuò)展分區(qū)后執(zhí)行
sudo xfs_growfs /mnt/data

sudo xfs_fsr /mnt/data

# 卸載后修復(fù)
sudo umount /dev/sdb1
sudo xfs_repair /dev/sdb1

# 創(chuàng)建 100 萬(wàn)個(gè)空文件測(cè)試
mkdir -p /mnt/xfs_test
cd /mnt/xfs_test
for i in {1..1000000}; do touch file_$i; done
ls -l | wc -l  # 仍能快速返回結(jié)果

# /etc/fstab 示例
/dev/sdb1 /data xfs defaults,noatime,nodiratime,logbufs=8,logbsize=256k 0 0

import java.io.*;
import java.nio.file.*;
import java.util.concurrent.*;
public class XfsChunkedUploader {
    private static final int CHUNK_SIZE = 64 * 1024 * 1024; // 64MB
    private ExecutorService executor = Executors.newFixedThreadPool(4);
    public void uploadFile(String sourcePath, String destDir) throws IOException {
        Path source = Paths.get(sourcePath);
        long fileSize = Files.size(source);
        int totalChunks = (int) Math.ceil((double) fileSize / CHUNK_SIZE);
        for (int i = 0; i < totalChunks; i++) {
            final int chunkIndex = i;
            executor.submit(() -> {
                try {
                    uploadChunk(source, destDir, chunkIndex);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
        executor.shutdown();
        try {
            if (!executor.awaitTermination(1, TimeUnit.HOURS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
    private void uploadChunk(Path source, String destDir, int chunkIndex) throws IOException {
        long offset = chunkIndex * CHUNK_SIZE;
        byte[] buffer = new byte[CHUNK_SIZE];
        try (RandomAccessFile raf = new RandomAccessFile(source.toFile(), "r")) {
            raf.seek(offset);
            int bytesRead = raf.read(buffer);
            if (bytesRead > 0) {
                Path chunkFile = Paths.get(destDir, "chunk_" + chunkIndex);
                Files.write(chunkFile, buffer, 0, bytesRead,
                    StandardOpenOption.CREATE,
                    StandardOpenOption.WRITE,
                    StandardOpenOption.TRUNCATE_EXISTING);
                System.out.println("? Chunk " + chunkIndex + " written to XFS volume.");
            }
        }
    }
    public static void main(String[] args) throws IOException {
        new XfsChunkedUploader().uploadFile("/tmp/large_video.mp4", "/mnt/xfs_data/uploads");
    }
}

import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
import ch.qos.logback.core.rolling.RollingFileAppender;
import ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class XfsOptimizedLogger {
    static {
        configureLogback();
    }
    private static Logger logger = LoggerFactory.getLogger(XfsOptimizedLogger.class);
    private static void configureLogback() {
        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
        RollingFileAppender appender = new RollingFileAppender<>();
        appender.setContext(context);
        appender.setFile("/mnt/xfs_data/logs/app.log");
        PatternLayoutEncoder encoder = new PatternLayoutEncoder();
        encoder.setContext(context);
        encoder.setPattern("%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");
        encoder.start();
        SizeAndTimeBasedRollingPolicy policy = new SizeAndTimeBasedRollingPolicy<>();
        policy.setContext(context);
        policy.setParent(appender);
        policy.setFileNamePattern("/mnt/xfs_data/logs/app.%d{yyyy-MM-dd}.%i.log.gz");
        policy.setMaxFileSize("100MB");
        policy.setMaxHistory(30);
        policy.setTotalSizeCap(FileSize.valueOf("10GB"));
        policy.start();
        appender.setEncoder(encoder);
        appender.setRollingPolicy(policy);
        appender.start();
        ch.qos.logback.classic.Logger root = context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
        root.addAppender(appender);
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) {
            logger.info("Log entry #{}", i);
            if (i % 10000 == 0) {
                System.out.println("?? Wrote " + i + " log entries to XFS volume.");
            }
        }
    }
}

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
public class XfsDaxMemoryMappedExample {
    public static void writeWithDax(String filePath, String data) throws Exception {
        try (RandomAccessFile file = new RandomAccessFile(filePath, "rw")) {
            FileChannel channel = file.getChannel();
            // 映射到內(nèi)存，XFS + DAX 可實(shí)現(xiàn)零拷貝
            MappedByteBuffer buffer = channel.map(
                FileChannel.MapMode.READ_WRITE, 0, data.length()
            );
            buffer.put(data.getBytes());
            buffer.force(); // 強(qiáng)制刷盤(pán)
            System.out.println("?? Data written via MappedByteBuffer on XFS/DAX volume.");
        }
    }
    public static String readWithDax(String filePath, int length) throws Exception {
        try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
            FileChannel channel = file.getChannel();
            MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, length);
            byte[] bytes = new byte[length];
            buffer.get(bytes);
            return new String(bytes);
        }
    }
    public static void main(String[] args) throws Exception {
        String path = "/mnt/xfs_dax/test.dat";
        String content = "Hello from Java on XFS with DAX support! ??";
        writeWithDax(path, content);
        String readBack = readWithDax(path, content.length());
        System.out.println("?? Read back: " + readBack);
    }
}

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: xfs-fast
provisioner: kubernetes.io/aws-ebs
parameters:
  type: gp3
  fsType: xfs
  iopsPerGB: "100"
  encrypted: "true"
allowVolumeExpansion: true
reclaimPolicy: Retain

apiVersion: v1
kind: Pod
metadata:
  name: app-with-xfs
spec:
  containers:
  - name: app
    image: my-java-app:latest
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: xfs-pvc

xfs_info /mnt/data
xfs_db -r -c frag /dev/sdb1  # 查看碎片率

xfs_io -c 'sync_range -w 0 0' /mnt/data/testfile  # 強(qiáng)制同步

dmesg | grep -i xfs
journalctl -u systemd-fsck@dev-sdb1

iostat -x 1  # 觀察 await、%util
iotop -a     # 查看進(jìn)程級(jí) I/O

echo 'deadline' > /sys/block/sdb/queue/scheduler

# postgresql.conf
data_directory = '/mnt/xfs_data/pgdata'
wal_level = replica
fsync = on
synchronous_commit = on

# elasticsearch.yml
path.data: /mnt/xfs_es/data
path.logs: /mnt/xfs_es/logs

sudo rsync -avxHAX /old_ext4/ /new_xfs/

#!/bin/bash
# xfs_benchmark.sh

MOUNT_POINT="/mnt/xfs_test"
TEST_FILE="$MOUNT_POINT/test.dat"

echo "?? Starting XFS Performance Benchmark..."

# 清理舊數(shù)據(jù)
rm -f $TEST_FILE

# 測(cè)試順序?qū)懭?
echo "?? Sequential Write Test..."
dd if=/dev/zero of=$TEST_FILE bs=1M count=1024 oflag=direct 2>&1 | grep -o '[0-9.]* MB/s'

# 測(cè)試隨機(jī)讀?。↗ava 實(shí)現(xiàn)）
echo "?? Random Read Test (Java)..."
javac RandomReadTest.java
java RandomReadTest $TEST_FILE 100000

# 清理
rm -f $TEST_FILE
echo "? Benchmark completed."

// RandomReadTest.java
import java.io.RandomAccessFile;
import java.util.Random;
public class RandomReadTest {
    public static void main(String[] args) throws Exception {
        String filePath = args[0];
        int iterations = Integer.parseInt(args[1]);
        RandomAccessFile file = new RandomAccessFile(filePath, "r");
        Random rand = new Random();
        long fileSize = file.length();
        long start = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            long pos = rand.nextLong() % fileSize;
            if (pos < 0) pos += fileSize;
            file.seek(pos);
            file.read();
        }
        long end = System.currentTimeMillis();
        System.out.printf("??  %d random reads in %d ms (%.2f ops/ms)\n",
            iterations, end - start, (double)iterations / (end - start));
        file.close();
    }
}