हम L4 माइक्रोकर्नल का अध्ययन करते हैं और Xameleon सिस्टम के लिए "हैलो वर्ल्ड" एप्लीकेशन लिखते हैं

यदि आपने कभी सी भाषा का अध्ययन किया है या एक नए विकास के माहौल में आया है, तो आपने शायद कम से कम एक बार "हैलो वर्ल्ड" प्रदर्शित करने वाले सरल एप्लिकेशन को लिखा है। तो, सी भाषा में संभव विकल्पों में से एक:

#include <stdio.h>
int main(int argc, char * argv[], char * envp[])
{
puts("Hello world!");
return 0;
}

हम इस कोड को "hello.c" फ़ाइल में सहेजेंगे और gcc संकलक का उपयोग करके हम निम्नलिखित फ़ाइल का उपयोग करके निष्पादन योग्य फ़ाइल का निर्माण करेंगे:
gcc hello.c -o hello

नतीजतन, यदि कंपाइलर, हेडर फाइलें और लाइब्रेरी आपके सिस्टम पर स्थापित हैं, तो हमें हैलो निष्पादन योग्य मिलता है। चलो इसे निष्पादित करें:
./hello

प्राथमिक? जब तक आप इस एप्लिकेशन को बनाने और चलाने का निर्णय नहीं लेते हैं, उदाहरण के लिए, अपने स्वयं के लिखित ऑपरेटिंग सिस्टम के नियंत्रण में। आगे, मैं इस प्रक्रिया और शर्त के बारे में विस्तार से बात करूंगा कि हर किसी को लेख को अंत तक पढ़ने की ताकत नहीं मिलेगी।

पहला, थोड़ा सिद्धांत और सरल चीजें। आइए एक निष्पादन योग्य नहीं, बल्कि एक ऑब्जेक्ट फ़ाइल इकट्ठा करने का प्रयास करें। ऐसा करने के लिए, हमें निम्नलिखित कमांड की आवश्यकता है:
gcc -c hello.c
परिणामस्वरूप, हमें hello.o ऑब्जेक्ट फ़ाइल मिलती है। ऑब्जेक्ट फ़ाइलों के लिए विशिष्ट क्या है? उनका कोड समान रूप से स्वतंत्र है, ऑब्जेक्ट फ़ाइलों में आयातित और निर्यात किए गए फ़ंक्शंस और चर के टेबल होते हैं, और, हमारे लिए अधिक दिलचस्प है, कोड सॉफ़्टवेयर प्लेटफ़ॉर्म पर बहुत निर्भर नहीं है, लेकिन प्रोसेसर आर्किटेक्चर से बंधा है। यह क्यों महत्वपूर्ण है, मैं आपको बाद में बताऊंगा, और अब निम्नलिखित कमांड का उपयोग करके ऑब्जेक्ट फ़ाइल की सामग्री पर करीब से नज़र डालें:
objdump -hxS hello.o

ऑब्जेक्ट फ़ाइल हैडर
hello.o: file format elf32-i386
hello.o
architecture: i386, flags 0x00000011:
HAS_RELOC, HAS_SYMS
start address 0x00000000

प्रयुक्त अनुभाग और उनके आकार
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 0000002e 00000000 00000000 00000034 2**2
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
1 .data 00000000 00000000 00000000 00000064 2**2
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000000 00000000 00000000 00000064 2**2
ALLOC
3 .rodata 0000000d 00000000 00000000 00000064 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .comment 00000012 00000000 00000000 00000071 2**0
CONTENTS, READONLY
5 .note.GNU-stack 00000000 00000000 00000000 00000083 2**0
CONTENTS, READONLY

.Text सेक्शन में हैलो मुख्य फ़ंक्शन का कोड कोड है। जैसा कि आप उदाहरण से देख सकते हैं, प्रोग्राम कोड का आकार 46 बाइट्स (0x24) है तिथि खंड खाली है, क्योंकि हमारा उदाहरण स्थिर और वैश्विक चर का उपयोग नहीं करता है जो इस खंड में संग्रहीत होंगे। अंत में, 13-बाइट (0xd) .रोडाटा अनुभाग में स्ट्रिंग "हैलो वर्ल्ड!" है।

