如何编写自动备份驱动脚本

本文目录导读：

1. Windows版本（PowerShell脚本）
2. Linux版本（Bash脚本）
3. 使用说明
4. 自动化设置

我来为您提供一个自动备份驱动脚本的解决方案,包含Windows和Linux两个版本。

Windows版本（PowerShell脚本）

基础备份脚本

# backup_drivers.ps1
param(
    [string]$BackupPath = "C:\DriversBackup",
    [switch]$Compress
)
# 创建备份目录
if (!(Test-Path $BackupPath)) {
    New-Item -ItemType Directory -Path $BackupPath -Force
}
# 获取当前日期
$date = Get-Date -Format "yyyyMMdd_HHmmss"
$backupFolder = Join-Path $BackupPath "Drivers_$date"
Write-Host "开始备份驱动程序到: $backupFolder" -ForegroundColor Green
# 使用dism导出驱动程序
try {
    # 创建备份子目录
    New-Item -ItemType Directory -Path $backupFolder -Force | Out-Null
    # 导出所有第三方驱动程序
    dism /online /export-driver /destination:$backupFolder
    Write-Host "驱动备份完成!" -ForegroundColor Green
    # 可选：压缩备份文件
    if ($Compress) {
        $zipFile = "$backupFolder.zip"
        Compress-Archive -Path $backupFolder -DestinationPath $zipFile
        Remove-Item -Path $backupFolder -Recurse -Force
        Write-Host "已压缩备份文件到: $zipFile" -ForegroundColor Green
    }
    # 生成备份报告
    $report = @"
备份时间: $(Get-Date)
备份路径: $backupFolder
驱动程序数量: $(Get-ChildItem $backupFolder -Filter "*.inf" | Measure-Object).Count
"@
    $report | Out-File "$backupFolder\backup_report.txt"
} catch {
    Write-Error "备份过程出错: $_"
    exit 1
}

高级版本（包含计划任务支持）

