लिनक्स से विंडोज का विभाजन


13

तो मुझे एक 120 जीबी इंटेल एसएसडी मिला है, जिसमें एक विभाजन विंडोज के लिए और दूसरा उबंटू के लिए है। उबंटू मेरा मुख्य ओएस है, विंडोज गेमिंग के लिए है। लेकिन अब मैं मैक ओएस एक्स को स्थापित करने के लिए देख रहा हूं, और मैं चाहूंगा कि यह एसएसडी पर हो, इसलिए मैं विंडोज को एक अलग ड्राइव (पुराने 160 जीबी बाहरी) में स्थानांतरित करना चाहता हूं जो मैंने इसे खोल से बाहर निकाल लिया है और किया गया है परीक्षण ड्राइव के रूप में उपयोग करना। मैं अपने गेम को किसी अन्य बाहरी रास्ते पर रखता हूं, इसलिए प्रदर्शन प्रभावित नहीं होना चाहिए, स्टार्ट अप टाइम के अलावा)।

इसके बारे में जाने का सबसे अच्छा तरीका क्या है? विभाजन के लिए कोई अच्छा उपकरण? मैं यह पूछता हूं क्योंकि Google आपके द्वारा उपयोग किए जा रहे ड्राइव को क्लोन करने पर बहुत सारे परिणामों को चालू कर रहा है, या उबंटू को स्थापित किया है, बजाय मुझे बताए कि किसी अन्य असंबंधित स्थान पर पूरी तरह से असंबंधित विभाजन को कैसे क्लोन किया जाए।

ओह, और क्या नया विंडोज विभाजन मुझे बिना किसी पूर्व-क्लोन किए ट्विकिंग के बिना चलने देगा? इस संबंध में किसी भी अन्य जानकारी की बहुत सराहना की जाएगी।

(मैं यह कर रहा हूं क्योंकि मुझे XCode पर अपने पंजे प्राप्त करने की आवश्यकता है, और मेरा मैकबुक प्रो धीरे-धीरे मर रहा है)।


ठीक है, आप सभी की जरूरत है cfdisk और dd है । एकमात्र चीज जो कुछ संदिग्ध है वह बूट सेक्टर है। विंडोज का कौन सा संस्करण?
XXL

विंडोज 7. मुझे याद है कि यह विभाजन से संबंधित कुछ समस्याओं के कारण, एक शाही दर्द है।
फॉल्ट

क्या आपके पास अपने निपटान में W7 डिस्क है?
XXL

पूरी तरह से निश्चित नहीं है कि मैंने इसे कहां रखा है, लेकिन जरूरत पड़ने पर मैं इसे खोद सकता हूं।
दोष

जवाबों:


7

आपको dd के साथ 2 विभाजन को क्लोन करने की आवश्यकता होगी - एक वह जगह है जहां बूटलोडर / बूटमैनगर रहता है (ओएस को चैन लोड करने के लिए आवश्यक है) [ सिस्टम आरक्षित , आमतौर पर 100M] और दूसरा वास्तविक W7 इंस्टॉलेशन होता है।

Cfdisk के साथ विभाजन तालिका देखें - यह आपको एक दृश्य प्रतिनिधित्व देगा। फिर लक्ष्य ड्राइव पर सभी विभाजन हटाएं - cfdisk आपका मित्र है।

क्लोनिंग के लिए वाक्यविन्यास यहां विकि पर पाया जा सकता है । आपको एक उचित एमबीआर की भी आवश्यकता होगी (यह शायद आपके टेस्ट ड्राइव पर पहले से मौजूद है )।

आपको संभवतः [सिस्टम आरक्षित] विभाजन के लिए एक बूट करने योग्य ध्वज निर्दिष्ट करना होगा (जो पहले एक क्लोन होना चाहिए) - cfdisk इसे पूरा कर सकता है।

यदि वह विफल रहता है - बस W7 इंस्टॉलेशन डिस्क से बूट करें और विस्टा के लिए यहां दिशानिर्देशों का पालन करें

अद्यतन :

पूरी प्रक्रिया के एक महत्वपूर्ण हिस्से का उल्लेख करना भूल गए जो शायद इतना स्पष्ट न हो। आपको या तो विभाजन ड्राइव को मूल ड्राइव से क्लोन करना होगा और सब कुछ हटाना होगा लेकिन 2 विंडोज से संबंधित विभाजन या उन्हें cfdisk के साथ फिर से बनाना / समान आकार के साथ जुदा करना होगा ।

यहां कुछ उदाहरण दिए गए हैं (यह मानते हुए, कि एसडीए आपका स्रोत ड्राइव है और एसडीडी लक्ष्य है):

dd if = / dev / sda bs = 1 Skip = 446 count = 66 of = / dev / sdb तलाश = 446 (यह प्रभावी रूप से आपके वर्तमान डॉस विभाजन तालिका को एमबीआर हस्ताक्षर के साथ आउटपुट ड्राइव पर क्लोन करेगा)

dd if = / dev / sda bs = 1 स्किप = 440 गणना = 72 का = / dev / sdb चाह = 440 (यह डिस्क आईडी की नकल भी करेगा जो कभी-कभी असफल बूट में परिणाम कर सकता है यदि गायब हो - हालांकि, ऐसे डिस्क नहीं होंगे Windows वातावरण पर एक साथ काम करने में सक्षम हो, जब तक कि आईडी बदल न जाए)

parted / dev / sda usp (यह आप वर्तमान विभाजन तालिका का निरीक्षण कर सकते हैं और बाद में cfdisk या parted के साथ लक्ष्य पर प्रतिकृति के लिए स्रोत ड्राइव पर क्षेत्रों में आकार )


यही कारण है कि एक दर्द है और आम तौर पर बूट नहीं करता है
sehe

क्यों? यदि बूट प्रक्रिया में कोई समस्या है - डब्लू 7 स्थापित डिस्क से कमांड प्रॉम्प्ट सत्र को तत्काल करना और बूटरेक / फिक्समब्र , बूटरेक / फिक्सबूट या बूट्रेक / रीबिल्डबैंक को निष्पादित करना समस्या को ठीक करने में सक्षम होना चाहिए।
XXL

काफी उचित। मेरे लिए यह अतीत में असफल रहा था। मुझे यकीन है कि यही कारण है कि मुझे हादसे को रोकने के लिए बर्तनों के बारे में पता चला। इसके अलावा, विभाजन को दोहराने के लिए dd का उपयोग करना कम से कम बहुत कुशल नहीं है
sehe 22'11

क्योंकि यह एक सेक्टर-बाय-सेक्टर कॉपी का उपयोग करता है और आवंटित फाइल सिस्टम में खाली जगह की नकल करेगा? मुझे लगता है, ओपी के संदर्भ में, यह शायद पूरी तरह से अप्रासंगिक होने जा रहा है। हम यह भी नहीं जानते हैं कि विभाजन पूर्ण है या नहीं, कम स्पष्ट वैकल्पिक समाधान की कोशिश करने के बजाय कुछ अतिरिक्त मिनट (समय का लाभ कम से कम हो सकता है) की प्रतीक्षा करने के लिए उसका उल्लेख न करें
XXL

लेकिन इसका अलग-अलग आकार के विभाजन की नकल करने में सक्षम होने का अलग फायदा है। डीडी मानता है कि गंतव्य बिल्कुल उसी आकार का है (यद्यपि, यह बड़ा हो सकता है )। यह एक बाधा समस्या हो सकती है, खासकर जब SSDs के शामिल कर रहे हैं (वे के नहीं हैं 'असीमित' क्षमता)
sehe

4

अच्छी तरह से देखिए

  • ntfsclone (उपयोग में केवल क्षेत्र की प्रतियां)
  • बूट जानकारी ऑफ़सेट को ठीक करने के लिए fixntfs.c

IIRC, ट्रिनिटी रेस्क्यू किट में आवश्यक सॉफ़्टवेयर के साथ-साथ कई अन्य (ssh, partimage, fdisk, fdisk, cfdisk, parted, gparted, testdisk, ntfsfix; ntfs-3g माउंटिंग, rsync आदि) शामिल हैं।

