अधिकतम करने के लिए GDB डीबगर का उपयोग करना

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

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

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

एक उदाहरण qemu का उपयोग है:
1. वर्चुअल मशीन चलाएं (उदाहरण के लिए, फ्लॉपी डिस्क से एक साधारण बूट ओएस का उपयोग करके):
qemu -fda ./boot.fdd -s -S -vnc none &
(हम qemu वर्चुअल मशीन शुरू करते हैं, जो एक डिस्केट से बूट होगी जिसकी छवि फ़ाइल में है "./boot .fdd"; "-s –S" का अर्थ है कि मशीन निलंबित मोड में और डीबग मोड में शुरू होगी; "-बैंक कोई नहीं" का अर्थ है यह मशीन एक सक्रिय टर्मिनल के बिना शुरू होगी (अर्थात पृष्ठभूमि में, यह ssh के माध्यम से काम करते समय विशेष रूप से सुविधाजनक है, और बूटलोडर और बूट सेक्टर को डिबग करने के लिए कंप्यूटर स्क्रीन को देखने के लिए शायद ही कभी आवश्यक है); "&" - पृष्ठभूमि में वर्चुअल मशीन चलाएं)।
2. अब, gdb डीबगर को स्वयं चलाएं:
$ gdb
GNU gdb (Ubuntu/Linaro 7.2-1ubuntu11) 7.2
Copyright (C) 2010 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-linux-gnu".
For bug reporting instructions, please see:
<www.gnu.org/software/gdb/bugs>.
(gdb)
3. gdb डिबगर में, qemu पोर्ट से कनेक्ट करें:
(Gdb) target remote localhost: 1234

वैसे, यह पोर्ट नेटस्टैट में दिखाई देता है:
$ netstat –tlpn
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0: 1234 0.0.0.0:* LISTEN 4014/qemu


उस पते पर ध्यान दें जहाँ हम डिबगिंग शुरू करते हैं:
(gdb) target remote localhost: 1234
Remote debugging using localhost: 1234
0x0000fff0 in ?? ()
(gdb)

इस पते से, कोई भी प्रोसेसर बिजली चालू होने पर अपना ऑपरेशन शुरू करता है। दूसरे शब्दों में, हम BIOS की शुरुआत में (वर्चुअल मशीन के अंदर, बिल्कुल) सही थे।
4. इसके बाद, हमें वास्तविक मोड कोड डीबग करने के लिए gdb तैयार करना होगा:
(gdb) set arch i8086
The target architecture is assumed to be i8086
(gdb)

5. अब हमें अपने बूट सेक्टर की शुरुआत में पहला ब्रेकपॉइंट लगाना होगा:
(gdb) break * 0x7c00
Breakpoint 1 at 0x7c00
(gdb)

(BIOS 0x7c00 पर मेमोरी में निर्दिष्ट डिवाइस (एक फ्लॉपी डिस्क से) से पहले 512 बाइट्स को लोड करेगा और इस मेमोरी क्षेत्र पर नियंत्रण स्थानांतरित करेगा)।

6. हम अपने बूट सेक्टर में कूदते हैं:
(gdb) c
Continuing.

Breakpoint 1, 0x00007c00 in ?? ()
(gdb)

7. हो गया! आप हमारे कोड को डीबग कर सकते हैं!
कई डिबगिंग कोड सुविधाएँ हैं जिनके साथ आपको काम करना है।
सबसे पहले, आपको RealMode मोड में डेटा एड्रेसिंग की सुविधाओं पर विचार करना होगा। किसी भी जानकारी को खंड: ऑफसेट के रूप में संबोधित किया जाता है, जबकि पते की गणना इस प्रकार की जा सकती है: खंड * 16 + ऑफसेट। इसका मतलब है कि कोड के पहले 10 निर्देशों को पढ़ने के लिए, वर्तमान निर्देश के साथ शुरू करते हुए, आपको कमांड का उपयोग करने की आवश्यकता है: (gdb) x/10i $cs*16+$eip । इस मामले में असुविधा यह है कि वर्तमान gdb निर्देश को कोड खंड के आधार को ध्यान में रखे बिना दिखाया गया है:
(gdb) x/10i $cs*16+$eip
0x80000: jmp 0x90013
0x80002: (bad)
0x80003: mov $0x8,%di
0x80006: add $0xff,%al
0x80008: aas
0x80009: add %al,(%bx,%si)
0x8000b: add %al,(%bx,%si)
0x8000d: add %al,(%bx,%si)
0x8000f: add %al,(%bx,%si)
0x80011: add %al,(%bx,%si)
(gdb)

जबकि निर्देश का पता है:
Program received signal SIGTRAP, Trace/breakpoint trap.
0x00000000 in ?? ()
(gdb)

दूसरे, आपको मैन्युअल रूप से ब्रेकपॉइंट सेट करना और निकालना होगा। इसका मतलब है कि यदि आप एक ब्रेकपॉइंट सेट करते हैं:
(gdb) break *0x80017
Breakpoint 4 at 0x800 17

... तो उसे मारो ..:
(gdb) c
Continuing.

Program received signal SIGTRAP, Trace/breakpoint trap.
0x000000 17 in ?? ()
(gdb)

... और फिर स्टेपी करते हैं, तो आपको फिर से ब्रेकपॉइंट पर ले जाया जाएगा, बजाय निर्देशों का पालन करने के और स्वयं को निम्नलिखित पर स्विच करने के लिए:
Program received signal SIGTRAP, Trace/breakpoint trap.
0x000000 17 in ?? ()
(gdb) stepi
0x000000 17 in ?? ()
(gdb)

इसलिए, डिबगिंग प्रक्रिया कुछ इस तरह दिख सकती है:
1. बूटलोडर कोड में कहीं:
Program received signal SIGTRAP, Trace/breakpoint trap.
0x00000023 in ?? ()
(gdb) x/10i $cs*16+$eip
0x80023: mov %ebx,0xb
0x80028: movl $0x0,0xf
0x80031: call 0x80c15
0x80034: or %ax,%ax
0x80036: je 0x80087
0x80038: call 0x809af
0x8003b: call 0x80193
0x8003e: or %ax,%ax
0x80040: je 0x80268
0x80042: mov $0x3f4,%dx
(gdb)
2. ब्रेकपाइंट सेट करें, कॉल के बाद कट करें:
(gdb) break *0x8003e
Breakpoint 6 at 0x8003e

3. इस ब्रेकपाइंट से पहले कार्यक्रम चलाएं:
(gdb) c
Continuing.

Program received signal SIGTRAP, Trace/breakpoint trap.
0x0000003e in ?? ()
(gdb)
4. ब्रेकपॉइंट हटा दें:
(gdb) delete 6
(gdb)

5. वापसी मूल्य की जाँच करें:
(gdb) print /x $ax
$2 = 0x8000
(gdb)

6. एक कदम और आगे ले जाएं:
(gdb) stepi
0x00000040 in ?? ()
(gdb)

और इसलिए आप फ़ंक्शन के किसी एक पैरामीटर का मान पढ़ सकते हैं:
(gdb) x/1w $ss*16+0x12
0x70012: 0x00b8fa00
(gdb)

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