कोर्टेक्स-एम पर पोस्टमार्टम डिबगिंग

पृष्ठभूमि:

मैंने हाल ही में उपभोक्ता इलेक्ट्रॉनिक्स वर्ग से मेरे लिए एक एटिपिकल डिवाइस के विकास में भाग लिया। ऐसा लगता है कि कुछ भी जटिल नहीं है, एक बॉक्स जिसे कभी-कभी स्लीप मोड से बाहर जाना चाहिए, सर्वर को रिपोर्ट करें और वापस सो जाएं।

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

डिबगिंग UART नोजल पर खराब हो गया था, जिसमें मैंने लॉग को आउटपुट करना शुरू कर दिया था। यह आसान हो गया, कुछ समस्याओं का समाधान हो गया। लेकिन फिर एक जोरदार हमला हुआ और यह सब हुआ।

#define USER_ASSERT( statement ) \ do \ { \ if(! (statement) ) \ { \ DEBUG_PRINTF_ERROR( "Assertion on line %d in file %s!\n", \ __LINE__, __FILE__ ); \ \ __disable_irq(); \ while(1) \ { \ __BKPT(0xAB); \ if(0) \ break; \ } \ } \ } while(0) 

कुछ कथनों के लिए, यह तुरंत स्पष्ट हो जाता है कि उनके कारण क्या हुआ - क्योंकि लॉग फ़ाइल का नाम और लाइन नंबर दिखाता है जिस पर मुखर ने काम किया है।

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

बेशक, कोई भी गोली को काट सकता है और आपके कोड को पढ़ सकता है, लेकिन मैं बहुत आलसी था, और फिर लेख काम नहीं करेगा।

चूंकि मैं आर्मप कंपाइलर के साथ uVision Keil 5 में लिखता हूं, इसके तहत आगे कोड की जाँच की गई थी। मैंने C ++ 11 का भी उपयोग किया, क्योंकि यह पहले से ही 2019 यार्ड में है, यह पहले से ही समय है।

स्टैकट्रेस

बेशक, पहली बात जो दिमाग में आती है, उसे धिक्कार है, क्योंकि जब एक सामान्य डेस्कटॉप कंप्यूटर पर एक मुखर होता है, तो स्टैक ट्रेस कंसोल पर आउटपुट होता है, जैसे कि केडीपीवी पर। स्टैक ट्रेस से, आप आमतौर पर समझ सकते हैं कि कॉल के किस क्रम में त्रुटि हुई।
ठीक है, इसलिए मुझे भी एक गुप्त ट्रैक की आवश्यकता है। इसे कैसे बनाया जाए?

शायद अगर आप एक अपवाद फेंकते हैं, तो वह कटौती की जाएगी?

हम एक अपवाद को फेंक देते हैं और इसे पकड़ नहीं पाते हैं; हम “ _sys_exit ” का आउटपुट देखते हैं और _sys_exit को कॉल करते हैं। सवारी नहीं, ठीक है, ठीक है, वास्तव में नहीं, और मैं वास्तव में अपवादों की अनुमति देना चाहता था।

अन्य लोग इसे कैसे करते हैं।

सभी तरीके प्लेटफ़ॉर्म- execinfo.h (बहुत आश्चर्य की बात नहीं), पोसिक्स के तहत जीसीसी के लिए backtrace() और execinfo.h । काले के लिए कुछ भी समझदारी नहीं थी। हम मतलबी आंसू गिराते हैं। आपको अपने हाथों से स्टैक पर चढ़ना होगा।

हम अपने हाथों से ढेर में चढ़ते हैं

सैद्धांतिक रूप से, सब कुछ काफी सरल है।

1. वर्तमान फ़ंक्शन से रिटर्न एड्रेस एलआर रजिस्टर में है, स्टैक के वर्तमान शीर्ष का पता (स्टैक में अंतिम तत्व के अर्थ में) एसपी रजिस्टर में है, वर्तमान कमांड का पता पीसी रजिस्टर में है।
2. किसी तरह, हम वर्तमान फ़ंक्शन के लिए स्टैक फ्रेम का आकार पाते हैं, स्टैक के साथ इतनी दूरी पर कदम रखते हैं, वहां पिछले फ़ंक्शन के लिए वापसी पता ढूंढें और इसे तब तक दोहराएं जब तक हम स्टैक से अंत तक नहीं जाते।
3. किसी तरह हम स्रोत कोड के साथ फ़ाइलों में लाइन नंबर के साथ रिटर्न पते से मेल खाते हैं।

ठीक है, शुरुआत के लिए - मुझे स्टैक फ्रेम का आकार कैसे पता चलेगा?

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

अब - स्रोत फ़ाइलों में स्ट्रिंग्स के साथ रिटर्न एड्रेस का मिलान कैसे करें?

