यूनिक्स जैसा ओएस विकास - चरित्र डिवाइस ड्राइवर (8)

पिछले लेख में, हमने मल्टीटास्किंग की शुरुआत की थी। आज चरित्र डिवाइस ड्राइवरों के विषय पर विचार करने का समय है।

विशेष रूप से, आज हम एक टर्मिनल ड्राइवर लिखेंगे, जो व्यवधानों के स्थगित प्रसंस्करण के लिए एक तंत्र है, और इंटरप्ट के ऊपरी और निचले हिस्सों के लिए हैंडलर के विषय पर विचार करें।

हम एक उपकरण संरचना बनाकर शुरू करते हैं, फिर मूल फ़ाइल I / O समर्थन को शुरू करते हैं, io_buf संरचना और stdio.h से फ़ाइलों के साथ काम करने के लिए कार्यों पर विचार करें।

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

बिल्ड सिस्टम (मेक, जीसीसी, गैस)। प्रारंभिक बूट (मल्टीबूट)। लॉन्च (qemu)। सी लाइब्रेरी (strcpy, memcpy, strext)। सी लाइब्रेरी (स्प्रिंटफ, स्ट्रैची, स्ट्रैम्प, स्ट्रेटोक, वा_लिस्ट ...)। लाइब्रेरी को कर्नेल मोड और उपयोगकर्ता एप्लिकेशन मोड में बनाना। कर्नेल सिस्टम लॉग। वीडियो मेमोरी टर्मिनल का आउटपुट (kprintf, kpanic, kassert)। डायनेमिक मेमोरी, हीप (kmalloc, kfree)। मेमोरी और इंटरप्ट हैंडलिंग (GDT, IDT, PIC, syscall) का संगठन। अपवाद। वर्चुअल मेमोरी (पेज डायरेक्टरी और पेज टेबल)। प्रक्रिया। समयबद्धक। मल्टीटास्किंग। सिस्टम कॉल (मार, निकास, पीएस)।

चरित्र डिवाइस ड्राइवर। सिस्टम कॉल (ioctl, fopen, fread, fwrite)। सी लाइब्रेरी (fopen, fclose, fprintf, fscanf)।

कर्नेल की फ़ाइल प्रणाली (initrd), योगिनी, और इसके आंतरिक। सिस्टम कॉल (निष्पादन)। कर्नेल के लिए एक पूर्ण कार्यक्रम के रूप में शेल। उपयोगकर्ता सुरक्षा मोड (रिंग 3)। टास्क स्टेटस सेगमेंट (tss)।

चरित्र ड्राइवर

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

struct cdev *my_cdev = cdev_alloc( ); my_cdev->ops = &my_fops; 

मुख्य बिंदु डिवाइस को फ़ाइल I / O फ़ंक्शन के कार्यान्वयन को असाइन करना है।

हम एक संरचना के साथ प्राप्त करेंगे, लेकिन अर्थ समान होगा:

 extern struct dev_t { struct clist_head_t list_head; /* should be at first */ char name[8]; /* device name */ void* base_r; /* base read address */ void* base_w; /* base write address */ dev_read_cb_t read_cb; /* read handler */ dev_write_cb_t write_cb; /* write handler */ dev_ioctl_cb_t ioctl_cb; /* device specific command handler */ struct clist_definition_t ih_list; /* low half interrupt handlers */ }; 

प्रत्येक डिवाइस इंटरप्ट की आधी सूची से मेल खाती है जिसे इंटरप्ट होने पर कहा जाता है।

लिनक्स में, ऐसे हिस्सों को ऊपरी कहा जाता है, इसके विपरीत, निचला (निचला स्तर)।

व्यक्तिगत रूप से, यह मेरे लिए अधिक तर्कसंगत लग रहा था और मैंने गलती से शर्तों को दूसरे तरीके से याद किया। हम रुकावट के निचले हिस्सों की सूची के प्रत्येक तत्व का वर्णन इस प्रकार करते हैं:

 extern struct ih_low_t { struct clist_head_t list_head; /* should be at first */ int number; /* interrupt number */ ih_low_cb_t handler; /* interrupt handler */ }; 

आरंभ होने पर, ड्राइवर अपने डिवाइस को dev_register फ़ंक्शन के माध्यम से पंजीकृत करेगा, दूसरे शब्दों में रिंग लिस्ट में एक नया डिवाइस जोड़ें:

 extern void dev_register(struct dev_t* dev) { struct clist_head_t* entry; struct dev_t* device; /* create list entry */ entry = clist_insert_entry_after(&dev_list, dev_list.head); device = (struct dev_t*)entry->data; /* fill data */ strncpy(device->name, dev->name, sizeof(dev->name)); device->base_r = dev->base_r; device->base_w = dev->base_w; device->read_cb = dev->read_cb; device->write_cb = dev->write_cb; device->ioctl_cb = dev->ioctl_cb; device->ih_list.head = dev->ih_list.head; device->ih_list.slot_size = dev->ih_list.slot_size; } 

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