# advanced_backup_drivers.ps1
param(
    [string]$BackupPath = "C:\DriversBackup",
    [int]$RetentionDays = 30,
    [switch]$CreateScheduledTask,
    [string]$TaskTime = "03:00"
)
function Initialize-Backup {
    param($Path)
    if (!(Test-Path $Path)) {
        New-Item -ItemType Directory -Path $Path -Force | Out-Null
    }
}
function Backup-Drivers {
    param($OutputPath)
    try {
        # 创建带时间戳的备份文件夹
        $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
        $backupFolder = Join-Path $OutputPath "Drivers_$timestamp"
        New-Item -ItemType Directory -Path $backupFolder -Force | Out-Null
        Write-Host "正在备份驱动程序..." -ForegroundColor Yellow
        # 导出驱动程序
        $result = dism /online /export-driver /destination:$backupFolder 2>&1
        if ($LASTEXITCODE -eq 0) {
            Write-Host "驱动程序导出成功!" -ForegroundColor Green
            # 获取驱动数量
            $driverCount = (Get-ChildItem $backupFolder -Filter "*.inf" -Recurse | Measure-Object).Count
            # 生成报告
            $reportContent = @"
========================================
驱动备份报告
========================================
备份时间: $(Get-Date)
备份路径: $backupFolder
驱动程序数量: $driverCount
========================================
"@
            $reportContent | Out-File "$backupFolder\backup_report.txt"
            return $backupFolder, $driverCount
        } else {
            throw "DISM导出失败"
        }
    } catch {
        Write-Error "备份失败: $_"
        return $null, 0
    }
}
function Cleanup-OldBackups {
    param($Path, $Days)
    try {
        $cutoffDate = (Get-Date).AddDays(-$Days)
        $oldBackups = Get-ChildItem $Path -Directory | Where-Object { 
            $_.CreationTime -lt $cutoffDate 
        }
        foreach ($backup in $oldBackups) {
            Write-Host "删除过期备份: $($backup.Name)" -ForegroundColor Yellow
            Remove-Item $backup.FullName -Recurse -Force
        }
    } catch {
        Write-Warning "清理旧备份时出错: $_"
    }
}
function Create-ScheduledBackupTask {
    $taskName = "DriverBackup"
    $scriptPath = $MyInvocation.MyCommand.Path
    $action = New-ScheduledTaskAction -Execute "PowerShell.exe" `
        -Argument "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`""
    $trigger = New-ScheduledTaskTrigger -Daily -At $TaskTime
    $principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" `
        -LogonType ServiceAccount -RunLevel Highest
    Register-ScheduledTask -TaskName $taskName -Action $action `
        -Trigger $trigger -Principal $principal -Force
    Write-Host "计划任务 '$taskName' 已创建" -ForegroundColor Green
}
# 主程序
Write-Host "=== 驱动备份工具 ===" -ForegroundColor Cyan
# 初始化
Initialize-Backup -Path $BackupPath
# 执行备份
$backupFolder, $driverCount = Backup-Drivers -OutputPath $BackupPath
if ($backupFolder) {
    Write-Host "成功备份 $driverCount 个驱动程序" -ForegroundColor Green
    # 清理旧备份
    Cleanup-OldBackups -Path $BackupPath -Days $RetentionDays
    # 创建计划任务
    if ($CreateScheduledTask) {
        Create-ScheduledBackupTask
    }
}
Write-Host "=== 备份完成 ===" -ForegroundColor Cyan

Linux版本（Bash脚本）

基础备份脚本

#!/bin/bash
# driver_backup.sh
# 配置
BACKUP_DIR="/backup/drivers"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_PATH="${BACKUP_DIR}/drivers_${DATE}"
LOG_FILE="${BACKUP_DIR}/backup_${DATE}.log"
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
# 日志函数
log() {
    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}" | tee -a "$LOG_FILE"
}
error() {
    echo -e "${RED}[ERROR] $1${NC}" | tee -a "$LOG_FILE"
    exit 1
}
# 创建备份目录
create_backup_dir() {
    if [ ! -d "$BACKUP_DIR" ]; then
        mkdir -p "$BACKUP_DIR" || error "无法创建备份目录"
    fi
    mkdir -p "$BACKUP_PATH" || error "无法创建备份路径"
}
# 备份内核模块
backup_kernel_modules() {
    log "备份内核模块..."
    # 备份当前内核模块
    KERNEL_VERSION=$(uname -r)
    MODULES_DIR="/lib/modules/${KERNEL_VERSION}"
    if [ -d "$MODULES_DIR" ]; then
        cp -r "$MODULES_DIR" "${BACKUP_PATH}/kernel_modules" || {
            error "备份内核模块失败"
        }
        log "内核模块备份完成"
    fi
}
# 备份显卡驱动
backup_gpu_drivers() {
    log "备份显卡驱动..."
    # NVIDIA驱动
    if command -v nvidia-smi &> /dev/null; then
        nvidia-smi --query-gpu=driver_version --format=csv,noheader > "${BACKUP_PATH}/nvidia_version.txt"
        log "NVIDIA驱动版本已保存"
        # 备份NVIDIA驱动配置
        if [ -d "/etc/nvidia" ]; then
            cp -r "/etc/nvidia" "${BACKUP_PATH}/nvidia_config"
        fi
    fi
    # AMD驱动
    if lspci | grep -i "amd\|ati" &> /dev/null; then
        if [ -d "/etc/amd" ]; then
            cp -r "/etc/amd" "${BACKUP_PATH}/amd_config" 2>/dev/null
        fi
    fi
}
# 备份WiFi/蓝牙驱动
backup_wireless_drivers() {
    log "备份无线驱动..."
    # 备份固件
    if [ -d "/lib/firmware" ]; then
        tar -czf "${BACKUP_PATH}/firmware_backup.tar.gz" /lib/firmware 2>/dev/null
        log "固件备份完成"
    fi
}
# 备份驱动配置
backup_driver_configs() {
    log "备份驱动配置..."
    # modprobe配置
    if [ -d "/etc/modprobe.d" ]; then
        cp -r "/etc/modprobe.d" "${BACKUP_PATH}/modprobe_config"
    fi
    # modules加载配置
    if [ -f "/etc/modules" ]; then
        cp "/etc/modules" "${BACKUP_PATH}/modules_load"
    fi
    # udev规则
    if [ -d "/etc/udev/rules.d" ]; then
        cp -r "/etc/udev/rules.d" "${BACKUP_PATH}/udev_rules"
    fi
}
# 生成驱动列表
generate_driver_list() {
    log "生成驱动列表..."
    {
        echo "=== 已加载的驱动模块 ==="
        lsmod | sort
        echo -e "\n=== PCI设备驱动 ==="
        lspci -k
        echo -e "\n=== USB设备驱动 ==="
        lsusb -t
    } > "${BACKUP_PATH}/driver_list.txt"
    log "驱动列表已生成"
}
# 备份系统驱动包列表（Debian/Ubuntu）
backup_package_list() {
    log "备份驱动包列表..."
    if command -v dpkg &> /dev/null; then
        dpkg --get-selections | grep -i "firmware\|driver\|nvidia\|amd" > "${BACKUP_PATH}/driver_packages.txt"
        log "驱动包列表已保存"
    elif command -v rpm &> /dev/null; then
        rpm -qa | grep -i "firmware\|kmod\|nvidia\|amd" > "${BACKUP_PATH}/driver_packages.txt"
        log "驱动包列表已保存"
    fi
}
# 创建备份摘要
create_summary() {
    log "创建备份摘要..."
    {
        echo "备份时间: $(date)"
        echo "系统版本: $(uname -a)"
        echo "内核版本: $(uname -r)"
        echo "备份路径: ${BACKUP_PATH}"
        echo ""
        echo "已备份内容:"
        echo "- 内核模块"
        echo "- GPU驱动配置"
        echo "- 固件文件"
        echo "- 驱动配置文件"
        echo "- 驱动列表"
        echo "- 驱动包列表"
    } > "${BACKUP_PATH}/backup_summary.txt"
}
# 清理旧备份
cleanup_old_backups() {
    local retention_days=${1:-30}
    log "清理${retention_days}天前的旧备份..."
    find "$BACKUP_DIR" -type d -name "drivers_*" -mtime +${retention_days} | while read dir; do
        rm -rf "$dir"
        log "已删除旧备份: $dir"
    done
}
# 主程序
main() {
    echo -e "${YELLOW}=== Linux驱动备份工具 ===${NC}"
    # 检查root权限
    if [ "$EUID" -ne 0 ]; then
        error "请使用sudo运行此脚本"
    fi
    # 开始备份
    log "开始备份驱动程序..."
    create_backup_dir
    backup_kernel_modules
    backup_gpu_drivers
    backup_wireless_drivers
    backup_driver_configs
    generate_driver_list
    backup_package_list
    create_summary
    # 显示备份结果
    echo ""
    log "备份完成！"
    echo -e "${GREEN}备份路径: ${BACKUP_PATH}${NC}"
    echo -e "${GREEN}日志文件: ${LOG_FILE}${NC}"
    # 可选：清理旧备份
    read -p "是否清理30天前的旧备份？(y/n): " cleanup_choice
    if [ "$cleanup_choice" = "y" ]; then
        cleanup_old_backups 30
    fi
}
# 执行主程序
main

高级Linux版本（包含自动化和邮件通知）

#!/bin/bash
# advanced_driver_backup.sh
# 配置
BACKUP_DIR="/backup/drivers"
RETENTION_DAYS=30
EMAIL_NOTIFY="admin@example.com"
USE_ENCRYPTION=true
ENCRYPTION_PASSWORD="YourEncryptionPassword"
# 初始化
mkdir -p "$BACKUP_DIR"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_PATH="${BACKUP_DIR}/drivers_${DATE}"
LOG_FILE="${BACKUP_DIR}/backup_${DATE}.log"
# 日志和通知
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}
send_notification() {
    if [ -n "$EMAIL_NOTIFY" ]; then
        mail -s "驱动备份状态" "$EMAIL_NOTIFY" < "$LOG_FILE"
    fi
}
# 执行完整备份
perform_full_backup() {
    log "开始完整驱动备份..."
    # 保存驱动状态
    mkdir -p "$BACKUP_PATH/system_info"
    {
        uname -a
        cat /etc/os-release
        lspci -v
        lsusb -v
    } > "$BACKUP_PATH/system_info/system_info.txt"
    # 备份所有相关文件
    tar -czf "$BACKUP_PATH/drivers_backup.tar.gz" \
        /lib/modules \
        /lib/firmware \
        /etc/modprobe.d \
        /etc/udev/rules.d \
        /etc/modules \
        2>/dev/null
    # 加密备份文件
    if [ "$USE_ENCRYPTION" = true ]; then
        gpg --batch --yes --passphrase "$ENCRYPTION_PASSWORD" \
            -c "$BACKUP_PATH/drivers_backup.tar.gz"
        rm "$BACKUP_PATH/drivers_backup.tar.gz"
        log "备份文件已加密"
    fi
    # 验证备份
    log "验证备份完整性..."
    if [ "$USE_ENCRYPTION" = true ]; then
        gpg --batch --yes --passphrase "$ENCRYPTION_PASSWORD" \
            -d "$BACKUP_PATH/drivers_backup.tar.gz.gpg" > /dev/null 2>&1
    fi
    if [ $? -eq 0 ]; then
        log "备份验证成功"
    else
        log "警告: 备份验证失败"
    fi
}
# 执行增量备份
perform_incremental_backup() {
    local last_backup=$(ls -t "$BACKUP_DIR" | head -1)
    if [ -n "$last_backup" ]; then
        log "执行增量备份..."
        rsync -av --link-dest="${BACKUP_DIR}/${last_backup}" \
            /lib/modules \
            /lib/firmware \
            /etc/modprobe.d \
            "$BACKUP_PATH/"
    else
        log "未找到上次备份，执行完整备份"
        perform_full_backup
    fi
}
# 清理函数
cleanup() {
    log "清理${RETENTION_DAYS}天前的备份..."
    find "$BACKUP_DIR" -type d -name "drivers_*" -mtime +${RETENTION_DAYS} -exec rm -rf {} \;
}
# 主函数
main() {
    echo "=== 高级驱动备份工具 ==="
    echo "开始时间: $(date)"
    # 执行备份
    perform_full_backup
    # 清理旧备份
    cleanup
    # 发送通知
    send_notification
    echo "备份完成!"
}
main

使用说明

Windows版本使用：

# 基础备份
.\backup_drivers.ps1
# 指定备份路径并压缩
.\backup_drivers.ps1 -BackupPath "D:\MyDrivers" -Compress
# 高级版本（创建计划任务）
.\advanced_backup_drivers.ps1 -CreateScheduledTask -TaskTime "02:00"

Linux版本使用：

# 给予执行权限
chmod +x driver_backup.sh
# 运行脚本（需要root权限）
sudo ./driver_backup.sh
# 高级版本
sudo ./advanced_driver_backup.sh

自动化设置

Windows计划任务：

# 使用脚本内置功能
.\advanced_backup_drivers.ps1 -CreateScheduledTask

Linux Crontab：

# 每天凌晨3点备份
0 3 * * * /path/to/driver_backup.sh
# 每周末备份
0 3 * * 0 /path/to/driver_backup.sh

这些脚本提供了完整的驱动备份解决方案，您可以根据实际需求选择使用,建议在重要操作前先测试脚本是否正常工作。