लिनक्स कर्नेल अनुक्रम फ़ाइलों का उपयोग करना

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

लिनक्स कर्नेल में अनुक्रम फ़ाइलों का उपयोग करने के विषय पर विचार करें, ऐसी फ़ाइलों को कर्नेल मोड से छपाई के लिए सबसे सुविधाजनक तंत्र माना जाता है। लेकिन व्यवहार में, उन्हें सही तरीके से उपयोग करना बहुत अधिक कठिन है जितना आप सोचेंगे।

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

आइए पहले अधिक विस्तार से विचार करें जब अनुक्रम फ़ाइलों का उपयोग करना स्वाभाविक है। सबसे आम स्थिति है अपनी फ़ाइल को / proc फ़ाइल सिस्टम में बनाना। इस प्रणाली की फाइलों को पढ़कर, आप उपयोग किए गए उपकरणों, इसके चालकों, रैम, प्रक्रियाओं, आदि के बारे में विभिन्न प्रकार की जानकारी प्राप्त कर सकते हैं।

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

उपर्युक्त स्रोत उम्मीद से थोड़े खराब थे। उदाहरण के लिए पुस्तक में, कुछ जानकारी आम तौर पर गलत निकली और यही बात मुझे इस नोट को लिखने के लिए प्रेरित करती है। यह विचार करना आम है कि योजना-चित्र के रूप में दी गई जानकारी समझने और उपयोग करने में सबसे आसान है। हालाँकि इस पुस्तक में विषय से संबंधित चित्र गलत है। ऐसी योजना का उपयोग करने से गंभीर त्रुटियां हो सकती हैं, हालांकि पुस्तक में उदाहरण सही ढंग से काम करता है और इस योजना का अनुसरण करता है। यह इस तथ्य के कारण है कि इस उदाहरण में, केवल कुछ बाइट्स ऐसे समय में प्रिंट किए जाते हैं जब / proc / iter एक्सेस किया जाता है। यदि आप इसे स्मृति के एक पृष्ठ से बड़े ग्रंथों को प्रिंट करने के लिए एक टेम्पलेट के रूप में उपयोग करते हैं, तो आश्चर्य होगा। लेखों की उपर्युक्त श्रृंखला में स्पष्ट त्रुटियाँ नहीं हैं, लेकिन कुछ विवरणों पर रिपोर्ट नहीं करते हैं जो विषय को समझने के लिए महत्वपूर्ण हैं।

तो, चलिए सबसे पहले इस बात पर विचार करते हैं कि अनुक्रम फ़ाइल के साथ कैसे काम किया जाए।



ऐसी फ़ाइल के साथ काम करने के लिए, आपको फ़ंक्शन प्रारंभ (), स्टॉप (), अगला () और शो () बनाना होगा। इन कार्यों के नाम किसी भी हो सकते हैं, मैंने सबसे छोटे शब्दों को चुना जो कार्यों के कार्यों के अर्थ में अनुरूप हैं। जब ऐसे फ़ंक्शन मौजूद होते हैं और ठीक से कर्नेल सिस्टम से जुड़े होते हैं, तो वे / proc निर्देशिका में उनके साथ जुड़ी फ़ाइल तक पहुँचते समय स्वचालित रूप से काम करना शुरू कर देते हैं। सबसे भ्रामक बात स्टॉप () फ़ंक्शन का उपयोग है, जिसे तीन अलग-अलग संदर्भों में कहा जा सकता है। स्टार्ट () के बाद इसे कॉल करने का मतलब है प्रिंट जॉब को खत्म करना। शो () के बाद इसे कॉल करने का मतलब है कि बफर का अंतिम प्रिंट ऑपरेशन (आमतौर पर इसके लिए seq_printf फ़ंक्शन का उपयोग किया जाता है) ने पेज बफर को ओवरफ्लो किया और यह प्रिंट ऑपरेशन रद्द कर दिया गया। अगली () के बाद इसकी कॉल सबसे दिलचस्प मामला है जो तब होता है जब कुछ डेटा को बफ़र पर प्रिंट करना समाप्त हो जाता है और आपको या तो काम पूरा करने या किसी अन्य डेटा का उपयोग करने की आवश्यकता होती है। उदाहरण के लिए, मान लें कि हमारी फ़ाइल / proc निर्देशिका में है, इसे एक्सेस करते समय, पहले ब्लॉक डिवाइस पर कुछ जानकारी उत्पन्न करता है, और फिर चरित्र वाले पर। सबसे पहले, प्रारंभ () फ़ंक्शन ब्लॉक डिवाइसों के लिए मुद्रण को इनिशियलाइज़ करता है, और अगला () और, संभवतः, शो () फ़ंक्शन इस इनिशियलाइज़ेशन डेटा का उपयोग ब्लॉक डिवाइसेस के बारे में चरण-दर-चरण जानकारी प्रिंट करने के लिए करते हैं। जब सब कुछ तैयार हो जाता है, तो अंतिम कॉल के बाद (), माना जाने वाला कॉल बंद हो जाएगा (), जिसके बाद प्रारंभ () कहा जाता है, जिसे इस बार पहले से ही चरित्र उपकरणों के लिए आगे की छपाई शुरू करनी चाहिए।

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

#include <linux/module.h> #include <linux/moduleparam.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/proc_fs.h> #include <linux/fs.h> #include <linux/seq_file.h> #include <linux/slab.h> static int limit = 10; //default value, it can be changed here or module_param(limit, int, S_IRUGO); //transfered as a module parameter static int* even_ptr; //we will work with dynamic memory /** * start */ static void *ct_seq_start(struct seq_file *s, loff_t *pos) { printk(KERN_INFO "Entering start(), pos = %Ld, seq-file pos = %lu.\n", *pos, s->count); if (*pos >= limit) { // are we done? printk(KERN_INFO "Apparently, we're done.\n"); return NULL; } //Allocate an integer to hold our increasing even value even_ptr = kmalloc(sizeof(int), GFP_KERNEL); if (!even_ptr) // fatal kernel allocation error return NULL; printk(KERN_INFO "In start(), even_ptr = %pX.\n", even_ptr); *even_ptr = (*pos)*2; return even_ptr; } /** * show */ static int ct_seq_show(struct seq_file *s, void *v) { printk(KERN_INFO "In show(), even = %d.\n", *(int*)v); seq_printf(s, "The current value of the even number is %d\n", *(int*)v); return 0; } /** * next */ static void *ct_seq_next(struct seq_file *s, void *v, loff_t *pos) { printk(KERN_INFO "In next(), v = %pX, pos = %Ld, seq-file pos = %lu.\n", v, *pos, s->count); (*pos)++; //increase my position counter if (*pos >= limit) //are we done? return NULL; *(int*)v += 2; //to the next even value return v; } /** * stop */ static void ct_seq_stop(struct seq_file *s, void *v) { printk(KERN_INFO "Entering stop().\n"); if (v) printk(KERN_INFO "v is %pX.\n", v); else printk(KERN_INFO "v is null.\n"); printk(KERN_INFO "In stop(), even_ptr = %pX.\n", even_ptr); if (even_ptr) { printk(KERN_INFO "Freeing and clearing even_ptr.\n"); kfree(even_ptr); even_ptr = NULL; } else printk(KERN_INFO "even_ptr is already null.\n"); } /** * This structure gathers functions which control the sequential reading */ static struct seq_operations ct_seq_ops = { .start = ct_seq_start, .next = ct_seq_next, .stop = ct_seq_stop, .show = ct_seq_show }; /** * This function is called when a file from /proc is opened */ static int ct_open(struct inode *inode, struct file *file) { return seq_open(file, &ct_seq_ops); }; /** * This structure gathers functions for a /proc-file operations */ static struct file_operations ct_file_ops = { .owner = THIS_MODULE, .open = ct_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release }; /** * This function is called when this module is loaded into the kernel */ static int __init ct_init(void) { proc_create("evens", 0, NULL, &ct_file_ops); return 0; } /** * This function is called when this module is removed from the kernel */ static void __exit ct_exit(void) { remove_proc_entry("evens", NULL); } module_init(ct_init); module_exit(ct_exit); MODULE_LICENSE("GPL"); 

अनुक्रम फ़ाइल के साथ काम करने के लिए कार्य अतिव्यापी कार्यक्षमता के साथ दो बिंदुओं का उपयोग करते हैं (यह भी कुछ भ्रमित है)। उनमें से एक को वर्तमान वस्तु को बफ़र से प्रिंट करके दिखाने के लिए इंगित करना चाहिए () - यह कार्यक्रम में `v'- पॉइंटर है। अन्य पॉइंटर `पॉस’ का उपयोग आमतौर पर काउंटर को इंगित करने के लिए किया जाता है।

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

 obj-m += evens.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean 

कर्नेल से कनेक्ट करना कमांड sudo insmod evens.ko साथ किया sudo insmod evens.ko , / proc / evens-file की कार्यक्षमता की जाँच करता है, जो इसके बाद दिखाई देता है, कमांड cat /proc/evens , इवेंट लॉग को पढ़कर सिस्टम ऑपरेशन के साथ समझाता है। कमांड sudo cat /var/log/messages ।

पृष्ठ बफ़र को ओवरफ़्लो करने के लिए, सीमा मान को एक बड़े मान पर सेट करें, उदाहरण के लिए, 200। इस मान को प्रोग्राम के पाठ में दर्ज किया जा सकता है या कमांड लोड करते समय मॉड्यूल को लोड किया जा सकता है।

लॉग विश्लेषण शेष अस्पष्ट बिंदुओं की व्याख्या कर सकता है। उदाहरण के लिए, आप नोटिस कर सकते हैं कि अगले () या प्रारंभ () के बाद स्टॉप () कॉल करने से पहले, सिस्टम वेरिएबल `v 'को शून्य करता है। आप यह भी देख सकते हैं कि स्टॉप से ​​पहले स्टार्ट () कॉल करने के बाद (), सिस्टम बफर की सामग्री को प्रिंट करता है।

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

स्रोत कोड भी यहां उपलब्ध है ।