Linux使用dd命令制作系统镜像的实践指南

dd if=<输入文件> of=<输出文件> [选项...]

sudo dd if=/dev/sda of=/backup/system.img bs=4M status=progress

# 推荐配置
dd if=/dev/sda of=image.img bs=4M conv=fsync status=progress

lsblk

NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sda           8:0    0 238.5G  0 disk
├─sda1        8:1    0   512M  0 part /boot/efi
├─sda2        8:2    0     1G  0 part /boot
└─sda3        8:3    0 237.5G  0 part /
sdb           8:16   1  14.9G  0 disk
└─sdb1        8:17   1  14.9G  0 part /media/usb

sudo mkdir -p /mnt/backup
sudo mount /dev/sdb1 /mnt/backup

sudo dd if=/dev/sda of=/mnt/backup/ubuntu_full.img bs=4M status=progress conv=fsync

sudo md5sum /dev/sda
md5sum /mnt/backup/ubuntu_full.img

sudo dd if=/mnt/backup/ubuntu_full.img of=/dev/sda bs=4M status=progress conv=fsync

sudo dd if=/dev/sda bs=4M | gzip -c > /mnt/backup/system.img.gz

gunzip -c /mnt/backup/system.img.gz | sudo dd of=/dev/sda bs=4M

sudo apt install pv

sudo dd if=/dev/sda | pv | dd of=/mnt/backup/system.img bs=4M

sudo pv < /dev/sda > /mnt/backup/system.img

sudo dd if=/dev/sda of=rescue.img bs=4M conv=noerror,sync status=progress

import java.io.*;
import java.util.concurrent.TimeUnit;
public class DDCommandExecutor {
    public static void main(String[] args) {
        String sourceDevice = "/dev/sda";
        String targetImage = "/backup/system.img";
        int blockSizeMB = 4;
        DDCommandExecutor executor = new DDCommandExecutor();
        boolean success = executor.createImage(sourceDevice, targetImage, blockSizeMB);
        if (success) {
            System.out.println("✅ 镜像创建成功！");
        } else {
            System.err.println("❌ 镜像创建失败！");
        }
    }
    public boolean createImage(String source, String target, int blockSizeMB) {
        // 构建 dd 命令
        String command = String.format(
            "sudo dd if=%s of=%s bs=%dM status=progress conv=fsync",
            source, target, blockSizeMB
        );
        System.out.println("🔧 执行命令: " + command);
        try {
            ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
            pb.redirectErrorStream(true); // 合并错误流和输出流
            Process process = pb.start();
            // 实时读取输出（包括进度）
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream())
            );
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("📡 " + line);
            }
            // 等待进程结束
            boolean completed = process.waitFor(2, TimeUnit.HOURS); // 最长等待2小时
            if (!completed) {
                process.destroyForcibly();
                System.err.println("⏰ 命令执行超时，已强制终止。");
                return false;
            }
            int exitCode = process.exitValue();
            return exitCode == 0;
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
            return false;
        }
    }
}

public boolean createCompressedImage(String source, String targetGz, int blockSizeMB) {
    String command = String.format(
        "sudo dd if=%s bs=%dM | gzip -c > %s",
        source, blockSizeMB, targetGz
    );
    System.out.println("📦 执行压缩镜像命令: " + command);
    try {
        ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
        pb.redirectErrorStream(true);
        Process process = pb.start();
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(process.getInputStream())
        );
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println("📡 " + line);
        }
        boolean completed = process.waitFor(3, TimeUnit.HOURS);
        if (!completed) {
            process.destroyForcibly();
            System.err.println("⏰ 压缩镜像创建超时。");
            return false;
        }
        return process.exitValue() == 0;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

