Klonen Sie die Windows-Partition von Linux

dd if=/dev/sda bs=1 skip=446 count=66 of=/dev/sdb seek=446 (Dies wird effektiv Ihre aktuelle DOS-Partitionstabelle zusammen mit der MBR-Signatur auf das Ausgabelaufwerk klonen)

dd if=/dev/sda bs=1 skip=440 count=72 of=/dev/sdb seek=440 (dadurch wird auch die Festplatten-ID kopiert, was manchmal zu einem fehlgeschlagenen Start führen kann, wenn sie fehlt - solche Festplatten können jedoch in einer Windows-Umgebung nicht zusammenarbeiten, bis die ID geändert wird)

parted /dev/sda u s p (So ​​können Sie die aktuelle Partitionstabelle und Größe in Sektoren auf dem Quelllaufwerk für eine spätere Replikation auf dem Ziel entweder mit cfdisk überprüfen oder getrennt selbst)

Siehe

• ntfsclone (kopiert nur verwendete Sektoren)
• fixntfs.c zum Korrigieren der Boot-Info-Offsets

IIRC, Trinity Rescue Kit enthält die notwendige Software sowie viele andere (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; ntfs-3g-Mounting, rsync etc. etc.).

/*
 * fixntfs: change some attributes of an NTFS bootsector
 *
 * brought to you by Phoenix
 * url: www.grhack.gr/phoenix
 * mail: [email protected]
 * irc: phoenix -> #grhack -> undernet
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    FILE *fd;
    FILE *idfd;
    struct stat fst;
    unsigned char cab[32];
    unsigned short log_heads;
    unsigned short ntfs_heads;
    unsigned short force_heads;
    unsigned short ntfs_cab;
    unsigned long long sectors;
    unsigned long long new_sectors;

    log_heads = 0;
    ntfs_heads = 0;
    force_heads = 0;
    ntfs_cab = 0;

    if(argc < 2)
    {
        fprintf(stderr, "Usage:\n\t%s <device> <total_sectors> <force_heads>\n", argv[0]);
        exit(0);
    }

    fprintf(stderr, "Stating file %s... ", argv[1]);

    stat(argv[1], &fst);

    if(!S_ISBLK(fst.st_mode))
    {
        fprintf(stderr, "not a block device\n");
        exit(-1);
    }

    fprintf(stderr, "a block device\n");


    fprintf(stderr, "Opening device %s rw... ", argv[1]);

    fd = fopen(argv[1], "r+");

    if(!fd)
    {
        perror("open device");
        exit(-1);
    }

    fprintf(stderr, "ok\n");


    fprintf(stderr, "Checking partition... ");

    fseek(fd, 3, SEEK_SET);

    if(fread(cab, 1, 4, fd) != 4)
    {
        perror("read system_id");
        exit(-1);
    }

    cab[5] = 0;

    if(strncmp(cab, "NTFS", 4))
    {
        fprintf(stderr, "%s\n", cab);
        exit(-1);
    }

    fprintf(stderr, "%s\n", cab);


    fprintf(stderr, "Reading NTFS bootsector heads... ");

    fseek(fd, 0x1a, SEEK_SET);

    ntfs_heads = 0;

    fread(&ntfs_heads, 1, 2, fd);

    fprintf(stderr, "%u\n", ntfs_heads);


    fprintf(stderr, "Reading NTFS bootsector sectors... ");

    fseek(fd, 0x18, SEEK_SET);

    ntfs_cab = 0;

    fread(&ntfs_cab, 1, 2, fd);

    fprintf(stderr, "%u\n", ntfs_cab);


    fprintf(stderr, "Reading NTFS bootsector sectors_per_cluster... ");

    fseek(fd, 0x0d, SEEK_SET);

    ntfs_cab = 0;

    fread(&ntfs_cab, 1, 1, fd);

    fprintf(stderr, "%u\n", ntfs_cab);


    fprintf(stderr, "Reading NTFS bootsector sectors_size... ");

    fseek(fd, 0x0b, SEEK_SET);

    ntfs_cab = 0;

    fread(&ntfs_cab, 1, 2, fd);

    fprintf(stderr, "%u\n", ntfs_cab);


    fprintf(stderr, "Reading NTFS bootsector boot_loader_routine_jump... ");

    fseek(fd, 0, SEEK_SET);

    bzero(cab, sizeof(cab));

    fread(cab, 1, 3, fd);

    fprintf(stderr, "0x%x 0x%x 0x%x\n", cab[0], cab[1], cab[2]);

    fprintf(stderr, "Reading NTFS bootsector total_sectors... ");

    fseek(fd, 0x28, SEEK_SET);

    sectors = 0;

    fread(&sectors, 1, 8, fd);

    fprintf(stderr, "%Lu\n", sectors);


    fprintf(stderr, "Reading device logical heads... ");

    sprintf(cab, "/proc/ide/hd%c/geometry", *(strrchr(argv[1],'/') + 3));

    idfd = fopen(cab, "r");

    if(!idfd)
    {
        perror(cab);
        exit(-1);
    }

    fscanf(idfd, "%*s %*s\n");

    fscanf(idfd, "%*s %s\n", cab);

    *(strrchr(cab, '/')) = 0;

    log_heads = (unsigned short) atoi(strchr(cab, '/') + 1);

    fprintf(stderr, "%u\n", log_heads);

    if(argc == 4)
    {
        force_heads=atoi(argv[3]);
        fprintf(stderr, "Forcing heads to %u\n", force_heads);
        log_heads=force_heads;
    }

    if(fclose(fd) == EOF)
    {
        perror("close device");
        exit(-1);
    }

    if(log_heads != ntfs_heads)
    {
        fprintf(stderr, "Heads are different... Logical=%u NTFS=%u\n\n"
                "Update NTFS bootsector? (y/n) ",
                log_heads, ntfs_heads);

        if(getc(stdin) == 'y')
        {
            fd = fopen(argv[1], "r+");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            ntfs_heads = log_heads;

            fseek(fd, 0x1a, SEEK_SET);

            fwrite(&ntfs_heads, 1, 2, fd);


            fprintf(stderr, "\nBootsector updated... Verifying... ");

            fclose(fd);

            fd = fopen(argv[1], "r");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            fseek(fd, 0x1a, SEEK_SET);

            ntfs_heads = 0;

            fread(&ntfs_heads, 1, 2, fd);

            if(ntfs_heads == log_heads)
            {
                fprintf(stderr, "ok\n\n");
            }
            else
            {
                fprintf(stderr, "error [%u]\n", ntfs_heads);
                exit(-1);
            }
            fclose(fd);
        }
        else
        {
            fprintf(stderr, "\nHeads update cancelled...\n");
        }

        getc(stdin);
    }

    if(argc >= 3 && atoll(argv[2]))
    {
        fprintf(stderr, "Update NTFS bootsector total_sectors from %Lu to %Lu? (y/n) ",
                sectors, atoll(argv[2]));

        if(getc(stdin) == 'y')
        {
            fd = fopen(argv[1], "r+");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            new_sectors = atoll(argv[2]);

            fseek(fd, 0x28, SEEK_SET);

            fwrite(&new_sectors, 1, 8, fd);


            fprintf(stderr, "\nBootsector updated... Verifying... ");

            fclose(fd);

            fd = fopen(argv[1], "r");

            if(!fd)
            {
                perror("open device");
                exit(-1);
            }

            fseek(fd, 0x28, SEEK_SET);

            sectors = 0;

            fread(&sectors, 1, 8, fd);

            if(sectors == new_sectors)
            {
                fprintf(stderr, "ok\n\n");
            }
            else
            {
                fprintf(stderr, "error [%Lu]\n", sectors);
                exit(-1);
            }

            fclose(fd);
        }
        else
        {
            fprintf(stderr, "\nTotal_sectors update cancelled...\n");
        }
        getc(stdin);
    }

    return(1);
}

Diese Anleitung zum Klonen eines Windows-Laufwerks hat bei mir hervorragend funktioniert. Da dies das erste Mal ist, dass ich eine Windows-Installation auf eine neue Festplatte übertragen kann, teile ich hier mein Verfahren, um dem nächsten Besuch von Google zu helfen.

Meine Situation:
Managers Windows 7 x64 hatte seine 128-GB-SSD ausgereizt, also kaufte ich einen 240-GB-Ersatz.

Problem:
Ich habe zwei SATA-Laufwerksdocks, aber Linux hat beide nicht gleichzeitig erkannt, was ein einfaches Kopieren zwischen ihnen verhindert.

Hardware:
Ich bin dabei, eine Dual-NIC-Firewall einzurichten, also habe ich die Quell-SSD in diesem Computer installiert. Ziel 240G SSD ging in externes Dock.

Prozess:
1) Der erste USB-Stick, den ich in die Hand nahm, hatte eine Live-CD von Linux Mint, die zu /dev/sda1 wurde
2) „Alte“ 128G-SSD wurde erkannt und wurde zu /dev/sdb1 und /dev/sdb2
3) Benutzte # fdisk -l /dev/sdb aus dem Tutorial und kopierte die Informationen des Quellpartitionsfensters nach Gedit.
-- Beachten Sie, dass das Tutorial den -u enthält Option, aber für mich hat fdisk bereits Blöcke angezeigt (die gewünschte Ausgabe), so dass das Einschließen dieses Schalters die falschen Informationen liefert.
4) Stecken Sie das Laufwerksdock mit der Ziel-240G-SSD ein und schalten Sie es ein, was zu /dev/sdc wird .
5) Verwenden Sie fdisk /dev/sdc um Partitionen auf /dev/sdc zu erstellen die genau /dev/sdb entsprechen , einschließlich Boot- und System-Flags.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1 um den MBR auf das Ziellaufwerk zu kopieren.
-- Die Anleitung schlägt jetzt die Verwendung von hdparm vor um DMA zu aktivieren, aber der Befehl ist bei mir fehlgeschlagen
7) ntfsclone -O /dev/sdc1 /dev/sdb1 um die versteckte Systempartition von Windows zu kopieren.
-- -O oder --overwrite Option wird verwendet, um das Ziel festzulegen, wodurch der Befehl rückwärts angezeigt wird. Kudos für die Live-CD von Linux Mint mit ntfsclone, da ich von diesem Befehl noch nie zuvor gehört hatte und ich nicht ins Netzwerk gehen musste.
8) Verwenden Sie ntfsclone -O /dev/sdc2 /dev/sdb2 um das Windows "C-Laufwerk" zu kopieren. Dies dauerte ein paar Bier zu vervollständigen.
9) Um die Größe der Partition zu ändern, habe ich gparted verwendet
10) Neue SSD im Windows-Computer neu installiert und Checkdisk ausgeführt (ich hatte das Tutorial verlassen und nicht bemerkt, dass er dies tut).
11) Windows neu gestartet und alles ist wieder normal, aber mit mehr freiem Speicherplatz.