Clonar partição do Windows do Linux

Então, eu tenho um SSD Intel de 120 GB, com uma partição para Windows e outra para Ubuntu. O Ubuntu é meu sistema operacional principal, o Windows é para jogos. Mas agora eu estou querendo instalar o Mac OS X e gostaria que ele estivesse no SSD, então estou querendo mudar o Windows para uma unidade diferente (externa de 160 GB antiga que tirei do seu shell e fui removida) uso como um test drive.Eu mantenho meus jogos em outro modo externo, para que o desempenho não seja afetado, exceto o tempo de inicialização).

Qual é a melhor maneira de fazer isso? Alguma boa ferramenta para clonar partições? Eu pergunto isso porque o Google está obtendo muitos resultados ao clonar a unidade em que você está realmente usando / tem o Ubuntu instalado, em vez de me dizer como clonar uma partição totalmente não relacionada para outro local não relacionado.

Ah, e a nova partição do Windows permitirá que eu a execute sem nenhum ajuste prévio ao clone? Qualquer outra informação sobre isso seria muito apreciada.

(Estou fazendo isso porque preciso colocar minhas patas no XCode e meu MacBook Pro está morrendo lentamente).

Você precisará clonar 2 partições com dd - uma é onde reside o gerenciador de inicialização / gerenciador de inicialização (necessário para carregar o sistema em cadeia) [ Sistema Reservado , geralmente 100M] e a outra é a instalação real do W7.

Verifique a tabela de partição com cfdisk - ele fornecerá uma representação visual. Em seguida, exclua todas as partições na unidade de destino - cfdisk é seu amigo.

A sintaxe para clonagem pode ser encontrada no wiki aqui . Você também precisará de um MBR adequado (provavelmente já está presente no seu test drive ).

Você provavelmente precisará atribuir um sinalizador inicializável também à partição [Sistema Reservado] (que deve ser o primeiro clonado) - o cfdisk pode fazer isso.

Se isso falhar - basta inicializar a partir de um disco de instalação do W7 e siga as orientações aqui para o Vista.

ATUALIZAÇÃO :

Esqueci de mencionar uma parte importante de todo o processo que pode não ser tão evidente. Você precisará clonar a tabela de partições da unidade original e excluir tudo, exceto as 2 partições relacionadas ao Windows, ou recriá-las com cfdisk / parted com o mesmo tamanho.

Aqui estão alguns exemplos (supondo que sda seja sua unidade de origem e sdb seja o destino):

dd if = / dev / sda bs = 1 skip = 446 count = 66 of = / dev / sdb seek = 446 (isso efetivamente clona sua tabela de partição atual do DOS junto com a assinatura MBR na unidade de saída)

dd if = / dev / sda bs = 1 skip = 440 count = 72 of = / dev / sdb seek = 440 (isso também copiará o ID do disco, que às vezes pode resultar em falha na inicialização, se estiver ausente - no entanto, esses discos não serão poder trabalhar juntos em um ambiente Windows, até que o ID seja alterado)

parted / dev / sda usp (é assim que você pode inspecionar a tabela e o tamanho da partição atual em setores na unidade de origem para posterior replicação no destino com cfdisk ou se partiu )

Dê uma olhada em

• ntfsclone (copia apenas setores em uso)
• fixntfs.c para corrigir os desvios das informações de inicialização

O IIRC, Trinity Rescue Kit contém o software necessário e muitos outros (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; montagem ntfs-3g, 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);
}

Este tutorial para clonar uma unidade do Windows funcionou esplendidamente para mim. Como é a primeira vez que posso transferir uma instalação do Windows para um novo disco rígido, compartilharei meu procedimento aqui para ajudar o próximo Googler a visitar.

Minha situação:
o Windows 7 x64 do gerente havia atingido seu SSD de 128G no máximo, então comprei um substituto de 240 GB.

Problema:
Eu tenho duas unidades de disco SATA, mas o Linux não reconheceu as duas ao mesmo tempo, impedindo uma cópia fácil entre elas.

Hardware:
Estou prestes a configurar um firewall NIC duplo, por isso instalei o SSD de origem neste computador. O destino 240G SSD entrou no dock externo.

Processo:
1) O primeiro pen drive que eu peguei tinha o CD live do Linux Mint, que se tornou /dev/sda1
2) O SSD 128G "antigo" foi detectado e se tornou /dev/sdb1e /dev/sdb2
3) Utilizado # fdisk -l /dev/sdbno tutorial e copiado as informações da janela da partição de origem no Gedit.
- Observe que o tutorial inclui a -uopção, no entanto, para mim, o fdisk já estava exibindo blocos (a saída desejada), portanto, incluir essa opção fornece informações incorretas.
4) Conecte e ligue a estação de acoplamento com o destino 240G SSD, que se torna /dev/sdc.
5) Use fdisk /dev/sdcpara criar partições /dev/sdcexatamente iguais /dev/sdb, incluindo sinalizadores de inicialização e sistema.
6) dd if=/dev/sdb of=/dev/sda bs=446 count=1para copiar o MBR para a unidade de destino.
- O guia agora sugere o usohdparmativar o DMA, mas o comando falhou para mim
7) ntfsclone -O /dev/sdc1 /dev/sdb1para copiar a partição do sistema oculto do Windows.
- -Oou --overwriteopção é usada para definir o destino, fazendo o comando aparecer para trás. Parabéns ao live CD do Linux Mint com o ntfsclone, pois eu nunca tinha ouvido falar desse comando e não precisava entrar na rede.
8) Use ntfsclone -O /dev/sdc2 /dev/sdb2para copiar a janela "C Drive". Isso levou algumas cervejas para ser concluído.
9) Para redimensionar a partição, usei gparted
10) Reinstalei o novo SSD no computador com Windows e execute o checkdisk (eu havia deixado o tutorial e não percebi que ele faz isso).
11) Reinicie o Windows e tudo voltará ao normal, mas com mais espaço livre.

1. Procurei " Disks " no menu de aplicativos do Ubuntu e abri o aplicativo utilitário Disks.
2. Eu selecionei a partição para copiar. Em seguida, clique no ícone de configurações e escolha " Criar imagem de disco ".
3. Levaria um tempo para gerar a imagem de recuperação .
4. Após terminar de gerar a imagem de recuperação, cliquei na partição em que queria clonar a partição anterior.
5. Em seguida, clique no ícone de configurações novamente e escolha " Restaurar imagem de disco " e selecione o arquivo de imagem de disco gerado anteriormente.
6. Então esperou que terminasse.

Acabei de explorar o aplicativo utilitário Disks, e é isso. Eu não instalei nada.