दो-अपने आप को एक फ्लैश ड्राइव के लिए एमबीआर या एक डिवाइस से तीन कैसे बनाया जाए

पाठक को मेरा सम्मान!
विषय केवल विनाशकारी रूप से विशाल हो सकता है, तो चलो बिंदु पर सही हो जाएं। आप में से एक कहानी यह है कि आप विंडोज ऑपरेटिंग सिस्टम और * निक्स दोनों के लिए एक साथ एक यूएसबी फ्लैश ड्राइव कैसे बना सकते हैं, साथ ही इसे लाइव-यूएसबी भी बना सकते हैं। मैं माफी के लिए अग्रिम में माफी माँगता हूँ, समर्थक नहीं, लेकिन इतना छोटा।

अमूर्त

किसी तरह, मुझे एक ही मशीन पर कई बार एक ही मशीन पर अलग-अलग ऑपरेटिंग सिस्टम का एक गुच्छा स्थापित करना पड़ा, दोनों साथी Microsoft सज्जनों और हमारे पसंदीदा * निक्स से। उसी समय, नए स्थापित ओएस के इंस्टॉलरों ने समय-समय पर पहले से स्थापित लोगों के लोडरों को रगड़ दिया, इसलिए उन्हें लाइव-यूएसबी से बूट करके मैन्युअल रूप से पुनर्स्थापित करना पड़ा। लेकिन सबसे बुरी बात यह है कि इस सब के साथ, हाथ में केवल एक फ्लैश ड्राइव था (और एक और 15 कंप्यूटर सच थे, लेकिन उनमें से बहुत कम समझ थी, क्योंकि अतिरिक्त हार्ड ड्राइव की उम्मीद में उन्हें वारंटी कारणों के लिए अलग करना असंभव था)। फ्लैश ड्राइव, सौभाग्य से, एक बड़ी मात्रा थी। यह तब था कि यह विचार दो बनाने के लिए उत्पन्न हुआ, और अधिमानतः तीन (हालांकि 4 संभव) एक फ्लैश ड्राइव से विभिन्न डिवाइस।

सिद्धांत की बिट

एक साथ कई इंस्टॉलेशन और एक अन्य लाइव ओएस पर बाद में इंस्टॉलेशन के उद्देश्य से एक फ्लैश ड्राइव से कई कैसे बनाएं? जवाब स्पष्ट है - एक फ्लैश ड्राइव पर कई विभाजन करें!

इंटरनेट पर अवचेतन की गहराई को ध्यान में रखते हुए , मुझे संस्थान के पाठ्यक्रम से याद आया कि विभाजन की जानकारी फ्लैश ड्राइव के ड्राइव के पहले सेक्टर में संग्रहीत की जाती है, जिसे मास्टर बूट टेबल ( एमबीआर ) कहा जाता है, या इसके अलग हिस्से में विभाजन कहा जाता है। यह भाग ऑफसेट 0x01BE पर स्थित है और 16 बाइट्स के 4 क्षेत्रों का प्रतिनिधित्व करता है, जिनमें से प्रत्येक एक अलग अनुभाग के बारे में एक प्रविष्टि का प्रतिनिधित्व करता है। एक ही समय में, सिद्धांत रूप में, एक डिवाइस पर बड़ी संख्या में विभाजन संभव है, लेकिन यह अधिक जटिल है और चार फ्लैश ड्राइव हमारे लिए पर्याप्त हैं।

उपकरण

वॉन्टेड ओएस में, फ्लैश ड्राइव विभाजन की संख्या पर एक अप्रिय सीमा है। यह 1 से अधिक नहीं होना चाहिए । अधिक सटीक रूप से, विभाजन किसी भी संख्या में हो सकते हैं, लेकिन ओएस विभाजन में केवल प्रविष्टियों में से पहला ही देखेगा। वास्तव में, इसने फ्लैश ड्राइव को प्रारूपित करने के साधनों की पसंद को निर्धारित किया। हम लिनक्स fdisk के साथ काम करेंगे!

लोडर खुद एफएएसएम में लिखा जाएगा, क्योंकि ओएस के बाहर चलने वाले प्रोग्रामिंग कोड के लिए यह मेरी राय में सबसे सुविधाजनक है।

आप एक भयानक विनाश डेटा ( dd ) का उपयोग करके ब्लॉक डिवाइस के रूप में एक फ्लैश ड्राइव के साथ काम कर सकते हैं, लेकिन चूंकि OSes का ऐसा मिश्म यहां से निकलता है, हम एक अधिक अनुकूल विंडो DMDE का उपयोग करेंगे।

