मैनुअल कर्षण विराम बिंदु (x86 आर्किटेक्चर के लिए)

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

निर्देश विराम

[इस प्रकार के विराम बिंदुओं के बारे में यह दो साल पहले पर्याप्त विस्तार से लिखा गया था , इसलिए मैंने संक्षेप में केवल सामान्य विचारों का हवाला दिया]



मान लीजिए कि हम एक JIT कंपाइलर लिखते हैं और कोड उत्पन्न करने वाले के अंदर ब्रेकपॉइंट्स सेट करना चाहते हैं। यह पता चला है कि इसके लिए यह उन स्थानों पर कोड स्ट्रीम में केवल एक int 3



निर्देश डालने के लिए पर्याप्त है जहां हम प्रोग्राम निष्पादन को रोकना चाहते हैं। जब प्रोसेसर इस निर्देश का सामना करता है, तो यह एक उचित व्यवधान उत्पन्न करेगा, जो कि OS का कर्नेल प्रोसेस करेगा और बदलेगा, उदाहरण के लिए, लिनक्स के तहत SIGTRAP सिग्नल में। नि: शुल्क तैराकी में शुरू किया गया एक कार्यक्रम बस int 3



सामना करने पर गिर जाएगा, लेकिन डिबगर इस संकेत को पकड़ लेगा, कार्यक्रम को रोक देगा और आपको इसकी स्थिति की जांच करने की अनुमति देगा।



वैसे, डिबगर्स स्वयं भी इस निर्देश का उपयोग करते हैं: वे बस इसे स्मृति में निर्देशों के साथ प्रतिस्थापित करते हैं जब हम उन्हें ब्रेक लगाने के लिए कहते हैं। इसीलिए int 3



को एक बाइट ( 0xCC



) के साथ एनकोड किया गया है और दो नहीं, प्रोग्राम 0xCD imm8



int X



( 0xCD imm8



) को जेनरेट करने के बाकी निर्देशों की तरह - अन्यथा int 3



सिंगल-बाइट के निर्देशों को बदलने के लिए उपयुक्त नहीं होगा।



जैसा कि हम देख सकते हैं, अनुदेश ब्रेकप्वाइंट के मैनुअल प्लेसमेंट में कुछ भी जटिल नहीं है। तुम भी उनके इंटरैक्टिव पर बंद लागू कर सकते हैं: बस उनके पदों को याद रखें और एक खाली nop



( 0x90



) निर्देश के साथ अनावश्यक बदलें।



बहुत अधिक दिलचस्प एक अन्य प्रकार के ब्रेकप्वाइंट के साथ मामला है - मेमोरी एक्सेस ब्रेकप्वाइंट।

पहुंच विराम बिंदु

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



दूसरे शब्दों में, हम उनके निपटान में एक समारोह में रखना चाहते हैं



void SetAccessBreak(void* addr);







यहां, अच्छे dr0



बचाव में आते हैं, अच्छी तरह से किए गए डिबग रजिस्टर dr0



, dr1



, dr2



, dr3



और उनके चाचा चेर्नोमोर dr7



, जिसमें नियंत्रण झंडे होते हैं।



उनका उपयोग करना काफी सरल है: रजिस्टरों में से एक में dr0



- dr3



उस पते को लोड करते हैं जिसे आपको मॉनिटर करने की आवश्यकता होती है, और dr7



उपयुक्त झंडे सेट करते हैं जो निर्धारित करते हैं कि संबंधित रजिस्टर का ब्रेकपॉइंट सक्रिय है या नहीं, यह घटना निम्नलिखित है (निष्पादित / पढ़ें / पढ़ें या लिखिए इस पते पर), डेटा आकार (1 बाइट, 2 बाइट्स, 4 बाइट्स, 8 बाइट्स)। ध्वज एन्कोडिंग नियमों के अस्पष्ट मौखिक स्पष्टीकरण पर स्थान को बर्बाद न करने के लिए, मैं तुरंत दो उपयोगिता कार्यों का कोड दूंगा: MakeFlags



, जो dr7



में उपयोग किए गए प्रारूप में दिए गए डिबग रजिस्टर के लिए झंडे को एन्कोड करता है, और MakeMask



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



enum DebugRegister { <br/>

kDR0 = 0 ,<br/>

kDR1 = 2 ,<br/>

kDR2 = 4 ,<br/>

kDR3 = 6 <br/>

} ; <br/>

<br/>

enum BreakState { <br/>

kDisabled = 0 , // disabled - 00 <br/>

kEnabledLocally = 1 , // task local - 01 <br/>

kEnabledGlobally = 2 , // global - 10 <br/>

kBreakStateMask = 3 // mask 11 <br/>

} ; <br/>

<br/>

enum Condition { <br/>

kWhenExecuted = 0 , // on execution - 00 <br/>

kWhenWritten = 1 , // on write - 01 <br/>

kWhenWrittenOrReaden = 3 , // on read or write - 11 <br/>

kConditionMask = 3 // mask 11 <br/>

} ; <br/>

<br/>

enum Size { <br/>

kByte = 0 , // 1 byte - 00 <br/>

kHalfWord = 1 , // 2 bytes - 01 <br/>

kWord = 3 , // 4 bytes - 11 <br/>

kDoubleWord = 2 , // 5 bytes - 10 <br/>

kSizeMask = 3 // mask 11 <br/>

} ; <br/>

<br/>

<br/>