निर्यात और आयातित वस्तुओं की तालिका
SYMBOL TABLE:
00000000 l df *ABS* 00000000 hello.c
00000000 ld .text 00000000 .text
00000000 ld .data 00000000 .data
00000000 ld .bss 00000000 .bss
00000000 ld .rodata 00000000 .rodata
00000000 ld .note.GNU-stack 00000000 .note.GNU-stack
00000000 ld .comment 00000000 .comment
00000000 g F .text 0000002e main
00000000 *UND* 00000000 puts

इस तालिका में, हम अंतिम दो पंक्तियों में रुचि रखते हैं - मुख्य फ़ंक्शन का वर्णन, जो हमारे सबसे सरल कार्यक्रम में परिभाषित किया गया है, और बाहरी पुट फ़ंक्शन का वर्णन, जिसे कहीं और परिभाषित किया गया है।
सिद्धांत रूप में, यदि आप लिनक्स के तहत इस उदाहरण को संकलित करते हैं, और परिणामस्वरूप स्रोत फ़ाइल FreeBSD के तहत जुड़ा हुआ है, तो सबसे अधिक संभावना है कि यह समस्याओं के बिना काम करेगा। सत्य और इसके विपरीत। अब हमारे प्रोग्राम के कोड कोड को देखें hello.c

खंड की समाप्ति

00000000 <main>:
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 51 push %ecx
e: 83 ec 04 sub $0x4,%esp
11: 83 ec 0c sub $0xc,%esp
14: 68 00 00 00 00 push $0x0
15: R_386_32 .rodata
19: e8 fc ff ff ff call 1a <main+0x1a>
1a: R_386_PC32 puts
1e: 83 c4 10 add $0x10,%esp
21: b8 00 00 00 00 mov $0x0,%eax
26: 8b 4d fc mov -0x4(%ebp),%ecx
29: c9 leave
2a: 8d 61 fc lea -0x4(%ecx),%esp
2d: c3 ret

* This source code was highlighted with Source Code Highlighter .

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

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

हमारे उदाहरण में, stdio.h शीर्ष लेख फ़ाइल में परिभाषित पुट फ़ंक्शन का उपयोग किया जाता है। पुट्स फ़ंक्शन क्या है? यह एक फ़ंक्शन है जो एक लाइन और एक मानक फ़ीड को एक आउटपुट इनपुट / आउटपुट स्ट्रीम के लिए आउटपुट करता है।
उदाहरण के लिए, पुट फ़ंक्शन को इस तरह लिखा जा सकता है:

int puts(char * str)
{
int status, len;

len = strlen(str); //
status = write( 1, str, len ); //
if( status == len ) status = write( 1, "\n", 1 ); // ,
if( status ==1 ) status += len;
return status;
}

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

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);

हमारा उदाहरण डिस्क्रिप्टर नंबर 1 को लिखने के लिए लिखता है, जो मानक से मानक आउटपुट स्ट्रीम के लिए डिस्क्रिप्टर से ज्यादा कुछ नहीं है। Bf पैरामीटर आउटपुट के लिए डेटा वाले मेमोरी के क्षेत्र के लिए एक संकेतक है (हां, स्ट्रिंग "हैलो वर्ल्ड") का पता होगा। तीसरा पैरामीटर आउटपुट डेटा का आकार है।

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

इसलिए, हम समझते हैं कि लाइब्रेरी फ़ंक्शन राइटिंग ऑपरेटिंग सिस्टम के कर्नेल को संदर्भित करता है, इसलिए हमें यह समझने की आवश्यकता है कि यह कैसे होता है। चूंकि गिरगिट प्रणाली को L4 पिस्ता माइक्रोक्राइन के शीर्ष पर लागू किया जाता है, सिस्टम कॉल दो चरणों के साथ एक IPC है:

1. ट्रांसफर चरण - फ़ाइल सिस्टम सेवा में ट्रांसफर होता है जो राइट फ़ंक्शन, फ़ाइल डिस्क्रिप्टर और एल 4 लाइन - एक डेटा प्रकार है जो मेमोरी क्षेत्र का वर्णन करता है।
2. रिसेप्शन चरण - फ़ाइल सिस्टम सेवा से ऑपरेशन की स्थिति प्राप्त करता है।

गिरगिट प्रलेखन में, लेखन प्रणाली कॉल इस प्रकार वर्णित है।