लघु गीतात्मक विषयांतर
वास्तव में, फ्लैश ड्राइव के साथ ओएस के विंडोज परिवार के साथ काम करने की ख़ासियत एक साधारण डेटा स्टोरेज डिवाइस के रूप में फ्लैश ड्राइव के आगे उपयोग के संबंध में मेरे द्वारा प्रदान की जाने वाली तकनीक का उपयोग करने की अनुमति देता है। मेरे पास उपलब्ध 16 जीबी के अंत में एक जोड़े को काटकर, मैं विंडोज पॉइंट से पहले की तरह काम करने वाले 14-गीग फ्लैश ड्राइव का मालिक बन गया (यानी, अन्य अनुभाग दिखाई नहीं दे रहे थे), लेकिन उसी समय जब इससे बूट करने की कोशिश की जा रही थी BIOS आपको अंत में बनाए गए दो गीगाबाइट विभाजन से ओएस स्थापित करने की अनुमति देता है।

टूथ फ्लैश कोल्हू

चलो सरलतम से शुरू करते हैं, हमारे फ्लैश ड्राइव पर फ़ाइल सिस्टम को चिह्नित करते हैं। विशेष रूप से, मैंने एक ट्रांसेंडेड जेटफ्लैश 16 जीबी फ्लैश ड्राइव का उपयोग किया (यह एक उपहार के रूप में प्राप्त हुआ था, लेकिन जैसा कि मुझे पता है, एक उपहार घोड़ा है ... हालांकि मुझे 1.5 साल तक इसके बारे में कोई शिकायत नहीं है)। जैसा कि मैंने कहा, हम लिनक्स fdisk (पुराने Ubuntu 9 आभासी मशीन हाथ में था) का उपयोग करेंगे।

इसलिए, हम USB फ्लैश ड्राइव को माउंट करते हैं (चूंकि हम एक्स के नीचे बैठे हैं, हम इसे केवल पोर्ट में चिपकाते हैं)। हमें डिवाइस / देव / sdb मिलता है।

हम fdisk शुरू करते हैं, इसे एक नए डिवाइस पर सेट करते हैं:
root @ kubuntu: / # fdisk / dev / sdb

हमारे पास एक निकास है:

  इस डिस्क के लिए सिलेंडरों की संख्या 1953 है।
 इसमें कुछ भी गलत नहीं है, लेकिन यह 1024 से बड़ा है,
 और कुछ सेटअपों में समस्याएँ हो सकती हैं:
 1) सॉफ्टवेयर जो बूट समय पर चलता है (जैसे, LILO के पुराने संस्करण)
 2) अन्य OS से बूटिंग और विभाजन सॉफ्टवेयर
    (उदाहरण के लिए, डॉस FDISK, OS / 2 FDISK)

 कमांड (मदद के लिए एम): एम
 कमान की कार्रवाई
    एक बूट करने योग्य झंडा टॉगल करें
    b bsd डिस्कलैब संपादित करें
    सी डॉस संगतता ध्वज को टॉगल करें
    d एक विभाजन हटाएं
    एल सूची विभाजन प्रकार ज्ञात
    m इस मेनू को प्रिंट करें
    n एक नया विभाजन जोड़ें
    o एक नया खाली DOS विभाजन तालिका बनाएँ
    p विभाजन तालिका को प्रिंट करें
    परिवर्तन को सहेजे बिना q छोड़ दिया
    s एक नया खाली सन डिक्लेबेल बनाएँ
    t किसी पार्टीशन के सिस्टम आईडी को बदलें
    यू प्रदर्शन / प्रविष्टि इकाइयों को बदलें
    v विभाजन तालिका को सत्यापित करें
    w डिस्क और निकास के लिए तालिका लिखें
    एक्स अतिरिक्त कार्यक्षमता (केवल विशेषज्ञ) 

हम मानते हैं कि डिस्क साफ है और इसमें कोई विभाजन नहीं है। अन्यथा, डी कमांड का उपयोग करते हुए, हम इस खामी को ठीक करते हैं (अग्रिम में आवश्यक डेटा की प्रतिलिपि बनाने के लिए भूलकर भी)।

कार्य सरल है - तीन खंड बनाएं। हम अनुभाग (प्राथमिक) बनाएंगे ताकि उनके बारे में सभी जानकारी विभाजन एमबीआर में संग्रहीत हो। हम n कमांड का उपयोग करते हैं।
पहला खंड सबसे बड़ा (14 जीबी) है, जैसा कि विंडोज बाद में इसे देखेगा, और हम इसे एक नियमित फ्लैश ड्राइव के रूप में उपयोग करेंगे:

  कमांड (मदद के लिए एम): एन
 कमान की कार्रवाई
    ई बढ़ाया गया
    पी प्राथमिक विभाजन (1-4)
 पी
 विभाजन संख्या (1-4): 1
 पहला सिलेंडर (1-15320, डिफ़ॉल्ट 1): 1
 अंतिम सिलेंडर या + आकार या + sizeM या + sizeK (1-15320, डिफ़ॉल्ट 15320): + 14336M 