यानी फ़ाइल खोलना संबंधित ड्राइवर फ़ाइल के लिए stdio से एक फ़ाइल संरचना बनाने के बराबर होगा।

इस स्थिति में, फ़ाइल नाम डिवाइस के नाम से मेल खाएगा। हम अपने सी लाइब्रेरी (stdio.h) में फ़ाइल डिस्क्रिप्टर की अवधारणा को परिभाषित करते हैं।

 struct io_buf_t { int fd; /* file descriptor */ char* base; /* buffer beginning */ char* ptr; /* position in buffer */ bool is_eof; /* whether end of file */ void* file; /* file definition */ }; #define FILE struct io_buf_t 

सादगी के लिए, सभी खुली फ़ाइलों को अभी के लिए एक रिंग सूची में संग्रहीत किया जाना चाहिए। सूची आइटम निम्नानुसार वर्णित है:

 extern struct file_t { struct clist_head_t list_head; /* should be at first */ struct io_buf_t io_buf; /* file handler */ char name[8]; /* file name */ int mod_rw; /* whether read or write */ struct dev_t* dev; /* whether device driver */ }; 

प्रत्येक खुली फ़ाइल के लिए, हम डिवाइस के लिए एक लिंक संग्रहीत करेंगे। हम खुली फ़ाइलों की एक रिंग सूची को लागू करते हैं और रीड / राइट / ओइक्टल सिस्टम कॉल को लागू करते हैं।

फ़ाइल खोलते समय, हमें बस ड्राइवर से io_buf_t संरचना के ड्राइवर को पढ़ने और लिखने के शुरुआती पदों को निर्दिष्ट करने की आवश्यकता होती है, और तदनुसार, डिवाइस ड्राइवर के साथ फ़ाइल संचालन को संबद्ध करता है।

 extern struct io_buf_t* file_open(char* path, int mod_rw) { struct clist_head_t* entry; struct file_t* file; struct dev_t* dev; /* try to find already opened file */ entry = clist_find(&file_list, file_list_by_name_detector, path, mod_rw); file = (struct file_t*)entry->data; if (entry != null) { return &file->io_buf; } /* create list entry */ entry = clist_insert_entry_after(&file_list, file_list.head); file = (struct file_t*)entry->data; /* whether file is device */ dev = dev_find_by_name(path); if (dev != null) { /* device */ file->dev = dev; if (mod_rw == MOD_R) { file->io_buf.base = dev->base_r; } else if (mod_rw == MOD_W) { file->io_buf.base = dev->base_w; } } else { /* fs node */ file->dev = null; unreachable(); /* fs in not implemented yet */ } /* fill data */ file->mod_rw = mod_rw; file->io_buf.fd = next_fd++; file->io_buf.ptr = file->io_buf.base; file->io_buf.is_eof = false; file->io_buf.file = file; strncpy(file->name, path, sizeof(file->name)); return &file->io_buf; } 

फ़ाइल ऑपरेशन्स रीड / राइट / ioctl को एक पैटर्न के रूप में परिभाषित किया जाता है, उदाहरण के लिए रीड सिस्टम कॉल का उपयोग करते हुए।

बहुत ही सिस्टम कॉल जो हमने आखिरी पाठ में लिखना सीखा, बस इन कार्यों को कॉल करेगा।

 extern size_t file_read(struct io_buf_t* io_buf, char* buff, u_int size) { struct file_t* file; file = (struct file_t*)io_buf->file; /* whether file is device */ if (file->dev != null) { /* device */ return file->dev->read_cb(&file->io_buf, buff, size); } else { /* fs node */ unreachable(); /* fs in not implemented yet */ } return 0; } 

संक्षेप में, वे केवल डिवाइस की परिभाषा से कॉलबैक खींचेंगे। अब हम टर्मिनल ड्राइवर लिखेंगे।

टर्मिनल चालक

हमें एक स्क्रीन आउटपुट बफर और कीबोर्ड इनपुट बफर की आवश्यकता है, साथ ही इनपुट और आउटपुट मोड के लिए कुछ झंडे भी चाहिए।

 static const char* tty_dev_name = TTY_DEV_NAME; /* teletype device name */ static char tty_output_buff[VIDEO_SCREEN_SIZE]; /* teletype output buffer */ static char tty_input_buff[VIDEO_SCREEN_WIDTH]; /* teletype input buffer */ char* tty_output_buff_ptr = tty_output_buff; char* tty_input_buff_ptr = tty_input_buff; bool read_line_mode = false; /* whether read only whole line */ bool is_echo = false; /* whether to put readed symbol to stdout */ 

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

 extern void tty_init() { struct clist_head_t* entry; struct dev_t dev; struct ih_low_t* ih_low; memset(tty_output_buff, 0, sizeof(VIDEO_SCREEN_SIZE)); memset(tty_input_buff, 0, sizeof(VIDEO_SCREEN_WIDTH)); /* register teletype device */ strcpy(dev.name, tty_dev_name); dev.base_r = tty_input_buff; dev.base_w = tty_output_buff; dev.read_cb = tty_read; dev.write_cb = tty_write; dev.ioctl_cb = tty_ioctl; dev.ih_list.head = null; /* add interrupt handlers */ dev.ih_list.slot_size = sizeof(struct ih_low_t); entry = clist_insert_entry_after(&dev.ih_list, dev.ih_list.head); ih_low = (struct ih_low_t*)entry->data; ih_low->number = INT_KEYBOARD; ih_low->handler = tty_keyboard_ih_low; dev_register(&dev); } 

कीबोर्ड के लिए निचला अवरोधक हैंडलर निम्नानुसार परिभाषित किया गया है:

 /* * Key press low half handler */ static void tty_keyboard_ih_low(int number, struct ih_low_data_t* data) { /* write character to input buffer */ char* keycode = data->data; int index = *keycode; assert(index < 128); char ch = keyboard_map[index]; *tty_input_buff_ptr++ = ch; if (is_echo && ch != '\n') { /* echo character to screen */ *tty_output_buff_ptr++ = ch; } /* register deffered execution */ struct message_t msg; msg.type = IPC_MSG_TYPE_DQ_SCHED; msg.len = 4; *((size_t *)msg.data) = (size_t)tty_keyboard_ih_high; ksend(TID_DQ, &msg); } 

यहां हम बस कीबोर्ड बफर में दर्ज चरित्र डालते हैं। अंत में, हम कीबोर्ड रुकावट के ऊपरी हिस्सों के हैंडलर के आस्थगित कॉल को पंजीकृत करते हैं। यह कर्नेल थ्रेड को एक संदेश (IPC) भेजकर किया जाता है।

कर्नेल धागा अपने आप में बहुत सरल है:

 /* * Deferred queue execution scheduler * This task running in kernel mode */ void dq_task() { struct message_t msg; for (;;) { kreceive(TID_DQ, &msg); switch (msg.type) { case IPC_MSG_TYPE_DQ_SCHED: /* do deffered callback execution */ assert(msg.len == 4); dq_handler_t handler = (dq_handler_t)*((size_t*)msg.data); assert((size_t)handler < KERNEL_CODE_END_ADDR); printf(MSG_DQ_SCHED, handler); handler(msg); break; } } exit(0); } 

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

 /* * Key press high half handler */ static void tty_keyboard_ih_high(struct message_t *msg) { video_flush(tty_output_buff); } 

अब यह आई / ओ कार्यों को लिखने के लिए रहता है, जिसे फ़ाइल संचालन कहा जाता है।

 /* * Read line from tty to string */ static u_int tty_read(struct io_buf_t* io_buf, void* buffer, u_int size) { char* ptr = buffer; assert((size_t)io_buf->ptr <= (size_t)tty_input_buff_ptr); assert((size_t)tty_input_buff_ptr >= (size_t)tty_input_buff); assert(size > 0); io_buf->is_eof = (size_t)io_buf->ptr == (size_t)tty_input_buff_ptr; if (read_line_mode) { io_buf->is_eof = !strchr(io_buf->ptr, '\n'); } for (int i = 0; i < size - 1 && !io_buf->is_eof; ++i) { char ch = tty_read_ch(io_buf); *ptr++ = ch; if (read_line_mode && ch == '\n') { break; } } return (size_t)ptr - (size_t)buffer; } /* * Write to tty */ static void tty_write(struct io_buf_t* io_buf, void* data, u_int size) { char* ptr = data; for (int i = 0; i < size && !io_buf->is_eof; ++i) { tty_write_ch(io_buf, *ptr++); } } 