uint32_t MakeFlags ( DebugRegister reg, BreakState state, Condition cond, Size size ) { <br/>

return ( state | cond << 16 | size << 24 ) << reg ; <br/>

} <br/>

<br/>

<br/>

uint32_t MakeMask ( DebugRegister reg ) { <br/>

return MakeFlags ( reg, kBreakStateMask, kConditionMask, kSizeMask ) ; <br/>

} <br/>









इन कार्यों के साथ सशस्त्र, आप बिना किसी को बताए पानी में भाग सकते हैं और एक सरल अंतर्निहित कोडांतरक के साथ SetAccessBreak



को लागू करने का प्रयास कर सकते हैं:



bool SetAccessBreak ( void * addr,<br/>

DebugRegister reg,<br/>

Condition cond,<br/>

Size size ) { <br/>

const uint32_t control = MakeFlags ( reg, kEnabledLocally, cond, size ) ; <br/>

__asm__ ( "movl %0, %%dr0 \n " <br/>

"movl %1, %%dr7 \n " : : "r" ( addr ) , "r" ( control ) : ) ; <br/>

}







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



/ thread_set_state



माध्यम से पढ़ और लिख सकते हैं। उनके माध्यम से आवश्यक रजिस्टरों तक पहुँच प्राप्त करने के बाद, हम आसानी से SetAccessBreak



लागू SetAccessBreak



:



bool SetAccessBreak ( pthread_t target_thread,<br/>

void * addr,<br/>

DebugRegister reg,<br/>

Condition cond,<br/>

Size size ) { <br/>

x86_debug_state dr ; <br/>

mach_msg_type_number_t dr_count = x86_DEBUG_STATE_COUNT ; <br/>

<br/>

// POSIX MACH . <br/>

mach_port_t target_mach_thread = pthread_mach_thread_np ( target_thread ) ; <br/>

<br/>

// . <br/>

kern_return_t rc = thread_get_state ( target_mach_thread,<br/>

x86_DEBUG_STATE,<br/>

reinterpret_cast < thread_state_t > ( & dr ) ,<br/>

& dr_count ) ; <br/>

<br/>

// <br/>

if ( rc ! = KERN_SUCCESS ) return false ; <br/>

<br/>

// , . <br/>

switch ( reg ) { <br/>

case kDR0 : dr. uds . ds32 .__dr0 = reinterpret_cast < unsigned int > ( addr ) ; break ; <br/>

case kDR1 : dr. uds . ds32 .__dr1 = reinterpret_cast < unsigned int > ( addr ) ; break ; <br/>

case kDR2 : dr. uds . ds32 .__dr2 = reinterpret_cast < unsigned int > ( addr ) ; break ; <br/>

case kDR3 : dr. uds . ds32 .__dr3 = reinterpret_cast < unsigned int > ( addr ) ; break ; <br/>

} <br/>

<br/>

// . <br/>

dr. uds . ds32 .__dr7 & = ~MakeMask ( reg ) ; <br/>

<br/>

// . <br/>

dr. uds . ds32 .__dr7 | = MakeFlags ( reg, kEnabledLocally, cond, size ) ; <br/>

<br/>

// . <br/>

rc = thread_set_state ( target_mach_thread,<br/>

x86_DEBUG_STATE,<br/>

reinterpret_cast < thread_state_t > ( & dr ) ,<br/>

dr_count ) ; <br/>

<br/>

// . <br/>

if ( rc ! = KERN_SUCCESS ) return false ; <br/>

<br/>

// . <br/>

return true ; <br/>

}







वह सब है! अब अच्छे अशुद्ध जेनिटर-कचरा कलेक्टर ब्रेकपॉइंट का प्रबंधन कर सकते हैं। जो विश्वास नहीं करता कि एक छोटा परीक्षण कार्यक्रम लिख सकता है:



static int16_t foo = 0 ; <br/>

static int32_t bar = 0 ; <br/>

<br/>

int main ( int argc, char * argv [ ] ) { <br/>

foo = 1 ; <br/>

bar = 1 ; <br/>

SetAccessBreak ( pthread_self ( ) , & bar, kDR0, kWhenWritten, kWord ) ; <br/>

foo = 2 ; <br/>

bar = 2 ; <br/>

SetAccessBreak ( pthread_self ( ) , & foo, kDR0, kWhenWritten, kHalfWord ) ; <br/>

foo = 3 ; <br/>

bar = 3 ; <br/>

return 0 ; <br/>

} <br/>









और डीबगर के नीचे इसे चलाने से यह सुनिश्चित हो जाएगा कि प्रत्येक व्यक्ति सही स्थानों पर बाधित है - अर्थात स्मृति क्षेत्र तक पहुँचने वाले निर्देशों का पालन करें:



(gdb) r

Starting program: /Users/mraleph/test

Reading symbols for shared libraries +++. done



Program received signal SIGTRAP, Trace/breakpoint trap.

main (argc=1, argv=0xbffff9f8) at test.cc:107

106 bar = 2; <= triggered SIGTRAP -- mr.aleph

107 SetAccessBreak(pthread_self(), &foo, kDR0, kWhenWritten, kHalfWord);

(gdb) c

Continuing.



Program received signal SIGTRAP, Trace/breakpoint trap.

main (argc=1, argv=0xbffff9f8) at test.cc:109

108 foo = 3; <= triggered SIGTRAP -- mr.aleph

109 bar = 3;

(gdb) c

Continuing.



Program exited normally.