गीगाबाइट में दूसरा और तीसरा:

  कमांड (मदद के लिए एम): एन
 कमान की कार्रवाई
    ई बढ़ाया गया
    पी प्राथमिक विभाजन (1-4)
 पी
 विभाजन संख्या (1-4): 2
 पहला सिलेंडर (13674-15320, डिफ़ॉल्ट 13674):
 डिफ़ॉल्ट मान 13674 का उपयोग करना
 अंतिम सिलेंडर या + आकार या + sizeM या + sizeK (13674-15320, डिफ़ॉल्ट 15320): + 1024M

 कमांड (मदद के लिए एम): एन
 कमान की कार्रवाई
    ई बढ़ाया गया
    पी प्राथमिक विभाजन (1-4)
 पी
 विभाजन संख्या (1-4): 3
 पहला सिलेंडर (14652-15320, डिफ़ॉल्ट 14652):
 डिफ़ॉल्ट मान 14652 का उपयोग करना
 अंतिम सिलेंडर या + आकार या + आकार M या + sizeK (14652-15320, डिफ़ॉल्ट 15320):
 डिफ़ॉल्ट मूल्य 15320 का उपयोग करना 

पी कमांड के साथ उत्पन्न विभाजन तालिका को प्रिंट करके परिणाम देखें:

  कमांड (मदद के लिए एम): पी

 डिस्क / देव / एसडीबी: 16.0 जीबी, 16064184320 बाइट्स
 64 हेड, 32 सेक्टर / ट्रैक, 15320 सिलेंडर
 इकाइयां = 2048 का सिलेंडर * 512 = 1048576 बाइट्स
 डिस्क पहचानकर्ता: 0x0dee0000

    डिवाइस बूट स्टार्ट एंड ब्लाक आईडी सिस्टम
 / dev / sdb1 1 13673 14001136 83 लिनक्स
 / dev / sdb2 13674 14651 1001472 83 लिनक्स
 / dev / sdb3 14652 15320 685056 83 लिनक्स 

जैसा कि आप देख सकते हैं, हमारे पास तीन खंड हैं: 14 जीबी, 1 जीबी और अवशिष्ट (गीगाबाइट से थोड़ा कम)। यह w कमांड के साथ प्राप्त परिवर्तनों को सहेजने के लिए बना हुआ है:

  कमांड (मदद के लिए एम): डब्ल्यू
 विभाजन तालिका बदल दी गई है!

 विभाजन तालिका को फिर से पढ़ने के लिए ioctl () को कॉल करना।
 सिंकिंग डिस्क।
 रूट @ kubuntu: / # 

वर्चुअल मशीन से फ्लैश ड्राइव को डिस्कनेक्ट करें और तुरंत निम्न फॉर्म का एक पॉप-अप विंडो देखें:



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

इसलिए, हम DMDE प्रोग्राम का उपयोग करेंगे, USB फ्लैश ड्राइव को ब्लॉक डिवाइस के रूप में खोलें और बूट सेक्टर के बाइट्स में तल्लीन करें।



हमने सही आकार का उपकरण चुना।



हमने इसे खोला और पहली चीज जो हम देखते हैं वह एक विभाजन तालिका है, जिसे खेतों द्वारा विभाजित किया गया है। संतुष्ट नहीं, हम कच्चे बाइट्स पर चढ़ते हैं। F2 दबाएं और एमबीआर की सामग्री देखें। याद रखें कि विभाजन 446 बाइट्स के साथ संग्रहीत हैं।



पहले खंड के बारे में रिकॉर्ड लाल रंग में उजागर किया गया है। अगला, एक नाइट की चाल बनाओ! हम एक नोटबुक में कहीं न कहीं तीनों रिकॉर्ड सहेजते हैं, और पहले रिकॉर्ड के स्थान पर हम दूसरा लिखते हैं (crtl + e, write, ctrl + w save)। DMDE को बंद करें, फ्लैश ड्राइव और ... बिंगो खींचें! हम निम्नलिखित विंडो देखते हैं:



विंडोज ने इस बार विशाल आकार में एक दूसरा खंड देखा। हम अपने हाथों और स्वरूप को रगड़ते हैं।

