ऑपरेटिंग सिस्टम ... कैसे चलाते हैं ... बिना OS के चलने के लिए?

Question

मैं अभी उत्सुक हूं। मैं एक पायथन प्रोग्रामर हूं, और इस सवाल ने मुझे परेशान कर दिया: आप एक ओएस लिखते हैं। आप इसे कैसे चलाते हैं? इसे किसी तरह चलाना होगा, और यह तरीका दूसरे ओएस के भीतर है?

बिना OS के कोई एप्लिकेशन कैसे चल सकता है? यदि आप कंप्यूटर को चलाने के लिए, कहते हैं, सी, और इन कमांड को स्क्रीन पर निष्पादित करने के लिए कैसे कहते हैं, अगर इसमें ओएस चलाने के लिए नहीं है?

यह एक UNIX कर्नेल के साथ क्या करना है? यदि हां, तो यूनिक्स कर्नेल, या सामान्य रूप से कर्नेल क्या है?

मुझे यकीन है कि OSes इससे अधिक जटिल हैं, लेकिन यह कैसे काम करता है?

Comments

मुझे पूरा यकीन है कि एक BIOS क्या है - यह वास्तव में एक छोटा ओएस है जो बड़े ओएस के चलने वाले बूटस्ट्रैप्स है।

— सेवेंससीट

एक ओएस सुविधाजनक है , लेकिन कंप्यूटर पर प्रोग्राम चलाने के लिए आपको किसी की आवश्यकता नहीं है।

— एंड्रेस एफ।

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

— मैक्स

यह भ्रम अद्भुत, सुरक्षित, अत्यधिक अमूर्त कंप्यूटिंग प्रणालियों की लागतों में से एक है जो हम इन दिनों का उपयोग करते हैं: लोग बहुत अच्छे और सक्षम प्रोग्रामर हो सकते हैं और यह भी नहीं जानते कि कंप्यूटर कैसे काम करता है। आप कितना कम जाना चाहते हैं? बहुत कम है, लेकिन अभी भी भौतिकी के ऊपर देखें कि पहले माइक्रोप्रोसेसरों को कैसे प्रोग्राम किया गया था? इलेक्ट्रॉनिक्स पर।

— dmckee

वर्तमान ओएस अवधारणा के आविष्कार से पहले प्रोग्रामिंग किया गया था। स्पष्ट रूप से उस स्तर पर कुछ है जो ओएस को बंद कर देता है। OS बूटस्ट्रैप्ड हैं। यह आमतौर पर कम से कम सीएस 4 साल के कार्यक्रम में कुछ बिंदु पर उल्लेख किया जाता है क्योंकि अधिकांश में ऑपरेटिंग सिस्टम पाठ्यक्रम के कंप्यूटर सिद्धांत की आवश्यकता होती है।

— रिग

Answer 1

बहुत सारी वेबसाइट हैं जो बूट प्रक्रिया से गुजरती हैं (जैसे कि हाउ कम्प्यूटर्स बूट अप )। संक्षेप में, इसकी एक बहु-चरण प्रक्रिया जो एक समय में सिस्टम को थोड़ा सा ऊपर रखती है जब तक कि यह अंततः ओएस प्रक्रियाओं को शुरू नहीं कर सकता।

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

यह बहुत अविश्वसनीय है कि यह बिल्कुल काम करता है!

Comments

अंतिम वाक्य के लिए +1।

— एक CVn

एक कारण है जिसे "बूटिंग" कहा जाता है; यह शब्द "बूटस्ट्रैपिंग" के लिए छोटा है, जैसे कि, "अपने बूटस्ट्रैप्स द्वारा खुद को ऊपर खींचना"।

— कीथ्स

एक समय था जब किसी को बूटस्ट्रैप कोड में कुंजी या टॉगल करना होता था। कभी-कभी यह रोम में एक कार्यक्रम के पहले निर्देश के लिए एक सरल कूद था। दूसरी बार यह एक डिवाइस से पढ़ने और डेटा में पहले प्रोग्राम इंस्ट्रक्शन पर कूदने के लिए कोड था। चीजें अब बहुत सरल हैं।

— बिलटोर

इन्हें भी देखें ibm.com/developerworks/linux/library/l-grub2/...

— टोबियास Kienzler

@BillThor: जहां "बहुत सरल" द्वारा, आप निश्चित रूप से, "बहुत अधिक जटिल"। वे उपयोग करने के लिए सिर्फ सरल हैं ।

— राफेल श्विकर्ट

Answer 2

एक "नंगे धातु" ऑपरेटिंग सिस्टम किसी भी चीज़ के भीतर नहीं चलता है । यह फिजिकल मशीन पर पूरा इंस्ट्रक्शन सेट चलाता है, और इसमें वर्चुअल मेमोरी सपोर्ट हार्डवेयर को नियंत्रित करने वाले सभी फिजिकल मेमोरी, सभी डिवाइस रजिस्टर और सभी विशेषाधिकार प्राप्त निर्देशों तक पहुंच होती है।

(यदि ऑपरेटिंग सिस्टम एक वर्चुअल मशीन पर चल रहा है, तो यह सोच सकता है कि यह ऊपर की तरह ही स्थिति में है। अंतर यह है कि कुछ चीज़ों का अनुकरण किया जाता है या किसी अन्य तरीके से हाइपरविज़र द्वारा नियंत्रित किया जाता है; यानी वह स्तर जो वर्चुअल मशीन चलाता है। ।)

वैसे भी, जबकि OS को (उदाहरण के लिए) C में लागू किया जा सकता है, इसमें सभी सामान्य सी लाइब्रेरी उपलब्ध नहीं होंगी। विशेष रूप से, इसमें सामान्य 'stdio' लाइब्रेरी नहीं होगी। बल्कि, यह एक डिस्क डिवाइस ड्राइवर को लागू करेगा (उदाहरण के लिए) यह डिस्क ब्लॉक को पढ़ने और लिखने की अनुमति देता है। यह डिस्क ब्लॉक परत के शीर्ष पर एक फ़ाइल सिस्टम को लागू करेगा, और इसके शीर्ष पर यह सिस्टम कॉल को लागू करेगा जो एक उपयोगकर्ता अनुप्रयोग के रनटाइम लाइब्रेरीज़ (उदाहरण के लिए) बनाते हैं, फ़ाइलों को पढ़ते हैं और लिखते हैं ... और इसी तरह।

बिना OS के कोई एप्लिकेशन कैसे चल सकता है?

इसके लिए एक विशेष प्रकार का एप्लिकेशन होना चाहिए (जैसे एक ऑपरेटिंग सिस्टम) जो जानता है कि I / O हार्डवेयर आदि के साथ सीधे कैसे संपर्क करें।

यदि आप कंप्यूटर को चलाने के लिए, कहते हैं, सी, और इन कमांड को स्क्रीन पर निष्पादित करने के लिए कैसे कहते हैं, अगर इसमें ओएस चलाने के लिए नहीं है?

तुम नहीं।

एप्लिकेशन (जो सी में लिखे गए तर्क के लिए था) को एक देशी कोड छवि देने के लिए किसी अन्य मशीन पर संकलित और लिंक किया गया है। तब छवि को हार्ड ड्राइव में ऐसी जगह लिखा जाता है कि BIOS उसे ढूंढ सके। BIOS छवि को मेमोरी में लोड करता है, और एप्लिकेशन के प्रवेश बिंदु पर कूदने के लिए एक निर्देश निष्पादित करता है।

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

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

यह एक UNIX कर्नेल के साथ क्या करना है? यदि हां, तो एक यूनिक्स कर्नेल या सामान्य रूप से कर्नेल क्या है?

हाँ यह करता है।

UNIX कर्नेल UNIX ऑपरेटिंग सिस्टम का मूल है। यह UNIX का हिस्सा है जो ऊपर वर्णित "नंगे धातु" सामान के सभी करता है।

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

वास्तव में, कर्नेल / कोर और गैर-कर्नेल / गैर-कोर के बीच का अंतर इससे अधिक जटिल है। और इस बात पर बहुत बहस हुई है कि वास्तव में एक गिरी में क्या होता है, और क्या नहीं। (उदाहरण के लिए माइक्रो-कर्नेल देखें।)

Comments

घटना का उत्तर। यदि संभव हो तो मैं आपको कई और अपवोट देता।

