लिनक्स कर्नेल के लेखन-संरक्षित क्षेत्रों को संशोधित करने का कोषेर तरीका

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

X86 के लिए, एक प्रसिद्ध समाधान रजिस्टर CR0 के WP बिट को रीसेट करके अस्थायी रूप से पृष्ठ सुरक्षा को अक्षम करना है। लेकिन आपको सावधानी के साथ इसका उपयोग करना चाहिए, क्योंकि पृष्ठ संरक्षण कई कर्नेल तंत्रों का आधार है। इसके अलावा, एसएमपी-सिस्टम पर काम की सुविधाओं को ध्यान में रखना आवश्यक है, जब विभिन्न अप्रिय परिस्थितियां हो सकती हैं।

पृष्ठ सुरक्षा बंद करें

X86 आर्किटेक्चर में एक विशेष रक्षा तंत्र है, जिसके अनुसार लिखने के लिए मेमोरी-संरक्षित क्षेत्रों को लिखने का प्रयास अपवाद बन सकता है। इस तंत्र को "पृष्ठ रक्षा" कहा जाता है और यह कई कर्नेल कार्यों के कार्यान्वयन का आधार है, जैसे कि, उदाहरण के लिए, गाय । इस स्थिति में प्रोसेसर का व्यवहार CR0 रजिस्टर के WP बिट द्वारा निर्धारित किया जाता है, और पृष्ठ के एक्सेस अधिकार इसके संबंधित PTE विवरणक संरचना में वर्णित हैं। जब रजिस्टर CR0 का WP बिट सेट किया जाता है, तो प्रोसेसर द्वारा संबंधित अपवाद (#GP) की पीढ़ी के लिए राइट-प्रोटेक्टेड पेज (PTE में RW बिट रीसेट होता है) को लिखने का प्रयास होता है।

इस समस्या का सबसे सरल समाधान CR0 रजिस्टर के WP बिट को रीसेट करके अस्थायी रूप से पृष्ठ सुरक्षा को अक्षम करना है। इस समाधान में एक जगह है, लेकिन इसे सावधानी से लागू किया जाना चाहिए, क्योंकि, जैसा कि नोट किया गया है, पृष्ठ तंत्र कई मुख्य तंत्रों का आधार है। इसके अलावा, एसएमपी सिस्टम पर, प्रोसेसर में से एक पर चल रहा एक धागा और WP बिट को हटाने से बाधित हो सकता है और दूसरे प्रोसेसर में स्थानांतरित हो सकता है!

फिर भी, यदि आप वास्तव में चाहते हैं, तो आपको पूर्वनिर्धारण को अक्षम करके ऐसा करने की आवश्यकता है :

static inline unsigned long native_pax_open_kernel(void) { unsigned long cr0; preempt_disable(); barrier(); cr0 = read_cr0() ^ X86_CR0_WP; BUG_ON(unlikely(cr0 & X86_CR0_WP)); write_cr0(cr0); return cr0 ^ X86_CR0_WP; } static inline unsigned long native_pax_close_kernel(void) { unsigned long cr0; cr0 = read_cr0() ^ X86_CR0_WP; BUG_ON(unlikely(!(cr0 & X86_CR0_WP))); write_cr0(cr0); barrier(); preempt_enable_no_resched(); return cr0 ^ X86_CR0_WP; } 

मैपिंग का उपयोग करना

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

 /* * map_writable creates a shadow page mapping of the range * [addr, addr + len) so that we can write to code mapped read-only. * * It is similar to a generalized version of x86's text_poke. But * because one cannot use vmalloc/vfree() inside stop_machine, we use * map_writable to map the pages before stop_machine, then use the * mapping inside stop_machine, and unmap the pages afterwards. */ static void *map_writable(void *addr, size_t len) { void *vaddr; int nr_pages = DIV_ROUND_UP(offset_in_page(addr) + len, PAGE_SIZE); struct page **pages = kmalloc(nr_pages * sizeof(*pages), GFP_KERNEL); void *page_addr = (void *)((unsigned long)addr & PAGE_MASK); int i; if (pages == NULL) return NULL; for (i = 0; i < nr_pages; i++) { if (__module_address((unsigned long)page_addr) == NULL) { pages[i] = virt_to_page(page_addr); WARN_ON(!PageReserved(pages[i])); } else { pages[i] = vmalloc_to_page(page_addr); } if (pages[i] == NULL) { kfree(pages); return NULL; } page_addr += PAGE_SIZE; } vaddr = vmap(pages, nr_pages, VM_MAP, PAGE_KERNEL); kfree(pages); if (vaddr == NULL) return NULL; return vaddr + offset_in_page(addr); } 

इस फ़ंक्शन का उपयोग करने से आप किसी भी मेमोरी क्षेत्र के लिए एक लिखने योग्य प्रदर्शन बना सकते हैं। इस तरह से बनाया गया क्षेत्र vfree फ़ंक्शन का उपयोग करके जारी किया जाता है, जिसका तर्क पृष्ठ सीमा से जुड़ा पता मान होना चाहिए।

गाड़ी रोको!

कर्नेल कोड संशोधन को सुरक्षित बनाने के लिए अंतिम तत्व stop_machine तंत्र है:

 #include <linux/stop_machine.h> int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus) 

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

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