जैसा कि यह अनुमान लगाना मुश्किल नहीं है, तो यह पहले वाले के स्थान पर तीसरे को डालने और दूसरे के स्थान पर पहले वाले को कॉपी करने के लायक है। फिर से फॉर्मेट करें और प्राप्त रिकॉर्ड को तीसरे स्थान पर लौटाएँ (यह मत भूलिए कि रिकॉर्ड 16 बाइट्स है, और फॉर्मेट करते समय, फ़ाइल सिस्टम पहचानकर्ता की बाइट बदल जाती है)। अंतिम चरण में, हम नोटबुक से उस स्थान पर पहला रिकॉर्ड लौटाते हैं। नतीजतन, यदि आप उबंटू में इस तरह के यूएसबी फ्लैश ड्राइव को माउंट करते हैं, तो हमें तीन अलग-अलग विभाजन मिलते हैं, और विंडोज के मामले में - केवल एक - पहला।

विभाजन स्वरूपण विधि के समान तरीके से, सभी प्रकार के ओएस आसानी से एक यूएसबी फ्लैश ड्राइव पर स्थापित होते हैं। मैंने अपने दम पर निम्नलिखित स्थापित किया:

• धारा 1 (14 जीबी) - विंडोज 7 इंस्टॉलर (+ का उपयोग नियमित फ्लैश ड्राइव के रूप में भी किया जाता है)
• धारा 2 (1 जीबी) - लाइव- usb विंडोज (bartPE)
• धारा 3 - लाइव-यूएसएस लिनक्स (बैकट्रैक)

और कोड कहां है?

आगे क्या है? हमारे पास तीन ओएस और ... एक विशाल माइनस के साथ एक सुंदर फ्लैश ड्राइव है! कंप्यूटर में BIOS लोड करने के बाद USB फ्लैश ड्राइव से लोडिंग शुरू करने के लिए, इसका एक विभाजन सक्रिय होना चाहिए (विभाजन प्रविष्टि में पहले बाइट का मान 0x01 है)। आसान, आप कहते हैं, उसी पसंदीदा DMDE का लाभ उठाएं। शायद, लेकिन यहां हमें एक और समस्या का सामना करना पड़ रहा है - क्या होगा अगर हम अक्सर अपने दिमाग को बदलते हैं कि फ्लैश ड्राइव के किस हिस्से से बूट करने के लिए? प्रत्येक बार DMDE से मैन्युअल रूप से विभाजन तालिका को संपादित न करें। बिल्कुल नहीं, हम इस प्रक्रिया को स्वचालित कर रहे हैं!

कुछ और सिद्धांत

MBR से क्या बनता है? MBR एक बूटलोडर + विभाजन तालिका प्रविष्टि है। BIOS फर्मवेयर कंप्यूटर ( POST ) की जांच करने के बाद, यह डिस्क के पहले सेक्टर को कॉपी करता है जिसमें से ऑपरेटिंग सिस्टम को 0x7C00 (वास्तविक पता मोड में प्रोसेसर चलता है) पर मेमोरी में लोड करना है और वहां नियंत्रण स्थानांतरित करता है। अगला, MBR बूटलोडर कोड (446 वीं बाइट तक सब कुछ) डिस्क की तत्परता की जांच करता है, विभाजन तालिका में प्रविष्टियों की जांच करता है (केवल एक सक्रिय होना चाहिए!) और बूटलोडर पर नियंत्रण के बाद हस्तांतरण के साथ सक्रिय विभाजन का चयन करता है।

हम क्या करेंगे

एक बार में डिस्क पर सक्रिय विभाजनों की संख्या से सीमा से छुटकारा पाने के लिए, हम अपने स्वयं के साथ MBR से बूटलोडर कोड को बदल देंगे, जो प्रविष्टियों की जांच करेगा, उन लोगों को सक्रिय के रूप में चिह्नित करेगा और विभाजन की संख्या से संबंधित संख्या के साथ कुंजी दबाने के लिए उपयोगकर्ता की प्रतीक्षा करेगा जिसमें से बूट हो।

जैसा कि मैंने कहा, हम FASM में कोड लिखेंगे (और डीबगिंग बोच में किया गया था)। निम्नलिखित विशेष स्पष्टीकरण के बिना एक सूची है, अन्यथा विषय कभी समाप्त नहीं होगा। मैं सिर्फ यह ध्यान देना चाहूंगा कि ऐसा हुआ है कि यह मेरा पहला कोडांतरक कार्यक्रम है, इसलिए सख्ती से न्याय न करें। कोड क्या है ऊपर वर्णित किया गया है।