— वेबर 2

यहाँ बहुत सारे अच्छे उत्तर हैं, इसलिए मैंने इसे एक टिप्पणी के रूप में जोड़ा है, क्योंकि अब तक किसी ने भी इसका उल्लेख नहीं किया है: एक ओएस में प्रमुख विशेषताओं में से एक उपयोगकर्ता के दृष्टिकोण से कई एप्लिकेशन को "एक साथ" निष्पादित करने की अनुमति देता है। प्रक्रियाओं को शेड्यूल करने और प्रक्रियाओं को एक-दूसरे के व्यवहार को बदलने से बचाने की क्षमता, आमतौर पर केवल ओएस में पाए जाने वाले फीचर्स हैं, न कि फर्मवेयर या BIOS।

— शॉन बारब्यू

The idea of a "kernel" is that you try to separate the system software into core stuffयह याद रखना आसान है कि यह शब्द kernelजर्मन से है Kern, जिसका अर्थ है कोर / नाभिक।

— deed02392

इस उत्तर को यहां प्यार करें क्योंकि यह उल्लेख करता है कि यह संकलित है और जुड़ा हुआ बाइनरी कोड है जो सी नहीं चल रहा है

— ट्रैविस पेसेटो

"उस से दूर हो रहे पीसी उपयोगकर्ताओं को कम स्मार्ट।" - कम स्मार्ट नहीं ... कम कंप्यूटर साक्षर। आप यह भी कह सकते हैं कि इसने पीसी उपयोगकर्ताओं की संख्या में वृद्धि की।

— स्टीफन सी

Answer 3

शुरुआत में सीपीयू में कोई शक्ति नहीं थी।

और मैन ने कहा "शक्ति होने दो", और सीपीयू स्मृति में दिए गए पते से पढ़ना शुरू किया और उस निर्देश को निष्पादित किया जो वहां मौजूद था। फिर अगले एक और इतने पर सत्ता के अंत तक।

यह बूट अप था। इसका कार्य पर्यावरण तक पहुंच प्राप्त करने के लिए सॉफ्टवेयर का एक और टुकड़ा लोड करना था, जहां मुख्य सॉफ्टवेयर था, और इसे लोड करना।

अंत में, एक अनुकूल स्क्रीन ने आपको लॉग ऑन करने के लिए आमंत्रित किया।

Comments

इस उत्तर को christianity.stackexchange.com

— Coomie

"दिया गया पता" क्या है, यह कहां से आता है। यहां चार्ल्स डार्विन के खेलने के लिए क्षमा करें।

— मिडहट

@ मिधात - सीपीयू द्वारा प्राप्त किया जाने वाला पहला पता इसके अंदर हार्डवार्ड है। आमतौर पर यह 0.

— माउविसील

... और 7 वें दिन, मैन ने अपने खेलों के साथ विश्राम किया

— कनाडाई ल्यूक

@mouviciel स्मृति में पता 0x7C00किसी भी x86संगत वास्तुकला के लिए है और सबसे पहले BIOS द्वारा भरा जाना है जो आमतौर पर बूट करने योग्य डिवाइस के पहले सेक्टर को लोड करता है ... अच्छा जवाब हालांकि: -7

— टोबीस किंजलर

Answer 4

देर से आने के लिए क्षमा करें, लेकिन मैं इसका वर्णन इस तरह से करूंगा:

• मदरबोर्ड को शक्ति मिलती है।

• यदि आवश्यक हो, तो उनकी विद्युत विशेषताओं के आधार पर समय सर्किट शुरू और स्थिर हो जाता है। कुछ नए उपकरण वास्तव में बहुत सीमित माइक्रोप्रोसेसर या सीक्वेंसर का उपयोग कर सकते हैं।

  यह ध्यान दिया जाना चाहिए, "टाइमिंग सर्किट शुरू करना और यदि आवश्यक हो तो स्थिर करना" जैसी चीजों का एक बहुत कुछ है जो वास्तव में अब हार्डवेयर में नहीं होता है। उस काम की एक जबरदस्त मात्रा वास्तव में बेहद विशिष्ट सॉफ्टवेयर है जो बहुत सीमित उपप्रोसेसर / सीक्वेंसर पर चल रहा है।

  - 25 अक्टूबर को 5:20 बजे जकरियन

• सीपीयू और रैम को पावर दी गई है।

• BIOS से सीपीयू लोड (इसकी आंतरिक वायरिंग पर आधारित) डेटा। कुछ मशीनों पर, BIOS को RAM को प्रतिबिंबित किया जा सकता है और फिर वहां से निष्पादित किया जा सकता है लेकिन यह दुर्लभ IIRC है।

  चालू होने पर, x86- संगत CPU पता स्थान पर 0xFFFFFFF0 पते पर प्रारंभ होता है ...

  -Micheal Steil, 17 गलतियों को Microsoft ने Xbox Security System ( संग्रह ) में बनाया

• BIOS हार्डवेयर बंदरगाहों और डिस्क और अन्य हार्डवेयर IO और डिस्क के लिए मदरबोर्ड द्वारा उपयोग किए जाने वाले पते को कॉल करता है, बाकी रैम को अन्य चीजों के साथ काम करता है।

• सीएमओएस द्वारा निर्दिष्ट एक क्रम में या एक मेनू के साथ एक उपयोगकर्ता ओवरराइड करके, प्रत्येक कोड के बूट सेक्टर को पढ़ने के लिए BIOS कोड (हार्डवेयर में संग्रहीत सीएमओएस सेटिंग्स के माध्यम से), निम्न-स्तरीय आईडीई या एसएटीए कमांड का उपयोग करता है।

• बूट सेक्टर के साथ पहली डिस्क अपने बूट सेक्टर को निष्पादित करती है। यह बूट सेक्टर असेंबली है जिसमें डिस्क से अधिक डेटा लोड करने, बड़ा लोड करने NTLDR, बाद के चरणों GRUBआदि के निर्देश हैं ।

• अंत में, OS मशीन कोड को बूटलोडर द्वारा सीधे या परोक्ष रूप से एक वैकल्पिक या ऑफसेट स्थान से एक बूट सेक्टर लोड करने वाले चेनलोडिंग के माध्यम से निष्पादित किया जाता है।

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

Comments

यह ध्यान दिया जाना चाहिए, "टाइमिंग सर्किट शुरू करना और यदि आवश्यक हो तो स्थिर करना" जैसी चीजों का एक बहुत कुछ वास्तव में हार्डवेयर में नहीं होता है। उस काम की एक जबरदस्त मात्रा वास्तव में बेहद विशिष्ट सॉफ्टवेयर है जो बहुत सीमित उपप्रोसेसर / सीक्वेंसर पर चल रहा है। - एक दोस्ताना पड़ोस फर्मवेयर इंजीनियर

— जकरियन

@jkerian क्या आपको लगता है कि मैंने अपनी टिप्पणी मेरे पोस्ट में उद्धृत की है?

— .--

हेह, बिल्कुल नहीं।

— 14

BIOS एक ऑपरेटिंग सिस्टम नहीं है। बेसिक इनपुट / आउटपुट सिस्टम के लिए BIOS शॉर्टहैंड है, और यह कि BIOS क्या करता है। यह प्रोग्रामर को निर्माता-प्रदत्त ड्राइवरों के साथ निम्न-स्तरीय संसाधनों का उपयोग करने की अनुमति देता है। जब OS संरक्षित (32 बिट) या लॉन्ग (64 बिट) मोड में प्रवेश करता है, तो BIOS उपलब्ध नहीं होता है और ओएस अपने स्वयं के ड्राइवरों का उपयोग करता है जो मूल रूप से "निचले" स्तरों पर प्रदान की गई कार्यक्षमता को बदल देता है। आधुनिक ऑपरेटिंग सिस्टम, उदाहरण के लिए लिनक्स और विंडोज, केवल उपयोग करने योग्य रैम सेक्शन का पता लगाने और अपने स्वयं के अधिक लोडर को लोड करने के लिए BIOS का उपयोग करते हैं जो अन्य ड्राइवरों को लोड कर सकते हैं।

— हनीस करपिला

@HesesKarppila अपडेट किया गया; यह अब लगभग चार साल पुराना है और मैं अब इस साइट पर सक्रिय नहीं हूं।

— ζ--

