क्रैश रिपोर्ट में * nix: backtrace, SEGFAULT (और reinterpret_cast)

हैलो, प्रिय habrayuzer!

सभी सॉफ्टवेयर डेवलपर्स जल्द या बाद में एक प्रोग्राम को क्रैश करने वाले उपयोगकर्ता की समस्या का सामना करते हैं। लेकिन हर कोई एक विशिष्ट कंप्यूटर तक नहीं पहुंच सकता है जिस पर कुछ गलत हो जाता है, वहां जीडीबी चलाएं और दुर्घटना को दोहराएं। और यहां तक ​​कि उपयोगकर्ता से जानकारी प्राप्त करना बेहद मुश्किल हो सकता है: संदेश "एक प्रोग्राम क्रैश, क्या करना है?" बगट्रैकर (या तकनीकी सहायता) पर आता है, लेकिन उपयोगकर्ता तकनीकी जानकारी को संलग्न नहीं करता है जो डेवलपर के लिए उसके संदेश के लिए बहुत महत्वपूर्ण है। हाँ, और हर कोई इसके बारे में नहीं लिखेगा! बस प्रोग्राम का उपयोग बंद कर दें - और यह बात है।

कुछ ऑपरेटिंग सिस्टम डेवलपर्स को क्रैश रिपोर्ट भेजने की पेशकश करते हैं। लेकिन! ओएस डेवलपर्स, आप नहीं, जो कि उन सभी लोगों पर नहीं हैं, जिन्हें वास्तव में इसकी आवश्यकता है! और फिर आपकी खुद की क्रैश रिपोर्ट बचाव में आती है, जिसे आपके प्रोग्राम को आपके सर्वर पर भेजना चाहिए। लेकिन उन्हें कैसे बनाया जाए? SEGFAULT को ठीक से कैसे संसाधित करें और उसी समय डेवलपर को समझदार जानकारी भेजें?

हेबेरे पर पहले से ही एरेनिम का एक दिलचस्प लेख था जो दुर्घटना के प्रसंस्करण के लिए समर्पित था। मैं संक्षेप में सार दोहराऊंगा: हम POSIX सिग्नल SIGSEGV को पकड़ते हैं, और इसे संसाधित करने के बाद, प्रोग्राम से बाहर निकलते हैं।

