Clona partizione Windows da Linux

Dovrai clonare 2 partizioni con dd - uno è dove risiede il bootloader/bootmanager (necessario per eseguire il chainload del sistema operativo) [Riservato al sistema , di solito 100M] e l'altro è l'effettiva installazione di W7.

Controlla la tabella delle partizioni con cfdisk - ti darà una rappresentazione visiva. Quindi elimina tutte le partizioni sull'unità di destinazione - cfdisk è tuo amico.

La sintassi per la clonazione può essere trovata sul wiki qui. Avrai anche bisogno di un MBR appropriato (probabilmente è già presente nel tuo test drive ).

Probabilmente dovrai assegnare un file avviabile flag anche alla partizione [Riservata di sistema] (che dovrebbe essere la prima clonata) - cfdisk può farlo.

Se fallisce, avvia semplicemente da un disco di installazione W7 e segui le linee guida qui per Vista.

AGGIORNA :

Ho dimenticato di menzionare una parte importante dell'intero processo che potrebbe non essere così evidente. Dovrai clonare la tabella delle partizioni dall'unità originale ed eliminare tutto tranne le 2 partizioni relative a Windows OPPURE ricrearle con cfdisk / separati con lo stesso taglia.

Ecco alcuni esempi (supponendo che sda è l'unità di origine e sdb è l'obiettivo):

dd if=/dev/sda bs=1 skip=446 count=66 of=/dev/sdb seek=446 (questo clonerà efficacemente la tua attuale tabella delle partizioni DOS insieme alla firma MBR sull'unità di output)

dd if=/dev/sda bs=1 skip=440 count=72 of=/dev/sdb seek=440 (questo copierà anche l'ID del disco che a volte può causare un avvio non riuscito se mancante - tuttavia, tali dischi non saranno in grado di funzionare insieme in un ambiente Windows, fino a quando l'ID non viene modificato)

parted /dev/sda u s p (questo è il modo in cui puoi ispezionare la tabella delle partizioni e le dimensioni correnti nei settori sull'unità di origine per la successiva replica sulla destinazione con cfdisk o separati stesso)

Dai un'occhiata a

• ntfsclone (copia solo i settori in uso)
• fixntfs.c per correggere gli offset delle informazioni di avvio

IIRC, Trinity Rescue Kit contiene il software necessario e molti altri (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; montaggio ntfs-3g, rsync ecc. ecc.).

/*
 * 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);
}

Questa procedura per la clonazione di un'unità Windows ha funzionato magnificamente per me. Poiché questa è la prima volta che riesco a trasferire un'installazione di Windows su un nuovo disco rigido, condividerò qui la mia procedura per aiutare il prossimo googler a visitare.

La mia situazione:
Windows 7 x64 di Manager aveva raggiunto il massimo del suo SSD da 128 GB, quindi ho acquistato un sostituto da 240 GB.

Problema:
Ho due dock per unità SATA ma Linux non li ha riconosciuti entrambi contemporaneamente, impedendo una facile copia tra di loro.

Hardware:
Sto per configurare un doppio firewall NIC, quindi ho installato l'SSD di origine in questo computer. L'unità SSD 240G di destinazione è stata inserita nel dock esterno.

Processo:
1) La prima chiavetta USB che ho preso in mano conteneva il live CD di Linux Mint, che è diventato /dev/sda1
2) Il "vecchio" SSD 128G è stato rilevato ed è diventato /dev/sdb1 e /dev/sdb2
3) Usato # fdisk -l /dev/sdb dal tutorial e ho copiato le informazioni della finestra della partizione di origine in Gedit.
-- Nota, il tutorial include il -u opzione, tuttavia per me, fdisk stava già visualizzando i blocchi (l'output desiderato), quindi includere quell'interruttore fornisce le informazioni sbagliate.
4) Collega e accendi il drive dock con destinazione 240G SSD, che diventa /dev/sdc .
5) Usa fdisk /dev/sdc per creare partizioni su /dev/sdc che corrispondono esattamente a /dev/sdb , inclusi i flag di avvio e di sistema.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1 per copiare l'MBR nell'unità di destinazione.
-- La guida ora suggerisce di utilizzare hdparm per attivare DMA, ma il comando non è riuscito per me
7) ntfsclone -O /dev/sdc1 /dev/sdb1 per copiare la partizione di sistema nascosta di Windows.
-- -O o --overwrite L'opzione viene utilizzata per impostare la destinazione, facendo apparire il comando al contrario. Complimenti per il live CD di Linux Mint con ntfsclone, poiché non avevo mai sentito parlare di questo comando prima e non ho dovuto collegarmi alla rete.
8) Usa ntfsclone -O /dev/sdc2 /dev/sdb2 per copiare il "C Drive" di Windows. Questo ha richiesto alcune birre per essere completato.
9) Per ridimensionare la partizione, ho usato gparted
10) Reinstallato il nuovo SSD nel computer Windows e esegue il checkdisk (avevo lasciato il tutorial e non ho notato che lo fa).
11) Windows riavviato e tutto torna alla normalità ma con più spazio libero.