import java.util.function.Consumer;
public class AsyncDDExecutor {
    public void createImageAsync(String source, String target, int blockSizeMB, Consumer<Boolean> callback) {
        new Thread(() -> {
            DDCommandExecutor executor = new DDCommandExecutor();
            boolean result = executor.createImage(source, target, blockSizeMB);
            callback.accept(result);
        }).start();
    }
    // 使用示例
    public static void main(String[] args) {
        AsyncDDExecutor async = new AsyncDDExecutor();
        async.createImageAsync("/dev/sda", "/backup/system.img", 4, success -> {
            if (success) {
                System.out.println("🎉 异步镜像创建完成！");
            } else {
                System.err.println("💔 异步镜像创建失败！");
            }
        });
        System.out.println("⏳ 主线程继续执行其他任务...");
    }
}

# 危险！这会把空白镜像写入你的系统盘！
dd if=system.img of=/dev/sda  # ❌ 如果 system.img 是空的或错误的

read -p "确定要将镜像写入 $TARGET_DEVICE 吗？(y/N): " confirm
[[ "$confirm" != "y" ]] && echo "取消操作。" && exit 1

dd if=/dev/sda of=image.img
# 输出：dd: failed to open '/dev/sda': Permission denied

dd: error writing 'image.img': No space left on device

SOURCE_SIZE=$(sudo blockdev --getsize64 /dev/sda)
TARGET_FREE=$(df --output=avail /backup | tail -1)

if [ $SOURCE_SIZE -gt $TARGET_FREE ]; then
    echo "❌ 目标空间不足！"
    exit 1
fi

sudo dd if=/dev/sda of=image.img bs=4M
sync  # 强制刷盘

# 本地执行，备份远程服务器的磁盘
ssh user@remote-server "sudo dd if=/dev/sda bs=4M" | dd of=remote_backup.img bs=4M

nc -l -p 9000 > received.img

sudo dd if=/dev/sda bs=4M | nc <receiver_ip> 9000

rsync -avz --progress system.img user@backup-server:/backups/

#!/bin/bash

# backup-dd.sh - 安全的 dd 镜像备份脚本

set -e  # 遇错即停

LOG_FILE="/var/log/dd-backup.log"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")

log() {
    echo "[$(date)] $1" | tee -a "$LOG_FILE"
}

confirm_device() {
    local device=$1
    if [[ ! -b "$device" ]]; then
        log "❌ $device 不是块设备！"
        exit 1
    fi

    read -p "即将备份设备 $device，确认继续？(y/N): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        log "🚫 用户取消操作。"
        exit 1
    fi
}

check_space() {
    local device=$1
    local target_dir=$2

    local dev_size=$(sudo blockdev --getsize64 "$device")
    local free_space=$(df --output=avail "$target_dir" | tail -1 | tr -d ' ')

    if [[ $dev_size -gt $free_space ]]; then
        log "❌ 目标目录空间不足！需要 $(numfmt --to=iec $dev_size)，可用 $(numfmt --to=iec $free_space)"
        exit 1
    fi
}

main() {
    if [[ $# -ne 2 ]]; then
        echo "用法: $0 <源设备> <目标目录>"
        echo "示例: $0 /dev/sda /mnt/backup"
        exit 1
    fi

    SOURCE_DEV="$1"
    TARGET_DIR="$2"
    TARGET_FILE="$TARGET_DIR/system_${TIMESTAMP}.img"

    log "🚀 开始备份设备 $SOURCE_DEV 到 $TARGET_FILE"

    confirm_device "$SOURCE_DEV"
    check_space "$SOURCE_DEV" "$TARGET_DIR"

    log "⏳ 开始 dd 复制..."
    sudo dd if="$SOURCE_DEV" of="$TARGET_FILE" bs=4M status=progress conv=fsync 2>&1 | tee -a "$LOG_FILE"

    log "✅ 镜像创建完成：$TARGET_FILE"
    ls -lh "$TARGET_FILE" | tee -a "$LOG_FILE"
}

main "$@"

chmod +x backup-dd.sh
sudo ./backup-dd.sh /dev/sda /mnt/backup