Answer 5

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

इस तरह के दुभाषिया सॉफ्टवेयर, आमतौर पर, एक भाषा में लिखा जाता है, जो मशीन कोड के लिए संकलित करता है, उदाहरण के लिए C या C ++। मशीन कोड वह है जिसे CPU संभाल सकता है। सीपीयू क्या कर सकता है मेमोरी से कुछ बाइट्स पढ़ते हैं और बाइट मूल्यों के आधार पर एक विशिष्ट ऑपरेशन शुरू करते हैं। इसलिए एक बाइट अनुक्रम मेमोरी से कुछ डेटा को एक रजिस्टर में लोड करने के लिए एक कमांड है, दो मान जोड़ने के लिए एक और अनुक्रम, एक रजिस्टर से मूल्य को मुख्य मेमोरी में स्टोर करने के लिए और जल्द ही (एक रजिस्टर एक विशेष मेमोरी क्षेत्र है जो हिस्सा है सीपीयू जहां यह सबसे अच्छा काम कर सकता है), इनमें से अधिकांश कमांड उस स्तर पर काफी कम हैं। इन मशीन कोड निर्देशों के लिए मानव पठनीय कोडांतरक कोड है। यह मशीन कोड, मूल रूप से, विंडोज या लिनक्स / यूनिक्स बायनेरिज़ में .exe or.com फ़ाइलों में संग्रहीत है।

अब यदि कोई कंप्यूटर शुरू किया जाता है तो वह गूंगा होता है, इसमें कुछ वायरिंग होती हैं जो इस तरह के मशीन कोड निर्देशों को पढ़ेंगे। पीसी पर यह आम तौर पर (वर्तमान में) BIOS के एक कीबोर्ड पर बेसिक चिप होता है (बेसिकनिट ouptput सिस्टम), यह सिस्टम ज्यादा कुछ नहीं कर सकता, यह कुछ हार्डवेयर आदि तक आसानी से पहुंच सकता है और फिर एक कुंजी ऑपरेशन कर सकता है: स्मृति में पहले कुछ बाइट्स (उर्फ मास्टर बूट रिकॉर्ड, उर्फ) को कॉपी करें और फिर सीपीयू को बताएं "यहां आपका प्रोग्राम है" सीपीयू फिर उन बाइट्स को मशीन कोड के रूप में व्यवहार करेगा और इसे निष्पादित करेगा। आमतौर पर यह कुछ ऑपरेटिंग सिस्टम लोडर होता है, जो कर्नेल को कुछ मापदंडों के साथ लोड करेगा और फिर उस कर्नेल पर नियंत्रण सौंप देगा, जो तब सभी हार्डवेयर एक्सेस को सभी हार्डवेयर तक लोड करेगा, कुछ डेस्कटॉप या शेल प्रोग्राम या जो भी लोड करेगा और उपयोगकर्ता को लॉगिन करने की अनुमति देगा सिस्टम का उपयोग करें।

Comments

"interpiled"? मैंने उस शब्द को पहले कभी नहीं सुना है।

— ब्रायन ओकले

"आधुनिक" व्याख्याकारों का वर्णन करने के लिए उस शब्द का उपयोग 5 या इतने साल पहले किया गया था, जिसका एक अलग संकलन चरण है जो निष्पादन से अलग है। अगर यह शब्द कहीं भी नहीं बचा तो ;-)

— जोहान्स

"ninterpreted"? मैंने उस शब्द को पहले कभी नहीं सुना है।

— कोल जॉनसन

Answer 6

आप पूछते हैं कि "OS में बिना एप्लिकेशन कैसे चल सकता है"। इसका आसान उत्तर है "OS एक एप्लीकेशन नहीं है"। जबकि एक OS को एप्लिकेशन के समान टूल के साथ बनाया जा सकता है, और एक ही कच्चे माल से बनाया जा सकता है, वे समान चीज नहीं हैं। एक OS को एप्लिकेशन के समान नियमों द्वारा नहीं खेलना है।

OTOH, आप वास्तविक हार्डवेयर और फर्मवेयर को "OS" के रूप में सोच सकते हैं जिसमें OS "एप्लिकेशन" चलता है। हार्डवेयर एक बहुत ही सरल ओएस है - यह जानता है कि मशीन कोड में लिखे निर्देशों को कैसे चलाना है, और यह जानता है कि जब यह शुरू होता है तो इसे अपने पहले निर्देश के लिए एक बहुत विशिष्ट मेमोरी पते पर देखना चाहिए। तो, यह शुरू होता है और फिर तुरंत चलता है कि बहुत पहले निर्देश, उसके बाद दूसरा, और इसी तरह।

तो, ओएस बस मशीन कोड है जो एक ज्ञात स्थान पर मौजूद है, और जो सीधे हार्डवेयर के साथ बातचीत कर सकता है।

Comments

+1 मुझे लगता है कि यह सबसे अच्छा जवाब है। अमूर्तता के संदर्भ में मुझे लगता है कि आप इसे सही स्तरों पर चित्रित कर रहे हैं।

— प्रीत संघ

Answer 7

आपके प्रश्न के उत्तर के लिए यह जानना आवश्यक है कि मूल (CPU के लिए) कोड कैसा दिखता है और CPU द्वारा इसकी व्याख्या कैसे की जाती है।

आमतौर पर पूरी संकलन प्रक्रिया सी, पास्कल या यहां तक ​​कि पाइथन (पाइपी का उपयोग करके) और सी # में लिखी गई चीजों का अनुवाद करने से होती है, जो सीपीयू समझता है, अर्थात "मेमोरी एड्रेस के तहत कुछ स्टोर करें" जैसे सरल निर्देश, रजिस्टरों ईएक्स के तहत नंबर जोड़ें। और ईबेक्स "," कॉल फंक्शन फू "," ईएक्सएक्स की तुलना 10 "करें। उन निर्देशों को, एक-एक करके निष्पादित, वे चीजें करें जो आप अपने कोड के साथ करना चाहते थे।

अब इस बारे में सोचें: इस मूल कोड को निष्पादित करने के लिए आपको वास्तव में ओएस की आवश्यकता नहीं है! आपको बस इस कोड को मेमोरी में लोड करना है और सीपीयू को यह बताना है कि आप इसे निष्पादित करना चाहते हैं। हालांकि इससे बहुत ज्यादा चिंतित मत होइए। यह काम BIOS के बारे में चिंता करना चाहिए - यह आपके कोड (केवल एक और एक क्षेत्र) को लोड करता है, बस सीपीयू शुरू होने के बाद, भौतिक पते 0x7C00 के तहत। तब सीपीयू आपके कोड के इस एक सेक्टर (512 बी) को निष्पादित करना शुरू कर देता है। और आप जो भी कल्पना कर सकते हैं वह कर सकते हैं! बिना, ज़ाहिर है, ओएस से कोई समर्थन। ऐसा इसलिए है क्योंकि आप ऑपरेटिंग सिस्टम हैं। शांत हुह? कोई मानक पुस्तकालय, कोई बढ़ावा, कोई अजगर, कोई कार्यक्रम नहीं, कोई ड्राइवर नहीं! आपको सब कुछ अपने आप से लिखना होगा।

और आप हार्डवेयर के साथ कैसे संवाद करते हैं? खैर, आपके पास दो विकल्प हैं:

1. आप "रियल मोड" के अंदर रहते हैं - केवल 1 एमबी मेमोरी (और इससे भी कम) के साथ सीपीयू निष्पादन मोड, सीपीयू एक्सटेंशन, मेमोरी सुरक्षा, मल्टीटास्किंग जैसी कोई उन्नत सीपीयू सुविधाएँ नहीं हैं; 16-बिट निष्पादन योग्य कोड, प्राचीन पता मोड ... लेकिन BIOS द्वारा प्रदान की गई कुछ दिनचर्या के साथ, सरल स्क्रीन आउटपुट, कीबोर्ड समर्थन, डिस्क I / O और पावर प्रबंधन शामिल हैं। एक शब्द में, आप एमएस-डॉस और 16-बिट सीपीयू के समय में वापस आ गए हैं।
2. आप अपने सीपीयू में सभी सुविधाओं के साथ "संरक्षित मोड" के तहत जाते हैं, आपके द्वारा स्थापित सभी मेमोरी और इसी तरह। लेकिन संरक्षित मोड में आप पूरी तरह से अकेले हैं और आपको स्वयं (और आप "इन" और "आउट" निर्देशों के साथ आई / ओ पोर्ट के इनपुट / आउटपुट डेटा और इंटरप्ट का उपयोग करके हार्डवेयर के साथ संचार करना है) और मेमोरी-मी-आई। / ओ)। क्या मुझे विंडोज 95 के बाद से हर ओएस को कहना होगा और बहुत पहले लिनक्स इस विकल्प को चुनता है?

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