void catchCrash(int signum) { reportTrouble(); //  - signal(signum, SIG_DFL); //   exit(3); //   } int main() { signal(SIGSEGV, catchCrash); //-- ... --// } 

अब यह छोटा है: समस्या का स्थानीयकरण करें! और यद्यपि उपरोक्त विधि विंडोज पर काम करती है, हम केवल * nix में एक सामान्य बैकट्रेस प्राप्त कर सकते हैं (वास्तव में, आप इसे विंडोज में भी प्राप्त कर सकते हैं, लेकिन आपको इसके लिए डिबग असेंबली वितरित करना होगा, जो बहुत अच्छा नहीं है)। इसलिए, हम मैनुअल धूम्रपान करते हैं और ऐसा करते हैं:

 void reportTrouble() { void *callstack[128]; int frames = backtrace(callstack, 128); char **strs=backtrace_symbols(callstack, frames); //      crash_report.txt //         -  , , etc FILE *f = fopen("crash_report.txt", "w"); if (f) { for(int i = 0; i < frames; ++i) { fprintf(f, "%s\n", strs[i]); } fclose(f); } free(strs); system("curl -A \"MyAppCrashReporter\" --form report_file=@\"crash_report.txt\" http://reports.myserver.com"); } 

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

अब हम अभ्यास में उल्लिखित विधि का परीक्षण करेंगे। चलो एक साधारण वर्ग और सरल अतिरिक्त कार्यों के साथ एक सरल कार्यक्रम बनाते हैं। और इस कोड को छोड़ने का प्रयास करें। सबसे सरल बात यह है कि कक्षा के लिए शून्य सूचक पर विधि को कॉल करना है, लेकिन यह बहुत अधिक आदिम है, इससे भी बेहतर अगर सूचक "आकाश" को इंगित करता है, तो यह अधिक दिलचस्प है। इसे कैसे प्राप्त किया जाए? ठीक है, निश्चित रूप से, हम सभी को बहुत प्यारे प्यारे reinterpret_cast लागू करें! इसलिए, बैकट्रैक को और अधिक दिलचस्प बनाने के लिए, हम फ़ंक्शन goCrash() और crash(void *) बनाते हैं।

 int crash(void *obj) { Crasher *crasher = reinterpret_cast<Crasher *>(obj); crasher->doSomething(); return -1; } void goCrash() { const char *str = "Hello, crash!"; const char *str2 = "Hello again, crash!"; char str3[200]; sprintf(str3, "%s\t\t%s\n", str, str2); long long add = rand() % 20000 + 1500234000l; // fire in my leg! crash(reinterpret_cast<void *>(str3 - add)); } 

ठीक है, ऐसा लग रहा है कि हम अपने Crasher वर्ग के लिए एक निश्चित अज्ञात पता दे रहे हैं। बहुत उत्सुक! आइए घोषित करें वर्ग:

 #define P_DOUBLE_COUNT 10000 class Crasher { public: // c-tor Crasher() { myPrivateString = new char[100]; sprintf(myPrivateString, "%s\n", "that\'s my private string!"); myPrivateInteger = 100; for (int i = 0; i < P_DOUBLE_COUNT; ++i) myPrivateDoubles[i] = i / 100.0; } // func void doSomething() { // here we can (?) crash fprintf(stderr, "%s\n", "That\'sa function!"); doSomethingPrivate(); } private: void doSomethingPrivate() { // crash? oh, no... fprintf(stderr, "%s myPrivateInteger == %d\n", "That\'sa private function!", myPrivateInteger); fprintf(stderr, "myPrivateDoubles[1] == %f\n", myPrivateDoubles[1]); fprintf(stderr, "myPrivateString == %p\n", myPrivateString); // still alive? crash! crash! crash! ((Crasher*)NULL)->doSomething(); } private: char *myPrivateString; int myPrivateInteger; double myPrivateDoubles[P_DOUBLE_COUNT]; }; 

ध्यान दें कि doSomethingPrivate() फ़ंक्शन में, हमारे पास अभी भी फ़ंक्शन है जो null पॉइंटर पर कहा जाता है। तो, बस मामले में। अचानक, एक अपरिभाषित पते के लिए doSomething() कॉल करने के बाद, क्या प्रोग्राम अभी भी जीवित रहेगा?

अब आप हमारे प्रोग्राम को बना और चला सकते हैं। और हम क्या देखेंगे? कार्यक्रम ने सफलतापूर्वक काम किया, लेकिन curl ने कसम खाई कि सर्वर नहीं मिला। ठीक है, यह बकवास है, आप हमारी दुर्घटना रिपोर्ट को तुरंत देखने के लिए अस्थायी रूप से cat crash_report.txt को क्रैश कर सकते हैं। तो हम और क्या देखते हैं?

और हम लाइन देखते हैं "That's a function!" doSomething() विधि से प्राप्त! दिलचस्प है, है ना? एक आकाश की ओर इशारा करता है, तरीके काम करते हैं? खैर, वास्तव में ऐसा नहीं है।

आखिरकार, प्रोग्राम क्रैश होता है (सबसे अधिक संभावना है) doSomethingPrivate() कॉल पर, और doSomethingPrivate() स्पष्ट रूप से हमें यह रिपोर्ट करता है:

 0 segfault 0x000000010d0a98c8 _Z13reportTroublev + 40 1 segfault 0x000000010d0a99d0 _Z10catchCrashi + 16 2 libsystem_c.dylib 0x00007fff99b5dcfa _sigtramp + 26 3 ??? 0x00007fff00000000 0x0 + 140733193388032 4 segfault 0x000000010d0a9c67 _ZN7Crasher11doSomethingEv + 71 5 segfault 0x000000010d0a9880 _Z5crashPv + 32 6 segfault 0x000000010d0a9ac7 _Z7goCrashv + 199 7 segfault 0x000000010d0a9b33 main + 67 8 segfault 0x000000010d0a9854 start + 52 

पहले प्रयोग करते हैं, crash() बुलाते समय एक अतिरिक्त पता शिफ्ट नहीं करें crash() , प्रोग्राम आउटपुट क्या होगा? यह कहां दुर्घटनाग्रस्त होता है? अहम!

 That's a function! That's a private function! myPrivateInteger == 1752392050 myPrivateDoubles[1] == 60993401604041306737928347282702617388988841504491171140800281285302442927306116721201046092641903128620672849302937378251940003901836219046866981678295779355600933772275817062376375849852470059862498765690530537583237171035779906888043337758015488.000000 myPrivateString == 0x63202c6f6c6c6548 That's a function! 0 segfault 0x0000000109a5e8c8 _Z13reportTroublev + 40 1 segfault 0x0000000109a5e9d0 _Z10catchCrashi + 16 2 libsystem_c.dylib 0x00007fff99b5dcfa _sigtramp + 26 3 ??? 0x0000040000000000 0x0 + 4398046511104 4 segfault 0x0000000109a5ec67 _ZN7Crasher11doSomethingEv + 71 5 segfault 0x0000000109a5ec1a _ZN7Crasher18doSomethingPrivateEv + 208 6 segfault 0x0000000109a5ec67 _ZN7Crasher11doSomethingEv + 71 7 segfault 0x0000000109a5e880 _Z5crashPv + 32 8 segfault 0x0000000109a5eac4 _Z7goCrashv + 196 9 segfault 0x0000000109a5eb33 main + 67 10 segfault 0x0000000109a5e854 start + 52 

यह देखा जा सकता है कि doSomethingPrivate() करने के लिए दूसरा कॉल, और पहले एक धमाके के साथ बंद हो गया, हालांकि यह हमें बिल्कुल नहीं doSomethingPrivate() कि क्या इरादा था।

तो, क्यों, यहां तक ​​कि जब एक अशक्त सूचक पर एक विधि को कॉल करते हैं, तो segfault केवल दूसरे फ़ंक्शन पर होता है? वे अलग कैसे हैं? अनुभवी प्लस ने लंबे समय तक अनुमान लगाया है और इस लेख को नहीं पढ़ा है , लेकिन बाकी के लिए मैं समझाऊंगा। वे वर्ग चर के उपयोग में भिन्न होते हैं! यदि चर का उपयोग नहीं किया जाता है, तो यह महत्वपूर्ण नहीं है कि किस सूचक को फ़ंक्शन कहा जाता है, क्योंकि छिपे हुए this पैरामीटर का उपयोग नहीं किया जाता है, अर्थात्, हमारे पास इसमें कचरा है। दूसरे उदाहरण में (एक बदलाव के बिना), एक निजी फ़ंक्शन को this 'स्ट्रिंग की ओर इशारा करते हुए' कहा जाता है, और हमारे वर्ग चर इस स्ट्रिंग के कुछ हिस्सों की ओर इशारा करते हैं और तदनुसार, इसमें प्रवेश करने वाला कोई भी कचरा होता है। और पहले मामले में, पॉइंटर, सबसे अधिक संभावना है, केवल प्रोग्राम के लिए दुर्गम क्षेत्र को संदर्भित करेगा, इसलिए निजी फ़ंक्शन के पहले कॉल को पहले से ही चित्रित किया जाएगा।

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

सामान्य तौर पर, एक सफल डिबगिंग! और कम दुर्घटना रिपोर्ट;)