👨🏾‍🚒 👨🏿‍🤝‍👨🏽 ⚓️ स्टैक ओवरफ्लो से बचाव कैसे करें (कोर्टेक्स एम पर)? 🧓 👨‍👨‍👧‍👧 🚊

यदि आप "बड़े" कंप्यूटर पर प्रोग्राम करते हैं, तो संभवतः आपके पास ऐसा कोई प्रश्न नहीं है। इसे ओवरफ्लो करने के लिए बहुत अधिक स्टैक है, आपको प्रयास करने की आवश्यकता है। सबसे खराब स्थिति में, आप इस तरह एक विंडो पर ओके क्लिक करते हैं और इसे समझ लेते हैं।

लेकिन अगर आप माइक्रोकंट्रोलर को प्रोग्राम करते हैं, तो समस्या थोड़ी अलग दिखती है। पहले आपको यह ध्यान देने की आवश्यकता है कि स्टैक भरा हुआ है।

इस लेख में मैं इस विषय पर अपने स्वयं के शोध के बारे में बात करूंगा। चूंकि मैं मुख्य रूप से एसटीएम 32 के तहत और मिलेंडर 1986 के तहत कार्यक्रम करता हूं - मैंने उन पर ध्यान केंद्रित किया।

परिचय

आइए सरलतम मामले की कल्पना करें - हम बिना किसी ऑपरेटिंग सिस्टम के सरल एकल-थ्रेडेड कोड लिखते हैं, अर्थात्। हमारे पास केवल एक स्टैक है। और यदि आप, मेरी तरह, uVision Keil में प्रोग्राम करते हैं, तो मेमोरी को किसी तरह वितरित किया जाता है:

और अगर आप, मेरी तरह, माइक्रोकंट्रोलर पर गतिशील स्मृति को बुराई मानते हैं, तो इस तरह:

वैसे

यदि आप ढेर के उपयोग को प्रतिबंधित करना चाहते हैं, तो आप इसे इस तरह से कर सकते हैं:

#pragma import(__use_no_heap_region)

यहाँ विवरण

ठीक है, क्या समस्या है? समस्या यह है कि Keil स्टैटिक डेटा क्षेत्र के तुरंत बाद स्टैक को रखता है। और कॉर्टेक्स-एम में स्टैक घटते पते की दिशा में बढ़ रहा है। और जब यह ओवरफ्लो हो जाता है, तो यह बस स्मृति के आवंटित टुकड़े से बाहर निकल जाता है। और किसी भी स्थिर या वैश्विक चर को अधिलेखित करता है।

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

तुरंत एक आरक्षण करें कि यदि आप एक ढेर का उपयोग करते हैं, तो समस्या कहीं भी नहीं जाती है, बस वैश्विक चर के बजाय ढेर खराब हो जाता है। ज्यादा बेहतर नहीं है।

ठीक है, समस्या स्पष्ट है। क्या करें?

MPU

सबसे सरल और सबसे स्पष्ट एमपीयू (दूसरे शब्दों में, मेमोरी प्रोटेक्शन यूनिट) का उपयोग करना है। आपको विभिन्न विशेषताओं को स्मृति के विभिन्न टुकड़ों में असाइन करने की अनुमति देता है; विशेष रूप से, आप रीड-ओनली क्षेत्रों के साथ स्टैक को घेर सकते हैं और वहां लिखते समय मेमफॉल्ट को पकड़ सकते हैं।

उदाहरण के लिए, stm32f407 में MPU है। दुर्भाग्य से, कई अन्य "जूनियर" एसटीएम में यह नहीं है। और मिलैंड्रोवस्की 1986VE1 में यह भी नहीं है।

यानी समाधान अच्छा है, लेकिन हमेशा सस्ती नहीं है।

मैनुअल नियंत्रण

संकलन करते समय, Keil एक कॉल ग्राफ (लिंकर विकल्प "--info = स्टैक") के साथ एक HTML रिपोर्ट उत्पन्न कर सकता है (डिफ़ॉल्ट रूप से)। और यह रिपोर्ट उपयोग किए गए स्टैक के बारे में भी जानकारी देती है। Gcc वह भी कर सकता है (विकल्प -स्टैक-उपयोग)। तदनुसार, आप कभी-कभी इस रिपोर्ट को देख सकते हैं (या एक स्क्रिप्ट लिख सकते हैं जो आपके लिए ऐसा करती है, और प्रत्येक निर्माण से पहले इसे कॉल करें)।

