🛀🏼 🌅 🧕 क्विक डायग्नोस्टिक्स और प्रॉब्लम सॉल्विंग के साथ लिनक्स कर्नेल की इनसाइड किचन सीखना 👈🏻 📬 👢

यह लेख आधुनिक लिनक्स के बारे में है। उदाहरण के लिए, 2.6.3x गुठली के साथ RHEL6 करेंगे, लेकिन 2.6.18 गुठली के साथ RHEL5 (वैसे, उत्पादन में सबसे लोकप्रिय) - अफसोस, नहीं। और फिर भी - परमाणु डिबगर्स या SytemTap लिपियों का कोई विवरण नहीं होगा; केवल अच्छे पुराने सरल कमांड जैसे "कैट / प्रोक / पीआईडी / xyz", / प्रोक्योर फ़ाइल सिस्टम के कुछ उपयोगी नोड्स के संबंध में।

"निरोधात्मक" प्रक्रिया के निदान

यहाँ एक बार-बार होने वाली समस्या का एक अच्छा उदाहरण है जिसे मैंने अपने लैपटॉप पर पुन: पेश किया: उपयोगकर्ता शिकायत करता है कि find "बहुत धीमा" काम करता है, बिना कोई परिणाम दिए। यह जानते हुए कि मामला क्या था, हमने समस्या हल कर दी। हालांकि, मुझे इस तरह की समस्याओं को हल करने के लिए एक व्यवस्थित दृष्टिकोण की रूपरेखा तैयार करने के लिए कहा गया था।

सौभाग्य से, सिस्टम OEL6, यानी चला रहा है काफी ताजा कर्नेल पर (अर्थात् - 2.6.39 UEK2)

तो, चलिए निदान शुरू करते हैं।

पहले, जाँच करें कि क्या खोज प्रक्रिया अभी भी जीवित है:

[root @ oel6 ~] # ps -ef | पकड़ना
रूट 27288 27245 4 11:57 पीटी / 0 00:00:01 खोजें। -प्रकार f
रूट 27334 27315 0 11:57 पीटीएस / 1 00:00:00 ग्रीप पाते हैं

हां, यह जगह में है - पीआईडी 27288 (नैदानिक उदाहरण में मैं इस पीआईडी का उपयोग करूंगा)

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

[रूट @ oel6 ~] # टॉप -cbp २ .२66
शीर्ष - 11:58:15 7 दिन, 3:38, 2 उपयोगकर्ता, लोड औसत: 1.21, 0.65, 0.47
कार्य: 1 कुल, 0 दौड़ना, 1 सोना, 0 रुकना, 0 ज़ोंबी
CPU (s): 0.1% us, 0.1% sy, 0.0% ni, 99.8% id, 0.0% wa, 0.0% hi, 0.0% si, 0.0% st
मेम: 2026460k कुल, 1935780k इस्तेमाल किया, 90680k मुफ्त, 64416k बफर
स्वैप: 4128764k कुल, 251004k इस्तेमाल किया, 3877760k मुफ्त, 662280k कैश किया गया

PID USER PR NI VIRT RES SHR S% CPU% MEM TIME + COMMAND
27288 रूट 20 0 109 मी 1160 844 डी 0.0 0.1 0: 01.11 खोजें। -प्रकार f

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

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

[रूट @ oel6 ~] # स्ट्रेस -cp २ .२66
प्रक्रिया 27288 जुड़ी - छोड़ने के लिए रुकावट

^ सी
^ Z
[१] + स्टॉप स्ट्रेस -cp २ .२oppedopped

[रूट @ oel6 ~] # मार-९%%
[१] + स्टॉप स्ट्रेस -cp २ .२oppedopped
[रूट @ oel6 ~] #
[१] + मारे गए स्ट्रेस -cp २ .२illedilled

उफ़… लगता है स्ट्रेस टीम ने भी खुद को लटका लिया है! उसने लंबे समय तक कुछ भी प्रदर्शित नहीं किया, और CTRL + C दबाने का भी जवाब नहीं दिया, इसलिए मुझे पहले उसे CTRL + Z दबाकर बैकग्राउंड में भेजना पड़ा, और फिर पूरी तरह से मार दिया। बहुत आसान निदान नहीं!