बेहतर समझ के लिए मैं आपको एक सलाह दे सकता हूं: अपना ओएस लिखने का प्रयास करें। भले ही यह स्क्रीन पर "हैलो वर्ल्ड" लिखने वाला हो।

Answer 8

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

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

स्टार्ट-अप फर्मवेयर आमतौर पर सिस्टम पर मौजूद हार्डवेयर के बारे में मान्यताओं के साथ लिखा जाता है। 286 साल पहले एक मशीन पर शायद एक धारणा होगी कि I / O एड्रेस X पर एक फ्लॉपी ड्राइव कंट्रोलर होगा और एक निश्चित मेमोरी लोकेशन पर सेक्टर 0 लोड करेगा यदि एक निश्चित सेट कमांड दिया गया हो (और सेक्टर 0 पर कोड अधिक कोड लोड करने के लिए BIOS के अपने कार्यों का उपयोग करने का तरीका जानता है, और अंततः ओएस होने के लिए पर्याप्त कोड)। माइक्रोकंट्रोलर पर एक धारणा हो सकती है कि कुछ सेटिंग्स के साथ काम करने वाला एक सीरियल पोर्ट है जिसे बूट प्रक्रिया के साथ जारी रखने से पहले एक्स राशि के लिए कमांड (अधिक जटिल फर्मवेयर को अपडेट करने के लिए) का इंतजार करना चाहिए।

किसी दिए गए सिस्टम की सटीक स्टार्ट-अप प्रक्रिया आपके लिए उतनी महत्वपूर्ण नहीं है, जितना यह जानना कि यह अलग-अलग प्रणालियों पर अलग-अलग है, बल्कि यह भी है कि वे सभी चीजें समान हैं। अक्सर स्टार्ट-अप (बूटस्ट्रैपिंग) कोड के भीतर जब I / O को I / O उपकरणों को करने की आवश्यकता होती है, तो व्यवधानों पर भरोसा करने के बजाय मतदान किया जाता है। ऐसा इसलिए है क्योंकि व्यवधान जटिल हैं, स्टैक रैम का उपयोग करें (जो अभी तक पूरी तरह से सेट नहीं किया जा सकता है), और आपको केवल ऑपरेशन होने पर अन्य संचालन को अवरुद्ध करने के बारे में चिंता करने की आवश्यकता नहीं है।

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

ओएस कोड आमतौर पर सी और असेंबली के मिश्रण में लिखा जाता है। OS कर्नेल के लिए पहला पहला कोड शायद हमेशा असेंबली में होता है और स्टैक सेट करने जैसी चीजें करता है, जिस पर C कोड निर्भर करता है, और फिर C फ़ंक्शन को कॉल करता है। अन्य हाथ से लिखी गई असेंबली वहां भी होगी क्योंकि कुछ ऑपरेशन जिन्हें ओएस को करने की आवश्यकता होती है, वे अक्सर C में व्यक्त नहीं होते हैं (जैसे संदर्भ स्विचिंग / स्वैपिंग स्टैक)। अक्सर विशेष झंडों को सी कंपाइलर को पास करना होता है, ताकि यह बताया जा सके कि यह मानक पुस्तकालयों पर भरोसा नहीं करता है जो कि अधिकांश सी प्रोग्राम उपयोग करते हैं और यह उम्मीद नहीं करते हैं कि कोई हैint main(int argc, char *argv[])कार्यक्रम में। इसके अतिरिक्त विशेष लिंकर विकल्प जो कि अधिकांश एप्लिकेशन प्रोग्रामर कभी भी उपयोग नहीं करते हैं उन्हें उपयोग नहीं करना पड़ता है। ये कर्नेल प्रोग्राम को एक निश्चित पते पर लोड करने की उम्मीद कर सकते हैं या चीजों को देखने के लिए सेट कर सकते हैं जैसे कि कुछ निश्चित स्थानों पर बाहरी चर हैं भले ही उन चर को किसी भी सी कोड में घोषित नहीं किया गया था (यह मेमोरी मैप्ड I / O के लिए उपयोगी है) अन्य विशेष स्मृति स्थान)।

पूरा ऑपरेशन पहली बार में जादू की तरह लगता है, लेकिन जब आप इसे देखते हैं और इसके कुछ हिस्सों को समझते हैं तो जादू सिर्फ उन कार्यक्रमों का एक सेट बन जाता है जिन्हें लागू करने के लिए बहुत अधिक योजना और सिस्टम ज्ञान की आवश्यकता होती है। हालांकि, उन्हें बहस करना जादू लगता है।

Answer 9

यह समझने के लिए कि ऑपरेटिंग सिस्टम कैसे काम करते हैं, यह उन्हें दो श्रेणियों में विभाजित करने में सहायक हो सकता है: वे जो केवल अनुरोध पर एप्लिकेशन को सेवाएं प्रदान करते हैं, और जो सीपीयू में हार्डवेयर सुविधाओं का उपयोग करते हैं वे अनुप्रयोगों को उन चीजों को करने से रोकते हैं जिन्हें उन्हें नहीं करना चाहिए। एमएस-डॉस पूर्व शैली का था; 3.0 के बाद से विंडोज के सभी संस्करण बाद की शैली हैं (कम से कम जब 8086 से अधिक शक्तिशाली कुछ भी चल रहा हो)।

पीसी-डॉस या एमएस-डॉस चलाने वाला मूल आईबीएम पीसी "ओएस" की पूर्व शैली का एक उदाहरण रहा होगा। यदि कोई एप्लिकेशन स्क्रीन पर एक चरित्र प्रदर्शित करना चाहता है, तो इसे करने के कुछ तरीके होंगे। इसे रूटीन कह सकते हैं जो MS-DOS को "मानक आउटपुट" पर भेजने के लिए कहेंगे। यदि यह ऐसा होता है, तो MS-DOS यह जाँच करेगा कि क्या आउटपुट पुनर्निर्देशित किया जा रहा है और यदि नहीं, तो यह ROM में संग्रहीत रूटीन (रूटीन के एक संग्रह में IBM को बेसिक इनपुट / आउटपुट सिस्टम कहा जाता है) को कॉल करेगा जो एक चरित्र प्रदर्शित करेगा कर्सर की स्थिति और कर्सर को ले जाएँ ("टेलेटाइप लिखें")। तब BIOS दिनचर्या 0xB800: 0 से 0xB800: 3999 की सीमा में बाइट्स की एक जोड़ी को स्टोर करेगी; रंग ग्राफिक्स एडाप्टर पर हार्डवेयर बार-बार उस सीमा के भीतर बाइट्स के जोड़े लाएगा, प्रत्येक जोड़ी के पहले बाइट का उपयोग करके एक वर्ण आकृति का चयन करना और दूसरा अग्रभूमि और पृष्ठभूमि के रंगों का चयन करना। बाइट्स को लाल, हरे और नीले सिग्नलों में लाया और संसाधित किया जाता है, एक अनुक्रम में जो एक सुपाठ्य पाठ प्रदर्शित करता है।

आईबीएम पीसी पर प्रोग्राम डॉस "मानक आउटपुट" रूटीन का उपयोग करके या BIOS "राइट टेलेटाइप" रूटीन का उपयोग करके या मेमोरी को प्रदर्शित करने के लिए इसे सीधे संग्रहीत करके पाठ प्रदर्शित कर सकता है। कई कार्यक्रमों को जो बहुत सारे पाठ प्रदर्शित करने की आवश्यकता होती है, वे बाद के दृष्टिकोण के लिए जल्दी से चुनते हैं, क्योंकि यह डॉस रूटीन का उपयोग करते हुए शाब्दिक रूप से सैकड़ों गुना तेज हो सकता है। ऐसा इसलिए नहीं था क्योंकि DOS और BIOS रूटीन असाधारण रूप से अक्षम थे; जब तक प्रदर्शन खाली नहीं किया गया था, यह केवल निश्चित समय पर लिखा जा सकता था। एक चरित्र को आउटपुट करने के लिए BIOS दिनचर्या को डिज़ाइन किया गया था, इसलिए इसे किसी भी समय कहा जा सकता है; इस प्रकार प्रत्येक अनुरोध को राइट टू टाइम राइटिंग ऑपरेशन शुरू करने के लिए नए सिरे से इंतजार करना शुरू करना पड़ा। इसके विपरीत, एप्लिकेशन कोड जो जानता था कि उसे क्या करने की जरूरत है वह प्रदर्शन को लिखने के लिए उपलब्ध अवसरों के आसपास व्यवस्थित कर सकता है।