धिक्कार है, फिर कोई रास्ता नहीं। डिबगिंग जानकारी को माइक्रोकंट्रोलर में फ्लैश नहीं किया जाता है (जो आश्चर्यजनक नहीं है, क्योंकि यह सभ्य स्थान लेता है)। क्या Cale उसे अभी भी वहां फ्लैश करने के लिए मिल सकता है, मुझे नहीं पता, मुझे नहीं मिला।

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

लेकिन यह बहुत दुखद लग रहा है, क्योंकि आपको .map फ़ाइल को पार्स करना है, जो कि पता चलता है कि प्रत्येक फ़ंक्शन का कब्जा है। और फिर एक विशेष लाइन खोजने के लिए अलग-अलग कोड वाली डिसाइड कोड वाली फाइलों को पार्स करें। स्कोर करने की तीव्र इच्छा है।

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

डिबगर यह कैसे करता है?

लेकिन डिबगर किसी तरह frame pointer'a बिना भी कॉल स्टैक दिखाता है। खैर, यह स्पष्ट है कि, आईडीई के पास सभी डिबग जानकारी कैसे है, उसके लिए कार्यों के पते और नामों की तुलना करना आसान है। हम्म।

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

लेकिन यह बहुत सरल है। बस जरूरत है हर दिन नितंबों में एक मोटी सोवियत निरंतरता रगड़ें स्टैक को उन मूल्यों के साथ आबाद करें जो गिरावट के समय थे और, जाहिरा तौर पर, रजिस्टरों की स्थिति को पुनर्स्थापित करते हैं। और यह सब, ऐसा लगता है?

फिर, इस विचार को उप-मुखौटे में तोड़ दें।

1. माइक्रोकंट्रोलर पर, आपको स्टैक के माध्यम से जाने की जरूरत है, इसके लिए आपको वर्तमान एसपी मूल्य और स्टैक की शुरुआत का पता प्राप्त करने की आवश्यकता है।
2. माइक्रोकंट्रोलर पर, आपको रजिस्टरों के मूल्यों को प्रदर्शित करने की आवश्यकता है।
3. IDE में, आपको किसी भी तरह से "minidump" से सभी मानों को स्टैक पर वापस धकेलना होगा। और रजिस्टरों के मूल्य भी।

सपा का वर्तमान मूल्य कैसे प्राप्त करें?

अधिमानतः, कोडांतरक पर हाथ नहीं मारना। Cale में, सौभाग्य से, एक विशेष कार्य (आंतरिक) है - __current_sp() । Gcc काम नहीं करेगा, लेकिन मुझे इसकी आवश्यकता नहीं है

स्टैक की शुरुआत का पता कैसे प्राप्त करें? चूंकि मैं अपनी स्क्रिप्ट का उपयोग ओवरफ्लो (जो मैंने यहां के बारे में लिखा था) से बचाने के लिए करता हूं, मेरा स्टैक एक अलग लिंकर खंड में स्थित है, जिसे मैंने REGION_STACK कहा है।
इसका मतलब यह है कि उनके पते को लिंकर में नामों में डॉलर के साथ अजीब चर का उपयोग करके पाया जा सकता है।

परीक्षण और त्रुटि से, हम वांछित नाम का चयन करते हैं - Image$$REGION_STACK$$ZI$$Limit , जाँच करें, यह काम करता है।

 extern unsigned int Image$$REGION_STACK$$ZI$$Limit; using MemPointer = const uint32_t *; //   ,   static const auto stack_upper_address = (MemPointer) &( Image$$REGION_STACK$$ZI$$Limit ); 

यदि आप परेशान होने का मन नहीं करते हैं, तो आप बस स्टैक के आकार को हार्डकोड कर सकते हैं, क्योंकि यह काफी कम बदलता है। सबसे खराब स्थिति में, हम कॉल स्टैक विंडो में सभी कॉल नहीं, बल्कि एक स्टब देखते हैं।

रजिस्टर मान कैसे प्रदर्शित करें?

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

हमें वास्तव में केवल लिंक रजिस्टर (एलआर) की आवश्यकता है, जो वर्तमान फ़ंक्शन, एसपी से रिटर्न एड्रेस को स्टोर करता है, जिसे हमने पहले ही निपटा दिया है, और प्रोग्राम काउंटर (पीसी), जो वर्तमान कमांड के पते को स्टोर करता है।

दोबारा, मुझे ऐसा विकल्प नहीं मिला जो किसी भी संकलक के साथ काम करेगा, लेकिन पीसी के लिए __current_pc() : __return_address() LR और __current_pc() लिए फिर से आंतरिक कार्य हैं।
बहुत बढ़िया। यह स्टैण्ड पर मिनीडम्प से सभी मूल्यों और रजिस्टरों में रजिस्टरों के मूल्यों को आगे बढ़ाने के लिए रहता है।

