कर्नेल स्थान और उपयोगकर्ता स्थान के बीच अंतर क्या है? क्या कर्नेल स्पेस, कर्नेल थ्रेड्स, कर्नेल प्रोसेस और कर्नेल स्टैक का अर्थ समान है? इसके अलावा, हमें इस भेदभाव की आवश्यकता क्यों है?
जवाबों:
वास्तव में सरलीकृत जवाब यह है कि गिरी गिरी अंतरिक्ष में चलता है, और सामान्य कार्यक्रमों उपयोगकर्ता अंतरिक्ष में चलाते हैं। उपयोगकर्ता स्थान मूल रूप से रेत-बॉक्सिंग का एक रूप है - यह उपयोगकर्ता कार्यक्रमों को प्रतिबंधित करता है ताकि वे अन्य कार्यक्रमों या ओएस कर्नेल द्वारा स्वामित्व वाली मेमोरी (और अन्य संसाधनों) के साथ गड़बड़ न कर सकें। यह सीमा (लेकिन आमतौर पर पूरी तरह से समाप्त नहीं करता है) मशीन को खराब करने जैसी बुरी चीजें करने की उनकी क्षमता है।
कर्नेल ऑपरेटिंग सिस्टम का मूल है। यह आम तौर पर सभी मेमोरी और मशीन हार्डवेयर (और मशीन पर बाकी सब कुछ) के लिए पूर्ण पहुंच है। मशीन को यथासंभव स्थिर रखने के लिए, आप सामान्यतः कर्नेल मोड / कर्नेल स्थान में चलाने के लिए केवल सबसे भरोसेमंद, अच्छी तरह से जांचा गया कोड चाहते हैं।
स्टैक सिर्फ मेमोरी का एक और हिस्सा है, इसलिए स्वाभाविक रूप से इसे बाकी मेमोरी के साथ-साथ सही से अलग किया जाता है।
रैंडम एक्सेस मेमोरी (RAM) तार्किक अर्थात् दो अलग-अलग क्षेत्रों में विभाजित किया जा सकता है -। गिरी अंतरिक्ष और उपयोगकर्ता अंतरिक्ष ( भौतिक पते रैम वास्तव में विभाजित नहीं कर रहे हैं केवल आभासी पतों , यह सब द्वारा कार्यान्वित MMU )
कर्नेल स्मृति के भाग में हकदार है। मेमोरी के इस हिस्से को सामान्य उपयोगकर्ताओं की प्रक्रियाओं द्वारा सीधे एक्सेस नहीं किया जा सकता है, जबकि कर्नेल मेमोरी के सभी हिस्सों तक पहुंच सकता है। कर्नेल के कुछ हिस्से तक पहुंचने के लिए, उपयोगकर्ता प्रक्रियाओं को पूर्वनिर्धारित सिस्टम कॉल का उपयोग करना होता है open, अर्थात read, writeआदि। इसके अलावा, Cलाइब्रेरी फ़ंक्शन जैसे printfसिस्टम कॉल writeको बदले में कॉल करते हैं।
सिस्टम उपयोगकर्ता प्रक्रियाओं और कर्नेल प्रक्रियाओं के बीच एक इंटरफेस के रूप में कार्य करता है। अनजाने में कर्नेल के साथ उपयोगकर्ताओं को गड़बड़ करने से रोकने के लिए एक्सेस अधिकारों को कर्नेल स्थान पर रखा गया है।
इसलिए, जब सिस्टम कॉल होता है, तो कर्नेल को एक सॉफ्टवेयर इंटरप्ट भेजा जाता है। सीपीयू नियंत्रण में अस्थायी रूप से संबंधित बाधा हैंडलर दिनचर्या को सौंप सकता है। कर्नेल प्रक्रिया जो रुकावट से रुकी हुई थी, रुकावट के बाद रुकावट का काम नियमित रूप से समाप्त हो गया।
कर्नेल स्पेस और वर्चुअल स्पेस वर्चुअल मेमोरी की अवधारणाएं हैं .... इसका मतलब यह नहीं है कि राम (आपकी वास्तविक मेमोरी) कर्नेल और उपयोगकर्ता स्थान में विभाजित है। प्रत्येक प्रक्रिया को वर्चुअल मेमोरी दी जाती है जिसे कर्नेल और यूजर स्पेस में विभाजित किया जाता है।
तो यह कहते हुए कि "रैंडम एक्सेस मेमोरी (RAM) को दो अलग-अलग क्षेत्रों में विभाजित किया जा सकता है - जैसे कर्नेल स्पेस और यूजर स्पेस।" गलत है।
और "कर्नेल स्पेस बनाम यूजर स्पेस" चीज़ के बारे में
जब एक प्रक्रिया बनाई जाती है और इसकी वर्चुअल मेमोरी को यूजर-स्पेस और एक कर्नेल-स्पेस में विभाजित किया जाता है, जहां यूजर स्पेस क्षेत्र में डेटा, कोड, स्टैक, प्रक्रिया का ढेर और कर्नेल-स्पेस शामिल होते हैं जैसे कि प्रक्रिया के लिए पेज टेबल। , कर्नेल डेटा स्ट्रक्चर्स और कर्नेल कोड आदि। कर्नेल स्पेस कोड चलाने के लिए, कंट्रोल को कर्नेल मोड (सिस्टम कॉल के लिए 0x80 सॉफ्टवेयर इंटरप्ट का उपयोग करके) में स्थानांतरित करना होगा और कर्नेल स्टैक मूल रूप से कर्नेल स्पेस में निष्पादित होने वाली सभी प्रक्रियाओं के बीच साझा किया जाता है।
सीपीयू के छल्ले सबसे स्पष्ट अंतर हैं
X86 संरक्षित मोड में, CPU हमेशा 4 रिंग में से एक में होता है। लिनक्स कर्नेल केवल 0 और 3 का उपयोग करता है:
यह कर्नेल बनाम उपयोगकर्ताभूमि की सबसे कठिन और तेज़ परिभाषा है।
क्यों लिनक्स 1 और 2 के छल्ले का उपयोग नहीं करता है: सीपीयू विशेषाधिकार के छल्ले: क्यों 1 और 2 के छल्ले का उपयोग नहीं किया जाता है?
वर्तमान रिंग कैसे निर्धारित की जाती है?
वर्तमान रिंग को इसके संयोजन द्वारा चुना गया है:
वैश्विक डिस्क्रिप्टर टेबल: जीडीटी प्रविष्टियों की इन-मेमोरी टेबल, और प्रत्येक प्रविष्टि में एक फ़ील्ड होता है Privlजो रिंग को एनकोड करता है।
LGDT इंस्ट्रक्शन वर्तमान डिस्क्रिप्टर टेबल पर पता सेट करता है।
इसे भी देखें: http://wiki.osdev.org/Global_Descriptor_Table
खंड सीएस, डीएस, आदि को पंजीकृत करता है, जो जीडीटी में एक प्रविष्टि के सूचकांक को इंगित करता है।
उदाहरण के लिए, CS = 0मतलब GDT की पहली प्रविष्टि वर्तमान में निष्पादित कोड के लिए सक्रिय है।
प्रत्येक अंगूठी क्या कर सकती है?
सीपीयू चिप को भौतिक रूप से बनाया गया है ताकि:
अंगूठी 0 कुछ भी कर सकती है
रिंग 3 कई निर्देश नहीं चला सकता है और कई रजिस्टरों को लिख सकता है, विशेष रूप से:
अपनी खुद की अंगूठी नहीं बदल सकते हैं! अन्यथा, यह खुद को 0 में सेट कर सकता है और रिंग बेकार हो जाएगा।
दूसरे शब्दों में, वर्तमान खंड वर्णनकर्ता को संशोधित नहीं कर सकता है , जो वर्तमान रिंग को निर्धारित करता है।
पृष्ठ तालिकाओं को संशोधित नहीं कर सकते: x86 पेजिंग कैसे काम करता है?
दूसरे शब्दों में, CR3 रजिस्टर को संशोधित नहीं किया जा सकता है, और पेजिंग स्वयं पेज तालिकाओं के संशोधन को रोकता है।
यह एक प्रक्रिया को सुरक्षा कारणों के लिए अन्य प्रक्रियाओं की स्मृति को देखने से रोकता है / प्रोग्रामिंग कारणों में आसानी।
बाधित हैंडलर पंजीकृत नहीं कर सकते। इन्हें स्मृति स्थानों पर लिखकर कॉन्फ़िगर किया जाता है, जिसे पेजिंग द्वारा भी रोका जाता है।
हैंडलर रिंग 0 में दौड़ते हैं, और सुरक्षा मॉडल को तोड़ देंगे।
दूसरे शब्दों में, LGDT और LIDT निर्देशों का उपयोग नहीं कर सकते।
IO जैसे निर्देश inऔर नहीं कर सकते out, और इस तरह मनमाने ढंग से हार्डवेयर एक्सेस हैं।
अन्यथा, उदाहरण के लिए, यदि किसी प्रोग्राम को डिस्क से सीधे पढ़ा जा सकता है, तो फ़ाइल अनुमति बेकार होगी।
माइकल पेटी के लिए अधिक सटीक रूप से धन्यवाद : यह वास्तव में ओएस के लिए रिंग 3 पर आईओ के निर्देशों की अनुमति देने के लिए संभव है, यह वास्तव में टास्क सेक्शन द्वारा नियंत्रित किया जाता है ।
क्या संभव नहीं है रिंग 3 के लिए खुद को ऐसा करने की अनुमति देना अगर यह पहली जगह में नहीं था।
लिनक्स हमेशा इसे नापसंद करता है। इसे भी देखें: लिनक्स TSS के माध्यम से हार्डवेयर संदर्भ स्विच का उपयोग क्यों नहीं करता है?
रिंगों के बीच प्रोग्राम और ऑपरेटिंग सिस्टम कैसे संक्रमण करते हैं?
जब CPU चालू होता है, तो यह रिंग 0 में प्रारंभिक प्रोग्राम चलाने लगता है (अच्छी तरह से, लेकिन यह एक अच्छा सन्निकटन है)। आप इस प्रारंभिक कार्यक्रम को कर्नेल होने के रूप में सोच सकते हैं (लेकिन यह आमतौर पर एक बूटलोडर है जो कर्नेल को अभी भी रिंग 0 में कहता है )।
जब कोई उपयोगकर्ता प्रक्रिया प्रक्रिया कर्नेल को इसके लिए कुछ करना चाहती है जैसे फ़ाइल में लिखना, यह एक निर्देश का उपयोग करता है जो एक बाधा उत्पन्न करता है जैसे कि int 0x80याsyscall कर्नेल को संकेत देने के लिए। x86-64 लिनक्स syscall हैलो दुनिया उदाहरण:
.data
hello_world:
.ascii "hello world\n"
hello_world_len = . - hello_world
.text
.global _start
_start:
/* write */
mov $1, %rax
mov $1, %rdi
mov $hello_world, %rsi
mov $hello_world_len, %rdx
syscall
/* exit */
mov $60, %rax
mov $0, %rdi
syscall
संकलित करें और चलाएं:
as -o hello_world.o hello_world.S
ld -o hello_world.out hello_world.o
./hello_world.out
जब ऐसा होता है, CPU एक कॉलबैक हैंडलर को कॉल करता है जिसे कर्नेल बूट समय पर पंजीकृत करता है। यहां एक ठोस नंगेपन का उदाहरण है जो एक हैंडलर को पंजीकृत करता है और इसका उपयोग करता है ।
यह हैंडलर रिंग 0 में चलता है, जो तय करता है कि कर्नेल इस क्रिया को करने देगा, एक्शन करेगा, और रिंग में यूजरलैंड प्रोग्राम को पुनः आरंभ करेगा 3. x86_64
जब execसिस्टम कॉल का उपयोग किया जाता है (या जब कर्नेल शुरू हो जाएगा/init ), कर्नेल नए यूज़रलैंड प्रक्रिया के रजिस्टरों और मेमोरी को तैयार करता है, तो यह प्रवेश बिंदु पर कूदता है और सीपीयू को रिंग 3 में स्विच करता है
यदि प्रोग्राम कुछ शरारती करने की कोशिश करता है जैसे निषिद्ध रजिस्टर या मेमोरी एड्रेस (पेजिंग के कारण) को लिखने के लिए, सीपीयू रिंग 0 में कुछ कर्नेल कॉलबैक हैंडलर को भी कॉल करता है।
लेकिन चूंकि यूजरलैंड शरारती था, कर्नेल इस बार प्रक्रिया को मार सकता है, या इसे सिग्नल के साथ चेतावनी दे सकता है।
जब कर्नेल बूट होता है, तो यह कुछ निश्चित आवृत्ति के साथ एक हार्डवेयर घड़ी सेटअप करता है, जो समय-समय पर व्यवधान उत्पन्न करता है।
यह हार्डवेयर क्लॉक रिंग 0 को चलाने वाले इंटरप्ट को जनरेट करता है, और इसे शेड्यूल करने की अनुमति देता है कि कौन सी यूजरलैंड उठती है।
इस तरह, शेड्यूलिंग तब भी हो सकती है, जब प्रक्रियाएं कोई सिस्टम कॉल नहीं कर रही हैं।
एकाधिक वलय होने की बात क्या है?
कर्नेल और उपयोगकर्ताभूमि को अलग करने के दो प्रमुख लाभ हैं:
इसके साथ कैसे खेलें?
मैंने एक नंगे धातु सेटअप का निर्माण किया है जो रिंगों को सीधे हेरफेर करने का एक अच्छा तरीका होना चाहिए: https://github.com/cirosantilli/x86-bare-metal-examples
मेरे पास दुर्भाग्य से एक उपयोगकर्ता के उदाहरण बनाने के लिए धैर्य नहीं था, लेकिन मैं सेटअप पेजिंग के रूप में दूर तक गया था, इसलिए उपयोगकर्ताभूमि को व्यवहार्य होना चाहिए। मुझे एक पुल अनुरोध देखना अच्छा लगेगा।
वैकल्पिक रूप से, लिनक्स कर्नेल मॉड्यूल रिंग 0 में चलते हैं, इसलिए आप उनका उपयोग विशेषाधिकार प्राप्त प्रचालनों को आज़माने के लिए कर सकते हैं, उदाहरण के लिए कंट्रोल रजिस्टर पढ़ें: कंट्रोल रजिस्टर को कैसे एक्सेस करें cr0, cr2, cr3 एक प्रोग्राम से? विभाजन की गलती हो रही है
यहाँ एक सुविधाजनक QEMU + Buildroot सेटअप है जो आपके मेजबान को मारे बिना इसे आज़माने के लिए है।
कर्नेल मॉड्यूल का नकारात्मक पक्ष यह है कि अन्य kthreads चल रहे हैं और आपके प्रयोगों में हस्तक्षेप कर सकते हैं। लेकिन सिद्धांत रूप में आप अपने कर्नेल मॉड्यूल के साथ सभी रुकावटों को संभाल सकते हैं और सिस्टम के मालिक हैं, जो वास्तव में एक दिलचस्प परियोजना होगी।
नकारात्मक वलय
जबकि नकारात्मक रिंग्स वास्तव में इंटेल मैनुअल में संदर्भित नहीं होते हैं, वास्तव में सीपीयू मोड हैं जिनके पास रिंग 0 की तुलना में आगे की क्षमताएं हैं, और इसलिए "नकारात्मक रिंग" नाम के लिए एक अच्छा फिट है।
एक उदाहरण वर्चुअलाइजेशन में उपयोग किया जाने वाला हाइपरविजर मोड है।
अधिक जानकारी के लिए देखें:
एआरएम
एआरएम में, छल्ले को इसके बजाय अपवाद स्तर कहा जाता है, लेकिन मुख्य विचार समान रहते हैं।
ARMv8 में 4 अपवाद स्तर मौजूद हैं, जिनका आमतौर पर उपयोग किया जाता है:
EL0: उपयोगकर्ता क्षेत्र
EL1: कर्नेल (एआरएम शब्दावली में "पर्यवेक्षक")।
svcनिर्देश (सुपरवाइजर कॉल) के साथ दर्ज किया गया , जिसे swi पहले एकीकृत असेंबली के रूप में जाना जाता था , जो कि लिनक्स सिस्टम कॉल करने के लिए उपयोग किया जाने वाला निर्देश है। नमस्ते दुनिया ARMv8 उदाहरण:
hello.S
.text
.global _start
_start:
/* write */
mov x0, 1
ldr x1, =msg
ldr x2, =len
mov x8, 64
svc 0
/* exit */
mov x0, 0
mov x8, 93
svc 0
msg:
.ascii "hello syscall v8\n"
len = . - msg
16.04 पर QEMU के साथ इसका परीक्षण करें:
sudo apt-get install qemu-user gcc-arm-linux-gnueabihf
arm-linux-gnueabihf-as -o hello.o hello.S
arm-linux-gnueabihf-ld -o hello hello.o
qemu-arm hello
यहां एक ठोस नंगेपन का उदाहरण है जो एसवीसी हैंडलर को पंजीकृत करता है और एसवीसी कॉल करता है ।
EL2: हाइपरविजर , उदाहरण के लिए Xen ।
hvcनिर्देश (हाइपरविजर कॉल) के साथ दर्ज किया गया ।
एक हाइपरविजर एक OS के लिए है, एक OS क्या है जो उपयोगकर्ता के लिए है।
उदाहरण के लिए, Xen आपको एक ही समय में एक ही सिस्टम पर कई OS जैसे Linux या Windows चलाने की अनुमति देता है, और यह OSes को एक दूसरे से सुरक्षा और डिबग में आसानी के लिए अलग करता है, ठीक वैसे ही जैसे कि लिनक्स उपयोगकर्ता के कार्यक्रमों के लिए करता है।
Hypervisers आज के क्लाउड बुनियादी ढांचे का एक महत्वपूर्ण हिस्सा हैं: वे कई सर्वरों को एक हार्डवेयर पर चलने की अनुमति देते हैं, हार्डवेयर उपयोग को हमेशा 100% के करीब रखते हैं और बहुत सारे पैसे बचाते हैं।
उदाहरण के लिए AWS ने 2017 तक Xen का उपयोग किया जब इसके KVM के कदम ने समाचार बनाया ।
EL3: अभी तक एक और स्तर। TODO उदाहरण।
smcनिर्देश (सुरक्षित मोड कॉल) के साथ दर्ज किया गया
ARMv8 वास्तुकला संदर्भ मॉडल DDI 0487C.a - अध्याय डी 1 - AArch64 सिस्टम स्तर प्रोग्रामर मॉडल - चित्रा D1-1 इस खूबसूरती से दिखाता है:
ARMv8.1 वर्चुअलाइजेशन होस्ट एक्सटेंशन्स (VHE) के आगमन के साथ ARM की स्थिति थोड़ी बदल गई । यह एक्सटेंशन कर्नेल को EL2 में कुशलतापूर्वक चलाने की अनुमति देता है:
VHE इसलिए बनाया गया था क्योंकि KVM जैसे लिनक्स-कर्नेल वर्चुअलाइजेशन सॉल्यूशंस ने ज़मीन पर ज़ेन का अधिग्रहण किया है (उदाहरण के लिए देखें कि AWS 'KVM में ऊपर उल्लिखित है), क्योंकि अधिकांश क्लाइंट को केवल Linux VMs की आवश्यकता होती है, और जैसा कि आप कल्पना कर सकते हैं, सभी एक ही में हो रहे हैं प्रोजेक्ट, KVM सरल और संभावित रूप से Xen से अधिक कुशल है। तो अब मेजबान लिनक्स कर्नेल उन मामलों में हाइपरवाइजर के रूप में कार्य करता है।
ध्यान दें कि कैसे एआरएम, शायद hindight के लाभ के कारण, नकारात्मक स्तर की आवश्यकता के बिना x86 की तुलना में विशेषाधिकार स्तरों के लिए एक बेहतर नामकरण सम्मेलन है: 0 कम और 3 उच्चतम। उच्च स्तर कम लोगों की तुलना में अधिक बार बनाए जाते हैं।
वर्तमान ईएल को MRSनिर्देश के साथ समझा जा सकता है : वर्तमान निष्पादन मोड / अपवाद स्तर, आदि क्या है?
एआरएम को कार्यान्वयन के लिए अनुमति देने के लिए सभी अपवाद स्तरों की आवश्यकता नहीं है जो चिप क्षेत्र को बचाने के लिए सुविधा की आवश्यकता नहीं है। ARMv8 "अपवाद स्तर" कहते हैं:
कार्यान्वयन में अपवाद स्तरों के सभी शामिल नहीं हो सकते हैं। सभी कार्यान्वयन में EL0 और EL1 शामिल होने चाहिए। EL2 और EL3 वैकल्पिक हैं।
Q1U उदाहरण के लिए EL1 में चूक, लेकिन EL2 और EL3 को कमांड लाइन विकल्पों के साथ सक्षम किया जा सकता है: qemu-system-aarch64 जब a1 पावर अप का अनुकरण करते हुए el1 में प्रवेश करता है
कोड स्निपेट्स ने उबंटू 18.10 पर परीक्षण किया।
कर्नेल स्थान और उपयोगकर्ता स्थान विशेषाधिकारित ऑपरेटिंग सिस्टम फ़ंक्शन और प्रतिबंधित उपयोगकर्ता अनुप्रयोगों का पृथक्करण है। आपके कंप्यूटर को बंद करने से उपयोगकर्ता अनुप्रयोगों को रोकने के लिए अलगाव आवश्यक है। यह एक बुरी बात होगी यदि कोई पुराना उपयोगकर्ता प्रोग्राम आपकी हार्ड ड्राइव पर यादृच्छिक डेटा लिखना शुरू कर सकता है या किसी अन्य उपयोगकर्ता प्रोग्राम की मेमोरी स्पेस से मेमोरी पढ़ सकता है।
उपयोगकर्ता अंतरिक्ष कार्यक्रम सीधे सिस्टम संसाधनों तक नहीं पहुंच सकते हैं इसलिए ऑपरेटिंग सिस्टम कर्नेल द्वारा प्रोग्राम की ओर से पहुंच को नियंत्रित किया जाता है। उपयोगकर्ता अंतरिक्ष कार्यक्रम आमतौर पर सिस्टम कॉल के माध्यम से ऑपरेटिंग सिस्टम के ऐसे अनुरोध करते हैं।
कर्नेल धागे, प्रक्रियाएं, स्टैक का मतलब एक ही बात नहीं है। वे कर्नेल स्पेस के लिए उपयोगकर्ता अंतरिक्ष में उनके समकक्षों के समान अनुरूप निर्माण हैं।
प्रत्येक प्रक्रिया की अपनी 4GB वर्चुअल मेमोरी होती है जो पेज टेबल के माध्यम से भौतिक मेमोरी में मैप होती है। वर्चुअल मेमोरी ज्यादातर दो भागों में विभाजित होती है: प्रक्रिया के उपयोग के लिए 3 जीबी और कर्नेल के उपयोग के लिए 1 जीबी। अधिकांश चर जिन्हें आप पता स्थान के पहले भाग में झूठ बनाते हैं। उस हिस्से को यूजर स्पेस कहा जाता है। अंतिम भाग वह है जहां कर्नेल रहता है और सभी प्रक्रियाओं के लिए सामान्य है। इसे कर्नेल स्पेस कहा जाता है और इस स्पेस का अधिकांश भाग भौतिक मेमोरी के शुरुआती स्थानों पर मैप किया जाता है, जहां कर्नेल छवि को बूट समय पर लोड किया जाता है।
पता स्थान का अधिकतम आकार सीपीयू पर पता रजिस्टर की लंबाई पर निर्भर करता है।
32-बिट एड्रेस रजिस्टर वाले सिस्टम पर, एड्रेस स्पेस का अधिकतम आकार 2 32 बाइट्स या 4 GiB है। इसी तरह, 64-बिट सिस्टम पर, 2 64 बाइट्स को संबोधित किया जा सकता है।
ऐसे एड्रेस स्पेस को वर्चुअल मेमोरी या वर्चुअल एड्रेस स्पेस कहा जाता है । यह वास्तव में भौतिक रैम आकार से संबंधित नहीं है।
लिनक्स प्लेटफार्मों पर, वर्चुअल एड्रेस स्पेस कर्नेल स्पेस और यूजर स्पेस में विभाजित होता है।
एक आर्किटेक्चर-विशिष्ट स्थिर जिसे कार्य आकार सीमा कहा जाता है , या TASK_SIZE, उस स्थिति को चिह्नित करता है जहां विभाजन होता है:
पता सीमा 0 से TASK_SIZE-1 तक उपयोगकर्ता स्थान के लिए आवंटित की जाती है;
TASK_SIZE2 से शेष 32 -1 (या 2 64 -1) कर्नेल स्थान के लिए आवंटित किया गया है।
उदाहरण के लिए किसी विशेष 32-बिट सिस्टम पर, 3 गिब को यूजर स्पेस के लिए और कर्नेल स्पेस के लिए 1 GiB पर कब्जा किया जा सकता है।
यूनिक्स-जैसे ऑपरेटिंग सिस्टम में प्रत्येक एप्लिकेशन / प्रोग्राम एक प्रक्रिया है; उनमें से प्रत्येक के पास प्रक्रिया पहचानकर्ता (या बस प्रक्रिया आईडी , यानी पीआईडी) नामक एक विशिष्ट पहचानकर्ता है । लिनक्स एक प्रक्रिया बनाने के लिए दो तंत्र प्रदान करता है: 1. fork()सिस्टम कॉल, या 2. exec()कॉल।
एक कर्नेल थ्रेड एक हल्की प्रक्रिया है और निष्पादन के तहत एक कार्यक्रम भी है। एक ही प्रक्रिया में कई थ्रेड्स समान डेटा और संसाधन साझा कर सकते हैं, लेकिन प्रोग्राम कोड के माध्यम से अलग-अलग पथ ले सकते हैं। लिनक्स clone()थ्रेड उत्पन्न करने के लिए एक सिस्टम कॉल प्रदान करता है ।
कर्नेल थ्रेड्स के उदाहरण उपयोग हैं: RAM का डेटा सिंक्रनाइज़ेशन, शेड्यूलर को CPU, आदि के बीच प्रक्रियाओं को वितरित करने में मदद करता है।
संक्षेप में: कर्नेल अंतरिक्ष में चलता है, कर्नेल स्थान की सभी मेमोरी और संसाधनों तक पूरी पहुंच है, आप कह सकते हैं कि मेमोरी दो भागों में विभाजित होती है, कर्नेल के लिए भाग, और उपयोगकर्ता स्वयं की प्रक्रिया के लिए भाग, (उपयोगकर्ता स्थान) सामान्य प्रोग्राम चलाता है, उपयोगकर्ता अंतरिक्ष सीधे कर्नेल अंतरिक्ष तक नहीं पहुंच सकता है इसलिए यह कर्नेल से संसाधनों का उपयोग करने का अनुरोध करता है। syscall द्वारा (ग्लिफ़क में पूर्वनिर्धारित सिस्टम कॉल)
एक कथन है जो विभिन्न को सरल करता है " उपयोगकर्ता स्थान कर्नेल के लिए सिर्फ एक परीक्षण भार है ..."
बहुत स्पष्ट होने के लिए: प्रोसेसर आर्किटेक्चर सीपीयू को दो मोड, कर्नेल मोड और उपयोगकर्ता मोड में संचालित करने की अनुमति देता है हार्डवेयर निर्देश एक मोड से दूसरे मोड पर स्विच करने की अनुमति देता है।
मेमोरी को यूजर स्पेस या कर्नेल स्पेस का हिस्सा होने के रूप में चिह्नित किया जा सकता है।
जब उपयोगकर्ता मोड में चल रहा है, तो सीपीयू केवल उस मेमोरी को एक्सेस कर सकता है जो यूजर स्पेस में हो रही है, जबकि सीपीयू कर्नेल स्पेस में मेमोरी को एक्सेस करने का प्रयास करता है, परिणाम "हार्डवेयर अपवाद" होता है, जब सीपीयू कर्नेल मोड में चल रहा होता है, तो सीपीयू सीधे एक्सेस कर सकता है। कर्नेल स्पेस और यूजर स्पेस दोनों के लिए ...
कर्नेल स्पेस का मतलब है कि मेमोरी स्पेस केवल कर्नेल द्वारा स्पर्श किया जा सकता है। 32 बिट लाइनक्स पर यह 1G है (0xC0000000 से 0xffffff को वर्चुअल मेमोरी एड्रेस के रूप में)। कर्नेल द्वारा बनाई गई हर प्रक्रिया भी एक कर्नेल थ्रेड है, इसलिए एक प्रक्रिया के लिए, दो स्टैक होते हैं: इस प्रक्रिया के लिए यूजर स्पेस में एक स्टैक और दूसरा कर्नेल में। कर्नेल थ्रेड के लिए स्थान।
कर्नेल स्टैक 2 पृष्ठों (32 बिट लिनक्स में 8k) पर कब्जा कर लिया, एक टास्क_स्ट्रक (लगभग 1k) और असली स्टैक (लगभग 7k) शामिल हैं। उत्तरार्द्ध का उपयोग कुछ ऑटो चर या फ़ंक्शन कॉल पार्म्स या फ़ंक्शन एड्रेस को कर्नेल फ़ंक्शन में संग्रहीत करने के लिए किया जाता है। यहाँ कोड है (Processor.h (linux \ शामिल \ asm-i386)):
#define THREAD_SIZE (2*PAGE_SIZE)
#define alloc_task_struct() ((struct task_struct *) __get_free_pages(GFP_KERNEL,1))
#define free_task_struct(p) free_pages((unsigned long) (p), 1)
__get_free_pages (GFP_KERNEL, 1) का अर्थ है कि मेमोरी को 2 ^ 1 = 2 पृष्ठों के रूप में आवंटित करें।
लेकिन प्रक्रिया स्टैक एक और बात है, इसका पता सिर्फ bellow 0xC0000000 (32bit linux) है, इसका आकार काफी बड़ा हो सकता है, जिसका उपयोग उपयोगकर्ता अंतरिक्ष फ़ंक्शन कॉल के लिए कर सकता है।
तो यहाँ एक सवाल सिस्टम कॉल के लिए आया है, यह कर्नेल स्पेस में चल रहा है, लेकिन यूजर स्पेस में प्रक्रिया द्वारा बुलाया गया था, यह कैसे काम करता है? क्या linux कर्नेल स्टैक या प्रोसेस स्टैक में इसके परिम और फ़ंक्शन एड्रेस डाल देगा? लिनक्स का समाधान: सभी सिस्टम कॉल को सॉफ्टवेयर अवरोध INT 0x80 द्वारा ट्रिगर किया जाता है। प्रविष्टि में परिभाषित किया गया है। (linux \ arch \ i386 \ कर्नेल), यहाँ उदाहरण के लिए कुछ पंक्तियाँ हैं:
ENTRY(sys_call_table)
.long SYMBOL_NAME(sys_ni_syscall) /* 0 - old "setup()" system call*/
.long SYMBOL_NAME(sys_exit)
.long SYMBOL_NAME(sys_fork)
.long SYMBOL_NAME(sys_read)
.long SYMBOL_NAME(sys_write)
.long SYMBOL_NAME(sys_open) /* 5 */
.long SYMBOL_NAME(sys_close)
सुनील यादव द्वारा , क्वोरा पर:
लिनक्स कर्नेल उन सभी चीजों को संदर्भित करता है जो कर्नेल मोड में चलती हैं और कई अलग-अलग परतों से बनी होती हैं। सबसे कम परत पर, कर्नेल HAL के माध्यम से हार्डवेयर के साथ इंटरैक्ट करता है। मध्य स्तर पर, UNIX कर्नेल को 4 अलग-अलग क्षेत्रों में विभाजित किया गया है। चार क्षेत्रों में से पहला चरित्र उपकरणों, कच्चे और पका हुआ TTY और टर्मिनल हैंडलिंग को संभालता है। दूसरा क्षेत्र नेटवर्क डिवाइस ड्राइवर, राउटिंग प्रोटोकॉल और सॉकेट को संभालता है। तीसरा क्षेत्र डिस्क डिवाइस ड्राइवर, पेज और बफर कैश, फाइल सिस्टम, वर्चुअल मेमोरी, फाइल नेमिंग और मैपिंग को हैंडल करता है। चौथा और आखिरी क्षेत्र प्रेषण प्रक्रिया, शेड्यूलिंग, निर्माण और समाप्ति के साथ-साथ सिग्नल हैंडलिंग को संभालता है। इन सबसे ऊपर हमारे पास कर्नेल की शीर्ष परत है जिसमें सिस्टम कॉल, इंटरप्ट और ट्रैप शामिल हैं। यह स्तर निचले स्तर के प्रत्येक फ़ंक्शन के लिए इंटरफ़ेस के रूप में कार्य करता है। एक प्रोग्रामर विभिन्न सिस्टम कॉल का उपयोग करता है और ऑपरेटिंग सिस्टम की सुविधाओं के साथ बातचीत करने के लिए बाधित करता है।
शॉर्ट कर्नेल स्पेस में मेमोरी का वह भाग होता है जहाँ लिनक्स कर्नेल चलता है (लिनक्स के मामले में शीर्ष 1 जीबी वर्चुअल स्पेस) और यूज़र स्पेस मेमोरी का वह भाग होता है जहाँ यूज़र एप्लीकेशन चलता है (लिनक्स के मामले में 3 जीबी वर्चुअल मेमोरी के नीचे) यदि आप अधिक नीचे दिए गए लिंक को देखना चाहते हैं :)
http://learnlinuxconcepts.blogspot.in/2014/02/kernel-space-and-user-space.html
बहुत सरलीकृत स्पष्टीकरण देने की कोशिश की जा रही है
वर्चुअल मेमोरी को कर्नेल स्पेस और यूजर स्पेस में विभाजित किया गया है। कर्नेल स्थान वर्चुअल मेमोरी का वह क्षेत्र है जहाँ कर्नेल प्रक्रियाएँ चलेंगी और उपयोगकर्ता स्थान वर्चुअल मेमोरी का वह क्षेत्र होगा जहाँ उपयोगकर्ता प्रक्रियाएँ चल रही होंगी।
मेमोरी एक्सेस प्रोटेक्शन के लिए यह विभाजन आवश्यक है।
जब भी बूटलोडर रैम में किसी लोकेशन पर लोड करने के बाद कर्नेल शुरू करता है, (एआरएम आधारित कंट्रोलर पर आमतौर पर) तो यह सुनिश्चित करने की जरूरत होती है कि कंट्रोलर FIQ और IRQ के डिसेबल के साथ सुपरवाइजर मोड में है।
कर्नेल स्पेस और यूजर स्पेस लॉजिकल स्पेस हैं।
अधिकांश आधुनिक प्रोसेसर विभिन्न विशेषाधिकार प्राप्त मोड में चलाने के लिए डिज़ाइन किए गए हैं। x86 मशीनें 4 अलग-अलग विशेषाधिकार प्राप्त मोड में चल सकती हैं।
और एक विशेष मशीन अनुदेश को निष्पादित किया जा सकता है जब / विशेष विशेषाधिकार मोड के ऊपर।
इस डिज़ाइन की वजह से आप सिस्टम को सुरक्षा दे रहे हैं या निष्पादन वातावरण को सैंड-बॉक्सिंग कर रहे हैं।
कर्नेल कोड का एक टुकड़ा है, जो आपके हार्डवेयर का प्रबंधन करता है और सिस्टम को अमूर्त प्रदान करता है। तो यह सभी मशीन अनुदेश के लिए उपयोग करने की आवश्यकता है। और यह सॉफ्टवेयर का सबसे भरोसेमंद टुकड़ा है। इसलिए मुझे उच्चतम विशेषाधिकार के साथ निष्पादित किया जाना चाहिए। और रिंग स्तर 0 सबसे विशेषाधिकार प्राप्त मोड है। इसलिए रिंग लेवल 0 को कर्नेल मोड भी कहा जाता है ।
उपयोगकर्ता अनुप्रयोग सॉफ्टवेयर का एक टुकड़ा है जो किसी भी तीसरे पक्ष के विक्रेता से आता है, और आप पूरी तरह से उन पर भरोसा नहीं कर सकते हैं। दुर्भावनापूर्ण इरादे वाला कोई व्यक्ति आपके सिस्टम को क्रैश करने के लिए एक कोड लिख सकता है यदि उसके पास सभी मशीन निर्देश तक पूरी पहुंच थी। इसलिए निर्देशों के सीमित सेट तक पहुंच के साथ आवेदन प्रदान किया जाना चाहिए। और रिंग लेवल 3 सबसे कम विशेषाधिकार वाला मोड है। तो आपका सारा एप्लीकेशन उस मोड में चलता है। इसलिए उस Ring Level 3 को User Mode भी कहा जाता है ।
नोट: मुझे रिंग लेवल 1 और 2 नहीं मिल रहे हैं। वे मूल रूप से मध्यवर्ती विशेषाधिकार वाले मोड हैं। तो हो सकता है डिवाइस ड्राइवर कोड को इस विशेषाधिकार के साथ निष्पादित किया जाए। AFAIK, लाइनक्स केवल कर्नेल कोड निष्पादन और उपयोगकर्ता अनुप्रयोग के लिए क्रमशः रिंग स्तर 0 और 3 का उपयोग करता है।
तो कर्नेल मोड में होने वाले किसी भी ऑपरेशन को कर्नेल स्पेस माना जा सकता है। और यूजर मोड में होने वाले किसी भी ऑपरेशन को यूजर स्पेस माना जा सकता है।
सही उत्तर है: कर्नेल स्पेस और यूजर स्पेस जैसी कोई चीज नहीं है। प्रोसेसर इंस्ट्रक्शन सेट में विनाशकारी चीजों को सेट करने की विशेष अनुमति होती है जैसे पेज टेबल मैप की जड़, या हार्डवेयर डिवाइस मेमोरी को एक्सेस करना आदि।
कर्नेल कोड में उच्चतम स्तर के विशेषाधिकार हैं, और उपयोगकर्ता कोड सबसे कम है। यह उपयोगकर्ता कोड को सिस्टम को क्रैश करने, अन्य कार्यक्रमों को संशोधित करने आदि से रोकता है।
आम तौर पर कर्नेल कोड को उपयोगकर्ता कोड की तुलना में एक अलग मेमोरी मैप के तहत रखा जाता है (जिस तरह यूजर स्पेस को एक दूसरे से अलग मेमोरी मैप में रखा जाता है)। यह वह जगह है जहां "कर्नेल स्पेस" और "यूजर स्पेस" शब्द आते हैं। लेकिन यह एक कठिन और तेज़ नियम नहीं है। उदाहरण के लिए, x86 के बाद से अप्रत्यक्ष रूप से इसके अवरोध / जाल संचालकों को हर समय मैप करने की आवश्यकता होती है, कर्नेल के भाग (या कुछ OSes) को उपयोगकर्ता स्थान में मैप किया जाना चाहिए। फिर, इसका मतलब यह नहीं है कि इस तरह के कोड में उपयोगकर्ता विशेषाधिकार हैं।
कर्नेल / उपयोगकर्ता को क्यों विभाजित करना आवश्यक है? कुछ डिजाइनर असहमत हैं कि यह वास्तव में आवश्यक है। माइक्रोकर्नल आर्किटेक्चर इस विचार पर आधारित है कि कोड के उच्चतम विशेषाधिकार वाले अनुभाग उपयोगकर्ता विशेषाधिकार कोड में किए गए सभी महत्वपूर्ण कार्यों के साथ यथासंभव छोटे होने चाहिए। आपको यह अध्ययन करने की आवश्यकता होगी कि यह एक अच्छा विचार क्यों हो सकता है, यह एक सरल अवधारणा नहीं है (और फायदे और कमियां दोनों के लिए प्रसिद्ध है)।
मेमोरी दो अलग-अलग क्षेत्रों में विभाजित है:
उपयोगकर्ता स्थान के अंतर्गत चलने वाली प्रक्रियाओं में मेमोरी के सीमित हिस्से तक ही पहुँच होती है, जबकि कर्नेल में मेमोरी की सभी तक पहुँच होती है। उपयोगकर्ता स्थान में चल रही प्रक्रियाओं में भी कर्नेल स्थान तक पहुँच नहीं है। उपयोगकर्ता अंतरिक्ष प्रक्रियाएं कर्नेल द्वारा उजागर किए गए इंटरफ़ेस के माध्यम से कर्नेल के एक छोटे से हिस्से तक पहुंच सकती हैं - सिस्टम कॉल करता है। यदि कोई प्रक्रिया एक सिस्टम कॉल करती है, तो एक सॉफ्टवेयर बाधा कर्नेल को भेजी जाती है, जो तब उचित बाधित हैंडलर को भेजती है और जारी रखती है हैंडलर समाप्त होने के बाद इसका काम।
लिनक्स में दो स्पेस हैं 1 यूजर स्पेस है और दूसरा एक कर्नेल स्पेस है। उपयोगकर्ता स्थान में केवल उपयोगकर्ता अनुप्रयोग शामिल है जिसे आप चलाना चाहते हैं। kernal सेवा के रूप में प्रक्रिया प्रबंधन, फ़ाइल प्रबंधन, सिग्नल हैंडलिंग, मेमोरी प्रबंधन, थ्रेड प्रबंधन, और इतनी सारी सेवाएं मौजूद हैं। अगर यू एप्लिकेशन को उपयोगकर्ता स्थान से चलाता है जो केवल कर्नेल सेवा के साथ तालमेल करता है। और यह सेवा डिवाइस ड्राइवर के साथ बातचीत करती है जो हार्डवेयर और कर्नेल के बीच मौजूद है। कर्नेल स्पेस और यूजर स्पेस सेपरेशन का मुख्य लाभ यह है कि हम वायरस से सुरक्षा को सुरक्षित कर सकते हैं। यूजर स्पेस में मौजूद सभी यूजर एप्लीकेशन के सेबेज और सर्विस स्पेस में मौजूद है। क्यों लिनक्स से t, वायरस से प्रभावित नहीं होता है।