यहां एक महत्वपूर्ण बिंदु यह है कि जब डॉस और BIOS ने डिस्प्ले को टेक्स्ट आउटपुट करने का एक साधन प्रदान किया, तो ऐसी क्षमताओं के लिए विशेष रूप से "जादुई" कुछ भी नहीं था। एक एप्लिकेशन जो डिस्प्ले पर टेक्स्ट लिखना चाहता था, वह प्रभावी रूप से ऐसा कर सकता था, कम से कम यदि डिस्प्ले हार्डवेयर ने जिस तरह से अपेक्षित एप्लिकेशन काम किया (यदि किसी ने मोनोक्रोम डिस्प्ले एडॉप्टर स्थापित किया था, जो CGA के समान था, लेकिन इसकी वर्ण मेमोरी थी 0xB000: 0000-0xB000: 3999) पर स्थित, BIOS स्वचालित रूप से वहाँ वर्णों का उत्पादन करेगा; एक ऐसा एप्लिकेशन जिसे एमडीए या सीजीए के साथ काम करने के लिए प्रोग्राम किया गया था, वह ऐसा भी कर सकता है, लेकिन एक एप्लीकेशन जिसे सीजीए के लिए ही प्रोग्राम किया गया था, वह एमडीए पर पूरी तरह से बेकार हो जाएगा)।

नए सिस्टम पर, चीजें थोड़ी अलग हैं। प्रोसेसर में विभिन्न "विशेषाधिकार" मोड हैं। वे सबसे विशेषाधिकार प्राप्त मोड में शुरू करते हैं, जहां कोड को कुछ भी करने की अनुमति है। वे फिर एक प्रतिबंधित मोड में जा सकते हैं, जहां केवल चयनित मेमोरी या I / O सुविधाएं उपलब्ध हैं। कोड सीधे प्रतिबंधित मोड से विशेषाधिकार मोड में नहीं जा सकता है, लेकिन प्रोसेसर ने विशेषाधिकार-मोड प्रविष्टि बिंदुओं को परिभाषित किया है, और प्रतिबंधित-मोड कोड प्रोसेसर को विशेषाधिकार प्राप्त मोड में उन प्रवेश बिंदुओं में से एक पर कोड चलाना शुरू करने के लिए कह सकता है। इसके अतिरिक्त, कई ऑपरेशनों से जुड़े विशेषाधिकार प्राप्त मोड में प्रवेश बिंदु हैं जो प्रतिबंधित मोड में निषिद्ध होंगे। उदाहरण के लिए, मान लें कि कोई व्यक्ति एक साथ कई MS-DOS एप्लिकेशन चलाना चाहता है, प्रत्येक की अपनी स्क्रीन है। यदि एप्लिकेशन 0xB800: 0 पर सीधे डिस्प्ले कंट्रोलर को लिख सकते हैं, तो किसी एप्लिकेशन को किसी अन्य एप्लिकेशन की स्क्रीन को ओवरराइट करने से रोकने का कोई तरीका नहीं होगा। दूसरी ओर, ओएस प्रतिबंधित मोड में एप्लिकेशन चला सकता है और डिस्प्ले मेमोरी में किसी भी एक्सेस पर ट्रैप कर सकता है; अगर यह पता चला कि एक एप्लिकेशन जो "पृष्ठभूमि" में होना चाहिए था, वह 0xB800: 160 लिखने की कोशिश कर रहा था, यह डेटा को कुछ मेमोरी में स्टोर कर सकता था जिसे उसने बैकग्राउंड-एप्लिकेशन स्क्रीन बफर के रूप में सेट किया था। यदि उस एप्लिकेशन को बाद में अग्रभूमि में ले जाया जाता है, तो बफर को वास्तविक स्क्रीन पर कॉपी किया जा सकता है। ओएस प्रतिबंधित मोड में एप्लिकेशन चला सकता है और डिस्प्ले मेमोरी में किसी भी एक्सेस पर ट्रैप कर सकता है; अगर यह पता चला कि एक एप्लिकेशन जो "पृष्ठभूमि" में होना चाहिए था, वह 0xB800: 160 लिखने की कोशिश कर रहा था, यह डेटा को कुछ मेमोरी में स्टोर कर सकता था जिसे उसने बैकग्राउंड-एप्लिकेशन स्क्रीन बफर के रूप में सेट किया था। यदि उस एप्लिकेशन को बाद में अग्रभूमि में ले जाया जाता है, तो बफर को वास्तविक स्क्रीन पर कॉपी किया जा सकता है। ओएस प्रतिबंधित मोड में एप्लिकेशन चला सकता है और डिस्प्ले मेमोरी में किसी भी एक्सेस पर ट्रैप कर सकता है; अगर यह पता चला कि एक एप्लिकेशन जो "पृष्ठभूमि" में होना चाहिए था, वह 0xB800: 160 लिखने की कोशिश कर रहा था, यह डेटा को कुछ मेमोरी में स्टोर कर सकता था जिसे उसने बैकग्राउंड-एप्लिकेशन स्क्रीन बफर के रूप में सेट किया था। यदि उस एप्लिकेशन को बाद में अग्रभूमि में ले जाया जाता है, तो बफर को वास्तविक स्क्रीन पर कॉपी किया जा सकता है।

ध्यान देने योग्य मुख्य बातें (1) हैं, हालांकि कई बार विभिन्न मानक सेवाओं जैसे कि पाठ प्रदर्शित करने के लिए दिनचर्या का एक मानक सेट होना आसान होता है, वे ऐसा कुछ भी नहीं करते हैं जो एक एप्लिकेशन जो "विशेषाधिकार प्राप्त मोड" में चल रहा हो। अगर यह ठीक से प्रोग्राम किया गया था कि हार्डवेयर स्थापित किया गया था; (२) हालाँकि आज चलने वाले अधिकांश अनुप्रयोगों को उनके ऑपरेटिंग सिस्टम द्वारा ऐसे I / O को सीधे करने से रोका जा सकेगा, एक प्रोग्राम जो विशेषाधिकार प्राप्त मोड में शुरू होता है, जो कुछ भी करना चाहता है उसे करने के लिए मिलता है, और जो भी नियम प्रतिबंधित मोड के लिए चाहता है उसे सेट कर सकता है कार्यक्रम।

Answer 10

जैसा कि स्टीफन सी ने कहा, यह सिर्फ ऑपरेटिंग सिस्टम को शुरू करने के बारे में नहीं है, यह इस बारे में भी है कि यह कैसे चलता है, हार्डवेयर के साथ और इसके शीर्ष पर सॉफ्टवेयर के साथ इंटरैक्ट करता है।

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

यदि आप अधिक विवरण में जाना चाहते हैं कि ऑपरेटिंग सिस्टम हार्डवेयर के साथ कैसे इंटरैक्ट करता है, तो मिनिक्स देखें ।

Answer 11

आप OS लिखिए। इसे किसी तरह चलाना होगा, और यह तरीका दूसरे ओएस के भीतर है?

आपका एप्लिकेशन OS के भीतर चल रहा है। यह ऑपरेटिंग सिस्टम आपके एप्लिकेशन, फ़ाइल खोलने और उस पर बाइट लिखने जैसी चीज़ें प्रदान करता है। ये सेवाएं आमतौर पर सिस्टम कॉल के माध्यम से प्रदान की जाती हैं।

ऑपरेटिंग सिस्टम हार्डवेयर के भीतर चल रहा है। हार्डवेयर ऑपरेटिंग सिस्टम को सेवाएं प्रदान करता है, एक सीरियल पोर्ट की बॉड दर सेट करने और उस पर बाइट्स लिखने जैसी चीजें। ये सेवाएं आमतौर पर मेमोरी मैप्ड रजिस्टरों या I / O पोर्ट के माध्यम से प्रदान की जाती हैं।

---

यह कैसे काम करता है का एक बहुत ही सरल उदाहरण देने के लिए:

आपका एप्लिकेशन किसी फ़ाइल में कुछ लिखने के लिए ऑपरेटिंग सिस्टम को बताता है। आपके अनुप्रयोग के लिए, ऑपरेटिंग सिस्टम फ़ाइलों और निर्देशिकाओं जैसी अवधारणाएँ प्रदान करता है।

हार्डवेयर पर, ये अवधारणाएँ मौजूद नहीं हैं। हार्डवेयर 512 बाइट्स के निर्धारित ब्लॉकों में विभाजित डिस्क जैसी अवधारणाएं प्रदान करता है। ऑपरेटिंग सिस्टम यह तय करता है कि आपकी फ़ाइल के लिए कौन से ब्लॉक का उपयोग किया जाए, और कुछ अन्य ब्लॉक जैसे मेटाडाटा के लिए फ़ाइल नाम, आकार और डिस्क पर स्थान। यह तब हार्डवेयर को बताता है: इन 512 बाइट्स को सेक्टर पर इस संख्या के साथ डिस्क पर उस संख्या के साथ लिखें; इन अन्य 512 बाइट्स को सेक्टर पर उसी संख्या के साथ डिस्क पर इस भिन्न संख्या के साथ लिखें; और इसी तरह।

ऑपरेटिंग सिस्टम जिस तरह से हार्डवेयर को बताता है वह बहुत भिन्न होता है। एक ऑपरेटिंग सिस्टम के कार्यों में से एक इन मतभेदों से अनुप्रयोगों को ढाल देना है। डिस्क उदाहरण के लिए, एक प्रकार के हार्डवेयर पर, ऑपरेटिंग सिस्टम को I / O पोर्ट के लिए डिस्क और सेक्टर नंबर लिखना होगा, और फिर एक अलग I / O पोर्ट पर एक-एक करके बाइट्स लिखना होगा। एक अन्य प्रकार के हार्डवेयर पर, ऑपरेटिंग सिस्टम को एक मेमोरी के एक क्षेत्र में पूरे 512 बाइट्स को कॉपी करना होगा, मेमोरी के उस क्षेत्र को एक विशेष मेमोरी लोकेशन पर लिखना होगा, और डिस्क और सेक्टर नंबर को अभी तक दूसरे पर लिखना होगा। विशेष स्मृति स्थान।

---

आज का हाई-एंड हार्डवेयर बेहद जटिल है। अपने सभी प्रोग्रामिंग विवरण देने वाले मैनुअल हजारों पृष्ठों के साथ डोरस्टॉपर्स हैं; उदाहरण के लिए, नवीनतम इंटेल सीपीयू मैनुअल सात खंड हैं, जिनमें कुल 4000 से अधिक पृष्ठ हैं - और यह केवल सीपीयू के लिए है। अधिकांश अन्य घटक मेमोरी या I / O पोर्ट के ब्लॉक को उजागर करते हैं, जो ऑपरेटिंग सिस्टम सीपीयू को अपने पते के स्थान के पते पर मैप करने के लिए कह सकता है। इनमें से कई घटक कुछ I / O पोर्ट या मेमोरी एड्रेस के पीछे और भी अधिक चीजों को उजागर करते हैं; एक उदाहरण के रूप में, RTC (रियल टाइम क्लॉक, वह घटक जो कंप्यूटर के समय को चालू रखता है) I / O पोर्ट की एक जोड़ी के पीछे कुछ सौ बाइट्स मेमोरी को उजागर करता है, और यह एक बहुत ही सरल घटक है जो वापस डेटिंग करता है। मूल पीसी / एटी। हार्ड डिस्क जैसी चीजों में पूरे अलग प्रोसेसर होते हैं, जो ऑपरेटिंग सिस्टम मानकीकृत कमांड के माध्यम से बात करता है। GPU और भी जटिल हैं।

ऊपर की टिप्पणियों में कई लोगों ने Arduino का सुझाव दिया। मैं उनसे सहमत हूं, यह समझना बहुत सरल है- ATmega328, जो सीरियल कनेक्टर के रूप में यूएसबी कनेक्टर को उजागर करने के अलावा Arduino Uno पर सब कुछ करता है, केवल कुछ सौ पृष्ठों के साथ एक मैनुअल है। Arduino पर, आप सीधे हार्डवेयर पर चलते हैं, बीच में कोई ऑपरेटिंग सिस्टम नहीं है; बस कुछ छोटी लाइब्रेरी रूटीन, जिन्हें आप नहीं चाहते हैं, तो आपको इस्तेमाल नहीं करना है।

Answer 12

चल उदाहरण

तकनीकी रूप से, एक कार्यक्रम जो बिना ओएस के चलता है, एक ओएस है। तो आइए देखते हैं कि कैसे कुछ माइनसक्यूल हैलो वर्ल्ड OSes बनाएं और चलाएं।

इस GitHub रेपो पर नीचे दिए गए सभी उदाहरणों का कोड मौजूद है ।

आरंभिक क्षेत्र

X86 पर, सबसे सरल और निम्नतम स्तर की चीज़ जो आप कर सकते हैं, वह है मास्टर बूट सेक्टर (MBR) , जो एक प्रकार का बूट सेक्टर है , और फिर इसे डिस्क पर स्थापित करें।

यहाँ हम एक printfकॉल के साथ एक बनाते हैं:

printf '\364%509s\125\252' > main.img
sudo apt-get install qemu-system-x86
qemu-system-x86_64 -hda main.img

परिणाम:

उबंटू 18.04, QEMU 2.11.1 पर परीक्षण किया गया।

main.img निम्नलिखित शामिल हैं:

• \3640xf4हेक्स में ऑक्टल == में: एक hltनिर्देश के लिए एन्कोडिंग , जो सीपीयू को काम करना बंद करने के लिए कहता है।

  इसलिए हमारा कार्यक्रम कुछ भी नहीं करेगा: केवल शुरू और रोकें।

  हम अष्टाधारी का उपयोग करते हैं क्योंकि \xहेक्स संख्या POSIX द्वारा निर्दिष्ट नहीं हैं।

  हम इस एन्कोडिंग को आसानी से प्राप्त कर सकते हैं:

  echo hlt > a.asm
  nasm -f bin a.asm
  hd a
  

  लेकिन 0xf4एन्कोडिंग को बेशक इंटेल मैनुअल पर भी प्रलेखित किया गया है।

• %509s509 रिक्त स्थान का उत्पादन। फ़ाइल को बाइट 510 तक भरने की आवश्यकता है।

• \125\252ऑक्टल == में 0x55इसके बाद 0xaa: हार्डवेयर द्वारा आवश्यक मैजिक बाइट्स। उन्हें बाइट्स 511 और 512 होना चाहिए।

  यदि मौजूद नहीं है, तो हार्डवेयर इसे बूट करने योग्य डिस्क के रूप में नहीं मानेगा।

ध्यान दें कि कुछ भी किए बिना, कुछ अक्षर स्क्रीन पर पहले से ही मुद्रित हैं। वे फर्मवेयर द्वारा मुद्रित किए जाते हैं, और सिस्टम की पहचान करने के लिए कार्य करते हैं।

वास्तविक हार्डवेयर पर चलाएँ

एमुलेटर मजेदार हैं, लेकिन हार्डवेयर असली सौदा है।

ध्यान दें कि यह खतरनाक है, और आप अपनी डिस्क को गलती से मिटा सकते हैं: केवल पुरानी मशीनों पर ऐसा करें जिसमें महत्वपूर्ण डेटा नहीं है! या इससे भी बेहतर, रास्पबेरी पाई जैसे डेबोर्ड, नीचे दिए गए एआरएम उदाहरण देखें।

एक विशिष्ट लैपटॉप के लिए, आपको कुछ करना होगा:

• छवि को USB स्टिक में जलाएं (आपके डेटा को नष्ट कर देगा!):

  sudo dd if=main.img of=/dev/sdX
  

• कंप्यूटर पर USB प्लग करें

• इसे चालू करो

• इसे USB से बूट करने के लिए कहें।

  इसका मतलब है कि हार्ड डिस्क से पहले फर्मवेयर को USB चुनें।

  यदि वह आपकी मशीन का डिफ़ॉल्ट व्यवहार नहीं है, तो पावर-ऑन के बाद Enter, F12, ESC या अन्य ऐसी अजीब कुंजियाँ मारते रहें, जब तक आपको बूट मेनू नहीं मिल जाता है जहाँ आप USB से बूट करना चुन सकते हैं।

  उन मेनू में खोज क्रम को कॉन्फ़िगर करना अक्सर संभव होता है।

उदाहरण के लिए, अपने पुराने लेनोवो थिंकपैड T430, UEFI BIOS 1.16 पर, मैं देख सकता हूं:

नमस्ते दुनिया

अब जब हमने एक न्यूनतम कार्यक्रम बना लिया है, तो आइए हम एक नमस्ते दुनिया की ओर रुख करें।

स्पष्ट प्रश्न है: IO कैसे करें? कुछ विकल्प:

• फर्मवेयर के लिए पूछें, उदाहरण के लिए BIOS या यूईएफआई, अगर हमारे लिए करना है
• वीजीए: विशेष मेमोरी क्षेत्र जो स्क्रीन पर लिखे जाने पर प्रिंट हो जाता है। संरक्षित मोड पर इस्तेमाल किया जा सकता है।
• ड्राइवर लिखें और सीधे डिस्प्ले हार्डवेयर पर बात करें। यह इसे करने का "उचित" तरीका है: अधिक शक्तिशाली, लेकिन अधिक जटिल।

• सीरियल पोर्ट । यह एक बहुत ही सरल मानकीकृत प्रोटोकॉल है जो होस्ट टर्मिनल से वर्ण भेजता और पुनर्प्राप्त करता है।

  

  स्रोत ।

  यह दुर्भाग्य से अधिकांश आधुनिक लैपटॉप पर उजागर नहीं है, लेकिन विकास बोर्डों के लिए जाने का सामान्य तरीका है, नीचे दिए गए एआरएम उदाहरण देखें।

  यह वास्तव में शर्म की बात है, क्योंकि इस तरह के इंटरफेस उदाहरण के लिए लिनक्स कर्नेल को डिबग करने के लिए वास्तव में उपयोगी हैं ।

• चिप्स की डिबग सुविधाओं का उपयोग करें। उदाहरण के लिए एआरएम ने उनकी सेमीहोस्टिंग को कॉल किया । वास्तविक हार्डवेयर पर, इसके लिए कुछ अतिरिक्त हार्डवेयर और सॉफ़्टवेयर सहायता की आवश्यकता होती है, लेकिन एमुलेटर पर यह एक मुफ्त सुविधाजनक विकल्प हो सकता है। उदाहरण है ।

यहाँ हम एक BIOS उदाहरण करेंगे क्योंकि यह x86 पर सरल है। लेकिन ध्यान दें कि यह सबसे मजबूत तरीका नहीं है।

main.S

.code16
    mov $msg, %si
    mov $0x0e, %ah
loop:
    lodsb
    or %al, %al
    jz halt
    int $0x10
    jmp loop
halt:
    hlt
msg:
    .asciz "hello world"

link.ld

SECTIONS
{
    . = 0x7c00;
    .text :
    {
        __start = .;
        *(.text)
        . = 0x1FE;
        SHORT(0xAA55)
    }
}

इकट्ठा और के साथ लिंक:

gcc -c -g -o main.o main.S
ld --oformat binary -o main.img -T linker.ld main.o

परिणाम:

पर परीक्षण किया गया: लेनोवो थिंकपैड T430, UEFI BIOS 1.16। एक Ubuntu 18.04 होस्ट पर डिस्क उत्पन्न हुई।

मानक उपयोगकर्ता भूमि विधानसभा निर्देशों के अलावा, हमारे पास:

• .code16: GAS को 16-बिट कोड आउटपुट करने के लिए कहता है

• cli: अक्षम सॉफ्टवेयर बाधा। वे प्रोसेसर को फिर से चलाने के बाद शुरू कर सकते हैंhlt

• int $0x10: एक BIOS कॉल करता है। यह वह है जो पात्रों को एक-एक करके प्रिंट करता है।

महत्वपूर्ण लिंक झंडे हैं:

• --oformat binary: कच्चे बाइनरी असेंबली कोड को आउटपुट करें, इसे ELF फ़ाइल के अंदर न डालें जैसा कि नियमित यूजरलैंड एक्जीक्यूटिव के लिए होता है।

विधानसभा के बजाय सी का उपयोग करें

चूंकि सी असेंबली के लिए संकलित है, मानक पुस्तकालय के बिना सी का उपयोग करना बहुत सरल है, आपको मूल रूप से बस आवश्यकता है:

• एक लिंकर स्क्रिप्ट सही जगह पर स्मृति में चीजों को रखने के लिए
• झंडे जो जीसीसी को मानक पुस्तकालय का उपयोग नहीं करने के लिए कहते हैं
• एक छोटे विधानसभा प्रवेश बिंदु main, जो विशेष रूप से C राज्य के लिए आवश्यक सेट करता है :
  • ढेर
  • शून्य बीएसएस

TODO: GitHub पर कुछ x86 उदाहरण लिंक करें। यहाँ एक ARM एक है जिसे मैंने बनाया है ।

यदि आप मानक पुस्तकालय का उपयोग करना चाहते हैं तो चीजें अधिक मजेदार होती हैं, क्योंकि हमारे पास लिनक्स कर्नेल नहीं है, जो पोसिक्स के माध्यम से सी मानक पुस्तकालय कार्यक्षमता का बहुत अधिक कार्यान्वयन करता है ।

लिनक्स जैसे पूर्ण विकसित ओएस पर जाने के बिना कुछ संभावनाएं शामिल हैं:

• Newlib

  इस पर विस्तृत उदाहरण: https://electronics.stackexchange.com/questions/223929/c-standard-lbooks-on-bare-metal/223931

  न्यूलिब में, आपको अपने आप को सिस्कॉल लागू करना होगा, लेकिन आपको एक बहुत ही न्यूनतम प्रणाली मिलती है, और उन्हें लागू करना बहुत आसान है।

  उदाहरण के लिए, आप printfUART या ARM सिस्टम पर रीडायरेक्ट कर सकते हैं, या सेमीहोस्टिंग केexit() साथ लागू कर सकते हैं ।

• FreeRTOS और Zephyr जैसे एम्बेडेड ऑपरेटिंग सिस्टम ।

  इस तरह के ऑपरेटिंग सिस्टम आम तौर पर आपको पूर्व-खाली शेड्यूलिंग को बंद करने की अनुमति देते हैं, इसलिए आपको प्रोग्राम के रनटाइम पर पूर्ण नियंत्रण प्रदान करते हैं।

  उन्हें पहले से लागू न्यूलिब के रूप में देखा जा सकता है।

एआरएम

एआरएम में, सामान्य विचार समान हैं। मैंने अपलोड किया है:

• GitHub पर कुछ सरल QEMU नंगे उदाहरण यहाँ दिए गए हैं । प्रॉम्प्ट . c उदाहरण आपके होस्ट टर्मिनल से इनपुट लेता है और नकली UART के माध्यम से सभी आउटपुट देता है:

  enter a character
  got: a
  new alloc of 1 bytes at address 0x0x4000a1c0
  enter a character
  got: b
  new alloc of 2 bytes at address 0x0x4000a1c0
  enter a character
  

  इसे भी देखें: https://stackoverflow.com/questions/38914019/how-to-make-bare-metal-arm-programs-and-run-them-on-qemu/50981397/50981397

• पूरी तरह से स्वचालित रास्पबेरी पाई ब्लिंकर सेटअप पर: https://github.com/cirosantilli/raspberry-pi-bare-metal-blinker

  

  इसे भी देखें: https://stackoverflow.com/questions/29837892/how-to-run-ac-program-with-no-os-on-the-raspberry-pi/40063032#40063032

रास्पबेरी पाई के लिए, https://github.com/dwelch67/raspberrypi आज सबसे लोकप्रिय ट्यूटोरियल उपलब्ध है।

X86 से कुछ अंतरों में शामिल हैं:

• IO सीधे जादू के पते पर लिखकर किया जाता है, कोई निर्देश inऔर outनिर्देश नहीं है।

  इसे मेमोरी मैपेड IO कहा जाता है ।

• कुछ वास्तविक हार्डवेयर के लिए, रास्पबेरी पाई की तरह, आप फर्मवेयर (BIOS) को डिस्क छवि में स्वयं जोड़ सकते हैं।

  यह एक अच्छी बात है, क्योंकि यह उस फर्मवेयर को अधिक पारदर्शी बनाता है।

फर्मवेयर

सच में, आपका बूट सेक्टर पहला सॉफ्टवेयर नहीं है जो सिस्टम के सीपीयू पर चलता है।

वास्तव में सबसे पहले चलने वाला तथाकथित फर्मवेयर है , जो एक सॉफ्टवेयर है:

• हार्डवेयर निर्माताओं द्वारा बनाया गया
• आमतौर पर बंद स्रोत लेकिन सी-आधारित होने की संभावना है
• केवल-पढ़ने के लिए मेमोरी में संग्रहीत किया जाता है, और इसलिए विक्रेता की सहमति के बिना संशोधित करना कठिन / असंभव है।

प्रसिद्ध फर्मों में शामिल हैं:

• BIOS : पुराने सभी-वर्तमान x86 फर्मवेयर। सीबीआईओएस QEMU द्वारा उपयोग किया जाने वाला डिफ़ॉल्ट ओपन सोर्स कार्यान्वयन है।
• UEFI : BIOS उत्तराधिकारी, बेहतर मानकीकृत, लेकिन अधिक सक्षम, और अविश्वसनीय रूप से फूला हुआ।
• कोरबूट : नोबल क्रॉस आर्क ओपन सोर्स प्रयास

फर्मवेयर कुछ इस तरह करता है:

• प्रत्येक हार्ड डिस्क, USB, नेटवर्क आदि पर लूप तब तक रखें जब तक आपको कुछ बूट करने योग्य न मिल जाए।

  जब हम QEMU चलाते हैं, तो -hdaकहते हैं कि main.imgहार्डवेयर से जुड़ी एक हार्ड डिस्क है, और

  hda पहला प्रयास किया जाना है, और इसका उपयोग किया जाता है।

• रैम मेमोरी एड्रेस में पहले 512 बाइट्स लोड करें 0x7c00, सीपीयू के आरआईपी को वहां रखें, और इसे चलने दें

• डिस्प्ले पर बूट मेनू या BIOS प्रिंट कॉल जैसी चीजें दिखाएं

फर्मवेयर OS जैसी कार्यक्षमता प्रदान करता है, जिस पर अधिकांश OS-es निर्भर करते हैं। उदाहरण के लिए पायथन सबसेट को BIOS / UEFI पर चलाने के लिए पोर्ट किया गया है: https://www.youtube.com/watch?v=bYQ_lq5dcvM

यह तर्क दिया जा सकता है कि फ़र्मवेयर OSes से अविभाज्य हैं, और यह फर्मवेयर केवल "सच" है नंगे धातु प्रोग्रामिंग एक कर सकता है।

जैसा कि यह कोरओएस देव डालता है :

कठिन हिस्सा

जब आप एक पीसी को पावर करते हैं, तो चिपसेट (नॉर्थब्रिज, साउथब्रिज और सुपरियो) बनाने वाले चिप्स अभी तक ठीक से शुरू नहीं किए गए हैं। भले ही BIOS ROM सीपीयू से उतना ही दूर है जितना कि यह हो सकता है, यह सीपीयू द्वारा सुलभ है, क्योंकि यह होना चाहिए, अन्यथा सीपीयू को निष्पादित करने के लिए कोई निर्देश नहीं होगा। इसका मतलब यह नहीं है कि BIOS ROM पूरी तरह से मैप किया गया है, आमतौर पर नहीं। लेकिन बूट प्रक्रिया को पूरा करने के लिए बस पर्याप्त मैप किया गया है। कोई अन्य उपकरण, बस इसे भूल जाओ।

जब आप QEMU के तहत Coreboot चलाते हैं, तो आप Coreboot की उच्च परतों और पेलोड के साथ प्रयोग कर सकते हैं, लेकिन QEMU निम्न स्तर के स्टार्टअप कोड के साथ प्रयोग करने का बहुत कम अवसर प्रदान करता है। एक बात के लिए, रैम शुरू से ही सही काम करता है।

पोस्ट BIOS प्रारंभिक स्थिति

हार्डवेयर में कई चीजों की तरह, मानकीकरण कमजोर है, और जिन चीजों पर आपको भरोसा नहीं करना चाहिए उनमें से एक रजिस्टर की प्रारंभिक स्थिति है जब आपका कोड BIOS के बाद चलना शुरू होता है।

तो अपने आप को एक एहसान करो और निम्नलिखित जैसे कुछ इनिशियलाइज़ेशन कोड का उपयोग करें : https://stackoverflow.com/a/32509555/5255245

रजिस्टरों को पसंद करते हैं %dsऔर %esमहत्वपूर्ण दुष्प्रभाव होते हैं, इसलिए आपको उन्हें शून्य करना चाहिए, भले ही आप उन्हें स्पष्ट रूप से उपयोग न कर रहे हों।

ध्यान दें कि कुछ एमुलेटर असली हार्डवेयर की तुलना में अच्छे होते हैं और आपको एक अच्छा प्रारंभिक राज्य देते हैं। फिर जब आप असली हार्डवेयर पर चलते हैं, तो सब कुछ टूट जाता है।

ग्नू ग्रुब मल्टीबूट

बूट सेक्टर सरल हैं, लेकिन वे बहुत सुविधाजनक नहीं हैं:

• आपके पास प्रति डिस्क केवल एक OS हो सकता है
• लोड कोड को वास्तव में छोटा होना चाहिए और 512 बाइट्स में फिट होना चाहिए। इसे int 0x13 BIOS कॉल के साथ हल किया जा सकता है ।
• आपको बहुत सारे स्टार्टअप खुद करने होंगे, जैसे संरक्षित मोड में जाना

यह उन कारणों के लिए है कि GNU GRUB ने एक अधिक सुविधाजनक फ़ाइल प्रारूप बनाया जिसे मल्टीबूट कहा जाता है।

न्यूनतम कार्यशील उदाहरण: https://github.com/cirosantilli/x86-bare-metal-examples/tree/d217b180be4220a0b4a453f31275d38e69a99a0e/multiboot/hello-world

मैं अपने GitHub उदाहरण रेपो पर भी इसका उपयोग करता हूं ताकि आसानी से USB को एक लाख बार जलाए बिना वास्तविक हार्डवेयर पर सभी उदाहरणों को चलाने में सक्षम हो। QEMU पर यह इस तरह दिखता है:

यदि आप अपने OS को एक मल्टीबूट फ़ाइल के रूप में तैयार करते हैं, तो GRUB इसे एक नियमित फाइल सिस्टम के अंदर खोजने में सक्षम है।

ओएस छवियों को नीचे रखकर यह सबसे अधिक विकृत करता है /boot।

मल्टीबूट फाइलें मूल रूप से एक विशेष हेडर के साथ एक ईएलएफ फ़ाइल हैं। वे GRUB द्वारा यहां निर्दिष्ट हैं: https://www.gnu.org/software/grub/manual/multiboot/multib.html.html

आप मल्टीबूट फ़ाइल को बूट करने योग्य डिस्क में बदल सकते हैं grub-mkrescue।

एल टोरिटो

सीडी को जलाया जा सकने वाला प्रारूप: https://en.wikipedia.org/wiki/El_Torito_%28CD-ROM_standard%29

हाइब्रिड छवि का उत्पादन करना भी संभव है जो आईएसओ या यूएसबी पर काम करता है। यह grub-mkrescue( उदाहरण के साथ ) किया जा सकता है , और make isoimageउपयोग करने पर लिनक्स कर्नेल द्वारा भी किया जाता है isohybrid।

साधन

• http://wiki.osdev.org उन मामलों के लिए एक महान स्रोत है।
• https://github.com/scanlime/metalkit एक अधिक स्वचालित / सामान्य नंगे धातु संकलन प्रणाली है, जो एक छोटे से कस्टम एपीआई प्रदान करती है