मेमोरी में मिनीडंप कैसे लोड करें?

सबसे पहले, मैंने LOAD डिबगर कमांड का उपयोग करने की योजना बनाई, जो आपको मेमोरी में .hex या .bin फ़ाइल से मान लोड करने की अनुमति देता है, लेकिन जल्दी से पता चला कि किसी कारण से लोड RAM में मान लोड नहीं करता है।
और मैं अभी भी इस कमांड के साथ रजिस्टर पूरा नहीं कर पाऊंगा।

ठीक है, ठीक है, इसे अभी भी बहुत सारे इशारों की आवश्यकता होगी, टेक्स्ट को बिन में कनवर्ट करें, बिन को हेक्स में परिवर्तित करें ...

सौभाग्य से, Cale के पास एक सिम्युलेटर है, और सिम्युलेटर के लिए आप कुछ मनहूस C- जैसी भाषा में स्क्रिप्ट लिख सकते हैं। और इस भाषा में स्मृति में लिखने का अवसर है! _WBYTE _WDWORD और _WBYTE जैसे विशेष कार्य हैं। हम सभी विचारों को एक ढेर में इकट्ठा करते हैं, और ऐसा कोड प्राप्त करते हैं।

 #define USER_ASSERT( statement ) \ do \ { \ if(! (statement) ) \ { \ DEBUG_PRINTF_ERROR( "Assertion on line %d in file %s!\n", \ __LINE__, __FILE__ ); \ \ print_minidump(); \ __disable_irq(); \ while(1) \ { \ __BKPT(0xAB); \ if(0) \ break; \ } \ } \ } while(0) //   ,    //   ,         scatter- extern unsigned int Image$$REGION_STACK$$ZI$$Limit; void print_minidump() { //   - armcc  arm-clang #if __CC_ARM || ( (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)) using MemPointer = const uint32_t *; //   ,   static const auto stack_upper_address = (MemPointer) &(Image$$REGION_STACK$$ZI$$Limit ); //      , ..      //  SP  stack_upper_address auto LR = __return_address(); auto PC = __current_pc(); auto SP = __current_sp(); auto i = 0; DEBUG_PRINTF("\nCopy the following function for simulator to .ini-file, \n" "start fresh debug session in simulator and call __load_minidump() from command window.\n" "You should be able to see the call stack in CallStack window\n\n"); DEBUG_PRINTF("func void __load_minidump() {\n "); for( MemPointer stack = (MemPointer)SP; stack <= stack_upper_address; stack++ ) { DEBUG_PRINTF("_WDWORD (0x%p, 0x%08x); ", stack, *stack ); //         if( i == 1 ) { DEBUG_PRINTF("\n "); i=0; } else { i++; } } DEBUG_PRINTF("\n LR = 0x%08x;", LR ); DEBUG_PRINTF("\n PC = 0x%08x;", PC ); DEBUG_PRINTF("\n SP = 0x%08x;", SP ); DEBUG_PRINTF("\n}\n"); #endif } 

मिनीडम्प को लोड करने के लिए, हमें एक। Ini फ़ाइल बनाने की आवश्यकता है, इसमें __load_minidump फ़ंक्शन को कॉपी करें, इस फ़ाइल को ऑटोरन - Project -> Options for Target -> Debug और इस .ini फ़ाइल का उपयोग सिम्युलेटर सेक्शन में "इनिशियलाइज़ेशन फ़ाइल" अनुभाग में लिखें।

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

सिद्धांत रूप में, वह सब है। जहाँ तक मैं सत्यापित करने में सक्षम था, मिनीडम्प नियमित कार्यों और व्यवधान संचालकों दोनों के लिए काम करता है। क्या यह setjmp/longjmp या alloca साथ सभी प्रकार की विकृतियों के लिए काम करेगा - मुझे नहीं पता, क्योंकि मैं विकृतियों का अभ्यास नहीं करता।

जो हुआ उससे मैं काफी प्रसन्न हूँ; थोड़ा कोड, उपरि - मुखर के लिए थोड़ा सूजा हुआ मैक्रो। इस मामले में, स्टैक पार्सिंग पर सभी उबाऊ काम आईडीई के कंधों पर गिर गए, जहां यह है।

फिर मैंने थोड़ा सा गुगली की और जीसीबी और जीडीबी के लिए एक समान चीज़ पाई - क्रैशचैकर ।

मैं समझता हूं कि मैंने कुछ नया आविष्कार नहीं किया है, लेकिन मैं एक तैयार किए गए नुस्खा को एक समान परिणाम के लिए नहीं खोज सका। मैं आभारी रहूंगा अगर वे मुझे बताएं कि क्या बेहतर किया जा सकता है।