इस तरह, POSIX सिस्टम IPC को कॉल ट्रांसलेट लिखता है, जैसा कि ऊपर दिए गए चित्र में दिखाया गया है।

लाइब्रेरी फ़ंक्शन लिखने का स्रोत कोड, जो एक तरफ, POSIX राइट () प्रदान करता है, दूसरी ओर, ऑपरेटिंग सिस्टम के कर्नेल के साथ सहभागिता प्रदान करता है:

ssize_t write(
int nFileDescriptor,
const void * pBuffer,
size_t nBytesWrite )
{
int nStatus;
int nChunk;
int nTotalSent;
char * pPointer;

L4_MsgTag_t tag;
L4_Msg_t msg;
L4_StringItem_t SendString;

nStatus = nTotalSent = 0;
pPointer = ( char *) pBuffer;

while ( nBytesWrite )
{
nChunk = (nBytesWrite > 4096) ? 4096 : nBytesWrite;
SendString = L4_StringItem ( nChunk, ( void *) pPointer );

L4_Clear( &msg );
L4_Set_Label( &msg, fsWriteFile );
L4_Append( &msg, nFileDescriptor );
L4_Append( &msg, &SendString );
L4_Load( &msg );
tag = L4_Call( fs_service_id );
if ( L4_IpcFailed(tag) )
{
nStatus = nTotalSent ? nTotalSent : XAM_EINTR;
break ;
}
else
{
L4_Store( tag, &msg );
nStatus = L4_Get( &msg, 0 );
if ( nStatus < 0 ) break;
nTotalSent += nStatus;
}

pPointer += nChunk;
nBytesWrite -= nChunk;
}

// POSIX workaround
if ( nStatus < 0 )
{
errno = nStatus;
nStatus = -1;
}
else
{
nStatus = nTotalSent;
}

return nStatus;
}

* This source code was highlighted with Source Code Highlighter .

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

• L4_MsgTag_t - संदेश टैग।
• L4_Msg_t - एक संरचना जो संदेश डेटा ले जाती है।
• L4_StringItem_t - लाइन L4

इन संरचनाओं को संदेश में निर्दिष्ट किया गया है। हेडर फ़ाइल, L4 पिस्ता माइक्रो-कर्नेल।

निम्न कोड फ़ाइल सिस्टम सेवा में संचरण के लिए एक संदेश तैयार करता है:
SendString = L4_StringItem ( nChunk, (void*) pPointer ); //
L4_Clear( &msg ); //
L4_Set_Label( &msg, fsWriteFile ); //
L4_Append( &msg, nFileDescriptor ); //
L4_Append( &msg, &SendString ); //
L4_Load( &msg ); //


इसके बाद माइक्रोकर्नल सिस्टम कॉल आता है, जो वास्तव में, इंटर प्रोसेस कम्युनिकेशन प्रदान करता है

tag = L4_Call( fs_service_id );

जहाँ fs_service_id L4_ThreadId_t प्रकार का एक चर है, जिसमें फ़ाइल सिस्टम सेवा के पहचानकर्ता होते हैं। इसे कैसे प्राप्त करें, मैं आपको नीचे बताऊंगा, जब हम सीआरटी (सी रनटाइम कोड) के जादू की ओर बढ़ते हैं। अब उस कोड को देखते हैं जो फाइल सिस्टम सेवा से प्रतिक्रिया का विश्लेषण करता है:

if ( L4_IpcFailed(tag) )
{
nStatus = nTotalSent ? nTotalSent : XAM_EINTR;
break;
}
else
{
L4_Store( tag, &msg );
nStatus = L4_Get( &msg, 0 );
if( nStatus < 0 ) break;
nTotalSent += nStatus;
}


यदि IPC टूट गया है, तो जांचें कि क्या डेटा पिछले पुनरावृत्ति पर स्थानांतरित किया गया था और संबंधित रिटर्न कोड उत्पन्न करता है। अगर IPC सही तरीके से पूरा होता है, तो हम रिटर्न कोड को प्रोसेस करते हैं।
L4_ उपसर्ग के साथ उपयोग किए जाने वाले कार्यों के कार्यों का विवरण L4 पिस्ता माइक्रो-कर्नेल की हेडर फ़ाइलों में देखा जा सकता है।

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

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

static const char szServiceName[3] = "fs" ; //