/*
 * fixntfs: change some attributes of an NTFS bootsector
 *
 * brought to you by Phoenix
 * url: www.grhack.gr/phoenix
 * mail: phoenix@grhack.gr
 * 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);
}

2

यह कैसे विंडोज ड्राइव क्लोनिंग के लिए मेरे लिए शानदार काम किया। चूंकि यह पहली बार है जब मैं एक नई हार्ड ड्राइव में विंडोज इंस्टाल ट्रांसफर करने में सक्षम हुआ हूं, इसलिए अगली गोगलर की यात्रा में मदद करने के लिए मैं अपनी प्रक्रिया यहां साझा करूंगा।

मेरी स्थिति:
प्रबंधक के विंडोज 7 x64 ने अपने 128 जी एसएसडी को अधिकतम कर दिया था, इसलिए मैंने 240 जीबी प्रतिस्थापन खरीदा।

समस्या:
मेरे पास दो SATA ड्राइव डॉक हैं, लेकिन लिनक्स एक ही समय में दोनों को नहीं पहचानता था, उनके बीच एक आसान प्रतिलिपि को रोकता था।

हार्डवेयर:
मैं एक दोहरी एनआईसी फ़ायरवॉल स्थापित करने वाला हूं, इसलिए मैंने इस कंप्यूटर में एसएसडी स्रोत स्थापित किया। गंतव्य 240G SSD बाहरी गोदी में चला गया।

प्रक्रिया:
1) मेरे द्वारा ली गई पहली USB स्टिक में लिनक्स मिंट लाइव सीडी थी, जो /dev/sda1
2 बन गई ) "ओल्ड" 128 जी एसएसडी का पता लगाया गया /dev/sdb1और बन गया और /dev/sdb2
3) # fdisk -l /dev/sdbट्यूटोरियल से उपयोग किया गया और स्रोत विभाजन विंडो की जानकारी को Gedit में कॉपी किया।
- ध्यान दें, ट्यूटोरियल में -uविकल्प भी शामिल है , हालांकि, मेरे लिए, fdisk पहले से ही ब्लॉक (वांछित आउटपुट) प्रदर्शित कर रहा था, इसलिए उस स्विच सहित गलत जानकारी देता है।
4) प्लग इन करें और गंतव्य गोदी को 240G एसएसडी के साथ चालू करें, जो बन जाता है /dev/sdc
5) बूट और सिस्टम झंडे सहित उस बिल्कुल मैच fdisk /dev/sdcपर विभाजन बनाने के लिए उपयोग करें । 6) गंतव्य ड्राइव को एमबीआर कॉपी करने के लिए। - गाइड अब उपयोग करने का सुझाव देता है/dev/sdc/dev/sdb
dd if=/dev/sdb of=/dev/sda bs=446 count=1
hdparmडीएमए चालू करने के लिए, लेकिन विंडोज
7 ntfsclone -O /dev/sdc1 /dev/sdb1सिस्टम विभाजन को कॉपी करने के लिए कमांड मेरे लिए 7) विफल रहा
- -Oया --overwriteविकल्प का उपयोग गंतव्य को सेट करने के लिए किया जाता है, जिससे कमांड पीछे की ओर दिखाई देती है। Kudos से लिनक्स मिंट की सीडी में ntfsclone है, क्योंकि मैंने इस कमांड के बारे में पहले नहीं सुना था और मुझे नेटवर्क पर नहीं आना था।
8) ntfsclone -O /dev/sdc2 /dev/sdb2विंडोज़ "सी ड्राइव" की प्रतिलिपि बनाने के लिए उपयोग करें । यह पूरा करने के लिए कुछ बियर ले लिया।
9) विभाजन के आकार के लिए, मैंने gparted
10 का उपयोग किया ) विंडोज़ कंप्यूटर में नए एसएसडी की स्थापना की और यह चेकडिस्क चलाता है (मैंने ट्यूटोरियल छोड़ दिया था और ध्यान नहीं दिया कि वह ऐसा करता है)।
11) विंडोज को रिबूट किया गया और सभी वापस सामान्य लेकिन अधिक खाली स्थान के साथ।


1
  1. मैंने उबंटू एप्लिकेशन मेनू में " डिस्क " की खोज की और डिस्क उपयोगिता ऐप खोला।
  2. मैंने विभाजन को कॉपी करने के लिए चुना। फिर सेटिंग्स आइकन पर क्लिक किया और " डिस्क छवि बनाएं " चुना ।
  3. रिकवरी इमेज जेनरेट करने में कुछ समय लगेगा ।
  4. यह पुनर्प्राप्ति छवि तैयार करने के बाद, मैंने उस विभाजन पर क्लिक किया जहां मैं पूर्व विभाजन को क्लोन करना चाहता था
  5. फिर सेटिंग्स आइकन पर फिर से क्लिक किया , और " रिस्टोर डिस्क इमेज " को चुना और पहले से तैयार डिस्क इमेज फाइल को चुना।
  6. फिर इसके खत्म होने का इंतजार किया।

मैंने अभी-अभी डिस्क उपयोगिता ऐप की खोज की, और यह बात है। मैंने कुछ भी स्थापित नहीं किया।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.