एक अखंड यूनिक्स जैसा ओएस विकसित करना - सी लाइब्रेरी (2)

पिछले लेख में, हमने सीखा कि हैलो वर्ल्ड कर्नेल को कैसे चलाना है और तार के साथ काम करने के लिए कुछ फ़ंक्शन लिखे। अब सी लाइब्रेरी का विस्तार करने का समय है, ताकि आप kprintf और अन्य आवश्यक कार्यों को लागू कर सकें। चलो चलते हैं!

सामग्री की तालिका

1. बिल्ड सिस्टम (मेक, जीसीसी, गैस)। प्रारंभिक बूट (मल्टीबूट)। लॉन्च (qemu)। सी लाइब्रेरी (strcpy, memcpy, strext)।
2. सी लाइब्रेरी (स्प्रिंटफ, स्ट्रैची, स्ट्रैम्प, स्ट्रेटोक, वा_लिस्ट ...)। लाइब्रेरी को कर्नेल मोड और उपयोगकर्ता एप्लिकेशन मोड में बनाना।
3. कर्नेल सिस्टम लॉग। वीडियो मेमोरी टर्मिनल का आउटपुट (kprintf, kpanic, kassert)।
4. डायनेमिक मेमोरी, हीप (kmalloc, kfree)।
5. मेमोरी और इंटरप्ट हैंडलिंग (GDT, IDT, PIC, syscall) का संगठन। अपवाद।
6. वर्चुअल मेमोरी (पेज डायरेक्टरी और पेज टेबल)।
7. प्रक्रिया। समयबद्धक। मल्टीटास्किंग। सिस्टम कॉल (मार, निकास, पीएस)।
8. कर्नेल की फ़ाइल प्रणाली (initrd), योगिनी, और इसके आंतरिक। सिस्टम कॉल (निष्पादन)।
9. चरित्र डिवाइस ड्राइवर। सिस्टम कॉल (ioctl, fopen, fread, fwrite)। सी लाइब्रेरी (fopen, fclose, fprintf, fscanf)।
10. कर्नेल के लिए एक पूर्ण कार्यक्रम के रूप में शेल।
11. उपयोगकर्ता सुरक्षा मोड (रिंग 3)। टास्क स्टेटस सेगमेंट (tss)।

लाइब्रेरी सी

पहले आपको स्पष्ट आयामों के साथ प्रकारों को लागू करने की आवश्यकता है।

चूंकि हम एक मंच के नीचे एकत्र करेंगे, जब तक कि हमारी परिभाषाएं और कार्यान्वयन सही नहीं हैं। यह सार्वभौमिक नहीं है, लेकिन यही कारण है कि यह पठनीय और सरल है। मैं दृष्टिकोण लेता हूं कि कभी-कभी कुछ ऐसा करना बेहतर होता है जो सार्वभौमिक नहीं है, लेकिन यह वर्तमान आवश्यकताओं को पूरा करता है, क्योंकि सार्वभौमिक समाधान का समर्थन करना बहुत मुश्किल है।

typedef unsigned char u8; typedef unsigned short u16; typedef unsigned int u32; typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned int u_int; typedef unsigned int u_long; 

यह बूलियन प्रकार को पेश करने के लिए चोट नहीं करता है।

 #pragma once /* types */ typedef int bool; #define true 1 #define false 0 #define null 0 

इसके अलावा, बाइट्स के साथ काम करने के लिए मैक्रोज़ के एक जोड़े को हमें चोट नहीं पहुंचेगी।

 typedef unsigned long size_t; #define HIGH_WORD(addr) ((addr & 0xffff0000) >> 16) #define LOW_WORD(addr) ((addr & 0xffff)) #define LOW_BYTE(addr) ((addr & 0x00ff)) #define HIGH_BYTE(addr) ((addr & 0xff00) >> 8) 

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

 typedef size_t* va_list; #define va_start(l, a) (l = (void*)((size_t)&a) + sizeof(a)) #define va_end(l) (l = (void*)0) #define va_arg(l, s) (*(s*)(l++)) 

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

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

 extern int strlen(const char* s); extern char* strcpy(char* s1, const char* s2); extern char* strncpy(char* s1, const char* s2, u_int n); extern void* memcpy(void* buf1, const void* buf2, u_int bytes); extern void* memset(void* buf1, u8 value, u_int bytes); extern int strcmp(const char* s1, const char* s2); extern int strncmp(const char* s1, const char* s2, u_int n); extern char* strcat(char* s1, const char* s2); extern char* strext(char* buf, const char* str, char sym); extern int strspn(char* str, const char* accept); extern int strcspn(char* str, const char* rejected); char* strchr(const char* str, char ch); extern char* strtok_r(char* str, const char* delims, char** save_ptr); extern char* memext(void* buff_dst, u_int n, const void* buff_src, char sym); extern char* itoa(unsigned int value, char* str, unsigned int base); extern unsigned int atou(char* str); extern char* strinv(char* str); extern unsigned int sprintf(char* s1, const char* s2, ...); extern unsigned int snprintf(char* s1, u_int n, const char* s2, ...); extern unsigned int vsprintf(char* s1, const char* s2, va_list list); extern unsigned int vsnprintf(char* s1, unsigned int n, const char* s2, va_list list); 

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

संदर्भ

एक अखंड यूनिक्स जैसा ओएस विकसित करना - शुरुआत करना
इस लेख के लिए वीडियो ट्यूटोरियल
स्रोत कोड (आपको एक पाठ 2 शाखा की आवश्यकता है)

संदर्भ

1. जेम्स मोलॉय। अपना खुद का खिलौना यूनिक्स-क्लोन ओएस रोल करें।
2. जुबकोव। डॉस, विंडोज, यूनिक्स के लिए असेंबलर
3. कलाश्निकोव। असेंबलर आसान है!
4. Tanenbaum। ऑपरेटिंग सिस्टम। कार्यान्वयन और विकास।
5. रॉबर्ट लव। लिनक्स कर्नेल विकास प्रक्रिया का विवरण।