L4_ThreadId_t fs_service_id = L4_nilthread;

extern "C" int xam_filesystem_init( void )
{
fs_service_id = GetDeviceHandle(szServiceName);
return L4_IsNilThread(fs_service_id) ? XAM_ENODEV : 0;
}


* This source code was highlighted with Source Code Highlighter .

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

extern L4_ThreadId_t rootserver_id; // Supervisor'

L4_ThreadId_t GetDeviceHandle( const char * szDeviceName)
{
L4_MsgTag_t tag;
L4_Msg_t msg;
L4_ThreadId_t Handle;

Handle = L4_nilthread;

do {

L4_Clear(&msg);
L4_Set_Label(&msg, cmdGetDeviceHandle );
L4_Append(&msg, L4_StringItem( 1+strlen(szDeviceName), ( void *) szDeviceName) );
L4_Load(&msg);
tag = L4_Call( rootserver_id );
if ( L4_IpcFailed(tag) ) break ;
L4_Store( tag, &msg );
Handle.raw = L4_Get(&msg, 1);

} while ( false );

return Handle;
}

* This source code was highlighted with Source Code Highlighter .

आप पिछले उदाहरण के साथ एक सादृश्य आकर्षित कर सकते हैं, लेकिन अभी भी एक अंतर है - यह चर rootserver_id है, जिसमें पर्यवेक्षक की पहचान होती है। चूंकि कार्यों xam_filesystem_init और GetDeviceHandle को CRT से कॉल किया जाता है, इसलिए लाइब्रेरी के आरंभ होने से पहले पर्यवेक्षक पहचानकर्ता को प्राप्त करना होगा।

एक आवेदन पर्यवेक्षक आईडी कैसे प्राप्त कर सकता है? हम बायटेक्स के बहुत करीब आ गए हैं, तो आइए कर्नेल इंटरफ़ेस पेज (KIP) नामक डेटा संरचना को देखें। यह संरचना L4 पिस्ता माइक्रोड्राफ्ट विनिर्देश में वर्णित है और इस प्रकार है:


चूंकि पर्यवेक्षक माइक्रोकर्नल के दृष्टिकोण से पहली उपयोगकर्ता प्रक्रिया है, इसलिए इसके पहचानकर्ता को KIP से थ्रेडइन्फो फ़ील्ड के आधार पर प्राप्त किया जा सकता है। केआईपी की ख़ासियत यह है कि माइक्रोकर्नल इस पृष्ठ को एक ही प्रतिलिपि में रखता है, लेकिन इसे प्रत्येक प्रक्रिया के पते स्थान पर मैप करता है। KIP पता पाने के लिए, इस प्रक्रिया को कमांड के निम्नलिखित क्रम को चलाना होगा:

lock; nop
mov %eax, kip


असेंबलर लॉक और एनओपी कमांड का अनुक्रम एक अपवाद को बढ़ाएगा जो अपवाद से लौटने से पहले ईएएक्स रजिस्टर में माइक्रो कर्नेल को पकड़ लेगा और कर्नेल इंटरफ़ेस पृष्ठ पते को प्रतिस्थापित कर देगा।

अंत में, अंतिम स्पर्श कर्नेल इंटरफ़ेस पृष्ठ से प्राप्त आंकड़ों के आधार पर पर्यवेक्षक सेवारत धारा के पहचानकर्ता को ढूंढ रहा है।

mov kip, %eax
movw 198(%eax), %ax
shrw $4, %ax
movzwl %ax, %eax
addl $2, %eax
sall $14, %eax
orl $1, %eax
movl %eax, rootserver_id



इस प्रकार, प्रोग्राम शुरू करने के समय CRT0 मॉड्यूल लाइब्रेरी फ़ंक्शंस को आरंभ करता है जो गिरगिट प्रणाली की विभिन्न सेवाओं के साथ विनिमय करता है।

प्रिय पाठकों, यह मेरे लिए बहुत आश्चर्य की बात है कि आपको एक सपना नहीं मिला, कि आपने ब्राउज़र विंडो को बंद नहीं किया और इस जगह पर पढ़ने की ताकत मिली। आपको शायद Xameleon सिस्टम डेवलपर टूलकिट के नवीनतम संस्करण को "स्पर्श" करने में रुचि होगी।

आपका ध्यान देने के लिए धन्यवाद।