चरित्र-दर-वर्ण ऑपरेशन अधिक जटिल नहीं हैं और मुझे नहीं लगता कि उन्हें टिप्पणी करने की आवश्यकता है।

 /* * Write single character to tty */ static void tty_write_ch(struct io_buf_t* io_buf, char ch) { if ((size_t)tty_output_buff_ptr - (size_t)tty_output_buff + 1 < VIDEO_SCREEN_SIZE) { if (ch != '\n') { /* regular character */ *tty_output_buff_ptr++ = ch; } else { /* new line character */ int line_pos = ((size_t)tty_output_buff_ptr - (size_t)tty_output_buff) % VIDEO_SCREEN_WIDTH; for (int j = 0; j < VIDEO_SCREEN_WIDTH - line_pos; ++j) { *tty_output_buff_ptr++ = ' '; } } } else { tty_output_buff_ptr = video_scroll(tty_output_buff, tty_output_buff_ptr); tty_write_ch(io_buf, ch); } io_buf->ptr = tty_output_buff_ptr; } /* * Read single character from tty */ static char tty_read_ch(struct io_buf_t* io_buf) { if ((size_t)io_buf->ptr < (size_t)tty_input_buff_ptr) { return *io_buf->ptr++; } else { io_buf->is_eof = true; return '\0'; } } 

यह केवल ioctl को लागू करने के लिए इनपुट और आउटपुट मोड को नियंत्रित करने के लिए बनी हुई है।

 /* * Teletype specific command */ static void tty_ioctl(struct io_buf_t* io_buf, int command) { char* hello_msg = MSG_KERNEL_NAME; switch (command) { case IOCTL_INIT: /* prepare video device */ if (io_buf->base == tty_output_buff) { kmode(false); /* detach syslog from screen */ tty_output_buff_ptr = video_clear(io_buf->base); io_buf->ptr = tty_output_buff_ptr; tty_write(io_buf, hello_msg, strlen(hello_msg)); video_flush(io_buf->base); io_buf->ptr = tty_output_buff_ptr; } else if (io_buf->base == tty_input_buff) { unreachable(); } break; case IOCTL_CLEAR: if (io_buf->base == tty_output_buff) { /* fill output buffer with spaces */ tty_output_buff_ptr = video_clear(io_buf->base); video_flush(io_buf->base); io_buf->ptr = tty_output_buff_ptr; } else if (io_buf->base == tty_input_buff) { /* clear input buffer */ tty_input_buff_ptr = tty_input_buff; io_buf->ptr = io_buf->base; io_buf->is_eof = true; } break; case IOCTL_FLUSH: /* flush buffer to screen */ if (io_buf->base == tty_output_buff) { video_flush(io_buf->base); } else if (io_buf->base == tty_input_buff) { unreachable(); } break; case IOCTL_READ_MODE_LINE: /* read only whole line */ if (io_buf->base == tty_input_buff) { read_line_mode = true; } else if (io_buf->base == tty_output_buff) { unreachable(); } break; case IOCTL_READ_MODE_ECHO: /* put readed symbol to stdout */ if (io_buf->base == tty_input_buff) { is_echo = true; } else if (io_buf->base == tty_output_buff) { unreachable(); } break; default: unreachable(); } } 

अब हम अपने पुस्तकालय सी के स्तर पर फ़ाइल इनपुट आउटपुट को लागू करते हैं।

 /* * Api - Open file */ extern FILE* fopen(const char* file, int mod_rw) { FILE* result = null; asm_syscall(SYSCALL_OPEN, file, mod_rw, &result); return result; } /* * Api - Close file */ extern void fclose(FILE* file) { asm_syscall(SYSCALL_CLOSE, file); } /* * Api - Read from file to buffer */ extern u_int fread(FILE* file, char* buff, u_int size) { return asm_syscall(SYSCALL_READ, file, buff, size); } /* * Api - Write data to file */ extern void fwrite(FILE* file, const char* data, u_int size) { asm_syscall(SYSCALL_WRITE, file, data, size); } 

ठीक है, यहाँ कुछ उच्च-स्तरीय कार्य हैं:

 /* * Api - Print user message */ extern void uvnprintf(const char* format, u_int n, va_list list) { char buff[VIDEO_SCREEN_WIDTH]; vsnprintf(buff, n, format, list); uputs(buff); } /* * Api - Read from file to string */ extern void uscanf(char* buff, ...) { u_int readed = 0; do { readed = fread(stdin, buff, 255); } while (readed == 0); buff[readed - 1] = '\0'; /* erase new line character */ uprintf("\n"); uflush(); } 

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

वह सब है। अब आप सुरक्षित रूप से अपने कर्नेल को ड्राइवरों को फास्ट कर सकते हैं!

संदर्भ

अधिक जानकारी के लिए वीडियो ट्यूटोरियल देखें।

→ जीआईटी रिपॉजिटरी में स्रोत कोड (आपको सबक 8 शाखा की आवश्यकता है)

संदर्भ

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