; dl c   ! use16 ;========      0000:0600h =================== mov ax, 7C0h mov ds, ax xor si, si mov ax, 60h mov es, ax xor di, di mov cx, 0FFh ; cx       ;[DS:SI] => [ES:DI]; SI += 2; DI += 2; rep movsw ;      jmp 0000:0618h ;========   =================================== mov ax, hello_msg_1 call print mov ax, hello_msg_2 call print ;========    =================================== mov si, [part_adr] mov bh, 80h mov cl, -1 partitions_chek: cmp cl, 3 ;    4 ,         je partition_select add si, 10h inc cl mov bl, [es:si] cmp bl, bh jne partitions_chek ;    call partitions_process ; ! ;[es:si]       ;cl -   jmp partitions_chek ;========       ============================= partitions_process: mov ax, boot_part_msg call print mov di, part_num add [ds:di], cl mov ax, part_num call print sub [ds:di], cl mov di, boot_flags mov ch, 0 add di, cx mov byte[ds:di], 1 ret; ;======================================================================= partition_select: ;   mov ax, select_part_msg call print choise: mov di, boot_flags mov si, [part_adr] mov ah, 0 int 16h p0: cmp al, 48 jne p1 add si, 10h jmp disk p1: cmp al, 49 jne p2 add si, 20h jmp disk p2: cmp al, 50 jne p3 add si, 30h jmp disk p3: add si, 40h cmp al, 51 je disk wrong_choise: mov ax, wrong_input_msg call print jmp choise disk: mov ah, 0 sub al, 48 ;  ,       add di, ax cmp byte [ds:di], 0 je wrong_choise ;  [es:si]     ;     mov ah, 41h ;      (> 8 GB) ; dl    mov bx, 55AAh int 13h jc ext_not_present_error shr cx, 1 jnb ext_not_present_error cmp bx, 0AA55h je read_boot_sect ext_not_present_error: mov ax, ext_not_pres_msg call print int 18h read_boot_sect: mov ah, 42h mov di, DAP_structure add di, 8 add si, 8 mov ebx, [ds:si] mov [ds:di], ebx mov si, DAP_structure int 13h jc ext_not_present_error jmp 0000:7C00h ;========    ================================ print: push si push bx mov bx, ax xor si, si mov ah, 0Eh p: mov al, [bx + si] cmp al, 0Ah int 10h je end_print inc si jmp p end_print: pop bx pop si ret ;======================================================================= hello_msg_1 db '************************', 0Dh, 0Ah hello_msg_2 db '*WELL`s LOADER (c) 2011*', 0Dh, 0Ah boot_part_msg db 'Find bootable partitions:', 0Dh, 0Ah select_part_msg db 'Select part to boot from (press 0 ... 3)', 0Dh, 0Ah wrong_input_msg db 'Wrong choise. Try again', 0Dh, 0Ah ext_not_pres_msg db 'a disk read error occured', 0Dh, 0Ah part_num db '0', 0Dh, 0Ah part_adr dw 1AEh boot_flags db 4 dup (0) DAP_structure db 10h, 0, 1, 0, 0, 7Ch, 0, 0, 8 dup (0) 

जैसा कि आप देख सकते हैं, बूटलोडर कार्यक्रम बिना किसी प्रवेश बिंदु, अनुभाग, या अन्य जटिलता के बिना एक साफ बाइनरी है। प्रोसेसर ऑपरेटिंग मोड असली (16-बिट) है।
इस बूटलोडर का उपयोग करने के लिए, आपको विभाजन तालिका को बरकरार रखते हुए, पहले सेक्टर (उदाहरण के लिए, DMDE का उपयोग करके) में USB फ्लैश ड्राइव पर अपलोड करना होगा। संकलित बाइनरी फ़ाइल का आकार 442 बाइट्स है।

संभावनाओं

यदि ऐसा कोई समाधान लोकप्रिय हो जाता है, तो चयन प्रक्रिया के दौरान स्क्रीन पर विभाजन जानकारी के आउटपुट को जोड़कर बूटलोडर की कार्यक्षमता को आसानी से बढ़ाया जा सकता है। USB फ्लैश ड्राइव पर बूटलोडर अपलोड करने की सुविधा के लिए और यह चुनने के लिए कि कौन सा अनुभाग सक्रिय होगा, आप एक छोटा टूल लिख सकते हैं। सामान्य तौर पर, आपकी इच्छाओं और सुझावों को टिप्पणियों में स्वीकार किया जाता है।

आप यहाँ से सोर्स कोड और बूटलोडर बाइनरी डाउनलोड कर सकते हैं ।