आइए pstack की कोशिश करें (लिनक्स पर, pstack GDB डीबगर के लिए सिर्फ एक आवरण स्क्रिप्ट है)। Pstack हमें कर्नेल की आंतरिक रसोई के बारे में कुछ भी नहीं बताएगा, लेकिन कम से कम यह इंगित करेगा कि यह किस प्रकार की प्रणाली है, (आमतौर पर यह उपयोगकर्ता स्टैक के शीर्ष पर एक libc लाइब्रेरी फ़ंक्शन कॉल की तरह दिखता है):

[रूट @ oel6 ~] # मंच २ .२66

^ सी
^ Z
[१] + रूका हुआ मवाद २8२]]

[रूट @ oel6 ~] # मार%%
[१] + रूका हुआ मवाद २8२]]
[रूट @ oel6 ~] #
[१] + समाप्त पृष्ठ २inated२ ]ack

Pstack भी बिना किसी स्पष्टीकरण के लटका दिया!

इसलिए, हम अभी भी नहीं जानते हैं कि हमारी प्रक्रिया 100% मुफ़्त है (अफसोस), या केवल 99.99% (उठता है और तुरंत सो जाता है) - और हम यह भी नहीं जानते कि वास्तव में ऐसा कहां हुआ है।

मैं और कहाँ देख सकता हूँ? एक और अक्सर सुलभ जगह है - स्थिति और WCHAN फ़ील्ड, जिनमें से सामग्री को पुराने पुराने ps कमांड (hmm ... का उपयोग करके जांच की जा सकती है ... शायद आपको इसे तुरंत चलाने के लिए सुनिश्चित करना चाहिए कि हम लाश के साथ काम नहीं कर रहे हैं):

[रूट @ oel6 ~] # ps -flp २6२66
FS UID PID PPID C PRI NI ADDR SZ WCHAN STIME TTY समय सीएमडी
0 D रूट 27288 27245 0 80 0 - 28070 rpc_wa 11:57 pts / 0 00:00:01 खोजें। -प्रकार f

यह सुनिश्चित करने के लिए कि प्रक्रिया एक ही स्थिति में जारी है, पीएस को एक पंक्ति में कई बार चलाने की आवश्यकता है (आप गलत समय पर किए गए एकमात्र प्रयास के आधार पर गलत निष्कर्ष पर नहीं आना चाहते हैं?)। हालांकि, यहां मैं बहादुरी से केवल एक लॉन्च दिखा रहा हूं।

प्रक्रिया राज्य डी ("ध्वनि नींद") में है, जो आमतौर पर डिस्क I / O से जुड़ी होती है (जैसा कि पीएस मैन पेज भी कहता है)। इसके अलावा, WCHAN फ़ील्ड (फ़ंक्शन का नाम जो प्रक्रिया को हाइबरनेशन / प्रतीक्षा स्थिति में लाता है) थोड़ा फसली है। मैं इस फ़ील्ड के आउटपुट को थोड़ा व्यापक बनाने के लिए ps कॉल में एक विकल्प जोड़ सकता हूं, हालाँकि, चूंकि किसी भी मामले में इसकी सामग्री / proc सिस्टम से आती है, तो हम सीधे स्रोत पर नज़र डालते हैं (फिर से, यह सुनिश्चित करने के लिए कई बार ऐसा करना अच्छा होता है कि यह फ्रीज हो जाए) क्या प्रक्रिया पूरी हो गई है, या क्या यह बहुत बार सो रहा है):

[रूट @ oel6 ~] # बिल्ली / proc / 27288 / wchan
rpc_wait_bit_killable

हम्म ... ऐसा लग रहा है कि प्रक्रिया किसी तरह की आरपीसी कॉल की उम्मीद कर रही है। इसका आमतौर पर मतलब है कि प्रक्रिया अन्य प्रक्रियाओं (या तो स्थानीय मशीन पर, या दूरस्थ सर्वर पर भी) के साथ संचार कर रही है। लेकिन हम अभी भी पता नहीं क्यों।

क्या कोई आंदोलन है, या प्रक्रिया पूरी तरह से अटक गई है?

लेख के "मांस" पर जाने से पहले, आइए निर्धारित करें कि प्रक्रिया पूरी तरह से अटक गई है या नहीं। आधुनिक गुठली पर, आप अध्ययन / खरीद / पीआईडी / स्थिति के बारे में पता लगा सकते हैं। स्पष्टता के लिए, मैंने हमारे लिए दिलचस्प मूल्यों पर प्रकाश डाला है:

[रूट @ oel6 ~] # बिल्ली / प्रोक / २ /२ status status / स्थिति
नाम: खोज
राज्य: D (डिस्क स्लीप)
Tgid: 27288
पिड: 27288
पीपीआईडी: 27245
ट्रेसरपिड: 0
उिद: ० ० ० ०
गिद: ० ० ० ०
Fdsize: 256
समूह: 0 1 2 3 4 6 10
VmPeak: 112628 kB
VmSize: 112280 kB
VmLck: 0 kB
VHHWM: 1508 kB
VmRSS: 1160 केबी
VmData: 260 kB
VmStk: 136 kB
VmExe: 224 kB
VmLib: 2468 kB
VmPTE: 88 kB
VmSwap: 0 kB
सूत्र: 1
SigQ: 4/15831
SigPnd: 0000000000040000
ShdPnd: 0000000000000000
सिब्लॉक: 0000000000000000
सिग्नगन: 0000000000000000
SigCgt: 0000000180000000
CapInh: 0000000000000000
CapPrm: ffffffffffffffff
CapEff: ffffffffffffffff
Capbnd: ffffffffffffffff
Cpus_allowed: ffffffff, ffffffff
Cpus_allowed_list: 0-63
Mems_allowed: 00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000.00000000 00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000001
Mems_allowed_list: 0
voluntary_ctxt_switches: 9950
nonvoluntary_ctxt_switches: 17104

प्रक्रिया राज्य में है - डिस्क नींद ("ध्वनि" नींद)। voluntary_ctxt_switches और nonvoluntary_ctxt_switches के मूल्यों पर भी ध्यान nonvoluntary_ctxt_switches - वे हमें बताएंगे कि प्रोसेसर ने कितनी बार सीपीयू का क्वांटा प्राप्त किया (या वापस दिया)। फिर, कुछ सेकंड के बाद, फिर से कमांड चलाएं और जांचें कि क्या मान बढ़ गए हैं। मेरे मामले में, संख्या में वृद्धि नहीं हुई, और इसलिए मैं यह सुझाव दूंगा कि प्रक्रिया तंग (अच्छी तरह से, या कम से कम टीमों के बीच उन कुछ सेकंड के दौरान कभी नहीं जागती)। इसलिए, अब मुझे अधिक विश्वास हो सकता है कि यह प्रक्रिया पूरी तरह से जमी हुई है (और सिर्फ रडार से नीचे नहीं उड़ रही है, लगातार प्रोसेसर के समय का 0.04% खपत करता है)।

वैसे, दो और स्थान हैं जहां आप संदर्भ स्विच की संख्या देख सकते हैं (और उनमें से दूसरा, इसके अलावा, प्राचीन गुठली पर उपलब्ध है):

[रूट @ oel6 ~] # कैट / प्रोक / २ /२ sched sched / शेड्यूल
खोजें (27288, # सूत्र: 1)
- se.exec_start: 617547410.689282
se.vruntime: 2471987.542895
se.sum_exec_runtime: 1119.480311
se.statistics.wait_start: 0.000000
se.statistics.sleep_start: 0.000000
se.statistics.block_start: 617547410.689282
se.statistics.sleep_max: 0.089192
se.statistics.block_max: 60082.951331
se.statistics.exec_max: 1.110465
se.statistics.slice_max: 0.334211
se.statistics.wait_max: 0.812834
se.statistics.wait_sum: 724.745506
se.statistics.wait_count: 27211
se.statistics.iowait_sum: 0.000000
se.statistics.iowait_count: 0
se.nr_migrations: 312
se.statistics.nr_migrations_cold: 0
se.statistics.nr_failed_migrations_affine: 0
se.statistics.nr_failed_migrations_running: 96
se.statistics.nr_failed_migrations_hot: 1794
se.statistics.nr_lied_migrations: 150
se.statistics.nr_wakeups: 18507
se.statistics.nr_wakeups_sync: 1
se.statistics.nr_wakeups_migrate: 155
se.statistics.nr_wakeups_local: 18504
se.statistics.nr_wakeups_remote: 3
se.statistics.nr_wakeups_affine: 155
se.statistics.nr_wakeups_affine_attempts: 158
se.statistics.nr_wakeups_passive: 0
se.statistics.nr_wakeups_idle: 0
avg_atom: 0.041379
avg_per_cpu: 3.588077
nr_switches: 27054
nr_voluntary_switches: 9950
nr_involuntary_switches: 17104
se.load.weight: 1024
नीति: 0
prio: 120
घड़ी-डेल्टा: 72

यहां आपको संख्या nr_switches (जो nr_voluntary_switches + nr_involuntary_switches बराबर है) को देखने की आवश्यकता है।

Nr_switches की कुल संख्या ऊपर के टुकड़े में 27054 है, और यह आउटपुट / proc / PID / अनुसूची में तीसरे क्षेत्र में भी स्थित है:

[रूट @ oel6 ~] # कैट / प्रोक / २ /२ sched sched / शेड्यूलैट
1119480311 724745506 27054

और यह बढ़ता नहीं है ...

/ खरीद फ़ाइल सिस्टम का उपयोग करके कोर कर्नेल रसोई की खोज करना

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

हम यह कैसे पता लगा सकते हैं कि किस सिस्टम कॉल में हम बिना स्ट्रेस या पीस्टैक के लटकाए थे? सौभाग्य से, हम एक आधुनिक कोर पर काम करते हैं! आपका स्वागत है / खरीद / पीआईडी / syscall!

[रूट @ oel6 ~] # बिल्ली / proc / 27288 / syscall
262 0xffffffffffffff9c 0x20cf6c8 0x7fff97c52710 0x100 0x100 0x676e776f645f616d 0x7fff97c52658 0x390e2da8ea

Zashib! और इसके साथ मुझे क्या करना चाहिए ???
खैर, आमतौर पर इन नंबरों को किसी चीज की जरूरत होती है। यदि हम "0xAVeryBigNumber" जैसी कोई चीज़ देखते हैं, तो यह आमतौर पर मेमोरी में एक पता होता है (और उन्हें pmap जैसी उपयोगिताओं के साथ इस्तेमाल किया जा सकता है), और यदि संख्या छोटी है, तो यह सबसे अधिक संभावना है कि किसी प्रकार के एक सूचकांक के लिए। उदाहरण के लिए, ओपन फाइल डिस्क्रिप्टर की एक सरणी (जिसे आप / proc / PID / fd में देख सकते हैं), या, इस मामले में, चूंकि हम सिस्टम कॉल के साथ काम कर रहे हैं, यह सिस्टम कॉल की संख्या है जो प्रक्रिया में है! तो, हम अब जानते हैं कि प्रक्रिया # 262 सिस्टम कॉल में फंस गई है!

ध्यान दें कि सिस्टम कॉल नंबर विभिन्न ऑपरेटिंग सिस्टम, ओएस संस्करणों और प्लेटफार्मों के बीच भिन्न हो सकते हैं, इसलिए आपको अपने ओएस से सही हेडर फ़ाइल की आवश्यकता होगी। / Usr / फ़ोल्डर में "syscall *" की तलाश करके शुरू करना एक अच्छा विचार है। मेरे संस्करण और लिनक्स प्लेटफ़ॉर्म (64 बिट) पर, सिस्टम कॉल फ़ाइल /usr/include/asm/unistd_64.h में परिभाषित की गई हैं:

[रूट @ oel6 ~] # grep 262 /usr/include/asm/unistd_64.h
#define __NR_ newfstatat 262

हम लगभग वहाँ हैं! 262 सिस्टम कॉल को newfstatat कहा जाता है। यह आदमी को चलाने और यह पता लगाने के लिए रहता है कि यह क्या है। मैं सिस्टम कॉल के नामों पर एक त्वरित टिप दूंगा: यदि मैन पेज में आपको आवश्यक नाम नहीं मिलता है, तो सभी प्रकार के प्रत्ययों और उपसर्गों के बिना खोज करने का प्रयास करें (उदाहरण के लिए, "आदमी pread64" के बजाय "आदमी" - और इस मामले में, आदमी को "नया" उपसर्ग के बिना चलाएं) man fstatat । खैर, या बस इसे google करें।

जैसा कि हो सकता है, यह "नया-fstat-at" सिस्टम कॉल नियमित फ़ाइल सिस्टम कॉल के तरीके के समान फ़ाइल गुणों को पढ़ना संभव बनाता है। और हम बस फ़ाइल के मेटाडेटा को पढ़ने के संचालन में लटका रहे हैं। इसलिए, हम एक कदम आगे बढ़ गए हैं। हालाँकि, हम अभी भी नहीं जानते कि फ़्रीज़ क्यों हुआ!

खैर, यह मेरे छोटे दोस्त / प्रॉप / पीआईडी / स्टैक को बधाई देने का समय है, जो आपको प्रक्रिया की परमाणु स्टैक की श्रृंखला को केवल खरीद-फ़ाइल की सामग्री को प्रिंट करने की अनुमति देगा !!!

[रूट @ oel6 ~] # बिल्ली / प्रोक / २ /२ stack stack / स्टैक
[] rpc_wait_bit_killable + 0x24 / 0x40 [sunrpc]
[] __rpc_execute + 0xf5 / 0x1d0 [sunrpc]
[] rpc_execute + 0x43 / 0x50 [sunrpc]
[] rpc_run_task + 0x75 / 0x90 [sunrpc]
[] rpc_call_sync + 0x42 / 0x70 [sunrpc]
[] nfs3_rpc_wrapper.clone.0 + 0x35 / 0x80 [nfs]
[] nfs3_proc_getattr + 0x47 / 0x90 [nfs]
[] __nfs_revalidate_inode + 0xcc / 0x1f0 [nfs]
[] nfs_revalidate_inode + 0x36 / 0x60 [nfs]
[] nfs _getattr + 0x5f / 0x110 [nfs]
[] vfs_getattr + 0x4e / 0x80
[] vfs_fstatat + 0x70 / 0x90
[] sys_ newfstatat + 0x24 / 0x50
[] system_call_fastpath + 0x16 / 0x1b
[] ०xffffffffffffffff

शीर्ष फ़ंक्शन वह जगह है जहां हम कर्नेल कोड में हैं। यह वही है जो WCHAN क्षेत्र ने हमें पहले ही बता दिया है (हालांकि, ध्यान दें कि वास्तव में वहाँ कुछ और कार्य हैं, जैसे कि कर्नेल फ़ंक्शन schedule() , जो आवश्यकतानुसार सोता या जागता है। हालाँकि, ये फ़ंक्शन यहाँ नहीं दिखाए गए हैं। , शायद इसलिए कि वे पहले से ही अपेक्षा की स्थिति का परिणाम हैं, और इसके कारण नहीं)।

इस कार्य के लिए एक पूर्ण कर्नेल स्टैक हाथ में होने के बाद, हम इसे नीचे से अध्ययन कर सकते हैं और यह पता लगाने की कोशिश कर सकते हैं कि rpc_wait_bit_killable फ़ंक्शन पर कॉल करने से rpc_wait_bit_killable का कॉल कैसे आया और हमें सोने के लिए डाल दिया।

system_call_fastpath कॉल मानक कर्नेल सिस्टम कॉल हैंडलर है जिसके कारण उस कोड का नेतृत्व किया गया है जो कि newfstatat ( sys_newfstatat ) सिस्टम कॉल को लागू करता है जिसे हम काम कर रहे हैं। "बच्चे" कार्यों में आगे बढ़ते हुए, हम एनएफएस से संबंधित कई चीजें देखते हैं। यह पहले से ही 100% अकाट्य प्रमाण है कि हम एनएफएस प्रसंस्करण कोड क्षेत्र में कहीं हैं! मैं यह नहीं कहता कि "एनएफएस कोड में", जब तक हम ऊपर देखते हैं, इन एनएफएस कार्यों के अंतिम, बदले में, किसी अन्य प्रक्रिया से संपर्क करने के लिए कुछ आरपीसी फ़ंक्शन (rpc_call_sync) को कॉल करता है। इस मामले में, यह संभवतः [kworker/N:N] , [nfsiod] , [lockd] या [rpciod] IO कर्नेल थ्रेड है। और इनमें से कुछ कारण किसी भी कारण से प्रतिक्रिया नहीं करते हैं (आमतौर पर आपको डिस्कनेक्ट किए गए नेटवर्क कनेक्शन, पैकेट हानि, या बस किसी प्रकार की नेटवर्क समस्याओं पर संदेह करना चाहिए)।

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

[रूट @ oel6 proc] # के लिए मैं `pgrep कार्यकर्ता` में; ps ps -fp $ i; बिल्ली / खरीद / $ i / स्टैक; किया
UID PID PPID C STIME TTY समय सीएमडी
जड़ ५३ २ ० फरवरी १४? 00:04:34 [ kworker / 1: 1]

[] __cond_resched + 0x2a / 0x40
[] lock_sock_nested + 0x35 / 0x70
[] tcp_sendmsg + 0x29 / 0xbe0
[] inet_sendmsg + 0x48 / 0xb0
[] sock_sendmsg + 0xef / 0x120
[] kernel_sendmsg + 0x41 / 0x60
[] xs_send_kvec + 0x8e / 0xa0 [sunrpc]
[] xs_sendpages + 0x173 / 0x220 [sunrpc]
[] xs_tcp_send_request + 0x5d / 0x160 [sunrpc]
[] xprt_transmit + 0x83 / 0x2e0 [sunrpc]
[] call_transmit + 0xa8 / 0x130 [sunrpc]
[] __rpc_execute + 0x66 / 0x1d0 [sunrpc]
[] rpc_async_schedule + 0x15 / 0x20 [sunrpc]
[] process_one_work + 0x13e / 0x460
[] कार्यकर्ता_थ्रेड + ०x१ / सी / ० एक्स ३ बी ०
[] kthread + 0x96 / 0xa0
[] kernel_thread_helper + 0x4 / 0x10

कर्नेल ट्रेसिंग को चालू करना और यह पता लगाना मुश्किल नहीं है कि कौन से कर्नेल धागे एक-दूसरे के साथ संवाद करते हैं, लेकिन इस लेख में मैं ऐसा नहीं करना चाहता। इसे व्यावहारिक (और सरल) नैदानिक अभ्यास होने दें!

हम समझते हैं और "मरम्मत"

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

चूंकि स्टैक के शीर्ष पर "किल करने योग्य" फ़ंक्शन (जिसे सुरक्षित रूप से बाधित किया जा सकता है, rpc_wait_bit_killable ) में से एक है, हम इसे kill -9 कमांड से kill -9 सकते हैं:

[रूट @ oel6 ~] # ps -fp २ .२66
UID PID PPID C STIME TTY समय सीएमडी
रूट 27288 27245 0 11:57 पीटीएस / 0 00:00:01 खोजें। -प्रकार f
[रूट @ oel6 ~] # मार-९ २ .२ .6

[रूट @ oel6 ~] # ls -l / proc / २ /२ stack stack / स्टैक
ls: एक्सेस नहीं कर सकते / खरीद नहीं सकते / 27288 / स्टैक: ऐसी कोई फ़ाइल या निर्देशिका नहीं

[रूट @ oel6 ~] # ps -fp २ .२66
UID PID PPID C STIME TTY समय सीएमडी
[रूट @ oel6 ~] #

प्रक्रिया पूरी हो गई है।

रूपरेखा कर्नेल थ्रेड्स "घुटने पर"

ध्यान दें कि फ़ाइल / proc / PID / स्टैक एक नियमित पाठ फ़ाइल की तरह दिखता है। इसलिए, आप आसानी से एक कर्नेल थ्रेड प्रोफ़ाइल प्राप्त कर सकते हैं! वर्तमान प्रणाली कॉल का पता लगाने के लिए, साथ ही साथ कर्नेल स्टैक (यदि हम सिस्टम कॉल में हैं) का प्रचार करने के लिए आप "घुटने पर" कैसे कर सकते हैं, और फिर इस सब को एक अर्ध-श्रेणीबद्ध प्रोफ़ाइल में संयोजित करें:

[रूट @ oel6 ~] # निर्यात LC_ALL = C ; i में {1..100} के लिए; do cat / proc / 29797 / syscall | awk '{प्रिंट $ 1}'; cat / proc / 29797 / स्टैक | / होम / ओरेकल / os_explain -k; usleep 100000; हो गया | सॉर्ट -r | uniq -c

  69 चल रहा है
       1 ffffff81534c83
       2 ffffff81534820
       6247
      25,180

     100 0xffffffffffffffff 
       1 थ्रेड_ग्रुप_ क्रिप्टाइम 
      27 sysenter_dispatch 
       3 ia32_sysret 
       1 task_sched_runtime 
      27 sys32_pread 
       1 कंप्‍लीट_सिज_यो_सुबमिट 
       2 कंप्रेशर_एसवाई_ओ_गेटवेंट्स 
      27 sys_pread64 
       2 sys_io_getevents 
       1 do_io_submit 
      27 vfs_read 
       2 read_events 
       1 io_submit_one 
      27 do_sync_read 
       1 aio_run_iocb 
      27 जेनेरिक_फाइल_ऑयो_्रेड 
       1 aio_rw_vect_retry 
      27 जेनेरिक_फाइल_डर_टर 
       1 जेनेरिक_फाइल_ऑयो_्रेड 
      27 mapping_direct_IO 
       1 जेनेरिक_फाइल_ड्रेड_टर 
      27 blkdev_direct_IO 
      27 __blockdev_direct_IO 
      27 do_blockdev_direct_IO 
      27 dio_post_submission 
      27 dio_await_completion 
       6 blk_flush_plug_list

यह आपको बहुत मोटे तौर पर यह आकलन करने की अनुमति देगा कि कर्नेल में प्रक्रिया अपना समय कहां खर्च करती है (यदि बिल्कुल भी)। सिस्टम कॉल नंबर शीर्ष पर अलग से हाइलाइट किए गए हैं। "रनिंग" का अर्थ है कि निदान के दौरान प्रक्रिया उपयोगकर्ता स्थान में काम करती है (और सिस्टम कॉल में नहीं)। इसलिए, 69% प्रक्रिया उपयोगकर्ता कोड में थी; सिस्टम कॉल पर 25% # 180 (मेरे सिस्टम पर nfsservctl), और सिस्टम कॉल पर 6% # 247 (वेटिड)।

ऊपर, लेखक कुछ स्क्रिप्ट / होम / ओरेकल / os_explain के लिए कॉल का उपयोग करता है। आप इसे संदर्भ द्वारा प्राप्त कर सकते हैं - लगभग। ट्रांस।

आउटपुट दो और "फ़ंक्शन" दिखाता है, किसी कारण से वे नाम से प्रकट नहीं हुए। हालांकि, उनके पते ज्ञात हैं, इसलिए हम उन्हें मैन्युअल रूप से जांच सकते हैं:

[रूट @ oel6 ~] # बिल्ली / proc / kalls Gym | grep -i ffffff81534c83
ffffffff81534c83 t ia32_sysret

ऐसा लगता है कि यह 32-बिट सबसिस्टम के लिए सिस्टम कॉल से एक वापसी है, हालांकि, चूंकि यह फ़ंक्शन अपने आप में सिस्टम कॉल नहीं है (यह सिर्फ एक आंतरिक सहायक फ़ंक्शन है), जाहिर है / proc / stack हैंडलर ने अपना नाम प्रदर्शित नहीं किया। यह भी संभव है कि ये पते दिखाए गए हैं क्योंकि / proc स्थिति पाठक के अनुरूप नहीं है: जबकि एक थ्रेड इन मेमोरी संरचनाओं को संशोधित करता है और थ्रेड को पढ़ने वाले तत्व कभी-कभी बासी डेटा को देखते हैं।

उसी समय दूसरा पता जांचें:

[रूट @ oel6 ~] # बिल्ली / proc / kalls Gym | grep -i ffffff81534820
[रूट @ oel6 ~] #

क्या कुछ नहीं मिला? हालाँकि, डिबगिंग यहाँ खत्म नहीं हुई है! आइए इस पते के आसपास कुछ दिलचस्प देखें। उदाहरण के लिए, पता के अंत में अंकों के अंतिम जोड़े को हटा दें:

[रूट @ oel6 ~] # बिल्ली / proc / kalls Gym | grep -i ffffff815348
ffffffff8153480d t sysenter_do_call
ffffffff81534819 t sysenter_dispatch
ffffffff81534847 t sysexit_from_sys_call
ffffffff8153487a t sysenter_auditsys
ffffffff815348b9 t sysexit_audit

ऐसा लगता है कि sysenter_dispatch फ़ंक्शन मूल पते से पहले / बाइट / PID / स्टैक में मैप करने से पहले शाब्दिक रूप से एक बाइट प्रारंभ होता है। इसलिए, हम सबसे अधिक संभावना लगभग एक बाइट (शायद गतिशील डिबगिंग के लिए वहां स्थित एनओपी कमांड) को पूरा करते हैं। हालांकि, ऐसा लगता है कि स्टैक के ये टुकड़े sysenter_dispatch फ़ंक्शन में हैं, जो अपने आप में एक सिस्टम कॉल नहीं है, लेकिन एक सहायक फ़ंक्शन है। ( यदि आप थोड़ा खोदते हैं - वहाँ अभी भी अंतर 1 नहीं है, लेकिन 7 बाइट्स हैं। संख्याएँ हेक्साडेसिमल हैं! - लगभग। अनुवाद

स्टैक प्रोफाइलिंग पर अधिक

ध्यान दें कि विभिन्न स्टैक प्रमोशन यूटिलिटीज, जैसे कि लिनक्स पर परफेक्ट, सोलारिस पर DTrace से Oprofile और profile यूटिलिटीज इंस्ट्रक्टर पॉइंटर रजिस्टरों (32-बिट इंटेल पर EIP या X64 पर RIP) को ठीक करती हैं, साथ ही 32 बिट और RSP पर स्टैक पॉइंटर (ESP) पर भी। x64) प्रोसेसर पर वर्तमान थ्रेड के लिए, और फिर स्टैक पॉइंटर्स के साथ वापस जाएं। इस प्रकार, ये उपयोगिताओं केवल उन थ्रेड्स को दिखाने में सक्षम हैं जो परीक्षण के समय सीपीयू पर चलते हैं!यह, निश्चित रूप से, अद्भुत है जब हम एक उच्च प्रोसेसर लोड के साथ समस्याओं की तलाश कर रहे हैं, लेकिन यह मृत-बंद या लंबे समय से प्रतीक्षा / हाइबरनेटिंग प्रक्रियाओं के निदान के लिए पूरी तरह से बेकार है।

Linux, Solaris, HP-UX, procstack (AIX पर), ORADEBUG SHORT_STACK पर pstack जैसी उपयोगिताएँ और बस / proc / PID / stack छद्म-फ़ाइल को पढ़ना सीपीयू प्रोफाइलिंग उपयोगिताओं के लिए एक अच्छा अतिरिक्त (लेकिन प्रतिस्थापन नहीं) हैं - जब तक वे प्रक्रिया मेमोरी को स्वतंत्र रूप से एक्सेस नहीं देते। शेड्यूलर में अपने राज्य से और स्टैक को वहीं से पढ़ें। यदि प्रक्रिया सोती है और सीपीयू को नहीं छूती है, तो प्रक्रिया स्टैक के शीर्ष को सहेजे गए संदर्भ से पढ़ा जा सकता है - जिसे संदर्भ स्विचिंग के दौरान ओएस अनुसूचक द्वारा कर्नेल मेमोरी में सहेजा जाता है।

बेशक, प्रोसेसर इवेंट प्रोफाइलिंग यूटिलिटीज अक्सर केवल pstack, OProfile, Perf, और यहां तक कि CPC प्रदाता से DTrace (Solaris11 पर) में अधिक कर सकते हैं। उदाहरण के लिए, मेमोरी एक्सेस की प्रतीक्षा करते समय छूटी हुई सीपीयू साइकिलों की संख्या जैसी चीजों का मूल्यांकन करने के लिए आंतरिक प्रोसेसर काउंटर सेट और पढ़ें; L1 / L2 कैश इत्यादि की संख्या याद आती है। लेकिन केविन क्लॉसन ने इस बारे में जो लिखा है उसे बेहतर ढंग से पढ़ें: ( परफ़ेक्ट , परफ़ेक्ट )

सौभाग्य

क्विक डायग्नोस्टिक्स और प्रॉब्लम सॉल्विंग के साथ लिनक्स कर्नेल की इनसाइड किचन सीखना