इसके अलावा, रिपोर्ट की शुरुआत में, एक पथ लिखा जाता है जो स्टैक का अधिकतम उपयोग करता है:

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

ट्रिकी स्टैक प्लेसमेंट

मैंने इस लेख से इस विधि के बारे में सीखा। लेख जंग के बारे में है, लेकिन मुख्य विचार यह है:

जीसीसी का उपयोग करते समय, यह " डबल लिंक " का उपयोग करके किया जा सकता है।

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

 ; ************************************************************* ; *** Scatter-Loading Description File generated by uVision *** ; ************************************************************* LR_IROM1 0x08000000 0x00020000 { ; load region size_region ER_IROM1 0x08000000 0x00020000 { ; load address = execution address *.o (RESET, +First) *(InRoot$$Sections) .ANY (+RO) } RW_IRAM1 0x20000000 0x00005000 { ; RW data .ANY (+RW +ZI) } }

आगे क्या करना है? संभव विकल्प। आधिकारिक दस्तावेज आरक्षित नामों के साथ वर्गों को परिभाषित करने का सुझाव देता है - ARM_LIB_HEAP और ARM_LIB_STACK। लेकिन यह अप्रिय परिणामों को मजबूर करता है, कम से कम मेरे लिए - स्टैक और ढेर के आकार को तितर बितर फ़ाइल में सेट करना होगा।

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

स्पॉइलर

 #! armcc -E ; with that we can use C preprocessor #define RAM_BEGIN 0x20000000 #define RAM_SIZE_BYTES (4*1024) #define FLASH_BEGIN 0x8000000 #define FLASH_SIZE_BYTES (32*1024) ; This scatter file places stack before .bss region, so on stack overflow ; we get HardFault exception immediately LR_IROM1 FLASH_BEGIN FLASH_SIZE_BYTES { ; load region size_region ER_IROM1 FLASH_BEGIN FLASH_SIZE_BYTES { ; load address = execution address *.o (RESET, +First) *(InRoot$$Sections) .ANY (+RO) } ; Stack region growing down REGION_STACK RAM_BEGIN { *(STACK) } ; We have to define heap region, even if we don't actually use heap REGION_HEAP ImageLimit(REGION_STACK) { *(HEAP) } ; this will place .bss region above the stack and heap and allocate RAM that is left for it RW_IRAM1 ImageLimit(REGION_HEAP) (RAM_SIZE_BYTES - ImageLength(REGION_STACK) - ImageLength(REGION_HEAP)) { *(+RW +ZI) } }

तब मैंने कहा कि STACK नाम की सभी वस्तुएँ REGION_STACK क्षेत्र में स्थित होनी चाहिए, और सभी HEAP वस्तुएँ REGION_HEAP क्षेत्र में स्थित होनी चाहिए। और बाकी सब कुछ RW_IRAM1 क्षेत्र में है। और उसने इस क्रम में क्षेत्रों की व्यवस्था की - ऑपरेटिव की शुरुआत, ढेर, ढेर, बाकी सब। गणना यह है कि कोडांतरक स्टार्टअप फाइल में स्टैक और हीप इस कोड का उपयोग करके सेट किए गए हैं (यानी, STACK और HEAP नामों के साथ सरणियों के रूप में):

स्पॉइलर

 Stack_Size EQU 0x00000400 AREA STACK, NOINIT, READWRITE, ALIGN=3 Stack_Mem SPACE Stack_Size __initial_sp Heap_Size EQU 0x00000200 AREA HEAP, NOINIT, READWRITE, ALIGN=3 __heap_base Heap_Mem SPACE Heap_Size __heap_limit PRESERVE8 THUMB

ठीक है, आप पूछ सकते हैं, लेकिन यह हमें क्या देता है? और यहाँ क्या है। अब, स्टैक से बाहर जाने पर, प्रोसेसर मेमोरी को लिखने (या पढ़ने) की कोशिश करता है जो मौजूद नहीं है। और STM32 पर, एक अपवाद के कारण एक व्यवधान उत्पन्न होता है - हार्डफॉल्ट।

यह एमपीयू के कारण मेम्फॉल्ट के रूप में सुविधाजनक नहीं है, क्योंकि हार्डफॉल्ट कई कारणों से हो सकता है, लेकिन कम से कम त्रुटि जोर से है और शांत नहीं है। यानी यह तुरंत होता है, और अज्ञात समय के बाद नहीं, जैसा कि पहले था।

सबसे अच्छा, हमने इसके लिए कुछ भी भुगतान नहीं किया, कोई ओवरहेड रनटाइम नहीं! वाह। लेकिन एक समस्या है।

यह मिलेंडर पर काम नहीं करता है।

हां। बेशक, मिलंद्रा पर (मुझे मुख्य रूप से 1986BE1 और BE91 में दिलचस्पी है), मेमोरी कार्ड अलग दिखता है। STM32 में, ऑपरेटिव की शुरुआत से पहले, कुछ भी नहीं है, और ऑपरेटिव से पहले मिलंद्रा पर, बाहरी बस का क्षेत्र निहित है।

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

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

तो एसटीएम पर भी यह हैक की तरह है, बस बहुत गंदा नहीं है।

तो, आपको किसी और तरीके की तलाश करने की आवश्यकता है।

रिकॉर्ड पर एक्सेस ब्रेकपॉइंट

अगर हम स्टैक को रैम की शुरुआत में ले जाते हैं, तो स्टैक का सीमा मूल्य हमेशा समान होगा - 0x20000000। और हम सिर्फ इस सेल में रिकॉर्ड पर एक विराम बिंदु डाल सकते हैं। यह कमांड के साथ किया जा सकता है और यहां तक कि .ini फ़ाइल का उपयोग करके ऑटोरन में पंजीकृत किया जा सकता है:

 // breakpoint on stackoverflow BS Write 0x20000000, 1

लेकिन यह बहुत विश्वसनीय तरीका नहीं है। स्टैक आरंभीकृत होने पर यह ब्रेकपॉइंट हर बार फायर करेगा। "सभी ब्रेकप्वाइंट्स को मारें" पर क्लिक करके इसे गलती से हरा देना आसान है। और वह केवल डिबगर की उपस्थिति में आपकी रक्षा करेगा। अच्छा नहीं है।

गतिशील अतिप्रवाह संरक्षण

इस विषय पर एक त्वरित खोज ने मुझे केइल के विकल्पों --protect_stack और --protect_stack_all पर ले जाया। उपयोगी विकल्प, दुर्भाग्यवश, वे पूरे स्टैक को ओवरफ्लो करने से नहीं, बल्कि किसी अन्य फ़ंक्शन को स्टैक फ्रेम में पॉपअप करने से बचाते हैं। उदाहरण के लिए, यदि आपका कोड किसी सरणी की सीमा से परे चला जाता है या मापदंडों की एक चर संख्या के साथ विफल हो जाता है। Gcc, निश्चित रूप से, ऐसा भी कर सकता है (-fstack-protector)।

इस विकल्प का सार इस प्रकार है: "गार्ड वेरिएबल" को प्रत्येक स्टैक फ्रेम में जोड़ा जाता है, अर्थात, एक गार्ड संख्या। यदि फ़ंक्शन से बाहर निकलने के बाद यह संख्या बदल गई है, तो त्रुटि हैंडलर फ़ंक्शन को कहा जाता है। यहाँ विवरण।

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

गतिशील एसपी नियंत्रण

सौभाग्य से, जीसीसी के पास अद्भुत विकल्प "-finstrument- फ़ंक्शन" है, जो आपको प्रत्येक फ़ंक्शन में प्रवेश करने और प्रत्येक फ़ंक्शन से बाहर निकलने पर उपयोगकर्ता-परिभाषित फ़ंक्शन को कॉल करने की अनुमति देता है। यह आमतौर पर डिबगिंग जानकारी को आउटपुट करने के लिए उपयोग किया जाता है, लेकिन क्या अंतर है?

और भी सौभाग्य से, केइल ने जानबूझकर जीसीसी कार्यक्षमता को कॉपी किया है, और "--gnu_instrument" ( विवरण ) नाम के तहत एक ही विकल्प उपलब्ध है।

उसके बाद, आपको बस यह कोड लिखना होगा:

स्पॉइलर

 //   ,    //   ,         scatter- extern unsigned int Image$$REGION_STACK$$RW$$Base; //    ,   static const uint32_t stack_lower_address = (uint32_t) &( Image$$REGION_STACK$$RW$$Base ); //         extern "C" __attribute__((no_instrument_function)) void __cyg_profile_func_enter( void * current_func, void * callsite ) { (void)current_func; (void)callsite; ASSERT( __current_sp() >= stack_lower_address ); } //   -   extern "C" __attribute__((no_instrument_function)) void __cyg_profile_func_exit( void * current_func, void * callsite ) { (void)current_func; (void)callsite; }

और वोइला! अब, प्रत्येक फ़ंक्शन (इंटरप्ट हैंडलर सहित) में प्रवेश करने पर, स्टैक ओवरफ्लो के लिए एक चेक प्रदर्शन किया जाएगा। और अगर स्टैक ओवरफ्लो होता है, तो एक मुखर होगा।

थोड़ा स्पष्टीकरण:

हां, निश्चित रूप से, आपको कुछ मार्जिन के साथ अतिप्रवाह की जांच करने की आवश्यकता है, अन्यथा स्टैक के शीर्ष पर "कूद" का जोखिम है।
छवि $ $ REGION_STACK $ $ RW $ $ आधार लिंकर द्वारा उत्पन्न स्थिरांक का उपयोग करके मेमोरी क्षेत्रों के बारे में जानकारी प्राप्त करने का एक विशेष जादू है। विवरण (हालाँकि स्थानों में बहुत समझदार नहीं है)।

क्या समाधान सही है? बिल्कुल नहीं।

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

दूसरे, यह सबसे अधिक संभावना है कि जब प्री-कंपाइल की गई लाइब्रेरी का उपयोग नहीं किया जाएगा (लेकिन चूंकि मैं उन्हें बिल्कुल भी उपयोग नहीं करता हूं, तो मैंने जांच नहीं की)।

लेकिन यह समाधान बहु-थ्रेडेड प्रोग्राम के लिए संभावित रूप से उपयुक्त है, क्योंकि हम स्वयं सत्यापन करते हैं। लेकिन मैंने वास्तव में इस विचार को नहीं सोचा है, इसलिए मैं इसे अभी के लिए पकड़ लूंगा।

संक्षेप में देना

यह stm32 के लिए और मिलेंडर के लिए काम के समाधान खोजने के लिए निकला, हालांकि बाद के लिए मुझे कुछ ओवरहेड के साथ भुगतान करना पड़ा।

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

और मैं आम तौर पर अपने लिए (और अन्य लोगों के लिए) यह अक्सर नोटिस करता हूं - Google में 5 मिनट बिताने और एक तुच्छ समाधान खोजने के बजाय - मैं वर्षों से अपनी समस्याओं के साथ रह रहा हूं।

मेरे लिए यही सब है मैं समझता हूं कि मैंने मौलिक रूप से कुछ भी नया नहीं खोजा है, लेकिन मैं इस तरह के निर्णय के साथ किसी भी तैयार लेख पर नहीं आया हूं (कम से कम, जोसेफ यू खुद इस विषय पर एक लेख में सीधे इसकी पेशकश नहीं करते हैं)। मुझे उम्मीद है कि टिप्पणियों में वे मुझे बताएंगे कि मैं सही हूं या नहीं और इस दृष्टिकोण के क्या नुकसान हैं।

UPD: यदि, एक स्कैटर फ़ाइल को जोड़ने पर, Keil एक असंगत चेतावनी जारी करना शुरू कर देता है, तो "AppData \ Local \ Temp \ p17af8-2 (33): चेतावनी: # 1-D: फ़ाइल की अंतिम पंक्ति बिना किसी नई पंक्ति के समाप्त हो जाती है" - लेकिन यह फ़ाइल स्वयं नहीं है खुलता है, क्योंकि यह अस्थायी है, तो बस तितर बितर फ़ाइल में अंतिम चरित्र के साथ लाइन ब्रेक जोड़ें।

स्टैक ओवरफ्लो से बचाव कैसे करें (कोर्टेक्स एम पर)?

परिचय

MPU

मैनुअल नियंत्रण

ट्रिकी स्टैक प्लेसमेंट

रिकॉर्ड पर एक्सेस ब्रेकपॉइंट

गतिशील अतिप्रवाह संरक्षण

गतिशील एसपी नियंत्रण

संक्षेप में देना

More articles: